A logical representation and its reasoning engine method

Abstract

The present invention discloses a logic representation and its reasoning engine method, namely, a method for representing semantics and semantic generation rules, and a calculation method for semantic understanding and new semantic generation based on the representation method, including three parts: a semantic representation method, a logic representation method, and a reasoning calculation method. The three parts are organically combined. Based on known semantics, new semantics are inferred according to logical rules or functions that can be defined by natural language. All logical rules that can be expressed in natural language can be represented. The present invention is one of the enabling technologies for realizing the understanding and generation of natural language and strong artificial intelligence; reasoning oriented to a specific goal, namely evidence-based reasoning, can be performed; evidence-based reasoning can optimize the use of computing and storage resources and focus on the goal; the reasoning system disclosed by the present invention is an open reasoning system for semantics, and this reasoning system can generate new semantics), rather than just selecting a predefined semantic set.

Description

Technical Field

[0001] The present invention relates to the fields of natural language processing and artificial intelligence, and more specifically, to a logic representation and reasoning engine method thereof, namely, a representation method of semantics and semantic generation rules, and a computational method for semantic understanding and new semantic generation based on the representation method. Background Art

[0002] Understanding natural language requires deconstructing the logical relationship between semantics and semantic sequences. A semantic can be described as a sequence of semantics. Each semantic that constitutes the sequence is related to the semantic described by the sequence. These relationships constitute a structure of interrelated semantics. The understanding of semantics is generated from this structure, the description of semantics depends on this structure, and the reasoning of semantics and the generation of new semantics need to be based on this structure. In the application of the invention patent "A method for structural representation of semantics and a method for identifying a semantic sequence as a semantic" and the invention patent "A method for encoding semantics and semantic sequences across symbol systems", two methods for representing, storing and identifying semantics that describe each semantic as a sequence composed of semantics are disclosed. Based on the logical structure between semantics provided by these methods, it is possible to establish a technology that can infer new semantics based on known semantics (or concepts, or ideas, or cognition of the state of the world; in this invention, these words have the same meaning, so they are collectively referred to as semantics) according to the logic of natural language.

[0003] The generation of semantics is related to logic. Logic is the process of thinking and the process of generating semantics. After a long period of development, research in the field of logic has found that there are many forms of thinking rules in natural language, among which propositional logic is the most well-known. Propositional logic describes what happens in a unique system. This system has some events (a set of atomic propositions) that may or may not occur (either this or that). At present, the research on propositional logic has been very in-depth, with practical reasoning engines, and can solve many practical problems, especially the proof of mathematical theorems. However, propositional logic cannot handle the situation of parallel systems. For example, a system is a patient receiving a certain treatment and reaching a certain outcome. In one parallel system, the patient is cured and the patient's treatment ends; in another parallel system, the patient dies and the patient's treatment ends. Propositional logic is difficult to express such parallel system events and needs to be expanded.

[0004] An extension of propositional logic is called modal logic, which focuses on the possibility and necessity in parallel systems. If the symbol "{box}" is used to represent necessity and the symbol "{diamond}" is used to represent possibility, then the states of the above parallel systems correspond to "{diamond} patient is cured", "{diamond} patient dies" and "{box} patient's treatment ends". At present, the research on modal logic is still mainly theoretical development, lacking practical applications and practical reasoning engines. Based on modal logic, theoretical research has further developed deontic logic (used to deal with reasoning about "should", "allowed" and "prohibited"), temporal logic (used to deal with reasoning about "will be", "always" and "was"), conditional and coherent logic (used to solve the problem that propositional logic believes that "if the sun rises from the west, 1+1=3" is a true proposition), sub-coherent logic (allows a statement and its negation to be asserted at the same time without causing the logic system to fail) and indexical logic (used to solve the reasoning about the meaning of pronouns such as "patient" in parallel systems). These branches of logic, like basic modal logic, are still mainly theoretical research and lack practical reasoning engines.

[0005] However, since the aforementioned types of non-classical propositional logic are indispensable components of human's advanced thinking process, there is currently a lack of a unified, effective, and standardized form of expression of natural language logical laws, as well as a corresponding reasoning engine that can achieve advanced logical reasoning capabilities similar to those of humans. Summary of the invention

[0006] In order to solve the deficiencies in the existing technical solutions, the present invention discloses a logic representation and its reasoning engine method, and the specific technical solution is as follows:

[0007] The present invention discloses a logic representation method and its reasoning engine technology, which includes a semantic representation method, a logic representation method, and a reasoning calculation method. The three parts are organically combined to infer new semantics based on known semantics according to logical rules or functions that can be defined by natural language, wherein:

[0008] 1) The characteristic of semantic representation method is that there is the following relationship between semantics:

[0009] i. A semantics (denoted as A) corresponds to a semantics (denoted as B) through a one-to-one relationship. B is called the paradigm semantics of A.

[0010] ii. A semantics (denoted as A) corresponds to one or more semantics through a one-to-many relationship. These one or more semantics are called the specific semantics of A.

[0011] iii. The semantics can be related by the mapping rule in item 2) below; the relationship based on the mapping rule is similar to the one-to-one relationship between the semantics in point i and the one-to-many relationship between the semantics in point ii above, and can be recorded and read;

[0012] iv. Two semantics can be merged to form one semantic, and the merged semantic has all the relationships between the two semantics before the merger and other semantics; from the definition of semantic merging, we can know that only semantics with the same paradigm semantics can be merged with each other, otherwise the merged semantic has two or more paradigm semantics, which violates the above-mentioned rule i;

[0013] v. In practical applications, if there is no situation where semantics need to be merged, the semantics-mergeable feature of the above semantic representation method may not be reflected in the specific implementation of the semantic representation method;

[0014] 2) The characteristic of the logical representation method is that the logical representation is a set of mapping rules, and the mapping rules have the following characteristics:

[0015] i. The mapping rule is a one-to-many mapping, that is, one semantic can be converted into one or more semantics through one mapping rule; different semantics can be converted into the same semantic through the same mapping rule; the present invention refers to the process of converting one semantic (denoted as A) into one or more semantics through one mapping rule as a mapping task, and A is the starting semantic of the mapping task;

[0016] ii. A specific mapping rule (denoted as T) has a specific domain, that is, T can only act on semantics with a specific semantics (denoted as D) as the paradigm semantics. In this invention, D is called the domain semantics of T;

[0017] iii. A specific mapping rule (denoted as T) has a specific value range, that is, through T, only a semantic with a specific semantic (denoted as R) as a paradigm semantic can be obtained. In the present invention, R is called the value range semantic of T;

[0018] iv. During the execution of a mapping task, a set of semantics related to the starting semantics of the task can be used as parameters. This set of semantics is called a parameter semantic set of a mapping task;

[0019] v. A mapping rule has a one-to-one correspondence with the combination of its domain semantics and range semantics; that is, a mapping rule has a domain semantics and a range semantics; when a pair of semantics is given as the domain semantics and range semantics of a mapping rule, the mapping rule can be uniquely determined or determined to be non-existent; therefore, a semantic tuple, denoted as (D, R), can be used to represent the name of a mapping rule;

[0020] vi. The mapping rule is reversible, that is, if there is a mapping rule (denoted as T), the domain semantics of T is D, and the range semantics of T is R, then there must be another mapping rule (denoted as T'), the domain semantics of T' is R, and the range semantics of T' is D; and when one semantics (denoted as A) can be obtained from another semantics (denoted as B) through the mapping rule T, B can be obtained from A through the mapping rule T';

[0021] 3) The characteristic of the inference calculation method is that when the semantics is generated or updated, the mapping task execution is triggered:

[0022] i. The generation of semantics refers to combining a paradigmatic semantics and at least one specific semantics into a new semantics;

[0023] ii. Updating of semantics refers to changing the relationship between a semantics and other semantics, including: recording the mapping relationship between the semantics and other semantics, merging two semantics into one semantics, adding or deleting the relationship between a semantics and its specific semantics; in practical applications, if there is no change in the relationship between certain semantics, the specific implementation of the reasoning calculation method may not reflect the content of processing the change in the relationship between these semantics;

[0024] iii. When a semantic is generated, the mapping task defined by the mapping rule that can act on the semantic is triggered to execute with the semantic as the starting semantic; when a semantic is updated, the execution process is triggered to update the result of the executed mapping task with the semantic as the parameter semantic; until there is no mapping task that can be executed or whose result should be updated; in actual applications, if there is no need to trigger the update result of the executed mapping task, the corresponding mechanism may not be reflected in the specific implementation of the reasoning calculation method.

[0025] As a further improvement, the inference calculation method implements the following features to achieve evidence-based reasoning; the present invention refers to a specific implementation of the inference calculation method as an inference engine, which is as follows:

[0026] 1) Define a method for expressing a semantic pattern; the function of the semantic pattern is to enable the reasoning engine to determine whether a semantic pattern meets specific requirements based on it;

[0027] 2) Implement the semantic screening function of the reasoning engine. The specific form is: combine a semantic (denoted as Aq) and a semantic pattern (denoted as Sq). The reasoning engine can filter out a set of semantics from the generated semantics. This set of semantics takes Aq as the paradigm semantics, and each semantic has at least one specific semantic that meets the requirements specified by Sq. In the subsequent description, the tuple (Aq, Sq) is called a semantic screening condition.

[0028] 3) Implement a working mode of the reasoning engine, called evidence-based reasoning; in the working mode of evidence-based reasoning, the reasoning engine or the user can propose a reasoning task to the reasoning engine, and provide a semantic filtering condition as a task parameter, and record the semantic filtering condition as (Aq, Sq). The reasoning engine obtains the semantics that meet the semantic filtering condition (Aq, Sq) through reasoning operations. After the reasoning is completed, the reasoning engine feeds back the semantics that meet the semantic filtering condition to the reasoning engine or the user.

[0029] As a further improvement, the method by which the reasoning engine completes the evidence-based reasoning operation is as follows:

[0030] 1) Define another type of task that is not a mapping task and is performed by the reasoning engine, called an evidence-based reasoning task. An evidence-based reasoning task has three core features, which can be recorded as a triple (Aq, Sq, At). Aq and At are two semantics, and Sq is a semantic pattern. The meaning of this triple is that the reasoning engine should obtain semantics that meet the semantic screening condition (Aq, Sq), and take each of these semantics as the starting semantic, and perform the mapping task according to the mapping rule named (Aq, At).

[0031] 2) If a to-be-completed evidence-based reasoning task can be completed by a non-inference method known to the reasoning engine, such as calling a process external to the reasoning engine, then the evidence-based reasoning task is completed in this way;

[0032] 3) If a to-be-completed evidence-based reasoning task cannot be completed by a non-inference method known to the reasoning engine, the reasoning engine analyzes the semantic screening condition of the evidence-based reasoning task, i.e., the semantic screening condition represented by the tuple consisting of the first and second elements of the feature triple of the evidence-based reasoning task in the content of item 1), denoted as (Aq, Sq). The reasoning engine compares all mapping rules and calculates which mapping rules may be used to obtain the result semantics that meet the semantic screening condition (Aq, Sq). When the result semantics that meet the condition are calculated, the mapping What semantic filtering conditions must the starting semantics of the task meet? The semantic filtering conditions that the starting semantics of the mapping task must meet are recorded as (Ao, So). The reasoning engine creates (i.e., proposes to the reasoning engine) the evidence-based reasoning task (Ao, So, Aq) to be completed based on the semantic filtering conditions (Ao, So) to obtain the starting semantics that meet the semantic filtering conditions (Ao, So), and executes the mapping tasks defined by the mapping rules (Ao, Aq) based on these starting semantics to obtain the semantics that meet the semantic filtering conditions (Aq, Sq).

[0033] 4) The reasoning engine continues to repeat steps 2) and 3) above until all pending evidence-based reasoning tasks are completed or are judged to be incomplete.

[0034] As a further improvement, the user proposes a reasoning task to the reasoning engine, and gives a semantic screening condition as a task parameter, where the semantic screening condition is (Aq, Sq). The reasoning engine needs to create a corresponding evidence-based reasoning task to be completed to obtain semantics that meet the semantic screening condition (Aq, Sq); under the above-mentioned evidence-based reasoning operation framework, the following special operations are performed:

[0035] 1) Create a special evidence-based reasoning task to be completed, represented as a triple (Aq, Sq, empty);

[0036] 2) Define a special type of mapping rules. This type of mapping rules has a two-tuple name (Aq, empty), where Aq is a semantic. The mapping task defined by this type of mapping rule will not obtain the result semantics, nor the relationship between the semantics. The mapping task only outputs its starting semantics and feeds back to the user of the inference engine.

[0037] As a further improvement, the inference engine uses two types of mapping rules, namely, feature extraction rules and semantic fusion rules; the inference calculation method extracts the features of semantics through the feature extraction rules, and fuses semantics with the same features through the semantic fusion rules to form new semantics, which are in the following form:

[0038] 1) Feature extraction rules:

[0039] i. A feature extraction rule (denoted as E) is based on the specific semantics of a semantics (denoted as A), and the specific semantics of the result semantics are calculated, and then the specific semantics of the result semantics are combined with the given paradigm semantics to obtain the result semantics of the feature extraction mapping (denoted as B); the present invention calls the above process a feature extraction task, E is the definition rule of the task, A is the starting semantics of the task, and B is the result semantics of the task;

[0040] ii. If a semantics (denoted as A) can be converted into a semantics (denoted as B) through a feature extraction task, B is called the characteristic semantics of A or A has characteristic semantics B;

[0041] iii. One semantics is processed through one feature extraction task to obtain a result semantics; multiple different semantics can be processed through the same or different feature extraction tasks to obtain the same result semantics;

[0042] 2) Semantic fusion rules:

[0043] i. A semantic fusion rule (denoted as F) is based on a semantic (denoted as A, A is a characteristic semantic, i.e., the result semantic of a certain feature extraction task). First, a set of semantics with characteristic semantics A is obtained (denoted as L), and then a set of (zero, one or more) specific semantics of the result semantics is calculated based on the semantics in the set L. Then, the specific semantics of the result semantics obtained are combined with the given paradigm semantics to obtain a set of (zero, one or more) result semantics of semantic fusion mapping, denoted as [B1, ..., Bn], one of which is denoted as Bi. The present invention calls the above process a semantic fusion task, F is the definition rule of the task, A is the starting semantic of the task, [B1, ..., Bn] is the result semantic set of the task, and L is the parameter semantic set of the task. In the execution process of all semantic fusion tasks with definition rule F, the set composed of the paradigm semantics of all possible member semantics of L is called the dependent semantic set of the semantic fusion rule F.

[0044] ii. If a meaning (denoted as A) can be converted into a meaning (denoted as Bi) through a semantic fusion task, Bi is called the extended meaning of A or A has the extended meaning Bi;

[0045] iii. A semantics may obtain a set of (zero, one or more) result semantics through a semantic fusion task; multiple different semantics may obtain the same result semantics through the same or different semantic fusion rules.

[0046] As a further improvement, in order to express the characteristics of a semantic, the semantic representation method adds a feature: a semantic (denoted as A) can, but does not have to, represent a sequence composed of semantics; a sequence composed of semantics is called a semantic sequence; when semantic A can represent a semantic sequence, semantic A is said to have the form of a semantic sequence, that is, the semantic sequence is the semantic sequence form of A; in the subsequent description, the use of semantic A defaults to its non-semantic sequence form, and it will be explicitly stated when its semantic sequence form is used.

[0047] As a further improvement, the semantic representation method can be implemented as any specific software or hardware system that meets the characteristics of the aforementioned semantic representation method, and the semantic representation function is abstracted into a set of standardized method call interfaces, which have the following characteristics:

[0048] 1) Use semantic codes to represent semantics, with one semantic code corresponding to its code;

[0049] 2) It has the function of "converting semantic sequence to semantic code": seqToCode(seq). seq is a sequence of semantic codes; this method returns a semantic code denoted by S, where seq is the semantic sequence form of S;

[0050] 3) It has the function of "converting semantic code to semantic sequence": codeToSeq(code). code is a semantic code, and the semantic with code as code has the form of semantic sequence. This method returns the semantic sequence in the form of a sequence of semantic codes;

[0051] 4) It has the function of "identifying a semantic by paradigm semantics and concrete semantics": identify(instance, paradigm). instance and paradigm are semantic codes, instance is a code of a single semantic or a semantic code in the form of a semantic sequence returned by the above seqToCode function; this method returns a semantic code, whose paradigm semantic is the semantic with code paradigm, and whose concrete semantic contains a single semantic or a semantic in the form of a semantic sequence represented by instance;

[0052] 5) It has the function of "adding a specific semantic to a semantic": addInstance(instance, code). The semantic with code instance is used as the specific semantic of the semantic with code code; instance is a single semantic code or a semantic code in the form of a semantic sequence returned by the above seqToCode function; this method has no return value;

[0053] 6) It has the function of "getting the paradigm semantics of a semantics": getParadigm(code). code is a semantic code; this method returns the code of the paradigm semantics of the semantics with code as code, and the return value is a semantic code;

[0054] 7) It has the function of "getting a specific semantics of a semantics": getInstance(code). code is a semantics code; this method returns the specific semantics code of the semantics with code code, and the return value is one or more semantics codes;

[0055] 8) It has the function of "recording that two semantics can be obtained through mapping rules": map(code1, code2). code1 and code2 are two semantic codes; when the paradigm semantics of the two semantics coded as code1 and code2 are different, this method records that the two semantics coded as code1 and code2 have a mapping relationship, that is, there is a specific mapping rule denoted as T, the domain semantics of T is the paradigm semantics of the semantics coded as code1, the range semantics of T is the paradigm semantics of the semantics coded as code2, the semantics coded as code2 is obtained from the semantics coded as code1 through the mapping rule T, and at this time, the semantics coded as code1 must be obtained from the semantics coded as code2 through the inverse of the mapping rule T; when the paradigm semantics of the two semantics coded as code1 and code2 are the same, this method merges the two semantics coded as code1 and code2, and the code of the merged semantics is code1. The merged semantics has all the relationships between the two un-merged semantics and other semantics; this method has no return value;

[0056] 9) It has the function of "obtaining the semantics of a semantics obtained through a mapping rule": translate(code, paradigm). code is a semantic code; if the code of the paradigm semantics of the semantics with code code is the same as paradigm, then code is returned; if they are not the same, then it is checked whether there is a mapping rule denoted by T, the domain semantics of T is the paradigm semantics of the semantics with code code, the range semantics of T is the semantics with code paradigm, and the semantics obtained by the semantics with code code through the mapping rule T has been recorded through the above-mentioned map function before, then this method returns one or a group of semantic codes that can be obtained by the semantics with code code through the mapping rule T; otherwise, this method returns null;

[0057] 10) It has the function of "forgetting that two semantics can be obtained through mapping rules": unMap(code1, code2). code1 and code2 are two semantic codes; when the paradigm semantics of the two semantics coded as code1 and code2 are different, this method confirms that the two semantics coded as code1 and code2 do not have a mapping relationship, the domain semantics of T is the paradigm semantics of the semantics coded as code1, the range semantics of T is the paradigm semantics of the semantics coded as code2, the semantics coded as code2 cannot be obtained from the semantics coded as code1 through the mapping rule T, and at the same time, the semantics coded as code1 cannot be obtained from the semantics coded as code2 through the inverse of the mapping rule T; when the paradigm semantics of the two semantics coded as code1 and code2 are the same, this method is the same as forget in item 11) below; this method has no return value;

[0058] 11) It has the function of "forgetting a semantic": forget(code). code is a semantic code; this method deletes the semantic with code code and the relationship between this semantic and all other semantics, including the relationship between this semantic and its paradigm semantics and specific semantics, as well as the relationship between this semantic and other semantics established by mapping rules;

[0059] 12) In actual applications, when some of the above functions are not needed, the unnecessary functions may not be implemented.

[0060] As a further improvement, the semantic representation method can be implemented based on a graph structure, namely, a semantic graph, which has the following characteristics: a semantic graph consists of nodes and edges; an edge connects two nodes in a direction, which are respectively called the starting node and the ending node of the edge, and the nodes and edges in the graph structure are marked by semantic codes; the operation of the graph structure is limited to first finding the node marked by A, then finding the edge marked by B starting from the node marked by A, and then obtaining the mark of the ending node of the edge, namely, the semantic code, when two semantic codes denoted as A and B are known; and in some cases where the corresponding node or edge cannot be found, the corresponding node or edge is created. The characteristics of this graph structure and its operation can ensure that the software algorithm based on the graph structure can be completed by specially designed hardware computing devices.

[0061] As a further improvement, the software algorithm can be implemented by a specially designed hardware computing device, and specifically implemented by a specially designed neural network computing hardware. The design and operation of the computing hardware device correspond to the structure and operation of the graph, and the characteristics of the corresponding relationship are: one semantic code corresponds to one hardware neuron, the semantic code is the label of the node or edge in the graph, the hardware neuron is the hardware computing unit, that is, each hardware neuron can be addressed and activated by a semantic code; the computing device contains a large number of spare hardware neurons, each spare hardware neuron corresponds to a unique code that can be used as a semantic code as its address, and the spare hardware neurons are enabled on demand.

[0062] As a further improvement, the computing device operation corresponding to the basic mode of operation of the graph structure is to find a third hardware neuron that can be activated through two hardware neurons with codes A and B that have been activated, and activate the hardware neuron under certain conditions; when the graph operation needs to generate a node or edge marked with a new semantic code, enable the spare hardware neuron to generate a new semantic code, and connect the newly enabled hardware neuron according to the logic of the graph operation; under normal circumstances, a hardware neuron can only be activated when its two input hardware neurons are in an activated state; if there is an edge in the graph whose mark is the same as the mark of its starting node, then the hardware neuron with the end node mark of the edge as the address can only be activated when a hardware neuron with the starting node mark of the edge as the address is in an activated state, and the functions of other computing devices are designed accordingly based on the above functions corresponding to the graph operation;

[0063] Specifically, when two semantic codes (denoted as A and B) are known, first find the node marked by A, then find the edge marked by B starting from the node marked by A, and then get the label of the end node of the edge, that is, the semantic code; and in some cases where the corresponding node or edge cannot be found, create the corresponding node or edge; the computing device operation corresponding to this graph operation mode is to find the third hardware neuron that can be activated through two activated hardware neurons and obtain its address, that is, the semantic code, and the semantic code or address of the hardware neuron is A and B; when the graph operation needs to generate a node or edge marked with a new semantic code, enable the spare hardware neuron to generate a new semantic code, and use the newly enabled hardware neuron The elements are connected accordingly according to the logic of graph operations (edges in the graph), that is, if the neuron needs to be activated through hardware neurons with addresses A and B, the two hardware neurons with addresses A and B should become the input of the neuron; in general, a hardware neuron can only be activated when its two input hardware neurons are in an activated state; if there is an edge in the graph whose mark is the same as the mark of its starting node, then the hardware neuron with the end node mark (semantic code) of the edge as the address can be activated only when a hardware neuron with the starting node mark (semantic code) of the edge as the address is in an activated state, and the functions of other computing devices are designed accordingly on the basis of the above functions corresponding to graph operations.

[0064] As a further improvement, the graph structure has the following features:

[0065] 1) The edges in the graph represent a specific form of association between semantics;

[0066] 2) Use a special form of edge to represent the relationship between a semantics and its paradigm semantics;

[0067] 3) A special form of edge is used to represent the association between a semantic term and its specific semantic term.

[0068] As a further improvement, the graph structure has the following specifications. To illustrate these specifications, consider an edge in the graph, which represents a specific form of association between three semantic codes A, B, and C. If the starting node of the edge is marked as A, the edge is marked as B, and the end node of the edge is marked as C, then the edge is recorded as A--B->C. At this time:

[0069] 1) An edge A--B->C means:

[0070] The paradigm semantics of iC is B;

[0071] ii. All possible semantics with B as the paradigm semantics form a set. There exists a mapping whose range is this set. C is the image of A under this mapping.

[0072] 2) A special form of edge V---1->U is used to indicate that the canonical semantics of V is U;

[0073] 3) A special form of edge X---2->Y is used to indicate that the specific meaning of X is Y;

[0074] 4) From the above specifications 1) and 2), we can see that when there is an edge T--U->V, there must be an edge V---1->U.

[0075] As a further improvement, a supplement is made to the specification of the graph structure: when there is an edge V---1->U, there must be an edge U--U->V; this supplement makes it possible to find a set of semantic structures with a certain semantics as the paradigm semantics through the aforementioned graph operation method.

[0076] As a further improvement, the specification of the graph structure can be simplified as follows:

[0077] 1) It is not necessary to represent the nodes marked with "-1" and "-2" in the graph, as well as the edges with these two nodes as the starting nodes or the ending nodes. The reason is that "-1" represents the common characteristics of all semantics that can be used as "paradigm semantics", and "-2" represents the common characteristics of all semantics that can be used as "specific semantics". "-1" and "-2" are not semantics that are usually concerned in practical applications, and they are related to almost all semantics. If the edges related to these two nodes are represented in the graph, the graph will contain a huge number of edges that will not be used, which will seriously reduce the computational efficiency.

[0078] 2) Edges that are not needed in actual applications may not be represented in the graph; for example, in actual applications, there is no need to retrieve all semantics that use it as a paradigm semantic through a semantic search, then the supplementary specification of the aforementioned graph structure, when there is an edge "V---1->U", there must be an edge "U--U->V" that may not be executed, that is, the corresponding edge is not represented in the graph; for another example, if according to the logic of the actual application, a certain edge will never be used in the aforementioned graph operation (finding a node based on a node and an edge), then the edge may not be represented in the graph.

[0079] As a further improvement, the standardized method calling interface for semantic representation is implemented based on the data structure of the semantic representation. A specific implementation is shown in Section 1.1.2 of the specific implementation method of this patent.

[0080] As a further improvement, the inference engine uses a mapping rule based on the specific semantics of the semantic sequence form to perform calculations, which is as follows:

[0081] 1) The feature extraction rule is based on the specific semantics of a semantic sequence form, extracts the semantics at a specific position on the semantic sequence, and reorganizes and transforms it to obtain the specific semantics of the semantic sequence form of the result semantics, and then combines the obtained specific semantics of the semantic sequence form of the result semantics with the given paradigm semantics to obtain the result semantics of the feature extraction mapping;

[0082] 2) The semantic fusion rule is based on a semantic (denoted as A, where A is the characteristic semantic). First, a set of semantics with characteristic semantics A is obtained (denoted as L). Then, based on the semantics in the set L, the specific semantics in the form of semantic sequence of the semantics in L are obtained. The semantics at specific positions on the semantic sequence are extracted and reorganized and transformed to obtain a set of (zero, one or more) specific semantics in the form of semantic sequence of the result semantics. The specific semantics in the form of semantic sequence of the obtained result semantics are combined with the given paradigm semantics to obtain a set of (zero, one or more) result semantics of semantic fusion mapping.

[0083] As a further improvement, the implementation method of the inference engine has the following characteristics:

[0084] 1) The inference engine records all known mapping rules; the name of a known mapping rule is represented by a tuple consisting of two semantics, namely, a tuple consisting of the domain semantics and the range semantics of the mapping rule;

[0085] 2) The content of the mapping rule is written in a standardized way that can be understood by the inference engine:

[0086] i. The inference engine can determine the type of a mapping rule with a specific name according to the standard writing method of the mapping rule, that is, whether the mapping rule is a feature extraction rule or a semantic fusion rule;

[0087] ii. The reasoning engine can determine the dependent semantics of a semantic fusion rule based on the standard writing of the mapping rule;

[0088] iii. The reasoning engine can complete the calculation of the specific semantics of the semantic sequence of the result semantics of a mapping task according to the standard writing of the mapping rules;

[0089] 3) The inference engine registers the mapping tasks to be executed and executes them when computing resources allow, until there are no more executable mapping tasks; a mapping task can be recorded as a triple (Md, Mr, A), where Md and Mr are the domain semantics and range semantics of the mapping rule respectively, and their combination (Md, Mr) indicates the name of a specific mapping rule, and A is the starting semantics of the mapping task;

[0090] 4) When executing a feature extraction task (Ed, Er, A), perform the following operations:

[0091] i. According to the standard writing of feature extraction rules (Ed, Er), based on A, a specific semantics R in the form of a semantic sequence corresponding to its characteristic semantics is generated;

[0092] ii. Confirm that there is (i.e., find or generate) a semantics (denoted as Fi) whose specific semantics include R and whose paradigm semantics is Er; in this process, if Fi is generated, then perform the relevant operations required for generating the new semantics with Fi as a parameter (the content of item 6 below);

[0093] iii. Confirming that the semantic representation system has recorded the mapping relationship between A and Fi can be understood as calling the map function of the semantic representation system with the two semantic codes as parameters; in this process, if a new mapping relationship is recorded, the relevant operations required for recording the new mapping relationship are performed with the tuple (A, Fi) as a parameter (the content of item 7 below);

[0094] 5) When executing a semantic fusion task (Fd, Fr, A), perform the following operations:

[0095] i. Instruct the semantic representation system to forget the previous execution result of the same semantic fusion task; the steps are as follows:

[0096] a) Obtaining the result semantic set of the previous semantic fusion task, which can be understood as calling the translate(A, Fr) method of the semantic representation system, the result is recorded as [B1, ..., Bn], and an element of the set is recorded as Bi;

[0097] b) instructing the semantic representation system to forget the mapping relationship between each pair (A, Bi), which can be understood as calling the unMap(A, Bi) method of the semantic representation system;

[0098] ii. Obtain the parameter semantic set L of the semantic fusion task by:

[0099] a) According to the name of the semantic fusion rule (Fd, Fr), the dependent semantic set of the rule is obtained, which is recorded as [P1, ..., Pn], and one of the dependent semantics is recorded as Pi;

[0100] b) For each Pi, find the result of applying the mapping (Fd, Pi) to A and merge the results, which can be understood as calling the translate(A, Pi) method of the semantic representation system and then merging the results into a set to obtain L;

[0101] iii. According to the standard writing of semantic fusion rules (Fd, Fr), based on L, a set of (zero, one or more) specific semantics of A in the form of semantic sequence [R1, ..., Rn] is calculated, one of which is denoted as Ri;

[0102] iv. Confirm the existence (i.e., find or generate) of a semantics (denoted as Ci) containing Ri and a paradigm semantics Fr; in this process, if Ci is generated, then perform the relevant operations required for generating the new semantics with Ci as a parameter (the content of item 6 below);

[0103] v. Confirm that the semantic representation system has recorded the mapping relationship between A and Ci, which can be understood as calling the map method of the semantic representation system with the two semantic codes as parameters; in this process, if a new mapping relationship is recorded, the relevant operations required for recording the new mapping relationship are performed with the tuple (A, Ci) as a parameter (the content of item 7 below);

[0104] 6) When a new semantic is generated, the following operations are performed: the newly generated semantic, i.e., the parameter of this operation is A, and this operation attempts to register (zero, one or more) feature extraction tasks to be executed with the inference engine, which is recorded as (Ed, ?, A); where Ed is the paradigm semantic of A, and (Ed, ?) represents all feature extraction rules with Ed as the domain semantic;

[0105] 7) When the new mapping relationship is recorded, the following operation is performed: if the record of the new mapping relationship corresponds to calling the map function of the semantic representation system with (A1, A2) as parameters, the parameters of this operation are recorded as (A1, A2), and this operation attempts to register (zero, one or more) semantic fusion tasks to be executed with the inference engine, which are recorded as (F2,?[F1],A2); where F2 is the paradigm semantics of A2, F1 is the paradigm semantics of A1, and (F2,?[F1]) represents all semantic fusion rules with F2 as the domain semantics and whose dependent semantic set includes F1;

[0106] 8) As an optional improvement to improve computing efficiency, when registering tasks to be executed, the inference engine only retains one record for the same task, that is, only one record for tasks to be executed with the same (Fd, Fr, A) triple is retained, and when the inference engine attempts to execute a semantic fusion task (the semantic fusion rule is denoted as R), it first checks whether there is a feature extraction task to be executed (the feature extraction rule is denoted as Q), and the value domain semantics of Q belongs to the dependent semantics of R; if such a feature extraction task to be executed exists, then such feature extraction task to be executed is executed first.

[0107] As a further improvement, the following specifications are used when expressing feature extraction rules:

[0108] 1) The value range semantics of the feature extraction rule has a unified special paradigm semantics, for example, its code is "-3";

[0109] 2) The domain semantics of the feature extraction rule has a specific semantics in the form of a semantic sequence. The first position of the semantic sequence is the domain semantics of the feature extraction rule. Starting from the second position, the position is numbered x. The semantic code at position x represents a number (denoted as nx). This number indicates that the semantic code at the (x-1)th position of the specific semantics in the form of a semantic sequence of the result semantics of the feature extraction task is the semantic code at the nxth position of the specific semantics in the form of a semantic sequence of the starting semantics of the feature extraction task.

[0110] 3) When the domain semantics of feature extraction rules are expressed using the specifications in items 1) and 2) above, since the domain semantics has already explained how the feature semantics are generated, the inference engine only needs the name of the feature extraction rule, i.e., a tuple consisting of its domain semantics and range semantics, and no other information is required to complete the feature extraction task.

[0111] As a further improvement, the semantic fusion rules are expressed in the standard form of seven tuples, which are recorded as (Ad, Ar, Dep, Api, Par, Map1, Map2), where:

[0112] 1) Ad is the domain semantics of the semantic fusion rule; Ar is the range semantics of the semantic fusion rule; therefore, the name of the semantic fusion rule with the standard form of (Ad, Ar, Dep, Api, Par, Map1, Map2) is (Ad, Ar);

[0113] 2) Dep is the dependent semantic set of the semantic fusion rule;

[0114] 3) Api is an application program interface that can be called by the inference engine, and its input is:

[0115] i. Parameter semantic set L of semantic fusion task;

[0116] ii. the parameter Par passed to the application program interface as indicated by the canonical form of the semantic fusion rule;

[0117] 4) The application program interface specified by Api outputs a set of (zero, one or more) semantic sequences; during the execution of a semantic fusion task, each semantic sequence output by Api is a specific semantic component in the form of a semantic sequence of the result semantics of the task; the semantic sequences output by this set of Api are denoted as [Rc1, ..., Rcn], and one of the semantic sequences is denoted as Rci;

[0118] 5) Map1 is a set of correspondences of sequence positions, which specifies the correspondence between the specific semantics of the semantic sequence form of the result semantics of a semantic fusion task and the specific semantic sequence form of the semantic sequence form of its starting semantics: the specific semantic position of the semantic sequence form of the starting semantics of a semantic fusion task corresponds to zero, one or more specific semantic positions of the semantic sequence form of the result semantics of the task;

[0119] 6) Map2 is a set of sequence position correspondences, which specifies the correspondence between the specific semantics of the semantic sequence form of the result semantics of a semantic fusion task and the sequence position of the semantic sequence output by its API: the position of the semantic sequence output by an API (Rci in the content of item 4 above) corresponds to zero, one or more specific semantic positions of the semantic sequence form of the result semantics of the task;

[0120] 7) Map1 and Map2 together can specify the source of the semantics at each sequence position of the specific semantics in the semantic sequence form of the result semantics of the semantic fusion task without conflict; the reasoning engine thereby obtains the specific semantics in the semantic sequence form of the complete result semantics of the semantic fusion task, that is, the specific semantics [R1,…,Rn] in the semantic sequence form of the extended semantics of the starting semantic A of the semantic fusion task as described in the operation of the aforementioned reasoning engine to perform the semantic fusion task.

[0121] As a further improvement, the definition of mapping rules is further standardized, requiring:

[0122] 1) The domain semantics of any feature extraction mapping is not the range semantics of any feature extraction mapping;

[0123] 2) The domain semantics of any semantic fusion mapping must be the value domain semantics of a feature extraction mapping;

[0124] 3) The range semantics of arbitrary semantic fusion mapping is not the range semantics of arbitrary feature extraction mapping.

[0125] As a further improvement, the following restrictions are made to the evidence-based working mode of the reasoning engine: when the user asks a question to the reasoning engine, the semantic screening condition given is recorded as (Aq, Sq), and Aq is not the value domain semantics of the feature extraction mapping; the principle of adding this restriction is that the essence of the semantic screening condition is to extract the features of a semantic sequence and judge whether it meets the requirements. Based on the specifications of the above mapping rules, the semantic screening condition should not extract features from the feature semantics, that is, the specific semantics in the form of a semantic sequence of the semantics of the value domain semantics mapped by a feature extraction, that is, the paradigm semantics.

[0126] As a further improvement, the specific implementation of the reasoning engine to handle evidence-based reasoning tasks is as follows:

[0127] 1) Define a canonical form of an evidence-based reasoning task. On the basis of the core characteristic triple of the evidence-based reasoning task, add information indicating the task execution status, which can be specifically expressed as a six-tuple (No, Aq, Sq, At, Prg, Chd); where No is a task number; (Aq, Sq) constitutes a semantic screening condition; At is a semantic code, which indicates obtaining a set of semantics that meet the semantic screening condition (Aq, Sq), the purpose of which is to use each of the semantics in the set as the starting semantics and execute the mapping rule named (Aq, At); Prg is the progress of obtaining the semantics, which can reflect the following progress status: "Task is known but not evaluated", "Task is executable and being executed", "Task is not executable", "Task is completed"; Chd is a set of task numbers, recording the numbers of the evidence-based reasoning tasks (created by the evidence-based reasoning task) that the completion of the evidence-based reasoning task depends on;

[0128] 2) The reasoning engine maintains a list of known evidence-based reasoning tasks; when the user starts the evidence-based reasoning working mode and proposes a semantic screening condition (Aq, Sq) to the reasoning engine, a standardized evidence-based reasoning task is registered: a six-tuple (a new task number, Aq, Sq, empty, the task is known but not evaluated, and an empty set);

[0129] 3) When there is an evidence-based reasoning task, denoted as X, whose canonical form is (No, Aq, Sq, At, Prg, Chd), Prg is "the task is known but not evaluated", Chd is an empty set, At is empty or the mapping rule named (Aq, At) is a feature extraction rule, the reasoning engine performs the following operations:

[0130] i. Obtain a mapping rule set whose result semantics may meet the semantic screening condition (Aq, Sq), that is, obtain a mapping rule set named (?, Aq), where ? represents any semantic; one such rule in the set is denoted as (Ao, Aq). Based on the specification of the above mapping rules, the value range semantics of any feature extraction mapping cannot be the definition domain semantics of any feature extraction mapping. Therefore, (Ao, Aq) is not a feature extraction mapping, but must be a semantic fusion mapping;

[0131] ii. For each (Ao, Aq), try to register a new evidence-based reasoning task (No1, Ao, So, Aq, Prg1, Chd1) with the reasoning engine; No1 is a new evidence-based reasoning task number; So is a semantic pattern calculated by the reasoning engine according to the definition of the semantic fusion rule named (Ao, Aq), which can form a semantic screening condition with the semantic Ao, so that each semantic that meets the semantic screening condition (Ao, So) is used as the starting semantic, and the semantic obtained by mapping (Ao, Aq) must contain all possible semantics that meet the semantic screening condition (Aq, Sq) obtained by mapping (Ao, Aq); Prg1 is set to "task known but not evaluated"; Chd1 is set to an empty set; the reasoning engine records the task number returned by the registration operation (item 5 below)) into the Chd set;

[0132] iii. If the Chd set is empty after completing the above steps i and ii, initiate an external evidence-based feasibility check (item 6 below) with the triple (No, Aq, Sq) as a parameter. If the check returns evidence-based, set Prg to "task executable and being executed", otherwise set it to "task not executable";

[0133] 4) When there is an evidence-based reasoning task X whose canonical form is (No, Aq, Sq, At, Prg, Chd), Prg is a known but not evaluated task, Chd is an empty set, and the mapping rule named (Aq, At) is a semantic fusion rule, the reasoning engine performs the following operations:

[0134] i. According to the definition of the semantic fusion rule named (Aq, At), its dependent semantic set [D1, ..., Dn] is obtained, and one of the semantics is Di. At this time, there must be a defined feature extraction mapping (Di, Aq);

[0135] ii. For each (Di, Aq), try to register a new evidence-based reasoning task (No1, Di, Sio, Aq, Prg1, Chd1) with the reasoning engine; No1 is a new evidence-based reasoning task number; Sio is a semantic pattern calculated by the reasoning engine according to the definition of the feature extraction rule named (Di, Aq), and the semantic pattern can form a semantic screening condition with the semantic Di, so that each semantic that meets the semantic screening condition (Di, Sio) is used as the starting semantic, and the semantic obtained by mapping (Di, Aq) must contain all possible semantics that meet the semantic screening condition (Aq, Sq) obtained by mapping (Di, Aq); Prg1 is set to "task known but not evaluated"; Chd1 is set to an empty set; the reasoning engine records the task number returned by the registration operation (item 5 below)) into the Chd set;

[0136] 5) The operation steps of the reasoning engine trying to register an evidence-based reasoning task are as follows: the evidence-based reasoning task to be registered is denoted as X, whose canonical form is (No, Aq, Sq, At, Prg, Chd); the reasoning engine searches whether there is a known evidence-based reasoning task, denoted as X1, whose canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), such that Aq is the same as Aq1, Sq is the same as Sq1, and At is the same as At1; if it exists, the evidence-based reasoning task X is not registered, and No1 is returned as the number of the registered evidence-based reasoning task; if it does not exist, the evidence-based reasoning task X is registered, and No is returned as the number of the registered evidence-based reasoning task;

[0137] 6) The operation steps of the reasoning engine to perform external evidence-based feasibility check are as follows, where the parameters of the operation are (No, Aq, Sq):

[0138] i. As the working parameter of the inference engine, the inference engine can access a list of external evidence-based interfaces, each of which is represented by a triple (Aq, Pq, Api), where Aq is a semantic; Pq is a parameter, through which the inference engine can judge: for any semantic screening condition composed of Aq, recorded as (Aq, Sq), whether the semantics that meet the semantic screening condition can be obtained by the external evidence-based interface; Api is an external program interface that can be called by the inference engine, and the external program interface can accept an execution instruction with (No, Aq, Sq) as a parameter to query a specific data source or complete a specific calculation, and then obtain the semantics whose paradigm semantics is Aq and whose specific semantics in the form of semantic sequence meet the pattern specified by Sq according to the query or calculation results; the semantics obtained by the external evidence-based interface are similar to the semantics obtained by the mapping task. When the new semantics are generated, the operations required for the generation of the new semantics described in the implementation method of the aforementioned inference engine will be executed;

[0139] ii. When the external evidence-based feasibility check is performed with the triple (No, Aq, Sq) as a parameter, the reasoning engine scans all external evidence-based interfaces, and determines whether the external evidence-based interface can obtain semantics that meet the semantic screening conditions (Aq, Sq) through the Aq and Pq information of an external evidence-based interface; if such an external evidence-based interface is found, a command to start data transmission is sent to the external evidence-based interface with the triple (No, Aq, Sq) as a parameter, and this external evidence-based feasibility check immediately returns that it can be verified;

[0140] iii. After the scanning in step ii above is completed, if no external evidence-based interface API is started, the external evidence-based feasibility check will return unavailable for verification;

[0141] iv. If an external evidence-based interface receives an execution instruction with parameters (No, Aq, Sq), it works as follows: through the semantic representation system, it obtains the semantics of Aq and its associated semantics, the semantics in the Sq sequence and its associated semantics, and the data corresponding to the semantics (such as Java object instances), and based on this information, it obtains or calculates data outside the reasoning engine, and then uses the function of the semantic representation system to convert these external data into semantics. Every time a semantic is obtained, it reports to the reasoning engine, and the reasoning engine records the semantic (if it is a new semantic, it triggers the operation required for generating new semantics described in the implementation method of the aforementioned reasoning engine). After the external evidence-based interface completes the acquisition or calculation of all data, it notifies the reasoning engine and sets the progress status of the semantic acquisition of the evidence-based reasoning task coded as No to "task completed";

[0142] 7) When there is an evidence-based reasoning task, denoted by X, whose canonical form is (No, Aq, Sq, At, Prg, Chd), and Chd is a non-empty set:

[0143] i. If Prg is "Task known but not evaluated", and the progress of the evidence-based reasoning task corresponding to any number saved in the Chd set is "Task executable and executing" or "Task completed", then set Prg to "Task executable and executing";

[0144] ii. If Prg is "Task known but not evaluated" or "Task executable and being executed", and there is at least one corresponding evidence-based reasoning task with the progress of "Task completed" among the numbers saved in the Chd set, and there is no evidence-based reasoning task with the progress of "Task executable and being executed" or "Task known but not evaluated", then set Prg to "Task completed";

[0145] iii. If Prg is "Task known but not evaluated", and the progress of all evidence-based reasoning tasks corresponding to the numbers saved in the Chd set is "Task not executable", then set Prg to "Task not executable";

[0146] 8) The reasoning engine stops when the progress of all evidence-based reasoning tasks is at "task completed" or "task cannot be executed".

[0147] As a further improvement, the following modifications are made to the working method of the inference engine to improve computational efficiency:

[0148] 1) Expand the progress status of the evidence-based reasoning task that can be reflected by Prg in the canonical form of the evidence-based reasoning task mentioned above, and add a state that can be reflected: "mapping task is being executed";

[0149] 2) The canonical form of the extended mapping task is a four-tuple, that is, the canonical form of the mapping task is expanded to (Md, Mr, A, Dep), where Md and Mr are the domain semantics and range semantics of a mapping rule respectively, and their combination (Md, Mr) indicates a specific mapping rule, and A is the starting semantics of the mapping task; Dep is a numbered set of evidence-based reasoning tasks; this mapping task will not be executed by the reasoning engine before all the evidence-based reasoning tasks in the set enter the "task completed" progress; if the set is an empty set, it can be executed by the reasoning engine; if any evidence-based reasoning task in the set enters the "task unexecutable" state, this mapping task cannot be executed and should be deleted by the reasoning engine;

[0150] 3) Extend the function of the original reasoning engine to register a mapping task when a new semantic is generated, that is, the operation triggered by the generation of a new semantic described in the implementation method of the aforementioned reasoning engine: let the newly generated semantic be X, let its paradigm semantic be Xp, the reasoning engine searches whether an evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) has been registered, Xp is the same as Aq, and there is at least one semantic pattern specified by Sq in the specific semantic of the semantic sequence form of X. At this time:

[0151] i. If (Aq, At) is a feature extraction mapping, register the mapping task (Aq, At, X, empty set);

[0152] ii. If (Aq, At) is a semantic fusion mapping, register the mapping task (Aq, At, X, Dep); the number set Dep of the evidence-based reasoning task is obtained by the following operations: the reasoning engine first obtains the dependent semantic set [D1, ..., Dn] of (Aq, At), and denotes one of the semantics as Di; the reasoning engine attempts to register an evidence-based reasoning task (No1, Di, Sio, Aq, Prg1, Chd1) for each Di, where No1 is the number of a new evidence-based reasoning task; Sio is A semantic pattern calculated by the inference engine according to the definition of the feature extraction rule named (Di, Aq), which can form a semantic screening condition with the semantic Di, so that each semantic that meets the semantic screening condition (Di, Sio) is used as the starting semantic, and the semantic obtained by mapping (Di, Aq) must contain all the semantics that may be mapped to (Di, Aq) to obtain X; Prg1 is set to "task known but not evaluated"; Chd1 is set to an empty set; the inference engine records the task number returned by the registration operation into the Dep set;

[0153] 4) Extending the operation of registering a new evidence-based reasoning task of the original reasoning engine, that is, the operation of registering a new evidence-based reasoning task described in the implementation method of the aforementioned reasoning engine processing evidence-based reasoning tasks, when a new evidence-based reasoning task, denoted as (No, Aq, Sq, At, Prg, Chd), needs to be registered, the following operations are performed: the reasoning engine scans all known semantics and finds a group of semantics, the paradigm semantics of which is Aq, and has specific semantics in the form of semantic sequences, and the specific semantics in the form of semantic sequences conform to the semantic pattern specified by Sq; the reasoning engine regards this group of semantics as newly generated semantics and performs the operations described in the above item 3); after the above operations are completed, the reasoning engine registers the new evidence-based reasoning task;

[0154] 5) Modify the working mode of the original external evidence-based interface, that is, the operation of performing external evidence-based feasibility check described in the implementation method of the aforementioned reasoning engine processing evidence-based reasoning tasks. The working mode of the modified external evidence-based interface is as follows: if an external evidence-based interface receives an execution instruction with parameters (No, Aq, Sq), its working mode is: through the semantic representation system, obtain the semantics of Aq and its associated semantics, the semantics in the Sq sequence and its associated semantics, and the data corresponding to the semantics (such as Java object instances), and based on this information, obtain or calculate the data outside the reasoning engine, and then use the function of the semantic representation system to convert these external data into semantics. Every time a semantic is obtained, it is reported to the reasoning engine, and the reasoning engine records the semantic (if it is a new semantic, it triggers the operation described in the above item 3). After the external evidence-based interface completes the acquisition or calculation of all data, it notifies the reasoning engine to set the progress status of the acquisition of the semantics of the evidence-based reasoning task coded as No to "mapping task is being executed";

[0155] 6) Revoke the function of the original reasoning engine to register the semantic fusion task when a new mapping relationship is recorded;

[0156] 7) Expand the operation of the original reasoning engine to change the progress status of the evidence-based reasoning task, that is, the content of modifying the progress of the evidence-based reasoning task described in the implementation method of the aforementioned reasoning engine processing the evidence-based reasoning task. The standard form of the evidence-based reasoning task is (No, Aq, Sq, At, Prg, Chd). The expanded operation is:

[0157] i. If Prg is a known but unevaluated task, and the progress of the evidence-based reasoning task corresponding to any number saved in the Chd set is "task executable and executing" or "mapping task is being executed" or "task completed", then set Prg to "task executable and executing";

[0158] ii. If Prg is "Task known but not evaluated", and the progress of all evidence-based reasoning tasks corresponding to the numbers saved in the Chd set is "Task not executable", then set Prg to "Task not executable";

[0159] iii. If Prg is "Task known but not evaluated" or "Task executable and being executed", and there is at least one corresponding evidence-based reasoning task with the progress of "Task completed" among the numbers saved in the Chd set, and there is no evidence-based reasoning task with the progress of "Task executable and being executed" or "Task known but not evaluated" or "Mapping task being executed", then set Prg to "Mapping task being executed";

[0160] iv. If Prg is "mapping task is being executed", the reasoning engine searches for a mapping task (Md, Mr, A, Dep) where Aq is the same as Md, At is the same as Mr, and A has a specific semantics in the form of a semantic sequence and conforms to the pattern specified by Sq; if there is no such mapping task, set Prg to "task completed"; if there is such a mapping task, try to execute each such mapping task: when the Dep set is an empty set or each evidence-based reasoning task in the Dep set enters the "task completed" state, the mapping task is executed immediately and after execution, it is removed from the waiting list. The mapping task is deleted from the list of mapping tasks; when there is an evidence-based reasoning task in the Dep set and its progress is "task cannot be executed", the mapping task is not executed and it is immediately deleted from the list of mapping tasks to be executed; when the Dep set is in other situations, the reasoning engine puts the mapping task on hold and processes the next mapping task; after all mapping tasks are processed, if there is no shelved mapping task, set Prg to "task completed", otherwise do not change Prg, and this operation returns, waiting for the reasoning engine to process the evidence-based reasoning task again later (No, Aq, Sq, At, Prg, Chd).

[0161] As a further improvement, the semantic pattern representation method and the semantic pattern related calculation method are implemented in the following manner:

[0162] 1) The following representation method of semantic patterns is used: the semantic pattern is represented as a special type of semantic sequence; a special semantic can be used in the semantic pattern, for example, its code is "-4"; when the semantic code "-4" appears at a certain position in a semantic pattern, it means that the semantic pattern has no restrictions on the semantic sequence at this position; when the code at a certain position in a semantic pattern is not "-4", it means that the semantic pattern requires the semantic sequence to have the same semantic code at this position;

[0163] 2) All mapping tasks have one and only one starting semantics; based on the standard definition of the aforementioned mapping rules, there is a correspondence between the sequence position of the specific semantics in the semantic sequence form of the starting semantics and the sequence position of the specific semantics in the semantic sequence form of the result semantics. According to this correspondence, the semantic pattern that the specific semantics in the semantic sequence form of the mapped result semantics conform to can be converted into the semantic pattern that the specific semantics in the semantic sequence form of the mapped starting semantics conform to (denoted as So); from the content of item 1) above, it can be seen that So is one a sequence of the same length as the specific semantics of the semantic sequence form of the starting semantics; the way to obtain So is: for each position (denoted as np) in the So sequence, if the specific semantics of the semantic sequence form of the starting semantics corresponds to a sequence position of the specific semantics of the semantic sequence form of the result semantics at position np, then the semantic code at the position of the semantic pattern sequence that the specific semantics of the semantic sequence form of the result semantics conform to is filled into the np position of So; if there is no corresponding relationship, the semantic code "-4" is filled into the np position of So;

[0164] 3) In the operation of the aforementioned reasoning engine performing the external evidence-based feasibility check, the external evidence-based interface is represented as a triple (Aq, Pq, Api), where Aq is a semantics and Pq is a parameter. The reasoning engine can judge by the parameter: for any semantics screening condition composed of Aq, recorded as (Aq, Sq), whether the semantics that meet the semantics screening condition can be obtained by the external evidence-based interface; based on the representation method of the semantic pattern Sq described in the aforementioned item 1), a method for representing the parameter Pq and a related judgment method are as follows:

[0165] 4) A sequence of three state symbols is used to represent Pq, and these three state symbols are recorded as "0", "1", and "2". If a position in the Pq sequence is "0", it means that Pq has no restriction on the position in the Sq sequence; if a position in the Pq sequence is "1", it means that Pq requires the semantic code of the position in the Sq sequence to be "-4"; if a position in the Pq sequence is "2", it means that Pq requires the semantic code of the position in the Sq sequence cannot be "-4".

[0166] i. Based on the Pq sequence and the Sq sequence, the reasoning engine can judge whether an external evidence-based interface can obtain the required semantics according to the rules of the aforementioned point i.

[0167] As a further improvement, the representation of semantics, the relationship between semantics, and the information in the canonical form required by the reasoning engine (an n-tuple can be understood as a sequence, and different types of n-tuples can be understood as semantics with different paradigm semantics; creating semantics, whose specific semantics in the form of a semantic sequence are n-tuples in the canonical form required by the reasoning engine, and whose paradigm semantics are the types of canonical forms, that is, the canonical form information required by the reasoning engine) can be simultaneously implemented based on tables and based on semantic diagrams (i.e., the graph-based implementation method of the method call interface of the semantic representation technology described in Section 1.1.2 of the specific embodiment below). These two implementation schemes can be converted equivalently to adapt to different software and hardware environments and achieve higher computing efficiency; the specific method is as follows:

[0168] 1) Use tabular data structures to represent semantics, relationships between semantics, and information in a standardized form required by the inference engine:

[0169] i. Use four tables, namely, the correspondence table between external semantics and semantic codes, the correspondence table between semantics and semantic sequences, the semantic definition table and the mapping relationship table;

[0170] ii. Use the correspondence table between external semantics and semantic codes to record the correspondence between semantics outside the inference engine (such as Java object instances) and semantic codes;

[0171] iii. Use the correspondence table between semantics and semantic sequences to record the correspondence between a semantic code and the semantic sequence form of the semantic; that is, when a semantic has a semantic sequence form (calling codeToSeq with the semantic as a parameter can return a semantic sequence, or the semantic is the return value of the seqToCode function), there is a row of records in the correspondence table between semantics and semantic sequences to indicate this correspondence; a special semantic code is used to correspond to an empty sequence, which is recorded as "0";

[0172] iv. Use the semantic definition table to record the relationship between a semantic code, the code of the paradigm semantics of the semantics, and the code of the specific semantics of the semantics;

[0173] v. Use the mapping relationship table to record the relationship between the starting semantics and the result semantics of the mapping task. For example, if there is a mapping task with a starting semantics of X and a result semantics of [Y1, ..., Yn], one of the result semantics is Yi, and X has a paradigm semantics A, and Yi has a paradigm semantics B, then there is a row of records (A, X, B, Yi) in the "mapping relationship table";

[0174] vi. All functions of the semantic representation system can be realized based on the above data structure;

[0175] 2) Use semantics data structures to represent the semantics of the table structure, the relationships between semantics, and the information in the canonical form required by the inference engine:

[0176] i. For each row of data in the table of correspondence between external semantics and semantic codes, create a node in the semantic diagram;

[0177] ii. For each row of data in the table of correspondence between semantics and ideographic sequences, create a semantic structure corresponding to the ideographic sequence according to the implementation of the seqToCode method of the semantic representation system in this patent specification;

[0178] iii. For the data in the semantic definition table, create corresponding nodes representing the semantics according to the specification of the semantic structure in this patent specification, and connect the nodes to represent the relationship between a semantic and its abstract semantics and concrete semantics;

[0179] iv. For the data in the mapping relationship table, create connections between corresponding nodes in accordance with the specifications of the semantic structure in this patent specification to represent the mapping relationship between the semantics.

[0180] As a further improvement, an optional special restriction is used when expressing semantics: in most cases, the sequence length of the specific semantics (denoted as Vap) in the semantic sequence form of the paradigm semantics (denoted as Ap) of a semantic (denoted as A) is made consistent with the sequence length of the specific semantics (denoted as Va) in the semantic sequence form of A; and the two semantics at corresponding positions in the two sequences have a class-instance relationship, the semantics at corresponding positions on the Vap sequence are class semantics, and the semantics at corresponding positions on the Va sequence are instance semantics; this restriction makes the evidence-based reasoning process easier to understand and design, but it is not necessary.

[0181] As a further improvement, the inference engine is abstracted into a set of standardized method calling interfaces as follows:

[0182] 1) It has the function "set feature extraction mapping rule": setFeatureExtractionRule(Ed, Er). (Ed, Er) is the name of a feature extraction rule, where Ed is the semantic code of the domain semantics of the feature extraction rule, and Er is the semantic code of the range semantics of the feature extraction rule. This method confirms the existence (record or find) of a feature extraction rule in the inference engine, and the method has no return value;

[0183] 2) It has the function of "setting semantic fusion mapping rules": setConstructFusionRule(Ad, Ar, Dep, Api, Par, Map1, Map2). (Ad, Ar, Dep, Api, Par, Map1, Map2) is the standard form of a semantic fusion rule, where Ad is the semantic code of the domain semantics of the semantic fusion rule; Ar is the semantic code of the value domain semantics of the semantic fusion rule; (Ad, Ar) is the name of the semantic fusion rule; Dep is the dependent semantic set of the semantic fusion rule; Api is an application program interface that can be called by the inference engine. It can obtain a semantic sequence set based on the parameter Par and the parameter semantic set of a semantic fusion task. Each semantic in the semantic sequence set The sequences can be combined with the specific semantics in the semantic sequence form of the starting semantics of the semantic fusion task to form a specific semantics in the semantic sequence form of the result semantics of the semantic fusion task. The position correspondence between the semantic sequences in the semantic sequence set and the specific semantics in the semantic sequence form of the result semantics of the semantic fusion task is specified by Map2; the position correspondence between the specific semantics in the semantic sequence form of the starting semantics of a semantic fusion task and the specific semantics in the semantic sequence form of its result semantics is specified by Map1; the method has no return value; the parameter representation specifications are as follows:

[0184] i.Api: An application program interface that can be called by the inference engine, which can be described as a function name. The function receives two parameters. The first parameter is the parameter semantic set of the semantic fusion task, and the second parameter is Par. Usually, Par is used to specify the behavior of the function. The function can call the semantic representation system to obtain relevant information about the semantics. The return value of Api is a semantic sequence set. Each semantic sequence in the semantic sequence set can be combined with the specific semantics in the semantic sequence form of the starting semantics of the semantic fusion task to form a specific semantics in the semantic sequence form of the result semantics of this semantic fusion task.

[0185] ii.Par: a parameter that can be understood by the API, used to specify the behavior of the API function; to simplify the description, in the present invention, the API of semantic fusion mapping is uniformly represented as a function "posRecomb", one parameter of which is the extraction and rearrangement rule of the semantic sequence described in natural language, and the parameter (the extraction and rearrangement rule of the semantic sequence described in natural language) is Par;

[0186] iii.Map1: a set of correspondences of sequence positions, which specifies the correspondence between the specific semantics of the semantic sequence form of the result semantics of a semantic fusion task and the sequence position of the specific semantics of the semantic sequence form of its starting semantics; let the starting semantics of a semantic fusion task be A, the result semantic set R of the task be [R1,…,Rn], let one of the result semantics be Ri, then the sequence position of the specific semantics of the semantic sequence form of Ri and the sequence position of the specific semantics of the semantic sequence form of A have the correspondence specified by Map1; the canonical form of the correspondence (i.e., the canonical form of Map1) is a set, each element of which is a tuple (x, y), where x and y are two numbers, and the tuple indicates that the semantic code at the xth position of the specific semantics of the semantic sequence form of Ri is the semantic code at the yth position of the specific semantics of the semantic sequence form of A;

[0187] iv.Map2: a set of correspondences of sequence positions, which specifies the correspondence between the specific semantics of the semantic sequence form of the result semantics of a semantic fusion task and the sequence position of a sequence in the semantic sequence set output by its API; let the semantic sequence set Rc of the API output of a semantic fusion task be [Rc1, ..., Rcn], one of which is Rci, and the result semantic set R of the semantic fusion task is [R1, ..., Rn], one of which is Ri, the set Rc is equal to the set R in size, and Rci has a one-to-one correspondence with Ri, at this time, Map2 specifies the sequence position correspondence between Rci and the specific semantics of the semantic sequence form of Ri; the canonical form of this correspondence, that is, the canonical form of Map2 is a set, each element in the set is a tuple (x, y), where x and y are two numbers, and the tuple indicates that the semantic code at the xth position of the specific semantics of the semantic sequence form of Ri is the semantic code at the yth position of Rci;

[0188] 3) It has the function of "registering mapping tasks": registerMapTask(D, R, A, Dep). (D, R) is the name of a mapping rule, A is the starting semantics of the mapping task, and Dep is the number set of the evidence-based reasoning tasks that the mapping task depends on; this method attempts to register a mapping task with the reasoning engine in the form of a four-tuple, and the method has no return value;

[0189] 4) It has the function "execute mapping task": executeMapTask(D, R, A). (D, R) is the name of a mapping rule, A is the starting semantics of the mapping task, and the triple (D, R, A) can uniquely determine the four-tuple canonical form of a mapping task (D, R, A, Dep); this method instructs the inference engine to try to execute the mapping task that exists in the list of known (to be executed) mapping tasks, and the method returns a Boolean value: when the task is successfully executed or is judged to be unexecutable, the task will be deleted from the list and the method returns True; when the task needs to be shelved, the method returns False;

[0190] 5) It has the function of "asking the reasoning engine": ask(Aq, Sq). (Aq, Sq) is a semantic screening condition proposed by the user, where Aq is a semantic code and Sq is a semantic mode. This method starts the evidence-based reasoning working mode of the reasoning engine and creates a special evidence-based reasoning task to be completed (No, Aq, Sq, Empty, Prg, Chd), where No is a new evidence-based reasoning task number, Prg is a task known but not evaluated, Chd is an empty set, and the method has no return value;

[0191] 6) It has the function of "registering evidence-based tasks": registerConstructAcquisitionTask(Aq, Sq, At). Aq is a semantic code, Sq is a semantic pattern, (Aq, Sq) constitutes the standard form of a semantic screening condition, and At is a semantic code; this method attempts to register an evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) with the reasoning engine, where No is a new evidence-based reasoning task number, Prg is a task that is known but not evaluated, and Chd is an empty set. This method returns the registered task number;

[0192] 7) It has the function of "evaluating evidence-based tasks": evaluateConstructAcquisitionTask(No). No is an evidence-based reasoning task number, and the standard form of the evidence-based reasoning task is (No, Aq, Sq, At, Prg, Chd); if At is empty or the mapping rule named (Aq, At) is a feature extraction rule, the reasoning engine obtains a set of mapping rules whose result semantics may meet the semantic screening condition (Aq, Sq), and for each rule in the set, tries to register a new evidence-based task; if the mapping rule named (Aq, At) is a semantic fusion rule, the reasoning engine obtains the defined feature extraction mapping based on its dependent semantic set, and for each mapping rule, tries to register a new evidence-based task; the method has no return value;

[0193] 8) It has the function of "evaluating the feasibility of external evidence-based reasoning": examineExternalSource(No, Aq, Sq). No is the number of an evidence-based reasoning task, (Aq, Sq) is a semantic screening condition, and this method takes the triple (No, Aq, Sq) as a parameter to initiate an external evidence-based feasibility check. If no external evidence-based interface API is started, the method returns "not evidence-based"; if any external evidence-based interface API is started, it returns "evidence-based";

[0194] 9) Has the function "evaluate new semantics": evaluateNewConstruct(code). code is a newly generated semantic code. The reasoning engine scans the list of known evidence-based reasoning tasks. If code meets the semantic screening conditions of a certain evidence-based reasoning task, it tries to register a new mapping task. The method has no return value.

[0195] 10) It has the function of "finishing the evidence-based task": finishConstructAcquisitionTask(No). No is an evidence-based reasoning task number, and the standard form of the evidence-based reasoning task is (No, Aq, Sq, At, Prg, Chd); the reasoning engine scans the list of known (to be executed) mapping tasks to find out whether there is a mapping task whose mapping rule name is (Aq, At), and the specific semantics of the semantic sequence form of the starting semantics of the mapping task conforms to the pattern specified by Sq; the method attempts to execute all the above-mentioned mapping tasks that meet the conditions, and the method returns a Boolean value; when the mapping task is successfully executed, the method returns True; when the mapping task needs to be shelved, the method returns False;

[0196] 11) Other functions of the inference engine are implemented on the basis of the above method call interface; in actual applications, when some of the above functions are not needed, the unnecessary functions may not be implemented.

[0197] Beneficial effects of the present invention:

[0198] 1. It can represent all logical rules that can be expressed in natural language. The present invention is one of the enabling technologies for realizing the understanding and generation of natural language and strong artificial intelligence;

[0199] 2. It can perform reasoning that is directed towards a specific goal, i.e. evidence-based reasoning; evidence-based reasoning can optimize the use of computing and storage resources and focus on the goal;

[0200] 3. The reasoning system disclosed in the present invention is an open reasoning system for semantics (propositions). This reasoning system can generate new semantics (propositions) rather than just selecting a predefined set of semantics (propositions). BRIEF DESCRIPTION OF THE DRAWINGS

[0201] Figure 1 It is a process schematic diagram of the semantic encoding method based on graph structure of the present invention;

[0202] Figure 2 It is the initial state semantic structure diagram of the evidence-based reasoning calculation process of the present invention;

[0203] Figure 3 It is the semantic structure diagram of the end state of the evidence-based reasoning calculation process of the present invention. DETAILED DESCRIPTION

[0204] The embodiments of the present invention are described in detail below. The following embodiments are exemplary and intended to be used to explain the present invention, but cannot be understood as limiting the present invention. The technical scheme of the present invention is further illustrated by the following specific embodiments:

[0205] In the following detailed description, the following symbols are used to simplify the description:

[0206] (E1, ..., En) represents an n-tuple, and the content represented by each element is determined by the type of the n-tuple;

[0207] <E1,…,En> Represents a sequence with n positions in total, each of which is a semantic code (when the sequence is a semantic sequence, the semantic code is generally represented by a number without quotation marks) or a Java object instance (when the sequence is a Java object instance sequence, the Java object instance is generally represented by the content in "") or other sequence forms (Pq information of the external evidence-based interface);

[0208] [E1, ..., En] represents a set with n elements in total, each of which is a semantic code (when the set is a semantic set, the semantic code is generally represented by a number without quotation marks) or a Java object instance (when the set is a Java object instance set, the Java object instance is generally represented by the content in "") or other two-tuple forms (Map1 and Map2 parameters of semantic fusion rules);

[0209] {“…”, …, “…”} This symbol is followed by a semantic code, or by the (…) symbol, or by the <…> symbol, or by the […] symbol. {…} represents an explanation of the preceding semantic code, n-tuple, sequence, or set using natural language. This explanation is only used to help readers understand the meaning of the preceding semantic code, n-tuple, sequence, or set, and does not participate in the reasoning and calculation process.

[0210] 1. Semantic Representation System

[0211] 1.1 Implementation Method of Semantic Representation System

[0212] 1.1.1 Implementing a semantic representation system using a graph structure

[0213] The graph structure adopts the following specifications:

[0214] 1) It consists of nodes and edges, both of which are marked by semantic codes;

[0215] 2) There is at most one edge with the same label between any two nodes.

[0216] 1.1.2 The semantic representation system implements the following functional methods that can be called

[0217] 1) learnPhysical(javaObj): javaObj is a Java object instance. This method converts a semantic representation system external to the semantic representation system (Java object instance) into a semantic code inside the semantic representation system. The method return value is a semantic code. The specific execution process is based on the graph structure. It searches the graph for a node with the attribute "javaObj" which is a Java object instance javaObj. If so, it returns the tag of the node (denoted as Y). If not, it creates a semantic code Y, creates a node marked by the semantic code Y in the graph, creates an attribute "javaObj" for the node, and sets its value to the Java object instance javaObj.

[0218] 2) getPhysical(code): code is a semantic code. This method converts a semantic code inside a semantic representation system into a semantic code outside the semantic representation system (Java object instance). The method return value is a Java object instance. The specific execution process is based on the graph structure, finds the node marked as code in the graph, and returns the value of its "javaObj" attribute.

[0219] 3) seqToCode(Seq): Seq is a sequence of semantic codes. The method returns a semantic code, and Seq is the semantic sequence form of the semantic code. The semantic sequence of a conversion task is recorded as<A1,A2,…,An-1,An> , where A1…An is the semantic code. The specific execution process is based on the graph structure and returns a sequence that can restore the semantic sequence.<A1,A2,…,An-1,An> The semantic code is denoted as S. The specific execution process adopts the method of suffix extension or prefix extension, starting from the shortest suffix or prefix sequence, and in order from short to long, the code that can restore the semantics of the suffix or prefix sequence of each semantic sequence is obtained in turn, and finally the code that can restore the semantics of the complete semantic sequence is obtained; the implementation steps are as follows:

[0220] i. The shortest suffix sequence of the ideographic sequence is "empty sequence", whose length is 0 and whose semantic code is "0";

[0221] ii. If the code that can restore the semantics of the suffix sequence of the length L of the semantic sequence is J, then based on J and the semantic code of the (L+1)th position from the end of the semantic sequence (denoted as B), a code that can restore the semantics of the suffix sequence of the length (L+1) of the semantic sequence can be obtained. The method is: find the node marked by B, and determine whether there is an edge marked by J that connects the node marked by B to another node; if such an edge exists, obtain the label of the end node of the edge (denoted as I), and I is the code that can restore the semantics of the suffix sequence of the length (L+1) of the semantic sequence; if not This edge creates a new semantics and its code (denoted as I), and creates a node marked as I in the graph, creates an edge marked as J from the node marked as B to the node marked as I, creates an edge marked as "-1" from the node marked as I to the node marked as J, creates an edge marked as "-2" from the node marked as I to the node marked as B, and creates an edge marked as J from the node marked as J to the node marked as I. At this time, I is the code that can restore the semantics of the suffix sequence of length (L+1) of the semantic sequence;

[0222] iii. Based on the above rules i and ii, the length of the suffix sequence can be continuously extended, and finally the complete semantic sequence can be restored.<A1,A2,…,An-1,An> The semantic code S.

[0223] 4) codeToSeq(code): code is a semantic code in the form of a semantic sequence. This method converts a semantic code into its semantic sequence form. The method return value is a semantic sequence composed of semantic codes. The specific execution process is based on the graph structure and performs the following operations:

[0224] i. In the graph structure, find the node marked as code, the specific semantic code of the semantic code as code, that is, the semantic code at the first position of the semantic sequence form of the semantic code as code;

[0225] ii. When it is known that "the specific semantic code of a certain semantic code with code I is the semantic code at the Lth position of the semantic sequence form of the semantic code with code code", the semantic code at the Lth position of the semantic sequence form of the semantic code with code code can be obtained by first finding the node marked with I, and then finding an edge marked with "-2" connecting the node marked with I to another node, the label of this node is the semantic code at the Lth position of the semantic sequence form of the semantic code with code code;

[0226] iii. When it is known that "the code of the specific semantics of a semantics with code I is the code of the semantics at the Lth position in the semantic sequence form of the semantics with code code", a semantics with code J can be obtained, so that "the code of the specific semantics of the semantics with code J is the code of the semantics at the (L+1)th position in the semantic sequence form of the semantics with code code". The method of obtaining the code is to first find the node marked with I, and then find an edge marked with "-1" connecting the node marked with I to another node, the label of which is J; if J is the semantic code "0", then the semantic sequence form of the semantics with code code has a total length of L, that is, there is no semantic code at the (L+1)th position;

[0227] iv. Based on the above rules ii and iii, the semantic code at each position of the semantic sequence form of the semantic code code can be obtained in sequence from front to back, and finally the complete semantic sequence form of the semantic code code is returned.

[0228] 5) identify(instance, paradigm): instance and paradigm are semantic codes. This method finds or generates a semantic code. The paradigm semantics represented by the code is the semantics with the code paradigm. The specific semantics represented by the code includes the semantics represented by instance in the form of a semantic sequence or a single semantic. The specific execution process is based on the graph structure. First, the node marked with paradigm is found in the graph. Then, all edges marked with paradigm starting from the node are found. The labels of the end nodes of these edges are recorded to obtain a set of semantic codes. Then, it is determined whether there is a semantic code marked as X in the set, such that There is an edge marked "-2" in the graph, the starting node of the edge is the node marked X, and the end node is the node marked instance; if X exists, return X; if X does not exist, create a new semantics and its corresponding new semantic code, record the semantic code as X, create a node marked X in the graph, create an edge marked paradigm from the node marked paradigm to the node marked X, create an edge marked "-2" from the node marked X to the node marked instance, create an edge marked "-1" from the node marked X to the node marked paradigm, and then return the semantic code X.

[0229] 6) addInstance(instance, code): instance and code are semantic codes. This method sets the semantic with code instance as the specific semantic of the semantic with code code. The method has no return value. The specific execution process is based on the graph structure. First, find the node marked with code in the graph, and check whether there is an edge marked with "-2" pointing to the node marked with instance from the node marked with code. If the edge exists, it means that the semantic with code instance is already the specific semantic of the semantic with code code. If the edge does not exist, create an edge marked with "-2" from the node marked with code to the node marked with instance.

[0230] 7) getParadigm(code): code is a semantic code. This method returns the code of the paradigm semantics of the semantics of code. The method return value is a semantic code. The specific execution process is based on the graph structure. First, find the node marked with code in the graph, then find the edge marked with "-1" from the node, and then return the label of the end node of the edge.

[0231] 8) getInstance(code): code is a semantic code. This method returns the specific semantic code of the semantic code whose code is code. The method return value is one or more semantic codes. The specific execution process is based on the graph structure. First, find the node marked with code in the graph, then find all the edges marked with "-2" starting from the node, record the labels of the end nodes of these edges, obtain a set of semantic codes, and then return the set.

[0232] 9)map(code1, code2): code1 and code2 are two semantic codes; when the paradigm semantics of the two semantics coded as code1 and code2 are different, the semantics coded as code2 can be obtained from the semantics coded as code1 through a certain mapping rule T, and then the semantics coded as code1 can be obtained from the semantics coded as code2 through the inverse of the mapping rule T; when the paradigm semantics of the two semantics coded as code1 and code2 are the same, this method merges the two semantics coded as code1 and code2, and the code of the merged semantics is code1; the method has no return value; the specific execution process is based on the graph structure, and the following operations are performed:

[0233] i. Find the paradigm semantic codes of the two semantics with codes code1 and code2: first find the node marked with code1 in the graph, then query the edge marked with "-1" from the node marked with code1, find the end node of the edge, if the node is marked with A, A is the paradigm semantic code of the semantics represented by code1; then find the node marked with code2 in the graph, then query the edge marked with "-1" from the node marked with code2, find the end node of the edge, if the node is marked with B, B is the paradigm semantic code of the semantics represented by code2;

[0234] ii. If the paradigm semantics of the two semantics coded as code1 and code2 are different, that is, A and B are different, then starting from the node marked by code1, check whether there is an edge marked by B to the node marked by code2. If this edge exists, it means that there is a mapping rule that allows the semantics coded with code1 to be converted into the semantics coded with code2. If this edge does not exist, create an edge marked by B, starting from the point marked by code1 and connecting to the node marked by code2; then starting from the node marked by code2, check whether there is an edge marked by A to the node marked by code1. If this edge exists, it means that there is an inverse of the mapping rule that allows the semantics coded with code2 to be converted into the semantics coded with code1. If this edge does not exist, create an edge marked by A, starting from the node marked by code2 and connecting to the node marked by code1;

[0235] iii. If the paradigm semantics of the two semantics with codes code1 and code2 are the same, that is, A and B are the same, then perform semantic fusion operation; the specific steps are as follows: update all edges with nodes marked by code2 as starting nodes, set their starting nodes to nodes marked by code1, update all edges reaching nodes marked by code2, set their end nodes to nodes marked by code1, update all edges marked by code2, set them to be marked by code1, then delete nodes marked by code2, and finally remove redundant edges (only one edge with the same mark and direction is retained between two nodes).

[0236] 10) Implement the application interface translate(code, paradigm): code is a semantic code; if there is a mapping rule (denoted as T), the domain semantics of T is the paradigm semantics of the semantics with code code, the range semantics of T is the semantics with code paradigm, and the semantics that can be obtained from the semantics with code code through the mapping rule T have been previously recorded through the map function of item 9) above, then this method returns one or a set of semantic codes that can be obtained from the semantics with code code through the mapping rule T, otherwise the method returns null; the specific execution process is based on the graph structure, first find the node marked with code in the graph, and query whether there is at least one edge marked with paradigm pointing to another node from the node; if the edge exists, then find all the edges marked with paradigm from the node, record the labels of the end nodes of these edges, obtain a set of semantic codes, and then return the set; if the edge does not exist, then return null.

[0237] 11) Implement the application interface unMap(code1, code2): code1 and code2 are two semantic codes; when the paradigm semantics of the two semantics with codes code1 and code2 are different, this method confirms that the two semantics with codes code1 and code2 do not have a mapping relationship, and at the same time, the semantic with code code1 cannot be obtained from the semantic with code code2 through the inverse of mapping rule T (i.e., T'); when the paradigm semantics of the two semantics with codes code1 and code2 are the same, this method is the same as forget in item 12) below; this method has no return value; the specific execution process is based on the graph structure, and the following operations are performed:

[0238] i. Find the paradigm semantic codes of the two semantics with codes code1 and code2: first find the node marked with code1 in the graph, then query the edge marked with "-1" from the node marked with code1, find the end node of the edge, if the node is marked with A, A is the paradigm semantic code of the semantics represented by code1; then find the node marked with code2 in the graph, then query the edge marked with "-1" from the node marked with code2, find the end node of the edge, if the node is marked with B, B is the paradigm semantic code of the semantics represented by code2;

[0239] ii. If the semantics of the two semantics with codes code1 and code2 are different, that is, A and B are different, then delete the edge connecting the node marked by code1 to the node marked by code2, and delete the edge connecting the node marked by code2 to the node marked by code1;

[0240] iii. If the semantics of the two semantic forms of code1 and code2 are the same, that is, A and B are the same, code1 and code2 are the same node, the operation performed by unMap(code1, code2) is equivalent to the operation of forget(code) in item 12) below;

[0241] 12) Implement the application program interface forget(code): code is a semantic code. This method deletes the semantic with code code and the relationship between the semantic and all other semantics. The method has no return value. The specific execution process is based on the graph structure, finding the node marked with code in the graph, deleting all edges with the node marked with code as the starting node, deleting all edges with the node marked with code as the ending node, deleting all edges marked with code, and then deleting the node marked with code.

[0242] 1.2 Use Cases of Semantic Representation Systems

[0243] 1.2.1 Case Description of Implementation Example

[0244] The specific situations represented by the semantic representation system are as follows:

[0245] "Two", "binary", "system", "ten", "1", and "0" are characters, which all have "physical" semantics; there is a semantics of "binary" and a semantics of "decimal"; "binary" and "decimal" can be converted to each other, and the Java character sequence <"1", "0", "1", "0"> under "binary" and the Java character sequence <"1", "0"> under "decimal" have the same meaning (value ten).

[0246] Objectives of this implementation case:

[0247] 1) Create a graph structure corresponding to the above-mentioned embodiment case description, and the final result is to create Figure 1 The data structure of Figure 1 This is a process diagram of the semantic encoding method based on graph structure of the present invention. However, when constructing the relationship of "1010 in binary semantics is equivalent to 10 in decimal semantics", the user mistakenly constructs the relationship of "1010 in decimal semantics is equivalent to 10 in binary semantics", so the user needs to delete the wrong relationship first and then construct the correct relationship.

[0248] 2) Obtain the semantics of the Java character sequence <"1", "0", "1", "0"> encoded in the "binary" context, convert it into a semantics with the same meaning encoded in the "decimal" context, obtain the semantic sequence form of the semantics, and convert it into a Java character sequence.

[0249] 3) Another user generates a semantic sequence in the form of "Binary" (its semantic code is "99"). The user then requests that the semantic code be merged into the "binary" semantic (i.e., "Binary" and "binary" have the same meaning), and confirms whether the operation is successful through the getParadigm application program interface.

[0250] 1.2.2 Specific steps to implement the example in 1.2.1 using the semantic representation system

[0251] The user first calls the function method of the semantic representation system through the following steps to create Figure 1 The data structure:

[0252] 1) learnPhysical("Two"): Convert the semantics outside a semantic representation system (Java object instance "Two") into a semantic code inside the semantic representation system. The return value of the method is the semantic code "1". This step first checks if there is a node with the "JavaObj" attribute being the Java object instance "Two". If so, it returns the label of that node. At this time, there is no node in the graph with the "JavaObj" attribute being the Java object instance "Two", so a semantic code "1" is created, a node labeled with the semantic code "1" is created in the graph, an attribute "JavaObj" is created for this node, and its value is set to the Java object instance "Two". At this point, the semantic code "1" represents a "physical" semantics: "Two".

[0253] 2) learnPhysical("Enter"): Convert the semantics outside a semantic representation system (Java object instance "Enter") into a semantic code inside the semantic representation system. The return value of the method is the semantic code "2". At this point, the semantic code "2" represents a "physical" semantics: "Enter".

[0254] 3) learnPhysical("System"): Convert the semantics outside a semantic representation system (Java object instance "System") into a semantic code inside the semantic representation system. The return value of the method is the semantic code "3". At this point, the semantic code "3" represents a "physical" semantics: "System".

[0255] 4) learnPhysical("Ten"): Convert the semantics outside a semantic representation system (Java object instance "Ten") into a semantic code inside the semantic representation system. The return value of the method is the semantic code "4". At this point, the semantic code "4" represents a "physical" semantics: "Ten".

[0256] 5) learnPhysical("One"): Convert the semantics outside a semantic representation system (Java object instance "One") into a semantic code inside the semantic representation system. The return value of the method is the semantic code "5". At this point, the semantic code "5" represents a "physical" semantics: "One".

[0257] 6) learnPhysical("Zero"): Convert the semantics outside a semantic representation system (Java object instance "Zero") into a semantic code inside the semantic representation system. The return value of the method is the semantic code "6". At this point, the semantic code "6" represents a "physical" semantics: "Zero".

[0258] 7) seqToCode(<1, 2, 3>): Convert the ideographic sequence <1, 2, 3> into a semantic code, and the return value of the method is the semantic code "10"; As can be seen from the previous steps 1)-3), the semantic code of the Java object instance "two" is "1", the semantic code of the Java object instance "binary" is "2", and the semantic code of the Java object instance "system" is "3". Therefore, the ideographic sequence of the Java character sequence <"two", "binary", "system"> is <1, 2, 3>; The implementation steps are as follows:

[0259] i. The shortest suffix sequence of this ideographic sequence is the "empty sequence", its length is 0, and its semantic code is "0";

[0260] ii. Since the semantic code that can restore the semantic of the suffix sequence with a length of 0 of this ideographic sequence is "0", then according to the semantic code "0" and the semantic code at the penultimate position of the ideographic sequence (i.e., "3"), the semantic code of the suffix sequence with a length of 1 that can restore the semantic of this ideographic sequence can be obtained. The method is: find the node marked by "3", and judge whether there is an edge marked by "0" starting from the node marked by "3" and connecting to another node; Since there is no such edge in the graph, create a new semantic and its code (denoted as "7"), and create a node marked by "7" in the graph, create an edge marked by "0" starting from the node marked by "3" and connecting to the node marked by "7", create an edge marked by "-1" starting from the node marked by "7" and connecting to the node marked by "0", create an edge marked by "-2" starting from the node marked by "7" and connecting to the node marked by "3", create an edge marked by "0" starting from the node marked by "0" and connecting to the node marked by "7". At this time, "7" is the semantic code of the suffix sequence with a length of 1 (i.e., <3>) that can restore the semantic of this ideographic sequence;

[0261] iii. Since the semantic code for the suffix sequence of length 1 that can restore the semantic meaning of this ideographic sequence is "7", the semantic code for the suffix sequence of length 2 that can restore the semantic meaning of this ideographic sequence can be obtained based on the semantic code "7" and the semantic code at the penultimate position of the ideographic sequence (i.e., "2"). The method is as follows: Locate the node marked by "2" and determine whether there is an edge marked by "7" starting from the node marked by "2" and connecting to another node. Since such an edge does not exist in the graph, create a new semantic meaning and its code (denoted as "8"), create a node marked by "8" in the graph, create an edge marked by "7" starting from the node marked by "2" and connecting to the node marked by "8", create an edge marked by "-1" starting from the node marked by "8" and connecting to the node marked by "7", create an edge marked by "-2" starting from the node marked by "8" and connecting to the node marked by "2", create an edge marked by "7" starting from the node marked by "7" and connecting to the node marked by "8". At this time, "8" is the semantic code for the suffix sequence of length 2 that can restore the semantic meaning of this ideographic sequence (i.e., <2, 3>).

[0262] iv. Since the semantic code for the suffix sequence of length 2 that can restore the semantic meaning of this ideographic sequence is "8", the semantic code for the suffix sequence of length 3 that can restore the semantic meaning of this ideographic sequence can be obtained based on the semantic code "8" and the semantic code at the third-to-last position of the ideographic sequence (i.e., "1"). The method is as follows: Locate the node marked by "1" and determine whether there is an edge marked by "8" starting from the node marked by "1" and connecting to another node. Since such an edge does not exist in the graph, create a new semantic meaning and its code (denoted as "9"), create a node marked by "9" in the graph, create an edge marked by "8" starting from the node marked by "1" and connecting to the node marked by "9", create an edge marked by "-1" starting from the node marked by "9" and connecting to the node marked by "8", create an edge marked by "-2" starting from the node marked by "9" and connecting to the node marked by "1", create an edge marked by "8" starting from the node marked by "8" and connecting to the node marked by "9". At this time, "9" is the semantic code for the suffix sequence of length 2 that can restore the semantic meaning of this ideographic sequence (i.e., <1, 2, 3>).

[0263] v. At this time, the length of the suffix sequence is equal to the complete length of the ideographic sequence. Therefore, the semantic code for the complete ideographic sequence <1, 2, 3> {"binary"} is "9".

[0264] 8) identify(9, 0): Find or generate a semantic code whose canonical semantics represented is the semantics with code "0", and the specific semantics it represents includes the semantics in the form of a semantic sequence represented by "9" or a single semantics. The return value of the method is the semantic code "10"; in this step, first find the node marked with "0" in the graph, then find all the edges marked with "0" starting from this node, record the marks of the end nodes of these edges to obtain a set of semantic codes; then determine whether there is a semantic code denoted as X in this set such that there is an edge marked with "-2" in the graph, the start node of this edge is the node marked with X, and the end node is the node marked with "9"; since the semantic code X does not exist yet, create a new semantics and its corresponding new semantic code, denote this semantic code as "10", create a node marked with "10" in the graph, create an edge marked with "0" starting from the node marked with "0" and connecting to the node marked with "10", create an edge marked with "-2" starting from the node marked with "10" and connecting to the node marked with "9", and then create an edge marked with "-1" starting from the node marked with "10" and connecting to the node marked with "0", and then return the semantic code "10". At this time, the semantics of the semantic code "10" can be understood as "binary".

[0265] 9) seqToCode(<4, 2, 3>): Convert the semantic sequence <4, 2, 3> into a semantic code. The return value of the method is the semantic code "11"; from the previous steps 2)-4), it can be known that the semantic code of the Java object instance "十" is "4", the semantic code of the Java object instance "进" is "2", and the semantic code of the Java object instance "制" is "3". Therefore, the semantic sequence of the Java character sequence <"十", "进", "制"> is <4, 2, 3>; the semantic code that can restore the complete semantic sequence <4, 2, 3>{"十", "进", "制"} is "11".

[0266] 10) identify(11, 0): Find or generate a semantic code whose canonical semantics represented is the semantics with code "0", and the specific semantics it represents includes the semantics in the form of a semantic sequence represented by "11" or a single semantics. The return value of the method is the semantic code "12"; at this time, the semantics of the semantic code "12" can be understood as "decimal".

[0267] 11)seqToCode(<5,6,5,6>): Convert the semantic sequence <5,6,5,6> into a semantic code. The method return value is the semantic code "16". From the above steps 5)-6), we can know that the semantic code of the Java character "1" is "5", and the semantic code of the Java character "0" is "6". Therefore, the semantic sequence of the Java character sequence <"1", "0", "1", "0"> is <5,6,5,6>. The semantic code of the complete semantic sequence <5,6,5,6> {"1", "0", "1", "0"} can be restored to "16".

[0268] 12)seqToCode(<5,6>): Convert the semantic sequence <5,6> to a semantic code. The method returns the semantic code "14". From the above steps 5)-6), we can know that the semantic code of the Java character "1" is "5" and the semantic code of the Java character "0" is "6". Therefore, the semantic sequence of the Java character sequence <"1", "0"> is <5,6>. The implementation steps are as follows:

[0269] i. The shortest suffix sequence of the ideographic sequence is "empty sequence", whose length is 0 and whose semantic code is "0";

[0270] ii. Since the semantic code of the suffix sequence of length 0 that can be restored to the semantic sequence is "0", the semantic code of the suffix sequence of length 1 that can be restored to the semantic sequence can be obtained based on the semantic code "0" and the semantic code of the penultimate position of the semantic sequence (i.e., "6"), and the method is: find the node marked by "6", and determine whether there is an edge marked by "0" connecting from the node marked by "6" to another node; since the edge exists in the graph, the mark (semantic code) "13" of the end node of the edge is obtained, and the mark is the suffix sequence of length 1 that can be restored to the semantic sequence (i.e., <6> )'s semantic code ("13");

[0271] iii. Since the code that can restore the semantics of the suffix sequence of length 1 of the semantic sequence is "13", the semantic code of the suffix sequence of length 2 of the semantic sequence can be obtained based on the semantic code "13" and the semantic code of the second-to-last position of the semantic sequence (i.e., "5"), and the method is: find the node marked by "5", and determine whether there is an edge marked by "13" connecting from the node marked by "5" to another node; since the edge exists in the graph, the mark (semantic code) "14" of the end node of the edge is obtained, and the mark is the code ("14") that can restore the semantics of the suffix sequence of length 2 of the semantic sequence (i.e., <5,6>);

[0272] iv. At this time, the length of the suffix sequence is equal to the complete length of the ideographic sequence. Therefore, the semantic code of the complete ideographic sequence <5,6> can be restored as "14".

[0273] 13)identify(16,12): find or generate a semantic code, the paradigmatic semantics of the semantics it represents is the semantics with code "12", the specific semantics of the semantics it represents includes the semantics represented by "16" in the form of a semantic sequence or a single semantic, and the method return value is the semantic code "19"; at this time, in the "decimal" context, the code for the semantics encoded by the Java character sequence <"1","0","1","0"> is "19".

[0274] 14)identify(14,10): find or generate a semantic code, the paradigmatic semantics of the semantics it represents is the semantics with code "10", the specific semantics of the semantics it represents includes the semantics represented by "14" in the form of a semantic sequence or a single semantic, and the method return value is the semantic code "20"; at this time, in the "binary" context, the code for the semantics encoded by the Java character sequence <"1", "0"> is "20".

[0275] 15)map(19,20): When the paradigm semantics of two semantics coded as "19" and "20" are different, the semantics coded as "19" can be obtained from the semantics coded as "20" through a certain mapping rule T. In this case, the semantics coded as "20" can be obtained from the semantics coded as "19" through the inverse of the mapping rule T. This method has no return value. The implementation steps are as follows:

[0276] i. Find the paradigm semantic codes of the two semantics with codes "19" and "20": first find the node marked with "19" in the graph, then query the edge marked with "-1" from the node marked with "19", find the end node of the edge, and the node marked with "12" is the paradigm semantic code of the semantics represented by "19"; then find the node marked with "20" in the graph, then query the edge marked with "-1" from the node marked with "20", find the end node of the edge, and the node marked with "10" is the paradigm semantic code of the semantics represented by "20";

[0277] ii. Since the paradigm semantics of the two semantic codes “19” and “20” are different, that is, “12” and “10” are different, starting from the node marked by “19”, check whether there is an edge marked by “10” to reach the node marked by “20”. Since such an edge does not exist in the graph, create an edge marked by “10” from the point marked by “19” to the node marked by “20”; then, starting from the node marked by “20”, check whether there is an edge marked by “12” to reach the node marked by “19”. Since such an edge does not exist in the graph, create an edge marked by “12” from the node marked by “20” to connect to the node marked by “19”.

[0278] The user has mistakenly constructed the relationship that "1010 in decimal semantics is equivalent to 10 in binary semantics", so the wrong relationship must be deleted first, and then a new correct relationship must be constructed:

[0279] 16) unMap(19,20): When the paradigm semantics of two semantics with codes "19" and "20" are different, this method confirms that the two semantics with codes "19" and "20" do not have a mapping relationship, and it is inevitable that the semantic with code "19" cannot be obtained from the semantic with code "20" through the inverse of mapping rule T (i.e. T'); this method has no return value; the specific execution process is based on the graph structure, and the following operations are performed:

[0280] i. Find the paradigm semantic codes of the two semantics with codes "19" and "20": first find the node marked with "19" in the graph, then query the edge marked with "-1" from the node marked with "19", find the end node of the edge, and the node marked with "12" is the paradigm semantic code of the semantics represented by "19"; then find the node marked with "20" in the graph, then query the edge marked with "-1" from the node marked with "20", find the end node of the edge, and the node marked with "10" is the paradigm semantic code of the semantics represented by "20";

[0281] ii. Since the two semantic codes “19” and “20” have different paradigm semantics, that is, “12” and “10” are different, delete the edge connecting from the node marked with “19” to the node marked with “20”, and delete the edge connecting from the node marked with “20” to the node marked with “19”.

[0282] 17) forget(19): This method deletes the semantics with code "19" and the relationship between this semantics and all other semantics. The method has no return value. This step first finds the node marked with "19" in the graph, deletes all edges with the node marked with "19" as the starting node, deletes all edges with the node marked with "19" as the ending node, deletes all edges marked with "19", and then deletes the node marked with "19".

[0283] 18) forget(20): This method deletes the semantics with code "20" and the relationship between this semantics and all other semantics. The method has no return value.

[0284] 19)identify(14,12): find or generate a semantic code, the paradigmatic semantics of the semantics it represents is the semantics with code "12", the specific semantics of the semantics it represents includes the semantics represented by "14" in the form of a semantic sequence or a single semantic, and the method return value is the semantic code "18"; at this time, in the "decimal" context, the code for the semantics encoded by the Java character sequence <"1", "0"> is "18".

[0285] 20)identify(16,10): find or generate a semantic code, the paradigmatic semantics of the semantics it represents is the semantics coded as "10", the specific semantics of the semantics it represents includes the semantics represented by "16" in the form of a semantic sequence or a single semantic, and the method return value is the semantic code "17"; at this time, in the "binary" context, the code for the semantics encoded by the Java character sequence <"1", "0", "1", "0"> is "17".

[0286] 21)map(17,18): When the paradigm semantics of two semantics coded as "17" and "18" are different, the semantics coded as "18" can be obtained from the semantics coded as "17" through a certain mapping rule T. At this time, the semantics coded as "17" can be obtained from the semantics coded as "18" through the inverse of the mapping rule T. The method has no return value.

[0287] 22) From the above steps 19)-21), it can be seen that the Java character sequence <"1", "0", "1", "0"> (semantic code "17") in "binary" and the Java character sequence <"1", "0"> (semantic code "18") in "decimal" have the same meaning.

[0288] The user then obtains the semantics of the Java character sequence <"1", "0", "1", "0"> encoded in the "binary" context through the following steps, converts it into a semantics with the same meaning encoded in the "decimal" context, obtains the semantic sequence encoded by the semantics, and converts it into a Java character sequence:

[0289] 23)Translate(17,12): Check whether there is a mapping rule (denoted as T), the domain semantics of T is the paradigm semantics of the semantics with code "17", the range semantics of T is the semantics with code "12", and the semantics of the semantics with code "17" that can be obtained through the mapping rule T has been previously recorded through the map function, and the method return value is the semantic code "18"; from the above step 20), it can be seen that the semantics of the Java character sequence <"1", "0", "1", "0"> in the "binary" context is the semantics represented by "17", and from the above step 10), it can be seen that the semantics representing the "decimal" context is the semantics represented by "12", so Therefore, this method converts the semantics encoded in the "binary" context of the Java character sequence <"1", "0", "1", "0"> into semantics in the "decimal" context, and the implementation steps are as follows: first, find the node marked with "17" in the graph, and query whether there is at least one edge marked with "12" pointing to another node from the node; since there is an edge marked with "12" starting from the node marked with "17" in the graph, the label "18" of the end node of the edge is obtained, and then the semantic code "18" is returned; at this time, there is a semantic code "18", and the paradigm semantics of the semantics it represents is the semantics represented by "12", which has the same meaning as the semantics represented by "17".

[0290] 24)getInstance(18): Returns the specific semantic code of the semantic code "18", and the method return value is the semantic code "14". This step first finds the node marked with "18" in the graph, and then finds all the edges marked with "-2" starting from this node. Since there is only one edge that meets the conditions in the graph, the mark "14" of the end node of the edge is recorded, and then the semantic code "14" is returned.

[0291] 25)codeToSeq(14): Convert the semantic code "14" to its semantic sequence form. The method return value is the semantic sequence <5,6>. The implementation steps are as follows:

[0292] i. In the graph structure, find the node marked as "14", the specific semantic code of the semantic code "14", that is, the semantic code of the first position of the semantic sequence form of the semantic code "14";

[0293] ii. When it is known that the specific meaning of a certain meaning (code “14”) is the meaning at the first position of the meaning sequence form of the meaning code “14”, the code of the meaning at the first position of the meaning sequence form of the meaning code “14” can be obtained by first finding the node marked with “14”, and then finding an edge marked with “-2” connecting the node marked with “14” to another node, and the mark (semantic code) “5” of this node is the semantic code at the first position of the meaning sequence form of the meaning code “14”;

[0294] iii. When it is known that the specific meaning of a certain meaning (code “14”) is the meaning at the first position of the meaning sequence form of the meaning code “14”, a meaning (code “13”) can be obtained, whose specific meaning is the meaning at the second position of the meaning sequence form of the meaning code “14”. The method of obtaining the meaning is to first find the node marked with “14”, and then find an edge marked with “-1” starting from the node marked with “14” and connecting to another node. The tag (semantic code) of the node is “13”, and the specific meaning of the meaning it represents is the meaning at the second position of the meaning sequence form of the meaning code “14”;

[0295] iv. When it is known that the specific meaning of a certain meaning (code “13”) is the meaning at the second position of the meaning sequence form of the meaning code “14”, the code of the meaning at the second position of the meaning sequence form of the meaning code “14” can be obtained by first finding the node marked with “13”, and then finding an edge marked with “-2” connecting the node marked with “13” to another node, and the mark (semantic code) “6” of this node is the semantic code at the second position of the meaning sequence form of the meaning code “14”;

[0296] v. When it is known that the specific meaning of a certain meaning (code "13") is the meaning at the second position of the meaning sequence form of the meaning code "14", a meaning (code "0") can be obtained, whose specific meaning is the meaning at the third position of the meaning sequence form of the meaning code "14". The method of obtaining it is to first find the node marked with "13", and then find an edge marked with "-1" connecting the node marked with "13" to another node, the label (semantic code) of the node is "0", and the specific meaning of the meaning it represents is the meaning at the third position of the meaning sequence form of the meaning code "14";

[0297] vi. When it is known that the specific meaning of the meaning with code “0” is the meaning at the third position of the meaning sequence form of the meaning with code “14”, it means that the total length of the meaning sequence form of the meaning with code “14” is 2;

[0298] vii. From the above steps i-vi, it can be obtained that the semantics of the code "14" has the semantic sequence form <5,6>.

[0299] 26)getPhysical(5): Converts the semantic code "5" to a semantic representation system external to the system (Java object instance), and the method return value is the Java object instance "1"; this step finds the node marked "5" in the graph and returns the value of its "javaObj" attribute "1".

[0300] 27)getPhysical(6): Converts the semantic code "6" to a semantic representation system external to the system (Java object instance), and the method return value is the Java object instance "0"; this step finds the node marked "6" in the graph and returns the value of its "javaObj" attribute "0".

[0301] 28) From the above steps 23)-27), it can be seen that the semantics of the Java character sequence <"1", "0", "1", "0"> encoded in the "binary" context (code is "17"), if it is converted into a semantics with the semantics of "decimal" (code is "18"), then the specific semantics of the semantic sequence form of the semantics (<5,6>) can be converted into the Java character sequence <"1", "0">.

[0302] At this time, another user created a semantic code "99", which represents the Java character sequence <"B", "i", "n", "a", "r", "y">, and this semantic can be merged into the "binary" semantic:

[0303] 29)addInstance(99,10): This method sets the semantics with code "99" as the specific semantics of the semantics with code "10". The method has no return value. This step first finds the node marked with "10" in the graph, and checks whether there is an edge marked with "-2" pointing to the node marked with "99" from the node marked with "10". Since this edge does not exist, an edge marked with "-2" is created from the node marked with "10" to the node marked with "99".

[0304] 30)getParadigm(99): This method returns the code of the paradigm semantics with the code "99", and the method return value is the semantic code "10"; this step first finds the node marked with "99" in the graph, then finds the edge marked with "-1" starting from this node, and then returns the mark (semantic code) "10" of the end node of the edge.

[0305] 31) From the above steps 29)-30), it can be seen that the semantics with the semantic sequence form "Binary" (semantic code "99") can be merged into the "binary" semantics (semantic code "10").

[0306] 2. Reasoning Engine (Evidence-Based Working Method)

[0307] 2.1 Inference Engine Implementation Method

[0308] 2.1.1 Implementing the data storage function of the inference engine

[0309] The inference engine uses the specific implementation of the semantic representation system described in Section 1.1.2 to store data.

[0310] 2.1.2 The inference engine implements the following functional methods that can be called

[0311] 1) Implement the application interface setFeatureExtractionRule(Ed, Er): (Ed, Er) is the name of a feature extraction rule, where Ed is the semantic code of the domain semantics of the feature extraction rule, and Er is the semantic code of the value domain semantics of the feature extraction rule. This method defines and records (or finds) a feature extraction rule in the inference engine, and the method has no return value; the specific steps are: first, query whether there is a record of a mapping rule named (Ed, Er) inside the inference engine. If the record exists, the inference engine does not need to record the feature extraction rule; if the record does not exist, define a new feature extraction rule, denoted as (Ed, Er), and record the mapping rule in the inference engine.

[0312] 2) Implement the application interface setConstructFusionRule(Ad, Ar, Dep, Api, Par, Map1, Map2): (Ad, Ar, Dep, Api, Par, Map1, Map2) is a canonical form of a semantic fusion rule, where Ad is the semantic code of the domain semantics of the semantic fusion rule, Ar is the semantic code of the range semantics of the semantic fusion rule, (Ad, Ar) is the name of the semantic fusion rule, Dep is the set of dependent semantics of the semantic fusion rule, Api is an application interface that can be called by the inference engine, and Par is indicated by the canonical form of the semantic fusion rule. Parameters passed to the application program interface, Map1 and Map2 are a set of correspondences of sequence positions; this method defines and records (or finds) a semantic fusion rule in the inference engine, and the method has no return value; the specific steps are: first, query whether there is a record of a mapping rule named (Ad, Ar, Dep, Api, Par, Map1, Map2) inside the inference engine; if the record exists, the inference engine does not need to record the semantic fusion rule; if the record does not exist, define a new semantic fusion rule, recorded as (Ad, Ar, Dep, Api, Par, Map1, Map2), and record the mapping rule in the inference engine.

[0313] 3) Implement the application interface registerMapTask(D, R, A, Dep): This method attempts to register a mapping task with the reasoning engine, and the method has no return value; (D, R) is the name of a mapping rule, A is the starting semantics of the mapping task, and Dep is the numbered set of evidence-based reasoning tasks on which the mapping task depends; the core feature of the mapping task is the triple (D, R, A); the specific steps are: the reasoning engine first queries the list of known (to be executed) mapping tasks to see whether there is a record whose core feature is the triple (D, R, A); if the record exists, the reasoning engine does not register the mapping task; if the record does not exist, the reasoning engine adds a record of the mapping task named (D, R, A, Dep) to the list of known (to be executed) mapping tasks.

[0314] 4) Implement the application program interface executeMapTask(D, R, A): (D, R) is the name of a mapping rule, A is the starting semantics of the mapping task, and the standard form of the mapping task quadruple is (D, R, A, Dep); this method allows the inference engine to try to execute a mapping task registered in the list of known (to be executed) mapping tasks, and the method returns a Boolean value; the specific execution process is as follows:

[0315] i. If (D, R) is a feature extraction rule, perform the following operations:

[0316] a) Since the Dep set of the mapping task is an empty set, the inference engine immediately executes the following steps b)-f);

[0317] b) If R is empty, the mapping task is a special feature extraction task, which only outputs its starting meaning and feeds it back to the user of the inference engine; go to step f);

[0318] c) According to the standard writing of the feature extraction rule (D, R), based on the semantic code A, a semantic code [R1, ..., Rn] of a specific semantic in the form of a semantic sequence corresponding to its characteristic semantics is generated, and one of the semantic codes is recorded as Ri;

[0319] d) identify(Ri, R): confirm the existence (i.e. find or generate) of a specific semantics containing the semantics represented by the semantic code Ri and the paradigm semantics represented by the semantics represented by the semantic code R. The method return value is the semantic code Fi. If Fi is a newly generated semantic code, take Fi as the parameter and execute the evaluateNewConstruct operation in item 9) below:

[0320] e) map(A, Fi): confirm that the semantic representation system records the mapping relationship between the semantics represented by A and the semantics represented by Fi;

[0321] f) In the list of known (to be executed) mapping tasks, delete the mapping task record (D, R, A, Dep), and the method returns True;

[0322] ii. If (D, R) is a semantic fusion rule, perform the following operations:

[0323] a) When the Dep set is an empty set or each evidence-based reasoning task in the Dep set enters the "task completed" state, the mapping task is executed immediately, that is, the reasoning engine immediately executes the following steps b)-f) and deletes the (D, R, A, Dep) record in the list of known (to be executed) mapping tasks, and the method returns True; when there is an evidence-based reasoning task in the Dep set whose progress is "task unexecutable", the mapping task cannot be executed, and the reasoning engine deletes the (D, R, A, Dep) record in the list of known (to be executed) mapping tasks, and the method returns True immediately; when the Dep set is in other situations, the reasoning engine puts the mapping task on hold, and the method returns False immediately;

[0324] b) Instruct the semantic representation system to forget the previous execution result of the same semantic fusion task; the steps are as follows:

[0325] ① translate(A, R): find out whether there is a mapping rule (denoted as T) such that the domain semantics of T is the paradigm semantics of the semantics coded as A, the range semantics of T is the semantics coded as R, and the semantics of the semantics coded as A that can be obtained through the mapping rule T have been recorded by the map function before. The method return value is denoted as [B1, ..., Bn], and an element of the set is denoted as Bi;

[0326] ②unMap(A, Bi): indicates that the system forgets the mapping relationship between each pair (A, Bi);

[0327] c) Obtain the parameter semantic set L of the semantic fusion task by:

[0328] ① According to the Dep parameter of the semantic fusion rule in the standard form (D, R, Dep, Api, Par, Map1, Map2), the dependent semantic set of the rule is obtained, which is recorded as [P1, ..., Pn], and one of the dependent semantics is recorded as Pi;

[0329] ② translate(A, Pi): For each Pi, find out whether there is a mapping rule (denoted as T) such that the domain semantics of T is the paradigm semantics of the semantics coded as A, the range semantics of T is the semantics coded as Pi, and the semantics of the semantics coded as A that can be obtained through the mapping rule T have been recorded by the map function before. All semantic codes returned by the (A, Pi) method are merged into a set to obtain the parameter semantic set L of the semantic fusion task;

[0330] d) According to the standard writing of semantic fusion rules (D, R, Dep, Api, Par, Map1, Map2), use the parameter semantic set L and Par of the semantic fusion task as input parameters, call the application interface Api, execute the Api of the external evidence-based interface and return a set of semantic sequences [Ra1, ..., Ran]; according to the standard writing of semantic fusion rule parameters Map1 and Map2, according to the specific semantics of the semantic sequence form of the starting semantic A and each semantic sequence in the Api output semantic sequence set [Ra1, ..., Ran], calculate the semantic code at each position of the semantic sequence form of each semantic in the specific semantic set [Rc1, ..., Rcn] of the semantic sequence form of the result semantic, and record a semantic code in [Rc1, ..., Rcn] as Rci;

[0331] e) identify(Rci, R): confirm the existence (i.e. find or generate) of a specific semantics containing the semantics represented by the semantic code Rci and the paradigm semantics represented by the semantic code R. The method return value is the semantic code Ci; if Ci is a newly generated semantic code, then take Ci as the parameter and execute the evaluateNewConstruct operation in item 9) below;

[0332] f)map(A, Ci): confirms that the semantic representation system records the mapping relationship between the semantics represented by semantic code A and the semantics represented by semantic code Ci.

[0333] 5) Implement the application program interface ask(Aq, Sq): (Aq, Sq) is a semantic screening condition proposed by the user, where Aq is a semantic code and Sq is a semantic pattern. This method attempts to register a special evidence-based reasoning task to be completed (No, Aq, Sq, empty, Prg, Chd) with the reasoning engine, where No is a new evidence-based reasoning task number, Prg is "task known but not evaluated", Chd is an empty set, and the method has no return value; the specific execution process is as follows:

[0334] i. The reasoning engine searches the list of known evidence-based reasoning tasks to check whether there is a known evidence-based reasoning task, denoted as X1, whose canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), such that Aq is the same as Aq1, Sq is the same as Sq1, and empty is the same as At1; if it exists, then the evidence-based task (No, Aq, Sq, empty, Prg, Chd) is not registered; if it does not exist, then (No, Aq, Sq, empty, Prg, Chd) is a new evidence-based reasoning task, and the operation described in step ii below is performed;

[0335] ii. The reasoning engine adds a record of an evidence-based reasoning task to the list of known evidence-based reasoning tasks: (No, Aq, Sq, Empty, Prg, Chd); since the evidence-based reasoning task is a new one, the reasoning engine scans all known semantics to find out whether there is a set of semantics whose paradigm semantics are the semantics represented by Aq, which have specific semantics in the form of semantic sequences, and whose specific semantics in the form of semantic sequences conform to the semantic pattern specified by Sq; if such a set of semantics that meets the conditions can be found, the reasoning engine regards this set of semantics as newly generated semantics relative to the newly generated evidence-based reasoning task, and uses each of the semantic codes in this set as a parameter to execute the evaluateNewConstruct operation in item 9) below. The execution process can only execute operations related to the newly added evidence-based reasoning task (that is, operations related to existing evidence-based reasoning tasks can be executed but not necessarily executed).

[0336] 6) Implement the application interface registerConstructAcquisitionTask(Aq, Sq, At): Aq is a semantic code, Sq is a semantic pattern, (Aq, Sq) constitutes a standard form of a semantic screening condition, At is a semantic code; this method attempts to register an evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) to the reasoning engine, where No is a new evidence-based reasoning task number, Prg is "task known but not evaluated", Chd is an empty set, and this method returns the registered task number; the specific execution process is as follows:

[0337] i. The reasoning engine searches the list of known evidence-based reasoning tasks to check whether there is a known evidence-based reasoning task, denoted as X1, whose canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), such that Aq is the same as Aq1, Sq is the same as Sq1, and At is the same as At1; if it exists, then the evidence-based task (No, Aq, Sq, At, Prg, Chd) is not registered, and the task number No1 is returned; if it does not exist, then (No, Aq, Sq, At, Prg, Chd) is a new evidence-based reasoning task, and the operation described in step ii below is performed;

[0338] ii. The reasoning engine adds a record of an evidence-based reasoning task to the list of known evidence-based reasoning tasks: (No, Aq, Sq, empty, Prg, Chd); since the evidence-based reasoning task is a new one, the reasoning engine scans all known semantics to find out whether there is a set of semantics whose paradigm semantics are the semantics represented by Aq, which have specific semantics in the form of semantic sequences, and whose specific semantics in the form of semantic sequences conform to the semantic pattern specified by Sq; if such a set of semantics that meets the conditions can be found, the reasoning engine regards this set of semantics as newly generated semantics relative to the newly generated evidence-based reasoning task, and uses each of the semantic codes in this set as a parameter to execute the evaluateNewConstruct operation in item 9) below. The execution process can only execute operations related to the newly added evidence-based reasoning task (that is, operations related to existing evidence-based reasoning tasks can be executed but not necessarily executed); the method returns the task number No.

[0339] 7) Implement the application interface evaluateConstructAcquisitionTask(No): No is an evidence-based reasoning task number, and the standard form of the evidence-based reasoning task is (No, Aq, Sq, At, Prg, Chd); if At is empty or the mapping rule named (Aq, At) is a feature extraction rule, the reasoning engine obtains a set of mapping rules whose result semantics may meet the semantic screening condition (Aq, Sq), and attempts to register a new evidence-based task for each rule in the set; if the mapping rule named (Aq, At) is a semantic fusion rule, the reasoning engine obtains the defined feature extraction rule based on its dependent semantic set, and attempts to register a new evidence-based task for each mapping rule; the method has no return value; the specific execution process is as follows:

[0340] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form (No, Aq, Sq, At, Prg, Chd) of the evidence-based reasoning task with task number No;

[0341] ii. If At is empty or the mapping rule named (Aq, At) is a feature extraction rule, perform the following operations:

[0342] a) Obtain a mapping rule set whose result semantics may meet the semantic screening condition (Aq, Sq), that is, obtain a mapping rule set named (?, Aq), where ? represents any semantics; the standard form of such a semantic fusion rule in the set is recorded as (Ao, Aq); the inference engine generates a semantic pattern So for each Ao, so that the semantics obtained by mapping (Ao, Aq) with each semantics meeting the semantic screening condition (Ao, So) as the starting semantics must contain all the semantics that may be obtained by mapping (Ao, Aq) and meet the semantic screening condition (Aq, Sq); the specific way to obtain So is as follows: first, according to the Map1 parameter in the standard form of the semantic fusion rule (Ao, Aq, Dep, Api, Par, Map1, Map2), obtain the corresponding relationship between the sequence positions of So and Sq, and according to the semantic sequence information of Sq, fill the semantic code into the corresponding position of So, and fill the semantic code "-4" for the sequence position in So that has no corresponding relationship with Sq;

[0343] b) The reasoning engine executes the registerConstructAcquisitionTask operation in item 6) above for each Ao with (Ao, So, Aq) as parameters, and records the task number returned by the operation into the Chd set of the evidence-based reasoning task with task number No;

[0344] c) If the Chd set is empty after completing the above steps a)-b), then use the triple (No, Aq, Sq) as a parameter to perform the examineExternalSource operation in item 8) below. If the check returns "evidence-based", then set the Prg of the evidence-based reasoning task with task number No to "task executable and being executed", otherwise set it to "task not executable";

[0345] iii. If the mapping rule named (Aq, At) is a semantic fusion rule, perform the following operations:

[0346] a) According to the Dep parameter of the canonical form of the semantic fusion rule named (Aq, At), its dependent semantic set [D1, ..., Dn] is obtained, and one of the semantics is Di. At this time, there must be a defined feature extraction mapping (Di, Aq); the inference engine generates a semantic pattern Sio for each Di, so that each semantic that meets the semantic screening condition (Di, Sio) is used as the starting semantic, and the semantic obtained by mapping (Di, Aq) must contain all possible semantics that meet the semantic screening condition (Aq, Sq) obtained by mapping (Di, Aq); Sio is obtained in the following specific way: first, according to the name of the feature extraction rule (Di, Aq), the corresponding relationship between the sequence positions of Sio and Sq is obtained, and according to the semantic sequence information of Sq, the semantic code is filled into the corresponding position of Sio, and the sequence position in Sio that has no corresponding relationship with Sq is filled with the semantic code "-4";

[0347] b) The reasoning engine executes the registerConstructAcquisitionTask operation in item 6) above for each Di with (Di, Sio, Aq) as parameters, and records the task number returned by the operation into the Chd set of the evidence-based reasoning task with task number No.

[0348] 8) Implement the application program interface examineExternalSource(No, Aq, Sq): No is the number of an evidence-based reasoning task, (Aq, Sq) is a semantic screening condition, this method takes the triple (No, Aq, Sq) as a parameter to initiate an "external evidence-based feasibility check". If no external evidence-based interface API is started, the method returns "not evidence-based"; if any external evidence-based interface API is started, it returns "evidence-based". The specific execution process is as follows:

[0349] i. The inference engine accesses the "external evidence-based interface" list and scans all external evidence-based interfaces in the list. Each external evidence-based interface is represented by a triple (Aq, Pq, Api) {"a semantic code", "a special sequence consisting of 0, 1, 2", "an external program interface that can be called by the inference engine"}; the inference engine uses the information of Aq and Pq of an external evidence-based interface to determine whether the external evidence-based interface can obtain semantics that meet the semantic screening conditions (Aq, Sq);

[0350] ii. If no external evidence-based interface API meets the requirements, the external evidence-based feasibility check returns "not evidence-based";

[0351] iii. If such an external evidence-based interface is found, the external evidence-based feasibility check will immediately return "evidence-based" and send a command to the external evidence-based interface with a triple (No, Aq, Sq) as a parameter to start data transmission. The API obtains the semantics of Aq and its associated semantics, the semantics in the Sq sequence and its associated semantics, and the data corresponding to the semantics (such as Java object instances) through the semantic representation system, and obtains or calculates data outside the reasoning engine based on this information, and then reports to the reasoning engine; the external evidence-based interface can use the function of the semantic representation system: Note that the external evidence-based interface intends to report a semantic to the reasoning engine, and the semantic has the external semantic sequence of the reasoning engine.<B1,…,Bn> The external evidence-based interface calls the learnPhysical and seqToCode functions of the semantic representation system.<B1,…,Bn> Convert it into a semantic code Bs, and use the semantic representation system's function identify(Bs, Aq) to get the semantic code B, and report the semantic code B to the reasoning engine; if the semantic code B is newly generated by the semantic representation system in this operation, the external evidence-based interface instructs the reasoning engine to perform the evaluateNewConstruct operation in item 9) below with B as the parameter;

[0352] iv. When the external evidence-based interface completes the acquisition or calculation of all data in step iii above, the reasoning engine is notified to set the progress status of the acquisition semantics of the evidence-based reasoning task coded as No to "mapping task is being executed".

[0353] 9) Implement the application program interface evaluateNewConstruct(code): code is a newly generated semantic code. The reasoning engine scans the list of known evidence-based reasoning tasks. If code meets the semantic screening conditions of a certain evidence-based reasoning task, it tries to register a new mapping task. The method has no return value. The specific execution process is as follows:

[0354] i. Use the getParadigm(code) function of the semantic representation system to return the semantic code Cp and obtain the paradigm semantics Cp of the semantics represented by code; use the getInstance(code) function of the semantic representation system to return a set of semantic codes [C1, ..., Cn] and obtain the specific semantic set [C1, ..., Cn] of the semantics represented by code; for any element Ci in the set, use the application interface codeToSeq(Ci) to return the sequence Si and obtain the semantic sequence form Si of the specific semantics;

[0355] ii. The reasoning engine searches whether the evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) has been registered, Cp is the same as Aq, and there is at least one Si that meets the semantic pattern specified by Sq; if so, the following steps iii-iv are performed for each such registered evidence-based reasoning task; if not, no attempt is made to register a new mapping task; the method returns;

[0356] iii. If (Aq, At) is a feature extraction map, execute the registerMapTask operation in item 3) above with (Aq, At, code, empty set) as parameters;

[0357] iv. If (Aq, At) is a semantic fusion mapping, take (Aq, At, code, Dep) as parameters and execute the registerMapTask operation in item 3) above; Dep is obtained by the following process: the inference engine first obtains the dependent semantic set [D1, ..., Dn] of (Aq, At), and denotes one of the semantics as Di; the inference engine generates a semantic pattern Sio for each Di, so that the semantics obtained by mapping (Di, Aq) with each semantics that meets the semantic screening condition (Di, Sio) as the starting semantics must contain all the possible semantics of code obtained by mapping (Di, Aq); the specific way to obtain Sio is as follows: first, according to the feature extraction rule, Then the name (Di, Aq) is obtained, the correspondence between the sequence positions of the specific semantics of the semantic sequence form of Sio and code is obtained, and the semantic code is filled into the corresponding position of Sio according to the sequence information of the specific semantics of the semantic sequence form of code, and the sequence position in Sio that has no correspondence with the specific semantics of the semantic sequence form of code is filled with the semantic code "-4"; then the inference engine uses (Di, Sio, Aq) as a parameter, executes the registerConstructAcquisitionTask operation in item 6) above, and records the task code returned by the operation into the Dep set of the mapping task (Aq, At, code, Dep) that is attempted to be registered.

[0358] 10) Implement the application interface finishConstructAcquisitionTask(No): No is an evidence-based reasoning task number, and the canonical form of the evidence-based reasoning task is (No, Aq, Sq, At, Prg, Chd); the reasoning engine scans the list of known (to be executed) mapping tasks to find out whether there is a mapping task named (Aq, At), and the starting semantics of the mapping task has a specific semantics in the form of a semantic sequence that conforms to the pattern specified by Sq; the method attempts to execute all the above-mentioned mapping tasks that meet the conditions, and the method returns a Boolean value; the specific execution process is as follows:

[0359] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form (No, Aq, Sq, At, Prg, Chd) of the evidence-based reasoning task with task number No;

[0360] ii. The inference engine queries the list of known (to be executed) mapping tasks to find out whether there is a mapping task (Md, Mr, A, Dep), where Aq is the same as Md, At is the same as Mr, and A has a specific semantics in the form of a semantic sequence and conforms to the pattern specified by Sq; if there is no such mapping task, Prg is set to "task completed"; if there is such a mapping task, the inference engine uses (Md, Mr, A) as parameters to execute the executeMapTask operation in item 4) above: when all mapping tasks that meet the above requirements are processed, if there are no pending mapping tasks, Prg is set to "task completed" and the method returns True; otherwise, Prg is not changed, and the reasoning engine waits for the finishConstructAcquisitionTask(No) operation to be executed again later, and the method returns False.

[0361] 2.2 Inference Engine Use Cases

[0362] 2.2.1 Case Description of Implementation Example

[0363] The specific situations of using the inference engine for reasoning are as follows:

[0364] "A" and "B" are two different experimental groups, and "C" is a quantitative physiological indicator. In evidence-based medicine, there is the following basic logic: "If the P value of the Student's t-test for indicator C of group A and group B is known to be 0.03, and the rule that P value <0.05 is significantly different is adopted, then it can be known that indicator C of group A and group B has a significant difference."

[0365] Objectives of this implementation case:

[0366] According to the above logic, there is data on the P value of Student's t-test between different experimental groups. Use the reasoning engine to query the results of the evidence-based reasoning question "Is there a significant difference in blood sodium between smokers and non-smokers?"

[0367] 2.2.2 Specific steps to implement the case using the inference engine

[0368] The user first converts the external semantics into semantic codes and constructs the required sequences:

[0369] 1) learnPhysical("group"): returns the semantic code "1", that is, the semantic code "1" has the "javaObj" attribute as the Java object instance "group".

[0370] 2) learnPhysical("indicator"): returns the semantic code "2", that is, the semantic code "2" has the "javaObj" attribute which is the Java object instance "indicator".

[0371] 3) learnPhysical("Student's t-test"): returns the semantic code "3", that is, the semantic code "3" has the "javaObj" attribute which is the Java object instance "Student's t-test".

[0372] 4) learnPhysical("P value"): returns the semantic code "4", that is, the semantic code "4" has the "javaObj" attribute which is the Java object instance "P value".

[0373] 5) learnPhysical("value"): returns the semantic code "5", that is, the semantic code "5" has the "javaObj" attribute which is the Java object instance "value".

[0374] 6) learnPhysical("Smoking Group"): returns the semantic code "6", that is, the semantic code "6" has the "javaObj" attribute which is the Java object instance "Smoking Group".

[0375] 7) learnPhysical("Non-smoking people"): returns the semantic code "7", that is, the semantic code "7" has the "javaObj" attribute which is the Java object instance "Non-smoking people".

[0376] 8) learnPhysical("blood sodium"): returns the semantic code "8", that is, the semantic code "8" has the "javaObj" attribute which is the Java object instance "blood sodium".

[0377] 9) learnPhysical("Is there a difference"): returns the semantic code "10", that is, the semantic code "10" has the "javaObj" attribute which is the Java object instance "Is there a difference".

[0378] 10) learnPhysical("1"): returns the semantic code "100", that is, the semantic code "100" has the "javaObj" attribute which is the Java object instance "1".

[0379] 11) learnPhysical("2"): returns the semantic code "101", that is, the semantic code "101" has the "javaObj" attribute which is the Java object instance "2".

[0380] 12) learnPhysical("5"): returns the semantic code "102", that is, the semantic code "102" has the "javaObj" attribute which is the Java object instance "5".

[0381] 13) learnPhysical("6"): returns the semantic code "103", that is, the semantic code "103" has the "javaObj" attribute which is the Java object instance "6".

[0382] 14)seqToCode(<1,1,2,3,4,5>): Returns the semantic code "12", that is, the semantic code "12" has the semantic sequence form <1,1,2,3,4,5>{"group","group","indicator","Student's t-test","P value","value"}.

[0383] 15)identify(12,0): returns the semantic code "13", that is, the paradigmatic semantics of the semantics represented by "13" is the semantics represented by "0", and the specific semantics of the semantics it represents includes the semantics represented by "12".

[0384] 16)seqToCode(<4,5,10>): Returns the semantic code "16", that is, the semantic code "16" has the semantic sequence form <4,5,10>{"P value", "value", "whether there is a difference"}.

[0385] 17)identify(16,0): returns the semantic code "17", that is, the paradigmatic semantics of the semantics represented by "17" is the semantics represented by "0", and the specific semantics of the semantics it represents includes the semantics represented by "16".

[0386] 18)seqToCode(<1,1,2,10>): returns the semantic code "20", that is, the semantic code "20" has the semantic sequence form <1,1,2,10>{"group", "group", "indicator", "whether difference"}.

[0387] 19)identify(20,0): returns the semantic code "21", that is, the paradigmatic semantics of the semantics represented by "21" is the semantics represented by "0", and the specific semantics of the semantics it represents includes the semantics represented by "20".

[0388] 20)seqToCode(<13,102,103>): Returns the semantic code "22", that is, the semantic code "22" has the semantic sequence form <13,102,103>{"group, group, indicator, Student's t-test, P value, value", "5", "6"}.

[0389] 21)identify(22,-3): returns the semantic code "23", that is, the paradigmatic semantics of the semantics represented by "23" is the semantics represented by "-3", and the specific semantics of the semantics it represents includes the semantics represented by "22".

[0390] 22)seqToCode(<17,100,101>): Returns the semantic code "24", that is, the semantic code "24" has the semantic sequence form <17,100,101>{"P value, value, whether it is different", "1", "2"}.

[0391] 23)identify(24,-3): Returns the semantic code "25", that is, the paradigm semantics of the semantics represented by "25" is the semantics represented by "-3", and the specific semantics of the semantics represented by it includes the semantics represented by "24"; because the semantic code "25" and the semantic code "23" are merged in the following step 24), Figure 2 In the example, the node marked with "23" is the node marked with "25" ( Figure 2 is the initial state semantic structure diagram of the evidence-based reasoning calculation process of the present invention);

[0392] 24)map(23,25): Since the two semantics coded as “23” {“P value, numerical value”} and “25” {“P value, numerical value”} have the same paradigm semantics, this method merges the two semantics coded as “23” and “25”, and the code of the merged semantics is “23”; the method has no return value.

[0393] At this time, the semantics indicates that the system stores Figure 2 The semantic structure of the inference engine is then recorded by the known mapping rules and the following operations are performed:

[0394] 25)setFeatureExtractionRule(13,23): Define and record (or find) a feature extraction rule named (13,23){"group, group, indicator, Student's t-test, P value, value", "P value, value"} in the inference engine. The method has no return value. The specific steps are: first query whether there is a record of a mapping rule named (13,23) in the inference engine. Since the record does not exist, define a new feature extraction rule, denoted as (13,23), and record the mapping rule in the inference engine.

[0395] 26)setFeatureExtractionRule(17,23): Define and record (or find) a feature extraction rule named (17,23){"P value, value, whether there is a difference", "P value, value"} in the inference engine. The method has no return value. The specific steps are: first query whether there is a record of a mapping rule named (17,23) in the inference engine. Since the record does not exist, define a new feature extraction rule, denoted as (17,23), and record the mapping rule in the inference engine.

[0396] 27)setConstructFusionRule(23,21,Dep1,Api1,Par1,Map11,Map12){"P value,numeric value","group,group,indicator,is there a difference","[13,17]","posRecomb","Use the 1st to 3rd digits of the semantic sequence form of the parameter semantics with the paradigm semantics "13" and the 3rd digit of the semantic sequence form of the parameter semantics with the paradigm semantics "17" to form a new sequence","empty set","[(1,1),(2,2),(3 ,3),(4,4)]”}: Define and record (or find) a semantic fusion rule in the inference engine. The name of the semantic fusion mapping rule is (23,21). The method has no return value. The specific steps are: first query inside the inference engine whether there is a record named (23,21,Dep1,Api1,Par1,Map11,Map12). Since the record does not exist, define a new semantic fusion rule, recorded as (23,21,Dep1,Api1,Par1,Map11,Map12), and record the mapping rule in the inference engine.

[0397] The user then calls the inference engine's function through the following steps to query the result of the evidence-based reasoning question "Is there a significant difference in blood sodium between smokers and non-smokers?":

[0398] 28)ask(21,<6,7,8,-4>){"Group, Group, Indicator, Is there a difference?", "Smokers, Non-smokers, Blood sodium,?"}: The reasoning engine attempts to register a special evidence-based reasoning task to be completed (1,21,<6,7,8,-4>, empty, "Task known but not evaluated", empty set){"Evidence-based task 1", "Group, Group, Indicator, Is there a difference?", "Smokers, Non-smokers, Blood sodium,?", "Results fed back to the user", "Task progress", "Dependent task set"}, the method has no return value; the specific execution process is as follows:

[0399] i. The reasoning engine searches the list of known evidence-based reasoning tasks to check whether there is a known evidence-based reasoning task, denoted as X1, whose canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), such that "21" is the same as Aq1, <6,7,8,-4> is the same as Sq1, and empty is the same as At1; since there is no evidence-based reasoning task that meets the above conditions, (1,21, <6,7,8,-4>, empty, "task is known but not evaluated", empty set) is a new evidence-based reasoning task;

[0400] ii. The reasoning engine adds a record of an evidence-based reasoning task to the list of known evidence-based tasks: (1,21,<6,7,8,-4>,empty,“task known but not evaluated”,empty set); since this evidence-based reasoning task is a new one, the reasoning engine scans all known semantics to find out whether there is a set of semantics whose paradigm semantics are the semantics represented by “21”, which have specific semantics in the form of semantic sequences, and whose specific semantics in the form of semantic sequences conform to the semantic pattern specified by <6,7,8,-4>; since such a set of semantics that meets the conditions cannot be found, no further operation is performed.

[0401] 29) The reasoning engine now notices that there is an evidence-based reasoning task in the list of known evidence-based reasoning tasks, whose Prg is "task known but not evaluated" and Chd is an empty set, and then evaluateConstructAcquisitionTask is executed with the task number "1" of the evidence-based reasoning task as a parameter, i.e., the operation in step 30) below;

[0402] 30)evaluateConstructAcquisitionTask(1): The inference engine obtains the mapping rule set of the result semantics that may meet the semantic screening condition (21, <6, 7, 8, -4>) {"group, group, indicator, whether it is different", "smokers, non-smokers, blood sodium,?"}, and attempts to register a new evidence-based task for each rule in the set; the method has no return value; the specific execution process is as follows:

[0403] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "1" (1, 21, <6, 7, 8, -4>, empty, "task known but not evaluated", empty set) {"evidence-based task 1", "group, group, indicator, whether it is different", "smoking population, non-smoking population, blood sodium,?", "results fed back to users", "task progress", "dependent task set"};

[0404] ii. Since At is empty, perform the following operations:

[0405] a) Obtain a mapping rule set whose result semantics may meet the semantic screening condition (21, <6,7,8,-4>), that is, obtain a mapping rule set named (?,21), where ? represents any semantics; the inference engine finds such a semantic fusion rule that meets the above conditions, and its standard form is (23,21,Dep1,Api1,Par1,Map11,Map12){"P value, numerical value","group,group,indicator,whether difference","[13,17]","posRecomb","Use the 1st to 3rd digits of the specific semantics of the semantic sequence form of the parameter semantics with the paradigm semantics "13" and the 3rd digit of the specific semantics of the semantic sequence form of the parameter semantics with the paradigm semantics "17" to form a new sequence","empty set","[(1,1),(2,2),(3,3),(4,4)]"};

[0406] b) The inference engine generates a semantic pattern So for the semantic code "23" {"P value, numerical value"}, so that each semantic that meets the semantic screening condition (23, So) is used as the starting semantic, and the semantic obtained by mapping (23, 21) {"P value, numerical value", "group, group, indicator, whether it is different"} must contain all the semantics that may be obtained by mapping (23, 21) that meet the semantic screening condition (21, <6, 7, 8, -4>) {"group, group, indicator, whether it is different", "smoking population, non-smoking population, blood sodium,?"}; So is specifically obtained as follows: Since the Map11 parameter in the standard form of the semantic fusion rule (23, 21, [13, 17], Api1, Par1, Map11, Map12) is "empty set", there is no corresponding relationship between So and the sequence position of <6, 7, 8, -4>, so each position in So is filled with the semantic code "-4", that is, the value of So is <-4, -4>;

[0407] c) The reasoning engine uses (23, <-4, -4>, 21) as a parameter, executes the registerConstructAcquisitionTask operation described in step 31) below, returns the task number "2", and records "2" in the Chd set of the evidence-based reasoning task with task number "1".

[0408] 31) The registerConstructAcquisitionTask operation in step c) of step ii of step 30) above, namely registerConstructAcquisitionTask(23,<-4,-4>,21){"P value, value","?,?"","group,group,index,whether different"} is as follows: the reasoning engine tries to register an evidence-based reasoning task(2,23,<-4,-4>,21,"task known but not evaluated",empty set){"evidence-based task 2","P value, value","?,?"","group,group,index,whether different","task progress","dependent task set"}, and the method returns the task number obtained by registration; the specific execution process is as follows:

[0409] i. The reasoning engine searches the list of known evidence-based reasoning tasks to check whether there is a known evidence-based reasoning task, denoted as X1, whose canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), such that "23" is the same as Aq1, <-4, -4> is the same as Sq1, and "21" is the same as At1; since there is no evidence-based reasoning task that meets the above conditions, (2, 23, <-4, -4>, 21, "task known but not evaluated", empty set) is a new evidence-based reasoning task;

[0410] ii. The reasoning engine adds a record of an evidence-based reasoning task to the list of known evidence-based tasks: (2, 23, <-4, -4>, 21, "Task is known but not evaluated", empty set); since this evidence-based reasoning task is a new one, the reasoning engine scans all known semantics to find out whether there is a set of semantics whose paradigm semantics are the semantics represented by "23", which have specific semantics in the form of semantic sequences, and whose specific semantics in the form of semantic sequences conform to the semantic pattern specified by <-4, -4>; since such a set of satisfying semantics cannot be found, no further operation is performed; the method returns the task number "2".

[0411] 32) The reasoning engine now notices that in the list of known evidence-based reasoning tasks, there is an evidence-based reasoning task whose Prg is "task known but not evaluated" and Chd is an empty set. It then executes evaluateConstructAcquisitionTask with the task number "2" of the evidence-based reasoning task as a parameter, i.e., the operation in step 33) below.

[0412] 33)evaluateConstructAcquisitionTask(2): The inference engine obtains the defined feature extraction mapping according to the dependent semantic set of semantic fusion rule (23,21) {"P value, value", "group, group, indicator, whether it is different"}, and tries to register a new evidence-based task for each mapping rule; the method has no return value; the specific execution process is as follows:

[0413] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "2" (2, 23, <-4, -4>, 21, "Task known but not evaluated", empty set) {"Evidence-based task 2", "P value, numerical value", "?,?", "Group, Group, Indicator, Is it different", "Task progress", "Dependent task set"};

[0414] ii. Since the mapping rule named (23,21) is a semantic fusion rule, the following operations are performed:

[0415] a) According to the Dep1 parameter of the canonical form (23,21,Dep1,Api1,Par1,Map11,Map12) of the semantic fusion rule named (23,21), its dependent semantic set [13,17] is obtained. At this time, there must be defined feature extraction mappings (13,23) {"group, group, indicator, Student's t-test, P value, value", "P value, value"} and (17,23) {"P value, value, whether it is different", "P value, value"};

[0416] b) The inference engine generates a semantic pattern Sio1 for the semantic code "13" {"group, group, indicator, Student's t-test, P value, value"}, so that each semantic that meets the semantic screening condition (13, Sio1) is used as the starting semantic, and after mapping (13, 23) {"group, group, indicator, Student's The semantics obtained by the mapping (13, 23) must include all the semantics that meet the semantic screening conditions (23, <-4, -4>) {"P value, numerical value", "? ,? "}; Sio1 is obtained as follows: first, according to the name of the feature extraction rule (13, 23), determine that the 5th to 6th bits of the Sio1 sequence correspond to the sequence <-4, -4>, and according to the semantic sequence information of <-4, -4>, fill the semantic code into the 5th to 6th bits of Sio1. For the sequence positions in Sio1 that have no corresponding relationship with Sq, fill in the semantic code "-4", that is, the value of Sio1 is <-4, -4, -4, -4, -4, -4>;

[0417] c) The reasoning engine executes the registerConstructAcquisitionTask operation described in step 34) below with (13,<-4,-4,-4,-4,-4,-4>,23) as the parameter, returns the task number "3", and records "3" into the Chd set of the evidence-based reasoning task with the task number "2";

[0418] d) The inference engine generates a semantic pattern Sio2 for the semantic code "17" {"P value, numerical value, whether it is different"}, so that the semantics that meet the semantic screening condition (17, Sio2) are used as the starting semantics. The semantics obtained by mapping (17, 23) {"P value, numerical value, whether it is different", "P value, numerical value"} must contain all possible semantics that meet the semantic screening condition (23, <-4, -4>) {"P value, numerical value", ? ,? ”}; The specific method of obtaining Sio2 is as follows: first, according to the name of the feature extraction rule (17,23), determine that the 1st and 2nd positions of the Sio2 sequence correspond to the sequence <-4,-4>, and according to the semantic sequence information of <-4,-4>, fill the semantic code into the 1st and 2nd positions of Sio2. For the sequence positions in Sio2 that have no corresponding relationship with <-4,-4>, fill the semantic code "-4", that is, the value of Sio2 is <-4,-4,-4>;

[0419] e) The reasoning engine executes the registerConstructAcquisitionTask operation described in step 35) below with (17,<-4,-4,-4>,23) as the parameter, returns the task number "4", and records "4" into the Chd set of the evidence-based reasoning task with task number "2".

[0420] 34) The registerConstructAcquisitionTask operation in step c) of step ii of step 33) above, i.e., registerConstructAcquisitionTask(13,<-4,-4,-4,-4,-4,-4>,23){"group, group, indicator, Student's t-test, P value, value","?,?,?,?,?,?",?","P value, value"} is as follows: The reasoning engine attempts to register an evidence-based reasoning task(3,13,<-4,-4,-4,-4,-4,-4>,23,"Task known but not evaluated", empty set){"Evidence-based task 3","group, group, indicator, Student's t-test, P value, value","?,?,?,?,?,?",?","P value, value","Task progress","Dependent task set"}, and the method returns the registered task number; the specific execution process is as follows:

[0421] i. The reasoning engine searches the list of known evidence-based reasoning tasks to check whether there is a known evidence-based reasoning task, denoted as X1, whose canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), such that "13" is the same as Aq1, <-4,-4,-4,-4,-4,-4> is the same as Sq1, and "23" is the same as At1; since there is no evidence-based reasoning task that meets the above conditions, (3, 13, <-4,-4,-4,-4,-4,-4>, 23, "task known but not evaluated", empty set) is a new evidence-based reasoning task;

[0422] ii. The reasoning engine adds a record of an evidence-based reasoning task to the list of known evidence-based reasoning tasks: (3, 13, <-4, -4, -4, -4, -4, -4>, 23, "Task is known but not evaluated", empty set); since this evidence-based reasoning task is a new one, the reasoning engine scans all known semantics to find out whether there is a set of semantics whose paradigm semantics are the semantics represented by "13" and have specific semantics in the form of semantic sequences, and whose specific semantics in the form of semantic sequences conform to the semantic pattern specified by <-4, -4, -4, -4, -4, -4>; since such a set of satisfying semantics cannot be found, no further operation is performed; the method returns the task number "3".

[0423] 35) The registerConstructAcquisitionTask operation in step e) of step ii) of step 33) above, i.e., registerConstructAcquisitionTask(17,<-4,-4,-4>,23){"P value, value, is there a difference","?,?,?","P value, value"} is as follows: the reasoning engine attempts to register an evidence-based reasoning task(4,17,<-4,-4,-4>,23,"Task known but not evaluated", empty set){"Evidence-based task 4","P value, value, is there a difference","?,?,?","P value, value","Task progress","Dependent task set"}, and the method returns the task number obtained by registration; the specific execution process is as follows:

[0424] i. The reasoning engine searches the list of known evidence-based reasoning tasks to check whether there is a known evidence-based reasoning task, denoted as X1, whose canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), such that "17" is the same as Aq1, <-4, -4, -4> is the same as Sq1, and "23" is the same as At1; since there is no evidence-based reasoning task that meets the above conditions, (4, 17, <-4, -4, -4>, 23, "task known but not evaluated", empty set) is a new evidence-based reasoning task;

[0425] ii. The reasoning engine adds a record of an evidence-based reasoning task to the list of known evidence-based tasks: (4, 17, <-4, -4, -4>, 23, "Task is known but not evaluated", empty set); since this evidence-based reasoning task is a new one, the reasoning engine scans all known semantics to find out whether there is a set of semantics whose paradigm semantics are the semantics represented by "17", which have specific semantics in the form of semantic sequences, and whose specific semantics in the form of semantic sequences conform to the semantic pattern specified by <-4, -4, -4>; since such a set of satisfying semantics cannot be found, no further operation is performed and the method returns the task number "4".

[0426] 36) The reasoning engine now notices that there is an evidence-based reasoning task in the list of known evidence-based reasoning tasks, whose Prg is "task known but not evaluated" and Chd is an empty set, and then evaluateConstructAcquisitionTask is executed with the task number "3" of the evidence-based reasoning task as a parameter, i.e., the following step 37);

[0427] 37)evaluateConstructAcquisitionTask(3): The inference engine obtains a set of mapping rules whose result semantics may meet the semantic screening condition (13, <-4, -4, -4, -4, -4>) {"group, group, indicator, Student's t-test, P value, value", "?,?,?,?,?,?,?"}, and tries to register a new evidence-based task for each rule in the set; the method has no return value; the specific execution process is as follows:

[0428] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "3" (3, 13, <-4, -4, -4, -4, -4, -4>, 23, "Task known but not evaluated", empty set) { "Evidence-based task 3", "Group, Group, Indicator, Student's t-test, P value, numerical value", "?, ?, ?, ?, ?, ?", "P value, numerical value", "Task progress", "Dependent task set"};

[0429] ii. Since the mapping rule named (13,23) is a feature extraction rule, the following operations are performed:

[0430] a) The resulting semantics may meet the semantic screening conditions (13, <-4, -4, -4, -4, -4>) {"group, group, indicator, Student's t-test, P value, value", "?,?,?,?,?,?"}, that is, the mapping rule set named (?, 13) is obtained, where? represents any semantics; since no semantic fusion rules that meet the above conditions can be found in the reasoning engine, the Chd table of the evidence-based reasoning task is empty at this time;

[0431] b) Since the Chd set is empty after completing step a) above, the reasoning engine takes (3,13,<-4,-4,-4,-4,-4,-4>) as parameters and executes examineExternalSource, that is, the following step 38). The operation returns "evidence-based reasoning" and the reasoning engine sets the Prg of the evidence-based reasoning task with task number "3" to "task executable and being executed".

[0432] 38) The examineExternalSource operation in step b) of step ii of step 37) above, namely examineExternalSource(3,13,<-4,-4,-4,-4,-4,-4>) is as follows: with the triple (3,13,<-4,-4,-4,-4,-4,-4>) as parameter, initiate the "external evidence-based feasibility check". If no external evidence-based interface API is started, the method returns "not evidence-based"; if any external evidence-based interface API is started, it returns "evidence-based". The specific execution process is as follows:

[0433] i. The inference engine accesses the list of "external evidence-based interfaces" and scans all external evidence-based interfaces in the list. Each external evidence-based interface is represented by a triple (Aq, Pq, Api) {"a semantic code", "a special sequence consisting of 0, 1, 2", "an external program interface that can be called by the inference engine"}; the inference engine uses the information of Aq and Pq of an external evidence-based interface to determine whether the external evidence-based interface can obtain semantics that meet the semantic screening conditions (13, <-4, -4, -4, -4, -4, -4>) {"group, group, indicator, Student's t-test, P value, value", "?,?,?,?,?,?,?"};

[0434] ii. Since such an external evidence-based interface (13, <0,0,0,0,0,0>, Api2) can be found, the external evidence-based feasibility check immediately returns "evidence-based", and sends a command to start data transmission to the external evidence-based interface with the triple (3, 13, <-4, -4, -4, -4, -4, -4>) as a parameter. The API obtains the semantics coded as "13" and its associated semantics, the semantics in the sequence <-4, -4, -4, -4, -4, -4> and its associated semantics, and the data corresponding to the semantics (such as Java object instances) through the semantic representation system, and obtains or calculates data outside the reasoning engine based on this information; the external evidence-based interface reports a retrieved external semantic sequence <"smoking population", "non-smoking population", "blood sodium", "Student's t-test", "P value", "0.03">, the process is, first use the function of the semantic representation system to convert this external semantic sequence into semantics, get the semantic code "15", and then report "15" to the reasoning engine; because "15" is a newly generated semantic, the external evidence-based interface instructs the reasoning engine to perform the evaluateNewConstruct operation in step 39) below with "15" as the parameter; then the external evidence-based interface notifies the reasoning engine to set the progress status of the semantic acquisition of the evidence-based reasoning task numbered "3" to "mapping task in progress";

[0435] The steps to obtain the semantic code "15" are as follows:

[0436] learnPhysical("smoking population") gets the semantic code "6";

[0437] learnPhysical("non-smoking population") gets the semantic code "7";

[0438] learnPhysical("blood sodium") gets the semantic code "8";

[0439] learnPhysical("Student's t-test") gets the semantic code "3";

[0440] learnPhysical("P value") gets the semantic code "4";

[0441] learnPhysical("0.03") gets the semantic code "9";

[0442] seqToCode(<6,7,8,3,4,9>) gets the semantic code "14";

[0443] identify(14,13) obtains the semantic code "15".

[0444] 39) The evaluateNewConstruct operation in step ii of step 38) above, namely evaluateNewConstruct(15), is as follows: the reasoning engine scans the list of known evidence-based reasoning tasks. If "15" meets the semantic screening condition of a certain evidence-based reasoning task, it attempts to register a new mapping task. The method has no return value. The specific execution process is as follows:

[0445] i. Use the getParadigm(15) function of the semantic representation system to obtain the paradigm semantics "13" of the semantics represented by "15"; use the getInstance(15) function of the semantic representation system to obtain the specific semantics "14" of the semantics represented by "15"; use the codeToSeq(14) function of the semantic representation system to obtain the semantic sequence form <6,7,8,3,4,9> of the specific semantics;

[0446] ii. The reasoning engine searches whether the evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) has been registered. "13" {"group, group, indicator, Student's t-test, P value, value"} is the same as Aq, and the semantic sequence <6,7,8,3,4,9> {"smokers, non-smokers, blood sodium, Student's t-test, P value, 0.03"} meets the semantic pattern specified by Sq; find the evidence-based reasoning task that meets the above conditions: (3,13,<-4,-4,-4,-4,-4,-4>,23,"mapping task is being executed", empty set) {"evidence-based task 3", "group, group, indicator, Student's t-test, P value, value", "?,?,?,?,?,?,?", "P value, value", "task progress", "dependent task set"}; therefore, execute the following step iii for this evidence-based reasoning task; after the execution is completed, the method returns;

[0447] iii. Since (13, 23) is a feature extraction mapping, the inference engine uses (13, 23, 15, empty set) {"group, group, indicator, Student's t-test, P value, value", "P value, value", "smoking population, non-smoking population, blood sodium, Student's t-test, P value, 0.03"} as parameters to execute the following step 40) registerMapTask operation.

[0448] 40) The registerMapTask operation in step iii of step 39) above, namely, registerMapTask(13,23,15,empty set){"group,group,index,Student's t-test,P value,value","P value,value","smokers,non-smokers,blood sodium,Student's t-test, P value, 0.03", "empty set"} are as follows: this method attempts to register a mapping task with the inference engine, and the method has no return value; (13, 23) is the name of a mapping rule, "15" is the starting semantics of the mapping task, and the mapping task has no dependent evidence-based reasoning tasks; the core feature of the mapping task is the triple (13, 23, 15); the specific steps are as follows: the inference engine first queries whether there is a record with the core feature of the triple (13, 23, 15) in the list of known (to be executed) mapping tasks; since the record does not exist, the inference engine adds a mapping task record named (13, 23, 15, empty set) to the list of known (to be executed) mapping tasks.

[0449] 41) The reasoning engine now notices that in the list of known evidence-based reasoning tasks, there is an evidence-based reasoning task whose Prg is "task known but not evaluated" and Chd is an empty set. It then executes evaluateConstructAcquisitionTask with the task number "4" of the evidence-based reasoning task as a parameter, i.e., the operation in step 42) below.

[0450] 42)evaluateConstructAcquisitionTask(4): The inference engine obtains a set of mapping rules whose result semantics may meet the semantic screening condition (17, <-4, -4, -4>) {"P value, value, whether it is different", "?,?,?"}, and attempts to register a new evidence-based task for each rule in the set; the method has no return value; the specific execution process is as follows:

[0451] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "4" (4, 17, <-4, -4, -4>, 23, "Task known but not evaluated", empty set) {"Evidence-based task 4", "P value, value, is it different", "?, ?, ?", "P value, value", "Task progress", "Dependent task set"};

[0452] ii. Since the mapping rule named (17,23) is a feature extraction rule, the following operations are performed:

[0453] a) The mapping rule set of the result semantics that may meet the semantic screening condition (17, <-4, -4, -4>) {"P value, numerical value, whether it is different", "?,?,?"} is obtained, that is, the mapping rule set named (?, 17) is obtained, where? represents any semantics; since no semantic fusion rule that meets the above conditions can be found in the reasoning engine, the Chd table of the evidence-based reasoning task is empty at this time;

[0454] b) Since the Chd set is empty after completing step a) above, the reasoning engine uses (4,17,<-4,-4,-4>) as parameters to execute examineExternalSource, i.e., the following step 43). The operation returns "not evidence-based", and the reasoning engine sets the Prg of the evidence-based reasoning task with task number "4" to "task not executable".

[0455] 43) The examineExternalSource operation in step b) of step ii of step 42) above, namely examineExternalSource(4,17,<-4,-4,-4>), is as follows: with the triple (4,17,<-4,-4,-4>) as the parameter, initiate the "external evidence-based feasibility check". If no external evidence-based interface API is started, the method returns "not evidence-based"; if any external evidence-based interface API is started, it returns "evidence-based". The specific execution process is as follows:

[0456] i. The inference engine accesses the "external evidence-based interface" list and scans all external evidence-based interfaces in the list. Each external evidence-based interface is represented by a triple (Aq, Pq, Api) {"a semantic code", "a special sequence consisting of 0, 1, 2", "an external program interface that can be called by the inference engine"}; the inference engine uses the information of Aq and Pq of an external evidence-based interface to determine whether the external evidence-based interface can obtain semantics that meet the semantic screening condition (17, <-4, -4, -4>);

[0457] ii. Since no external evidence-based interface API meets the requirements, this external evidence-based feasibility check returns "not evidence-based".

[0458] 44) The reasoning engine now notices that there is an evidence-based reasoning task in the list of known evidence-based reasoning tasks, and its Prg is "executing mapping task", so it executes finishConstructAcquisitionTask with the task number "3" of the evidence-based reasoning task as a parameter, which is the operation in step 45) below.

[0459] 45) finishConstructAcquisitionTask(3): The inference engine scans the list of known (to-be-executed) mapping tasks to find out whether there is a mapping task named (13,23){"group, group, indicator, Student's t-test, P value, value", "P value, value"}, and whether the starting semantics of the mapping task have the specific semantics in the form of semantic sequence that conforms to the pattern specified by <-4,-4,-4,-4,-4,-4>; this method attempts to execute all the mapping tasks that meet the above conditions, and the method returns a Boolean value; the specific execution process is as follows:

[0460] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "3" (3, 13, <-4, -4, -4, -4, -4, -4>, 23, "Executing mapping task", empty set) { "Evidence-based task 3", "Group, Group, Indicator, Student's t-test, P value, value", "?, ?, ?, ?, ?, ?", "P value, value", "Task progress", "Dependent task set"};

[0461] ii. The inference engine queries the list of known (to be executed) mapping tasks to find out whether there is a mapping task (Md, Mr, A, Dep), where "13" is the same as Md, "23" is the same as Mr, and A has a specific semantics in the form of a semantic sequence and conforms to the pattern specified by <-4,-4,-4,-4,-4,-4>, and finds such a mapping task (13,23,15, empty set) {"group, group, indicator, Student's t-test, P value, value", "P value, value", "smokers, non-smokers, blood sodium, Student's t-test, P value, 0.03", "empty set"}, then the inference engine uses (13,23,15) as parameters and executes executeMapTask, i.e., step 46) below;

[0462] iii. When all mapping tasks that meet the above requirements are processed, since there are no pending mapping tasks, the Prg of the evidence-based reasoning task with task number "3" is set to "task completed", and the method returns True.

[0463] 46) The executeMapTask operation in step ii of step 45) above, namely executeMapTask(13,23,15){"group,group,index,Student's t-test,P value,value","P value,value","smokers,non-smokers,blood sodium,Student's t-test,P value,0.03"} is as follows: This method allows the inference engine to try to execute a mapping task registered in the known (to be executed) mapping task list, and the method returns a Boolean value; since (13,23) is a feature extraction rule, the specific execution process is as follows:

[0464] i. Since the Dep set of the mapping task is an empty set, the mapping task is executed immediately, that is, the inference engine immediately executes the following steps ii-iv, deletes the record (13, 23, 15, empty set) in the list of known (to be executed) mapping tasks, and the method returns True;

[0465] ii. According to the standard writing of feature extraction rule (13, 23), based on the semantic code "15", a semantic code "26" of a specific semantic corresponding to the semantic sequence form of its characteristic semantic is generated, and the semantic code has a semantic sequence form <4, 9> {"P value", "0.03"};

[0466] iii.identify(26,23): confirms the existence (i.e. finds or generates) of a specific semantics containing the semantics represented by the semantic code "26" and the paradigm semantics represented by the semantic code "23". The method return value is the semantic code "27". Since "27" is a newly generated semantic code, the inference engine uses "27" as a parameter and executes evaluateNewConstruct, i.e. step 47) below.

[0467] iv.map(15,27): confirms that the semantic representation system has recorded the mapping relationship between the semantics represented by the semantic code “15” and the semantics represented by the semantic code “27”.

[0468] 47) The evaluateNewConstruct operation in step ii of step 46) above, namely evaluateNewConstruct(27){"P value, 0.03"}, is as follows: the reasoning engine scans the list of known evidence-based reasoning tasks. If "27" meets the semantic screening condition of a certain evidence-based reasoning task, it attempts to register a new mapping task. The method has no return value. The specific execution process is as follows:

[0469] i. Use the getParadigm(27) function of the semantic representation system to return the semantic code "23" and obtain the paradigm semantics "23" of the semantics represented by "27"; use the getInstance(27) function of the semantic representation system to return the semantic code "26" and obtain the semantic code "26" of the specific semantics represented by "27"; use the codeToSeq(26) function of the semantic representation system to return the sequence <4,9> and obtain the semantic sequence form <4,9>{"P value", "0.03"} of the specific semantics;

[0470] ii. The reasoning engine searches whether the evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) has been registered. "23" {"P value, numerical value"} is the same as Aq, and <4,9> {"P value", "0.03"} conforms to the semantic pattern specified by Sq. The evidence-based reasoning task that meets the above conditions is found: (2,23, <-4, -4>, 21, "Task known but not evaluated", [3,4]) {"Evidence-based task 2", "P value, numerical value", "?,?", "Group, Group, Indicator, Is there a difference", "Task progress", "Dependent task set"}; Therefore, for this evidence-based reasoning task, execute the following step iii; after the execution is completed, the method returns;

[0471] iii. Since (23,21) is a semantic fusion mapping, the inference engine uses (23,21,27,Dep) as a parameter and executes the registerMapTask operation, i.e., the following step 48); Dep is obtained by the following process: the inference engine first obtains the dependent semantic set [13,17] of (23,21), and for the semantic codes "13" and "17", the inference engine executes the following steps iv-vii;

[0472] iv. The inference engine generates a semantic pattern Sio1 for the semantic code "13" {"group, group, indicator, Student's t-test, P value, value"}, so that each semantic that meets the semantic screening condition (13, Sio1) is used as the starting semantic, and after mapping (13, 23) {"group, group, indicator, Student's The semantics obtained by the mapping (13,23) must include all possible semantics represented by "27" {"P value, 0.03"}; Sio1 is obtained in the following way: first, according to the name of the feature extraction rule (13,23), determine that the 5th to 6th bits of Sio1 correspond to the specific semantics of the semantic sequence form represented by "27", and according to the sequence information of <4,9>, fill <4,9> into the 5th to 6th bits of Sio1. For the sequence positions in Sio1 that have no corresponding relationship with the specific semantics of the semantic sequence form represented by "27", fill the semantic code "-4", that is, the Sio1 value is <-4,-4,-4,-4,4,9>;

[0473] v. The inference engine executes registerConstructAcquisitionTask with (13,<-4,-4,-4,-4,4,9>,23) as the parameter, i.e., the operation in step 49) below, and records the task code "5" returned by the operation into the Dep set of the mapping task (23,21,27,Dep) attempted to be registered in step iii above;

[0474] vi. The inference engine generates a semantic pattern Sio2 for the semantic code "17" {"P value, numerical value, whether it is different"}, so that each semantic that meets the semantic screening condition (17, Sio2) is used as the starting semantic, and the semantic obtained by mapping (17, 23) {"P value, numerical value, whether it is different", "P value, numerical value"} must contain all possible semantics represented by "27" obtained by mapping (17, 23); the specific method of obtaining Sio2 is as follows: first, according to the name of the feature extraction rule (17, 23), the 1st to 2nd bits of Sio2 are obtained to correspond to the specific semantics of the semantic sequence form of the semantics represented by "27", and according to the sequence information of <4, 9>, <4, 9> is filled into the 1st to 2nd bits of Sio2, and the sequence position in Sio2 that has no corresponding relationship with the specific semantics of the semantic sequence form of the semantics represented by "27" is filled with the semantic code "-4", that is, the Sio2 value is <4, 9, -4>;

[0475] vii. The inference engine uses (17, <4, 9, -4>, 23) as parameters to execute the registerConstructAcquisitionTask operation, which is the step 52) below, and records the task code "6" returned by the operation into the Dep set of the mapping task (23, 21, 27, Dep) attempted to be registered in the above step iii.

[0476] 48) The registerMapTask operation in step iii of step 47) above, namely registerMapTask(23,21,27,[5,6]){"P value, numerical value","group,group,indicator,whether difference","P value,0.03","dependent task set"} is as follows: This method attempts to register a mapping task to the inference engine, and the method has no return value; (23,21) is the name of a mapping rule, "27" is the starting semantics of the mapping task, and [5,6] is the number set of the evidence-based reasoning tasks on which the mapping task depends; the core feature of the mapping task is the triple (23,21,27); the specific steps are as follows: the inference engine first queries whether there is a record with the core feature of the triple (23,21,27) in the list of known (to be executed) mapping tasks; since the record does not exist, the inference engine adds a mapping task record named (23,21,27, empty set) to the list of known (to be executed) mapping tasks.

[0477] 49) The registerConstructAcquisitionTask operation in step v of step 47) above, namely, registerConstructAcquisitionTask(13,<-4,-4,-4,-4,4,9>,23){"group, group, indicator, Student's t-test, P value, value","?,?,?,?, P value, 0.03","P value, value"} is as follows: The reasoning engine attempts to register an evidence-based reasoning task(5,13,<-4,-4,-4,-4,4,9>,23,"Task known but not evaluated", empty set){"Evidence-based task 5","group, group, indicator, Student's t-test, P value, value","?,?,?,?, P value, 0.03","P value, value","Task progress","Dependent task set"}, and the method returns the task number obtained by registration; the specific execution process is as follows:

[0478] i. The reasoning engine searches the list of known evidence-based reasoning tasks to check whether there is a known evidence-based reasoning task, denoted as X1, whose canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), such that "13" is the same as Aq1, <-4,-4,-4,-4,4,9> is the same as Sq1, and "23" is the same as At1; since there is no evidence-based reasoning task that meets the above conditions, (5, 13, <-4,-4,-4,-4,4,9>, 23, "the task is known but not evaluated", empty set) is a new evidence-based reasoning task;

[0479] ii. The reasoning engine adds a record of an evidence-based reasoning task to the list of known evidence-based reasoning tasks: (5, 13, <-4, -4, -4, -4, 4, 9>, 23, "Task is known but not evaluated", empty set); since this evidence-based reasoning task is a new one, the reasoning engine scans all known semantics to find out whether there is a set of semantics whose paradigm semantics are the semantics represented by "13" and have specific semantics in the form of semantic sequence, and the specific semantics in the form of semantic sequence conform to the semantic pattern specified by <-4, -4, -4, -4, 4, 9>; since such a semantic that meets the conditions can be found (the semantics represented by "15"), the reasoning engine adds "15" {"smoking population, non-smoking population, blood sodium, Student's t-test, P value, 0.03"} is regarded as a newly generated semantics, and the semantic code is used as a parameter to execute evaluateNewConstruct, that is, the following step 50). The execution process can only execute operations related to the newly added evidence-based reasoning task (that is, operations related to the existing evidence-based reasoning tasks can be executed but not executed); the method returns the task number "5".

[0480] 50) The evaluateNewConstruct operation in step ii of step 49) above, namely evaluateNewConstruct(15){"smokers, non-smokers, blood sodium, Student's t-test, P value, 0.03"} is as follows: the reasoning engine scans the list of known evidence-based reasoning tasks. If "15" meets the semantic screening condition of a certain evidence-based reasoning task, it tries to register a new mapping task; the method has no return value; the specific execution process is as follows:

[0481] i. Use the getParadigm(15) function of the semantic representation system to return the semantic code "13" and obtain the paradigm semantics "13" of the semantics represented by "15"; use the getInstance(15) function of the semantic representation system to return the semantic code "14" and obtain the specific semantics "14" of the semantics represented by "15"; use the codeToSeq(14) function of the semantic representation system to return the sequence <6,7,8,3,4,9> and obtain the semantic sequence form <6,7,8,3,4,9> of the specific semantics;

[0482] ii. The reasoning engine searches whether the evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) has been registered. "13" {"group, group, indicator, Student's t-test, P value, value"} is the same as Aq, and the semantic sequence <6,7,8,3,4,9> {"smoking population", "non-smoking population", "blood sodium", "Student's t-test", "P value", "0.03"} meets the semantic pattern specified by Sq; find the evidence-based reasoning tasks that meet the above conditions: (3,13,<-4,-4,-4,-4,-4,-4>,23,"mapping task is being executed", empty set) {"evidence-based task 3","group, group, indicator, Student's t-test,P value,numeric","? ,? ,? ,? ,? ,?","P value,numeric","task progress","dependent task set"}and(5,13,<-4,-4,-4,-4,4,9>,23,"task known but not evaluated",empty set){"evidence-based task 5","group,group,indicator,Student's t-test,P value,numeric","? ,? ,? ,? ,P value,0.03","P value,numeric","task progress","dependent task set"};Therefore,the following steps iii-iv are executed respectively for the above two evidence-based reasoning tasks;after the execution,the method returns;

[0483] iii. For the evidence-based reasoning task (3,13,<-4,-4,-4,-4,-4,-4>,23,“Executing mapping task”, empty set), since (13,23) is a feature extraction mapping, the reasoning engine takes (13,23,15, empty set) as a parameter and executes registerMapTask, which is the step 51) below;

[0484] iv. For the evidence-based reasoning task (5,13,<-4,-4,-4,-4,4,9>,23,“Task known but not evaluated”, empty set), since (13,23) is a feature extraction mapping, the reasoning engine executes registerMapTask with (13,23,15, empty set) as parameters, that is, executes the following step 51) again.

[0485] 51) The registerMapTask operation in step iii of step 50) above, namely, registerMapTask(13,23,15,empty set){"group,group,indicator,Student's t-test,P value,value","P value,value","smokers,non-smokers,blood sodium,Student's t-test,P value,0.03","empty set"} is as follows: This method attempts to register a mapping task with the inference engine, and the method has no return value; (13,23) is the name of a mapping rule, and "15" is the starting semantics of the mapping task, and the mapping task has no dependent evidence-based reasoning tasks; the core feature of the mapping task is the triple (13,23,15); the specific steps are: the inference engine first queries whether there is a record with the core feature of the triple (13,23,15) in the list of known (to be executed) mapping tasks; since the record exists, the inference engine does not register the mapping task.

[0486] 52) The registerConstructAcquisitionTask operation in step vii of step 47) above, namely registerConstructAcquisitionTask(17,<4,9,-4>,23){"P value, value, is there a difference","P value,0.03,?","P value, value"} is as follows: The reasoning engine attempts to register an evidence-based reasoning task(6,17,<4,9,-4>,23,"Task known but not evaluated",empty set){"Evidence-based task 6","P value, value, is there a difference","P value,0.03,?","P value, value","Task progress","Dependent task set"}, and the method returns the task number obtained by registration; the specific execution process is as follows:

[0487] i. The reasoning engine searches the list of known evidence-based reasoning tasks to check whether there is a known evidence-based reasoning task, denoted as X1, whose canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), such that "17" is the same as Aq1, <4,9,-4> is the same as Sq1, and "23" is the same as At1; since there is no evidence-based reasoning task that meets the above conditions, (6,17, <4,9,-4>, 23, "task known but not evaluated", empty set) is a new evidence-based reasoning task, and the operations described in step ii below are performed;

[0488] ii. The reasoning engine adds a record of an evidence-based reasoning task to the list of known evidence-based tasks: (6, 17, <4, 9, -4>, 23, "Task is known but not evaluated", empty set); since this evidence-based reasoning task is a new one, the reasoning engine scans all known semantics to find out whether there is a set of semantics whose paradigm semantics are the semantics represented by "17", which have specific semantics in the form of semantic sequences, and whose specific semantics in the form of semantic sequences conform to the semantic pattern specified by <4, 9, -4>; since such a set of semantics that meets the conditions cannot be found, the method returns the task number "6".

[0489] 53) The reasoning engine now notices that in the list of known evidence-based reasoning tasks, there is an evidence-based reasoning task whose Prg is "task known but not evaluated" and Chd is an empty set. It then executes evaluateConstructAcquisitionTask with the task number "5" of the evidence-based reasoning task as a parameter, i.e., the operation in step 54) below.

[0490] 54)evaluateConstructAcquisitionTask(5): The inference engine obtains a set of mapping rules whose result semantics may meet the semantic screening condition (13,<-4,-4,-4,-4,4,9>) {"group, group, indicator, Student's t-test, P value, value", "?,?,?,?, P value, 0.03"}, and attempts to register a new evidence-based task for each rule in the set; the method has no return value; the specific execution process is as follows:

[0491] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "5" (5, 13, <-4, -4, -4, -4, 4, 9>, 23, "Task known but not evaluated", empty set) { "Evidence-based task 5", "Group, Group, Indicator, Student's t-test, P value, numerical value", "?, ?, ?, ?, P value, 0.03", "P value, numerical value", "Task progress", "Dependent task set"};

[0492] ii. Since the mapping rule named (13,23) is a feature extraction rule, the following operations are performed:

[0493] a) The resulting semantics may meet the semantic screening conditions (13, <-4, -4, -4, -4, 4, 9>) {"group, group, indicator, Student's t-test, P value, value", "?,?,?,?, P value, 0.03"}, that is, the mapping rule set named (?, 13) is obtained, where? represents any semantics; since no semantic fusion rules that meet the above conditions can be found in the reasoning engine, the Chd table of the evidence-based reasoning task is empty at this time;

[0494] b) Since the Chd set is empty after completing step a) above, the reasoning engine takes (5,13,<-4,-4,-4,-4,4,9>) as parameters and executes examineExternalSource, that is, the following step 55). The operation returns "evidence-based", and the reasoning engine sets the Prg of the evidence-based reasoning task with task number "5" to "task executable and being executed".

[0495] 55) The examineExternalSource operation in step b) of step ii of step 54) above, namely examineExternalSource(5,13,<-4,-4,-4,-4,4,9>) is as follows: with the triple (5,13,<-4,-4,-4,-4,4,9>) as parameter, initiate the "external evidence-based feasibility check". If no external evidence-based interface API is started, the method returns "not evidence-based"; if any external evidence-based interface API is started, it returns "evidence-based". The specific execution process is as follows:

[0496] i. The inference engine accesses the list of "external evidence-based interfaces" and scans all external evidence-based interfaces in the list. Each external evidence-based interface is represented by a triple (Aq, Pq, Api) {"a semantic code", "a special sequence consisting of 0, 1, 2", "an external program interface that can be called by the inference engine"}; the inference engine uses the information of Aq and Pq of an external evidence-based interface to determine whether the external evidence-based interface can obtain semantics that meet the semantic screening conditions (13, <-4, -4, -4, -4, 4, 9>) {"group, group, indicator, Student's t-test, P value, value", "?,?,?,?, P value, 0.03"};

[0497] ii. Since such an external evidence-based interface (13, <0,0,0,0,0,0>, Api2) can be found, the external evidence-based feasibility check immediately returns "evidence-based", and sends a command to start data transmission to the external evidence-based interface with the triple (5,13, ​​<-4,-4,-4,-4,4,9>) as a parameter. The API obtains the semantics coded as "13" and its associated semantics, the semantics in the sequence <-4,-4,-4,-4,4,9> and its associated semantics, and the data corresponding to the semantics (such as Java object instances) through the semantic representation system, and obtains or calculates data outside the reasoning engine based on this information; the external evidence-based interface reports a retrieved external semantic sequence <"smoking population", "non-smoking population", "blood sodium", "Student's t-test", "P value", "0.03" >, the process is, first use the function of the semantic representation system to convert this external semantic sequence into semantics, get the semantic code "15", and then report "15" to the reasoning engine; then the external evidence-based interface notifies the reasoning engine to set the progress status of the semantic acquisition of the evidence-based reasoning task numbered "5" to "mapping task in progress";

[0498] The steps to obtain the semantic code "15" are as follows:

[0499] learnPhysical("smoking population") gets the semantic code "6";

[0500] learnPhysical("non-smoking population") gets the semantic code "7";

[0501] learnPhysical("blood sodium") gets the semantic code "8";

[0502] learnPhysical("Student's t-test") gets the semantic code "3";

[0503] learnPhysical("P value") gets the semantic code "4";

[0504] learnPhysical("0.03") gets the semantic code "9";

[0505] seqToCode(<6,7,8,3,4,9>) gets the semantic code "14";

[0506] identify(14,13) obtains the semantic code "15".

[0507] 56) The reasoning engine now notices that there is an evidence-based reasoning task in the list of known evidence-based reasoning tasks, and its Prg is "executing mapping task", so it executes finishConstructAcquisitionTask with the task number "5" of the evidence-based reasoning task as a parameter, which is the operation in step 57) below.

[0508] 57) finishConstructAcquisitionTask(5): The inference engine scans the list of known (to-be-executed) mapping tasks to find out whether there is a mapping task named (13,23) whose starting semantics have a semantic sequence form and conforms to the pattern specified by <-4,-4,-4,-4,4,9>; this method attempts to execute all mapping tasks that meet the above conditions and returns a Boolean value; the specific execution process is as follows:

[0509] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "5" (5, 13, <-4, -4, -4, -4, 4, 9>, 23, "Executing mapping task", empty set) { "Evidence-based task 5", "Group, Group, Indicator, Student's t-test, P value, numerical value", "?, ?, ?, ?, P value, 0.03", "P value, numerical value", "Task progress", "Dependent task set"};

[0510] ii. The inference engine queries the list of known (to be executed) mapping tasks to find out whether there is a mapping task (Md, Mr, A, Dep) where "13" is the same as Md, "23" is the same as Mr, and A has a specific semantics in the form of a semantic sequence and conforms to the pattern specified by <-4,-4,-4,-4,4,9>. Since there is no such mapping task, Prg is set to "Task Completed" and the method returns True.

[0511] 58) The reasoning engine now notices that in the list of known evidence-based reasoning tasks, there is an evidence-based reasoning task whose Prg is "task known but not evaluated" and Chd is an empty set. It then executes evaluateConstructAcquisitionTask with the task number "6" of the evidence-based reasoning task as a parameter, i.e., the operation in step 59) below.

[0512] 59)evaluateConstructAcquisitionTask(6): The inference engine obtains a set of mapping rules whose result semantics may meet the semantic screening condition (17, <4, 9, -4>), and attempts to register a new evidence-based task for each rule in the set; this method has no return value; the specific execution process is as follows:

[0513] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "6" (6, 17, <4, 9, -4>, 23, "Task known but not evaluated", empty set) {"Evidence-based task 6", "P value, value, is it different", "P value, 0.03,?", "P value, value", "Task progress", "Dependent task set"};

[0514] ii. Since the mapping rule named (17,23) is a feature extraction rule, the following operations are performed:

[0515] a) The mapping rule set of the result semantics that may meet the semantic screening conditions (17, <4, 9, -4>) {"P value, value, whether it is different", "P value, 0.03,?"} is obtained, that is, the mapping rule set named (?, 17) is obtained, where? represents any semantics; since no semantic fusion rules that meet the above conditions can be found in the reasoning engine, the Chd table of the evidence-based reasoning task is empty at this time;

[0516] b) Since the Chd set is empty after completing step a) above, the reasoning engine uses (6,17,<4,9,-4>) as parameters to execute examineExternalSource, i.e., the following step 60). The operation returns "evidence-based", and the reasoning engine sets the Prg of the evidence-based reasoning task with task number "6" to "task executable and being executed".

[0517] 60) The examineExternalSource operation in step b) of step ii of step 59) above, namely examineExternalSource(6,17,<4,9,-4>), is as follows: with the triple (6,17,<4,9,-4>) as the parameter, initiate the "external evidence-based feasibility check". If no external evidence-based interface API is started, the method returns "not evidence-based"; if any external evidence-based interface API is started, it returns "evidence-based". The specific execution process is as follows:

[0518] i. The inference engine accesses the "external evidence-based interface" list and scans all external evidence-based interfaces in the list. Each external evidence-based interface is represented by a triple (Aq, Pq, Api) {"a semantic code", "a special sequence consisting of 0, 1, 2", "an external program interface that can be called by the inference engine"}; the inference engine uses the information of Aq and Pq of an external evidence-based interface to determine whether the external evidence-based interface can obtain semantics that meet the semantic screening conditions (17, <4, 9, -4>) {"P value, numerical value, whether it is different", "P value, 0.03,?"};

[0519] ii. Since such an external evidence-based interface (17, <2,2,1>, Api3) can be found, the external evidence-based feasibility check immediately returns "evidence-based", and sends a command to start data transmission to the external evidence-based interface with the triple (6,17, <4,9,-4>) as a parameter. The Api obtains the semantics with code "17" and its associated semantics, the semantics in the sequence <4,9,-4> and its associated semantics, and the data corresponding to the semantics (such as Java object instances) through the semantic representation system, and obtains or calculates data outside the reasoning engine based on this information; the external evidence-based interface reports a retrieved result to the reasoning engine. The external semantic sequence <"P value", "0.03", "significant difference"> is obtained. The process is to first use the function of the semantic representation system to convert this external semantic sequence into semantics, obtain the semantic code "19", and then report "19" to the reasoning engine; since "19" is a newly generated semantic, the external evidence-based interface instructs the reasoning engine to perform the evaluateNewConstruct operation in step 61) below with "19" as the parameter; then the external evidence-based interface notifies the reasoning engine to set the progress status of the semantic acquisition of the evidence-based reasoning task numbered "6" to "mapping task in progress";

[0520] The steps to obtain the semantic code "19" are as follows:

[0521] learnPhysical("P value") gets the semantic code "4";

[0522] learnPhysical("0.03") gets the semantic code "9";

[0523] learnPhysical("There is a significant difference") gets the semantic code "11";

[0524] seqToCode(<4,9,11>) gets the semantic code "18";

[0525] identify(18,17) obtains the semantic code "19".

[0526] 61) The evaluateNewConstruct operation in step ii of step 60) above, namely evaluateNewConstruct(19){"P value, 0.03, significant difference"} is as follows: the reasoning engine scans the list of known evidence-based reasoning tasks. If "19" meets the semantic screening condition of a certain evidence-based reasoning task, it tries to register a new mapping task. The method has no return value. The specific execution process is as follows:

[0527] i. Use the getParadigm(19) function of the semantic representation system to return the semantic code "17" and obtain the paradigm semantics "17" of the semantics represented by "19"; use the getInstance(19) function of the semantic representation system to return the semantic code "18" and obtain the specific semantics "18" of the semantics represented by "19"; use the codeToSeq(18) function of the semantic representation system to return the sequence <4,9,11> and obtain the semantic sequence form <4,9,11> of the specific semantics;

[0528] ii. The reasoning engine searches whether the evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) has been registered. "17" is the same as Aq, and the semantic sequence <4, 9, 11> conforms to the semantic pattern specified by Sq. The evidence-based reasoning tasks that meet the above conditions are found: (4, 17, <-4, -4, -4>, 23, "Task is not executable", empty set) {"Evidence-based task 4", "P value, numerical value, is there a difference", "?, ?, ?", "P value, numerical value", "Task progress", "Dependent task set"} and (6, 17, <4, 9, -4>, 23, "Task is executable and is being executed", empty set) {"Evidence-based task 6", "P value, numerical value, is there a difference", "P value, 0.03, ?", "P value, numerical value", "Task progress", "Dependent task set"}; Therefore, the following steps iii-iv are executed for the above two evidence-based reasoning tasks respectively; after the execution is completed, the method returns;

[0529] iii. For the evidence-based reasoning task (4,17,<-4,-4,-4>,23,“Task cannot be executed”, empty set), since (17,23) is a feature extraction map, the reasoning engine takes (17,23,19, empty set) as a parameter and executes registerMapTask, which is the following step 62);

[0530] iv. For the evidence-based reasoning task (6,17,<4,9,-4>,23,“The task is executable and is being executed”, empty set), since (17,23) is a feature extraction map, the reasoning engine uses (17,23,19, empty set) as a parameter to execute registerMapTask, that is, execute the following step 62) again.

[0531] 62) The registerMapTask operation in step iii of step 61) above, namely registerMapTask(17,23,19,empty set){"P value, numerical value, whether there is a difference","P value, numerical value","P value,0.03, there is a significant difference","empty set"} is as follows: This method attempts to register a mapping task with the inference engine, and the method has no return value; (17,23) is the name of a mapping rule, and "19" is the starting semantics of the mapping task, and the mapping task has no dependent evidence-based reasoning tasks; the core feature of the mapping task is the triple (17,23,19); the specific steps are as follows: the inference engine first queries whether there is a record with the core feature of the triple (17,23,19) in the list of known (to be executed) mapping tasks; since the record does not exist, the inference engine adds a mapping task record named (17,23,19,empty set) to the list of known (to be executed) mapping tasks.

[0532] 63) The reasoning engine now notices that there is an evidence-based reasoning task in the list of known evidence-based reasoning tasks, and its Prg is "executing mapping task", so it executes finishConstructAcquisitionTask with the task number "6" of the evidence-based reasoning task as a parameter, which is the operation in step 64) below.

[0533] 64) finishConstructAcquisitionTask(6): The inference engine scans the list of known (to be executed) mapping tasks to find out whether there is a mapping task named (17,23){"P value, value, whether it is different", "P value, value"}, and the starting semantics of the mapping task have a specific semantics in the form of a semantic sequence that conforms to the pattern specified by <4,9,-4>{"P value", "0.03", "?"}; this method attempts to execute all the mapping tasks that meet the above conditions, and the method returns a Boolean value; the specific execution process is as follows:

[0534] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "6" (6, 17, <4, 9, -4>, 23, "mapping task is being executed", empty set) {"evidence-based task 6", "P value, value, is it different", "P value, 0.03,?", "P value, value", "task progress", "dependent task set"};

[0535] ii. The inference engine queries the list of known (to be executed) mapping tasks to find out whether there is a mapping task (Md, Mr, A, Dep), where "17" is the same as Md, "23" is the same as Mr, and A has a specific semantics in the form of a semantic sequence and conforms to the pattern specified by <4,9,-4>. It finds such a mapping task (17,23,19, empty set) {"P value, value, whether it is different", "P value, value", "P value, 0.03, there is a significant difference", "empty set"}, then the inference engine uses (17,23,19) as parameters and executes executeMapTask, i.e., step 65) below;

[0536] iii. When all mapping tasks that meet the above requirements are processed, since there are no pending mapping tasks, the Prg of the evidence-based reasoning task with task number "6" is set to "task completed", and the method returns True.

[0537] 65) The executeMapTask operation in step ii of step 64) above, namely executeMapTask(17,23,19){"P value, value, whether it is different","P value, value","P value, 0.03, there is a significant difference"} is as follows: This method allows the inference engine to try to execute a mapping task registered in the known (to be executed) mapping task list, and the method returns a Boolean value; since (17,23) is a feature extraction rule, the specific execution process is as follows:

[0538] i. Since the Dep set of the mapping task is an empty set, the mapping task is executed immediately, that is, the inference engine immediately executes the following steps ii-iv, deletes the record (17, 23, 19, empty set) in the list of known (to be executed) mapping tasks, and the method returns True;

[0539] ii. According to the standard writing of feature extraction rules (17, 23), based on the semantic code "19", a semantic code "26" of a specific semantic corresponding to the semantic sequence form of its characteristic semantics is generated, and the semantic code has a semantic sequence form <4, 9> {"P value", "0.03"};

[0540] iii.identify(26,23): confirms the existence (i.e. finds or generates) of a specific semantics containing the semantics represented by the semantic code "26" and the paradigm semantics represented by the semantic code "23". The method return value is the semantic code "27";

[0541] iv.map(19,27): confirms that the semantic representation system has recorded the mapping relationship between the semantics represented by the semantic code “19” and the semantics represented by the semantic code “27”.

[0542] 66) The reasoning engine now notices that in the list of known evidence-based reasoning tasks, there is an evidence-based reasoning task (task number "2"), whose Prg is "task known but not evaluated", and there is at least one corresponding evidence-based reasoning task with the progress of "task completed" in the number saved in the Chd set, and there is no evidence-based reasoning task with the progress of "task executable and executing" or "task known but not evaluated", so it sets its Prg to "mapping task executing";

[0543] 67) The reasoning engine now notices that there is an evidence-based reasoning task in the list of known evidence-based reasoning tasks, and its Prg is "executing mapping task", so it executes finishConstructAcquisitionTask with the task number "2" of the evidence-based reasoning task as a parameter, which is the operation in step 68) below.

[0544] 68) finishConstructAcquisitionTask(2): The inference engine scans the list of known (to be executed) mapping tasks to find out whether there is a mapping task named (23,21){"P value, value","group, group, indicator, whether it is different"}, and the starting semantics of the mapping task have the specific semantics in the form of semantic sequence that conforms to the pattern specified by <-4,-4>; this method attempts to execute all the mapping tasks that meet the above conditions, and the method returns a Boolean value; the specific execution process is as follows:

[0545] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "2" (2,23,<-4,-4>,21,"Mapping task is being executed",[3,4]){"Evidence-based task 2","P value, value","?,?"","Group, Group, Indicator, Is it different","Task progress","Dependent task set"};

[0546] ii. The inference engine queries the list of known (to be executed) mapping tasks to find out whether there is a mapping task (Md, Mr, A, Dep), where "23" is the same as Md, "21" is the same as Mr, and A has a specific semantics in the form of a semantic sequence and conforms to the pattern specified by <-4,-4>; since there is such a mapping task (23,21,27,[5,6]){"P value, numerical value", "group, group, indicator, whether it is different", "P value, 0.03", "dependent task set"}, the inference engine uses (23,21,27) as parameters and executes executeMapTask, that is, the following step 69);

[0547] iii. When the mapping tasks (23, 21, 27) are processed, since there are no pending mapping tasks, the Prg of the task number "2" is set to "task completed", and the method returns True.

[0548] 69) In the executeMapTask operation in step ii of step 68) above, namely executeMapTask(23,21,27){"P value, value","group,group,index,whether difference","P value,0.03"}: the inference engine tries to execute a mapping task registered in the list of known (to be executed) mapping tasks, and the method has no return value; since (23,21) is a semantic fusion rule, the specific execution process is as follows:

[0549] i. Since each evidence-based reasoning task in the Dep set of the mapping task has entered the "task completed" state, the mapping task is executed immediately, that is, the reasoning engine immediately executes the following steps ii-v, deletes the (23,21,27,[5,6]) record in the list of known (to be executed) mapping tasks, and the method returns True;

[0550] ii. Indicates that the semantics indicates that the system has forgotten the execution result of the last same semantic fusion task; the steps are as follows: translate(27,21), find out whether there is a mapping rule (denoted as T) such that the domain semantics of T is the paradigm semantics of the semantics with code "27", the value range semantics of T is the semantics with code "21", and the semantics of the semantics with code "27" that can be obtained through the mapping rule T has been recorded by the map function before. Since the method returns null, there is no execution result of the last same semantic fusion task;

[0551] iii. Obtain the parameter semantic set L of the semantic fusion task by:

[0552] a) According to the Dep1 parameter of the semantic fusion rule in the standard form (23,21,Dep1,Api1,Par1,Map11,Map12), the dependent semantic set of the rule is obtained, which is recorded as [13,17];

[0553] b) translate(27,13): Check if there is a mapping rule (denoted as T) such that the domain semantics of T is the paradigm semantics of the semantics with code "27", the range semantics of T is the semantics with code "13", and the semantics with code "27" that can be obtained through the mapping rule T has been recorded through the map function before, and the method returns the semantic code "15";

[0554] c) translate(27,17): Check if there is a mapping rule (denoted as T) such that the domain semantics of T is the paradigm semantics of the semantics with code "27", the range semantics of T is the semantics with code "17", and the semantics of the semantics with code "27" that can be obtained through the mapping rule T has been recorded through the map function before, and the method returns the semantic code "19";

[0555] d) Merge the results to obtain the parameter semantic set of the semantic fusion task [15,19];

[0556] iv. According to the semantic fusion rule (23, 21, Dep1, Api1, Par1, Map11, Map12) {“P value, numerical value”, “group, group, indicator, whether it is different”, “[13,17]”, “posRecomb”, “use the 1st to 3rd digits of the semantic sequence form of the parameter semantics with the paradigm semantics “13” and the 3rd digit of the semantic sequence form of the parameter semantics with the paradigm semantics “17” to form a new sequence”, “empty set”, “[(1,1),(2,2),(3,3),(4,4)]”}, use the parameter semantic set [15,19] and Par1 of the semantic fusion task as input parameters, call the application program interface “posRecomb”, execute the API of the external evidence-based interface and return a semantic sequence <6,7,8,11>; since Map11 is an empty set, the “result” of the semantic fusion task There is no corresponding relationship between the "specific semantics of the semantic sequence form of the result semantics" and the sequence position of the semantics represented by "27"; since Map12 is [(1,1),(2,2),(3,3),(4,4)]), the 1-4 bits of the "specific semantics of the semantic sequence form of the result semantics" are the same as the 1-4 bits of the Api output sequence, that is, <6,7,8,11>{"smokers", "non-smokers", "blood sodium", "significant difference"}; then the seqToCode(<6,7,8,11>) function of the semantic representation system is used to obtain the semantic code "28", and the identify(28,21) function of the semantic representation system is used to obtain the semantic code "29", and then "29" is reported to the inference engine. Since "29" is a newly generated semantic code, the inference engine uses "29" as a parameter to execute evaluateNewConstruct, that is, the following step 70);

[0557] v.map(27,29): confirms that the semantic representation system has recorded the mapping relationship between the semantics represented by the semantic code “27” and the semantics represented by the semantic code “29”.

[0558] At this time, the semantics indicates that the system stores Figure 3 The semantic structure of Figure 3 It is the semantic structure diagram of the end state of the evidence-based reasoning calculation process of the present invention.

[0559] Then do the following:

[0560] 70) The evaluateNewConstruct operation in step iv of step 69) above, namely evaluateNewConstruct(29){"smokers, non-smokers, blood sodium, significant difference"} is as follows: the reasoning engine scans the list of known evidence-based reasoning tasks. If "29" meets the semantic screening condition of a certain evidence-based reasoning task, it tries to register a new mapping task; the method has no return value; the specific execution process is as follows:

[0561] i. Use the getParadigm(29) function of the semantic representation system to return the semantic code "21" and obtain the paradigm semantic code "21" of the semantic represented by "29"; use the getInstance(29) function of the semantic representation system to return the semantic code "28" and obtain the specific semantic code "28" of the semantic represented by "29"; use the codeToSeq(28) function of the semantic representation system to return the sequence <6,7,8,11> and obtain the semantic sequence form <6,7,8,11> of the specific semantic;

[0562] ii. The reasoning engine searches whether the evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) has been registered. "21" {"group, group, indicator, whether it is different"} is the same as Aq, and <6,7,8,11> {"smokers", "non-smokers", "blood sodium", "significant difference"} meets the semantic pattern specified by Sq. The evidence-based reasoning task that meets the above conditions is found: (1,21, <6,7,8,-4>, empty, "task known but not evaluated", [2]) {"evidence-based task 1", "group, group, indicator, whether it is different", "smokers, non-smokers, blood sodium,?", "results fed back to users", "task progress", "dependent task set"}. Therefore, the following step iii is executed for this evidence-based reasoning task. After the execution is completed, the method returns.

[0563] iii. Since (21, empty) is a special feature extraction mapping, the inference engine uses (21, empty, 29, empty set) as parameters and executes registerMapTask, which is the step 71 below.

[0564] 71) The registerMapTask operation in step iii of step 70) above, namely registerMapTask(21, empty, 29, empty set) {"group, group, indicator, whether there is a difference", "results are fed back to the user", "smokers, non-smokers, blood sodium, there is a significant difference", "empty set"} is as follows: This method attempts to register a mapping task with the reasoning engine, and the method has no return value; (21, empty) is the name of a special mapping rule, "29" is the starting semantics of the mapping task, and the mapping task has no dependent evidence-based reasoning tasks; the core feature of the mapping task is the triple (21, empty, 29); the specific steps are: the reasoning engine first queries whether there is a record with the core feature of the triple (21, empty, 29) in the list of known (to be executed) mapping tasks; since the record does not exist, the reasoning engine adds a mapping task record named (21, empty, 29, empty set) to the list of known (to be executed) mapping tasks.

[0565] 72) The reasoning engine now notices that in the list of known evidence-based reasoning tasks, there is an evidence-based reasoning task (task number "1"), whose Prg is "task known but not evaluated", and there is at least one corresponding evidence-based reasoning task with the progress of "task completed" in the number saved in the Chd set, and there is no evidence-based reasoning task with the progress of "task executable and being executed" or "task known but not evaluated", then set its Prg to "mapping task being executed".

[0566] 73) The reasoning engine now notices that there is an evidence-based reasoning task in the list of known evidence-based reasoning tasks, and its Prg is "executing mapping task", so it executes finishConstructAcquisitionTask with the task number "1" of the evidence-based reasoning task as a parameter, which is the operation in step 74) below.

[0567] 74) finishConstructAcquisitionTask(1): The inference engine scans the list of known (to-be-executed) mapping tasks to find out whether there is a mapping task named (21, empty) whose starting semantics have a semantic sequence form and conforms to the pattern specified by <6,7,8,-4>; this method attempts to execute all the mapping tasks that meet the above conditions and returns a Boolean value; the specific execution process is as follows:

[0568] i. The reasoning engine queries the list of known evidence-based reasoning tasks and obtains the canonical form of the evidence-based reasoning task with task number "1" (1,21,<6,7,8,-4>,empty,"mapping task is being executed",[2]){"evidence-based task 1","group,group,indicator,is there a difference","smokers,non-smokers,blood sodium,?","results are fed back to the user","task progress","dependent task set"};

[0569] ii. The inference engine queries the list of known (to be executed) mapping tasks to find out whether there is a mapping task (Md, Mr, A, Dep), where "21" {"group, group, indicator, whether it is different"} is the same as Md, "empty" is the same as Mr, and A has a specific semantics in the form of a semantic sequence and conforms to the pattern specified by <6,7,8,-4> {"smokers", "non-smokers", "blood sodium", "?"}; since such a mapping task exists, the inference engine takes (21, empty, 29) as parameters and executes executeMapTask, that is, the following step 75):

[0570] iii. When the above mapping task is processed, the Prg of the evidence-based reasoning task with task number "1" is set to "task completed", and the method returns True.

[0571] 75) The executeMapTask operation in step ii of step 74) above, namely executeMapTask(21, empty, 29){"group, group, indicator, whether it is different", "results are fed back to the user", "smokers, non-smokers, blood sodium, there is a significant difference"} is as follows: the inference engine tries to execute a mapping task registered in the list of known (to be executed) mapping tasks, and the method has no return value; since (21, empty) is a feature extraction rule, the specific execution process is as follows:

[0572] i. Since the Dep set of the mapping task is an empty set, the mapping task is executed immediately, that is, the inference engine immediately executes the following step ii operation, deletes the (21, empty, 29, empty set) record in the list of known (to be executed) mapping tasks, and the method returns True;

[0573] ii. Since the value domain semantics of the mapping task is empty, the mapping task is a special feature extraction task. The mapping task only outputs its starting semantics (the semantics represented by "29") {"smoking population, non-smoking population, blood sodium, there is a significant difference"} and feeds it back to the user of the inference engine.

[0574] 76) At this point, the reasoning engine notices that the progress of all evidence-based reasoning tasks is at "task completed" or "task unexecutable", and the reasoning engine shuts down.

[0575] (III) Conversion between semantic intent data structure and table data structure

[0576] 3.1 How to express semantics through data tables

[0577] 3.1.1 Case Description of Implementation Example

[0578] Will Figure 1 The graph structure shown is converted into a table structure as follows:

[0579] Correspondence table between external semantics and semantic codes

[0580] "Semantic Code" "Java object instance" 1 "two" 2 "Enter" 3 "system" 4 "ten" 5 "1” 6 "0”

[0581] Correspondence table between semantics and semantic sequences

[0582]

[0583] Semantic Definition Table

[0584] "Semantic Code" "Paradigm Semantic Code" "Specific semantic code" 10 0 9 12 0 11 17 10 16 18 12 14

[0585] Mapping relationship table

[0586] "Paradigm Semantic Code 1" "Semantic Code 1" "Paradigm Semantic Code 2" "Semantic Code 2" 10 17 12 18

[0587] Objectives of this implementation case:

[0588] 1) Figure 1 The graph structure shown is converted into the table structure in 3.1.1 above;

[0589] 2) Convert the table structure in 3.1.1 above to Figure 1 The structure of the graph shown;

[0590] 3.1.2 Specific steps to convert semantic meaning into data table

[0591] Assume that the user has created Figure 1 Execute the following operations to convert the semantic meaning of the data into the data table described in 3.1.1 above:

[0592] 1) For each node in the graph, check whether it has the "javaObj" attribute. If the node has the "javaObj" attribute, add a new row of data in the "correspondence table of external semantics and semantic codes", store the information of the node's semantic code in the first column of the row, and store the information of the node's "javaObj" attribute in the second column of the row.

[0593] 2) For each node in the graph, determine whether it has a semantic sequence form: If the node has a semantic sequence form, and starting from the node, there is no edge marked with the node marker pointing to another node, then in the "correspondence table between semantics and semantic sequences", a new row of data is added, and the information of the node semantic code is stored in the first column of the row, and the information of the semantic sequence form of the node semantics is stored in the second column of the row.

[0594] 3) For each node in the graph, denoted as A, determine whether it constitutes a semantic meaning and record it in the "semantic definition table". The specific implementation method is as follows:

[0595] i.getParadigm(A): Returns the code of the paradigm semantics of the semantics with code A, and the return value is recorded as semantic code B;

[0596] ii.getInstance(A): Returns the specific semantic code of the semantic code A. The return value is the set [C1, ..., Cn], and an element in the set is Ci;

[0597] iii. For each pair of edges marked with “-1” and “-2” (B, Ci), if Ci is the semantic code stored in the first column of the “sequence table”, then in the “semantic definition table”, add a new row of data, store A in the first column of the row, store B in the second column of the row, and store Ci in the third column of the row.

[0598] 4) For each node in the graph, determine whether it has a mapping relationship with other nodes and record the relationship in the "mapping relationship table". The specific implementation method is as follows:

[0599] i. For each node in the graph, check whether it has the "javaObj" attribute. If the node does not have the "javaObj" attribute, check whether there is an edge from the node that is not marked by a special semantic code (special semantic codes include "-1", "-2", "-3", "-4" or its own mark) to another node. If there are edges that meet the above conditions, record the mark of the starting node of these edges as A, record the set of these edge marks as [E1, ..., En], record an element in the set as Ei, and perform the operations in the following steps for each element in the set;

[0600] ii.getParadigm(A): returns the code of the paradigm semantics of the semantics with code A, and the return value is recorded as semantic code B;

[0601] iii. translate(A, Ei): If there exists a mapping rule (denoted as T), the semantic domain of T is the canonical semantics of the semantics with code A, the semantic range of T is the semantics with code Ei, and the semantics obtained by the semantics with code A through the mapping rule T has been previously recorded by the map function, then this method returns one or a set of semantic codes [Si1,..., Sin], and an element in the set is denoted as Sij;

[0602] iv. For each set of records (B, A, Ei, Sij), query whether there is a row of data (B, A, Ei, Sij) or (Ei, Sij, B, A) in the "mapping relationship table". If it exists, this mapping relationship has been recorded. If it does not exist, a new row of data (B, A, Ei, Sij) is added to the "mapping relationship table".

[0603] 5) Through the above steps 1)-4), it can be converted into the form of the table structure in 3.1.1 according to Figure 1 the graph structure shown.

[0604] 3.1.3 Specific steps to convert the data table into a semantic graph

[0605] Assume that the user has created the data table described in the above 3.1.1, and perform the following operations to convert it into the graph structure form as Figure 1 shown:

[0606] 1) For each row of data in the "corresponding table of external semantics and semantic codes", use the learnPhysical function to encode the external semantics:

[0607] i. learnPhysical("two"): Returns the semantic code "1";

[0608] ii. learnPhysical("enter"): Returns the semantic code "2";

[0609] iii. learnPhysical("system"): Returns the semantic code "3";

[0610] iv. learnPhysical("ten"): Returns the semantic code "4";

[0611] v. learnPhysical("1"): Returns the semantic code "5";

[0612] vi. learnPhysical("0"): Returns the semantic code "6";

[0613] 2) For each row of data in the "correspondence table between semantics and semantic sequences", use the seqToCode function to encode the sequence and add a new node to the graph based on each row of data:

[0614] i.seqToCode(<>): returns the semantic code "0";

[0615] ii.seqToCode(<1,2,3>): converts the semantic sequence <1,2,3> into a semantic code. The method returns the semantic code "10";

[0616] iii.seqToCode(<4,2,3>): converts the semantic sequence <4,2,3> into a semantic code. The method returns the semantic code "11";

[0617] iv.seqToCode(<5,6,5,6>): converts the semantic sequence <5,6,5,6> into a semantic code. The method returns the semantic code "16".

[0618] v.seqToCode(<5,6>): Converts the semantic sequence <5,6> into a semantic code. The method return value is the semantic code "14".

[0619] 3) For each row of data in the "Semantic Definition Table", use the identify function to create a new semantic code, whose paradigm semantics are the semantics corresponding to the "Paradigm Semantics" column, and whose specific semantics include the semantics corresponding to the "Specific Semantics" column, and add a new node to the graph based on each row of data:

[0620] i.identify(9,0); find or generate a semantic code, the paradigm semantics of the semantics represented by it is the semantics with code "0", and the specific semantics of the semantics represented by it includes the semantic sequence semantics or single semantics represented by "9", and the method return value is the semantic code "10";

[0621] ii.identify(11,0); find or generate a semantic code, the paradigm semantics of the semantics represented by the code is the semantics of code "0", and the specific semantics of the semantics represented by the code includes the semantic sequence semantics or single semantics represented by "11", and the method return value is the semantic code "12";

[0622] iii.identify(16,10); find or generate a semantic code, the paradigm semantics of the semantics represented by the code is the semantics of code "10", the specific semantics of the semantics represented by the code includes the semantic sequence semantics or single semantics represented by "16", and the method return value is the semantic code "17";

[0623] iv.identify(14,12): find or generate a semantic code, the paradigmatic semantics of the semantics it represents is the semantics with code "12", the specific semantics of the semantics it represents includes the semantic sequence semantics or single semantics represented by "14", and the method return value is the semantic code "18".

[0624] 4) For each row of data in the "mapping relationship table", use the map function to build the relationship between the two semantics: map(17,18): The semantics with code "18" can be obtained from the semantics with code "17" through a certain mapping rule T. At this time, the semantics with code "17" can be obtained from the semantics with code "18" through the inverse of mapping rule T; the method has no return value.

[0625] 5) Through the above steps 1)-4), the table structure in 3.1.1 can be converted into Figure 1 The constructed graph structure.

[0626] The above examples are only specific embodiments of the present invention. Obviously, the present invention is not limited to the above examples, and may have many variations. All variations that can be directly derived or associated with the contents disclosed by ordinary technicians in this field should be considered to be within the protection scope of the present invention.

Claims

1. A logic representation and reasoning engine method, characterized in that: The method includes a semantic representation method, a logical representation method and a reasoning calculation method. The three parts are organically combined to obtain new semantics based on known semantics reasoning, wherein: 1) In the semantic representation method described above, the following relationship exists between the semantics: i. A semantics denoted as A corresponds to a semantics denoted as B through a one-to-one relationship. B is called the paradigm semantics of A. ii. A semantics denoted as A corresponds to one or more semantics through a one-to-many relationship. These one or more semantics are called the specific semantics of A. iii. The semantics are related by the mapping rule in item 2) below; the relationship established based on the mapping rule is similar to the one-to-one relationship between the semantics in point i and the one-to-many relationship between the semantics in point ii above, and can be recorded and read; iv. Two semantics merge to form one semantic, and the merged semantic has all the relationships between the two semantics before the merger and other semantics; from the definition of semantic merging, we can know that only semantics with the same paradigm semantics can be merged with each other, otherwise the merged semantic has two or more paradigm semantics, which violates the above-mentioned rule i; v. In actual applications, if there is no need to merge semantics, the semantic merging feature of the above semantic representation method may not be reflected in the specific implementation of the semantic representation method; 2) The logical representation method described above is a set of mapping rules, and the mapping rules have the following characteristics: i. The mapping rule is a one-to-many mapping, that is, one semantics can be obtained through one mapping rule to obtain one or more semantics; Different semantics obtain the same semantics through the same mapping rule; the process of obtaining one or more semantics through a mapping rule is called a mapping task, and A is the starting semantics of the mapping task; ii. A specific mapping rule denoted by T has a specific domain, that is, T only acts on the semantics with a specific semantics denoted by D as the paradigm semantics. D is called the domain semantics of T. iii. A specific mapping rule denoted by T has a specific value range, that is, through T, only the semantics with a specific semantics denoted by R as the paradigm semantics are obtained, and R is called the value range semantics of T; iv. During the execution of a mapping task, a set of semantics related to the starting semantics of the task is used as parameters. This set of semantics is called a parameter semantic set of a mapping task; v. A mapping rule has a one-to-one correspondence with the combination of its domain semantics and range semantics; that is, a mapping rule has a domain semantics and a range semantics; when a pair of semantics is given as the domain semantics and the range semantics of a mapping rule, the mapping rule is uniquely determined or determined to exist; therefore, a semantic tuple denoted as (D, R) is used to represent the name of a mapping rule; vi. The mapping rule is reversible, that is, if there is a mapping rule denoted by T, the domain semantics of T is D, and the range semantics of T is R, then there must be another mapping rule denoted by T', the domain semantics of T' is R, and the range semantics of T' is D; and when a semantics denoted by A is obtained by another semantics denoted by B through the mapping rule T, B is obtained by the mapping rule T'. 3) The reasoning calculation method described above triggers the execution of the mapping task when the semantics is generated or updated: i. The generation of semantics refers to combining a paradigmatic semantics and at least one specific semantics into a new semantics; ii. Updating of semantics refers to changing the relationship between one semantics and other semantics, including: recording the mapping relationship between the semantics and other semantics, merging two semantics into one semantics, adding or deleting the relationship between a semantic and its specific semantics; in practical applications, if there is no change in the relationship between certain semantics, the specific implementation of the reasoning calculation method may not reflect the content of processing the change in the relationship between these semantics; iii. When a semantic is generated, the execution of a mapping task defined by a mapping rule that can act on the semantic is triggered, taking the semantic as the starting semantic; when a semantic is updated, the execution process is triggered to update the result of the executed mapping task using the semantic as the parameter semantic; until there is no mapping task that can be executed or should update the result; in actual application, if there is no need to trigger the update result of the executed mapping task, the corresponding mechanism is not reflected in the specific implementation of the reasoning calculation method; The method is implemented by a specially designed hardware computing device, and is specifically implemented by a specially designed neural network computing hardware. The design and operation of the hardware computing device correspond to the structure and operation of the graph. The characteristics of the corresponding relationship are: one semantic code corresponds to one hardware neuron, the semantic code is the label of the node or edge in the graph, the hardware neuron is the hardware computing unit, that is, each hardware neuron can be addressed and activated by a semantic code; the hardware computing device includes a large number of spare hardware neurons, each spare hardware neuron corresponds to a unique code that can be used as a semantic code as its address, and the spare hardware neurons are enabled on demand; The hardware computing device operation corresponding to the basic mode of operation of the graph structure is to find the third hardware neuron that can be activated through two activated hardware neurons with codes A and B, and activate the hardware neuron under certain conditions; when the graph operation needs to generate nodes or edges marked with new semantic codes, enable the spare hardware neurons to generate new semantic codes, and connect the newly enabled hardware neurons accordingly according to the logic of the graph operation; a hardware neuron can only be activated when its two input hardware neurons are in an activated state; if there is an edge in the graph whose mark is the same as the mark of its starting node, then the hardware neuron with the end node mark of the edge as the address can only be activated when a hardware neuron with the starting node mark of the edge as the address is in an activated state, and the functions of other hardware computing devices are designed accordingly on the basis of the above functions corresponding to the graph operation.

2. The logic representation and reasoning engine method according to claim 1, characterized in that: The reasoning calculation method is further improved to realize evidence-based reasoning. The specific implementation of a reasoning calculation method is a reasoning engine. The improvement is as follows: 1) Define a method for expressing a semantic pattern; the function of the semantic pattern is to enable the reasoning engine to determine whether a semantic pattern meets specific requirements based on it; 2) Implementing the semantic screening function of the inference engine, specifically in the form of: combining a semantic denoted as Aq and a semantic pattern denoted as Sq, the inference engine screens a set of semantics from the generated semantics, the set of semantics takes Aq as the paradigm semantics, and each semantic has at least one specific semantic, and the specific semantic meets the requirements specified by Sq; the tuple (Aq, Sq) is called a semantic screening condition; 3) Implement a working mode of the reasoning engine, called evidence-based reasoning; in the working mode of evidence-based reasoning, the reasoning engine or the user proposes a reasoning task to the reasoning engine, and provides a semantic screening condition as a task parameter, where the semantic screening condition is denoted as (Aq, Sq). The reasoning engine obtains the semantics that meet the semantic screening condition (Aq, Sq) through reasoning operations. After the reasoning is completed, the reasoning engine feeds back the semantics that meet the semantic screening condition to the reasoning engine or the user.

3. The logic representation and reasoning engine method according to claim 2, characterized in that: The method for the reasoning engine to complete the evidence-based reasoning operation is as follows: 1) Define another type of task that is not a mapping task and is performed by the reasoning engine, called an evidence-based reasoning task; an evidence-based reasoning task has three core features, recorded as a triple (Aq, Sq, At); where Aq and At are two semantics, and Sq is a semantic pattern; the meaning of the triple is that the reasoning engine should obtain semantics that meet the semantic screening condition (Aq, Sq), and take each of these semantics as a starting semantic, and perform the mapping task according to the mapping rule named (Aq, At); 2) If a to-be-completed evidence-based reasoning task can be completed by a non-inference method known to the reasoning engine, then the evidence-based reasoning task is completed in this way; 3) If a pending evidence-based reasoning task cannot be completed by a non-reasoning method known to the reasoning engine, the reasoning engine analyzes the semantic screening condition of the evidence-based reasoning task, that is, the semantic screening condition represented by the tuple composed of the first and second elements of the feature triple of the evidence-based reasoning task, which is recorded as (Aq, Sq). The reasoning engine compares all mapping rules, calculates which mapping rules may obtain the result semantics that meet the semantic screening condition (Aq, Sq), and calculates which semantic screening condition the starting semantics of the mapping task needs to meet when the result semantics that meet the condition are obtained; the semantic screening condition that the starting semantics of the mapping task needs to meet is recorded as (Ao, So). The reasoning engine creates a pending evidence-based reasoning task (Ao, So, Aq) based on the semantic screening condition (Ao, So) to obtain the starting semantics that meet the semantic screening condition (Ao, So), and executes the mapping task defined by the mapping rule (Ao, Aq) based on these starting semantics to obtain the semantics that meet the semantic screening condition (Aq, Sq); 4) The reasoning engine repeats steps 2) and 3) above until all pending evidence-based reasoning tasks are completed. or is judged to be incompletable.

4. The logic representation and reasoning engine method according to claim 2 or 3, characterized in that: The user proposes a reasoning task to the reasoning engine, and gives a semantic screening condition as a task parameter. The semantic screening condition is recorded as (Aq, Sq). The reasoning engine needs to create a corresponding evidence-based reasoning task to be completed to obtain semantics that meet the semantic screening condition (Aq, Sq); under the evidence-based reasoning operation framework, the following special operations are performed: 1) Create a special evidence-based reasoning task to be completed, represented as a triple (Aq, Sq, empty); 2) Define a special type of mapping rules. This type of mapping rules has a two-tuple name (Aq, empty), where Aq is a semantic. The mapping task defined by this type of mapping rules will not obtain the result semantics, nor the relationship between the semantics. The mapping task only outputs it as the starting semantics and feeds it back to the user of the inference engine.

5. The logic representation and reasoning engine method according to claim 1, characterized in that: The mapping rules include feature extraction rules and semantic fusion rules; the inference calculation method extracts the features of semantics through the feature extraction rules, and fuses semantics with the same features through the semantic fusion rules to form new semantics, which are in the following form: 1) Feature extraction rules: i. A feature extraction rule denoted as E is based on a specific semantics denoted as A semantics, and the specific semantics of the result semantics are calculated, and then the specific semantics of the result semantics are combined with the given paradigm semantics to obtain the result semantics denoted as B of the feature extraction mapping; the above process is called a feature extraction task, E is the definition rule of the task, A is the starting semantics of the task, and B is the result semantics of the task; ii. If a semantics denoted as A is obtained through a feature extraction task to obtain a semantics denoted as B, B is called the characteristic semantics of A or A has characteristic semantics B; iii. One semantics is processed through one feature extraction task to obtain a result semantics; multiple different semantics can be processed through the same or different feature extraction tasks to obtain the same result semantics; 2) Semantic fusion rules: i. A semantic fusion rule denoted as F is based on a semantic denoted as A, where A is a characteristic semantic. First, a set of semantics denoted as L with characteristic semantics A is obtained. Then, based on the semantics in the set L, a set of specific semantics of result semantics is calculated. Then, the specific semantics of the result semantics obtained are combined with the given paradigm semantics to obtain a set of result semantics of semantic fusion mapping, denoted as [B1, ..., Bn], one of which is denoted as Bi. The above process is called a semantic fusion task, F is the definition rule of the task, A is the starting semantics of the task, [B1, ..., Bn] is the result semantic set of the task, and L is the parameter semantic set of the task. In the execution process of all semantic fusion tasks with definition rule F, the set composed of the paradigm semantics of all possible member semantics of L is called the dependent semantic set of the semantic fusion rule F. ii. If a semantics denoted as A is obtained through a semantic fusion task to obtain a semantics denoted as Bi, Bi is called the extended semantics of A or A has the extended semantics Bi; iii. A semantics may obtain a set of result semantics through a semantic fusion task; multiple different semantics may obtain the same result semantics through the same or different semantic fusion rules.

6. The logic representation and reasoning engine method according to claim 1, characterized in that: In order to express the characteristics of a semantic, a feature is added to the semantic representation method: a semantic denoted by A represents a sequence composed of semantics; a sequence composed of semantics is called a semantic sequence; when semantic A can represent a semantic sequence, semantic A is said to have the form of a semantic sequence; in the subsequent description, the use of semantic A defaults to its non-semantic sequence form, and will be explicitly stated when using its semantic sequence form.

7. The logic representation and reasoning engine method according to claim 6, characterized in that: Use any semantic representation technology that meets the characteristics of the semantic representation method, and abstract the semantic representation function into a set of standardized method call interfaces. This set of method call interfaces has the following characteristics: 1) Use semantic codes to represent semantics, with one semantic code corresponding to its code; 2) having the function "converting a semantic sequence into a semantic code": seqToCode(seq), where seq is a sequence of semantic codes; the method returns a semantic code denoted as S, and seq is the semantic sequence form of S; 3) having the function "convert semantic code to semantic sequence": codeToSeq(code), code is a semantic code, the semantic with code as code has the form of semantic sequence, and the method returns the semantic sequence in the form of a sequence of semantic codes; 4) Has the function of "identifying a semantic through paradigm semantics and specific semantics": identify(instance, paradigm), the instance and paradigm are semantic codes, instance is a code of a single semantic or a code of a semantic in the form of a semantic sequence returned by the above seqToCode function; the method returns a semantic code, whose paradigm semantic is the semantic coded as paradigm, and whose specific semantic includes a single semantic or a semantic in the form of a semantic sequence represented by instance; 5) has the function "add a specific semantic to a semantic": addInstance(instance, code), which adds the semantic with code instance as the specific semantic of the semantic with code code; instance is a single semantic code or a semantic code in the form of a semantic sequence returned by the above seqToCode function; the method has no return value; 6) It has the function "get a semantic paradigm semantics": getParadigm(code), code is a semantic code; The method returns the code of the semantic paradigm of the semantic code code, and the return value is a semantic code; 7) having the function of "getting a specific semantics of a semantics": getInstance(code), where code is a semantics code; the method returns the code of the specific semantics of the semantics whose code is code, and the return value is one or more semantics codes; 8) It has the function of "recording that two semantics can be obtained through mapping rules": map(code1, code2), where code1 and code2 are two semantic codes; when the paradigm semantics of the two semantics with codes code1 and code2 are different, the method records that the two semantics with codes code1 and code2 have a mapping relationship, that is, there is a specific mapping rule denoted as T, the domain semantics of T is the paradigm semantics of the semantics with code code1, the range semantics of T is the paradigm semantics of the semantics with code code2, the semantics with code code2 is obtained from the semantics with code code1 through the mapping rule T, and at this time, the semantics with code code1 must be obtained from the semantics with code code2 through the inverse of the mapping rule T; when the paradigm semantics of the two semantics with codes code1 and code2 are the same, the method merges the two semantics with codes code1 and code2, the code of the merged semantics is code1, and the merged semantics has all the relationships between the two un-merged semantics and other semantics; the method has no return value; 9) Has the function of "obtaining a semantic meaning obtained through a mapping rule": translate(code, paradigm), code is a semantic code; if the code of the paradigm semantics of code is the same as paradigm, then code is returned; If they are not the same, then check whether there is a mapping rule denoted as T, the domain semantics of T is the paradigm semantics of the semantics with code code, the range semantics of T is the semantics with code paradigm, and the semantics obtained by the semantics with code code through the mapping rule T has been previously recorded through the above-mentioned map function, then the method returns one or a group of codes of the semantics obtained by the semantics with code code through the mapping rule T; otherwise, the method returns null; 10) It has the function of "forgetting that the relationship between two semantics can be obtained through mapping rules": unMap(code1, code2), code1 and code2 are two semantic codes; when the paradigm semantics of the two semantics coded as code1 and code2 are different, the method confirms that the two semantics coded as code1 and code2 do not have a mapping relationship, the domain semantics of T is the paradigm semantics of the semantics coded as code1, the range semantics of T is the paradigm semantics of the semantics coded as code2, the semantics coded as code2 cannot be obtained from the semantics coded as code1 through the mapping rule T, and the semantics coded as code1 cannot be obtained from the semantics coded as code2 through the inverse of the mapping rule T; when the paradigm semantics of the two semantics coded as code1 and code2 are the same, the method is the same as the forget in item 11) below; the method has no return value; 11) having the function of "forgetting a semantic": forget(code), code is a semantic code; the method deletes the semantic with code code and the relationship between the semantic and all other semantics, including the relationship between the semantic and its paradigm semantics and specific semantics, and the relationship between the semantic and other semantics established by mapping rules; 12) In actual applications, when some of the above functions are not needed, the unnecessary functions are not implemented.

8. The logic representation and reasoning engine method according to claim 5, 6 or 7, characterized in that: The mapping rules are calculated using the specific semantics in the form of semantic sequence based on the semantics, and the form is as follows: 1) The feature extraction rule is based on the specific semantics of a semantic sequence form, extracts the semantics at a specific position on the semantic sequence, and reorganizes and transforms it to obtain the specific semantics of the semantic sequence form of the result semantics, and then combines the obtained specific semantics of the semantic sequence form of the result semantics with the given paradigm semantics to obtain the result semantics of the feature extraction mapping; 2) The semantic fusion rule is based on a semantic denoted by A, where A is a characteristic semantic. First, a set denoted by L of semantics with characteristic semantic A is obtained. Then, based on the semantics in the set L, the specific semantics in the form of a semantic sequence of the semantics in L are obtained. The semantics at specific positions on the semantic sequence are extracted and reorganized and transformed to obtain a set of specific semantics in the form of a result semantic sequence. The specific semantics in the form of a result semantic sequence is combined with the given paradigm semantic to obtain a set of result semantics of semantic fusion mapping.

9. The logic representation and reasoning engine method according to claim 8, characterized in that: The semantic reasoning calculation method is implemented as a reasoning engine with the following features: 1) The inference engine records all known mapping rules; the names of known mapping rules are represented by a tuple consisting of two semantics; 2) The content of the mapping rules is written in a standardized way that can be understood by the inference engine: i. The inference engine can determine the type of mapping rule with a specific name based on the standard writing method of the mapping rule; ii. The reasoning engine can determine the dependent semantics of a semantic fusion rule based on the standard writing of the mapping rule; iii. The reasoning engine can complete the calculation of the specific semantics of the semantic sequence of the result semantics of a mapping task according to the standard writing of the mapping rules; 3) The inference engine registers the mapping tasks to be executed and executes them when computing resources allow, until there are no more executable mapping tasks; a mapping task can be recorded as a triple (Md, Mr, A), where Md and Mr are the domain semantics and range semantics of the mapping rule, respectively, and the combination (Md, Mr) indicates the name of a specific mapping rule, and A is the starting semantics of the mapping task; 4) When executing a feature extraction task (Ed, Er, A), perform the following operations: i. According to the standard writing of feature extraction rules (Ed, Er), based on A, a specific semantics R in the form of a semantic sequence corresponding to its characteristic semantics is generated; ii. Confirm that there is a specific semantics containing R and a paradigm semantics Er, which is recorded as Fi; in this process, if Fi is generated, then the relevant operations required for generating new semantics are performed with Fi as a parameter, and the operation is the following item 6); iii. Confirm that the semantic representation system records the mapping relationship between A and Fi; in this process, if a new mapping relationship is recorded, the relevant operation required for recording the new mapping relationship is performed with the tuple (A, Fi) as a parameter, and the operation is the following item 7); 5) When executing a semantic fusion task (Fd, Fr, A), the following operations are performed: i. Instruct the semantic representation system to forget the previous execution result of the same semantic fusion task; the steps are as follows: a) Obtain the semantic set of the result of the previous semantic fusion task, the result is recorded as [B1, ..., Bn], and an element of the set is recorded as Bi; b) The instructive semantic representation system forgets the mapping relationship between each pair (A, Bi); ii. Obtain the parameter semantic set L of the semantic fusion task by: a) According to the name of the semantic fusion rule (Fd, Fr), the dependent semantic set of the rule is obtained, which is recorded as [P1, ..., Pn], and one of the dependent semantics is recorded as Pi; b) For each Pi, find the result of applying the mapping (Fd, Pi) to A, and combine the results to obtain L; iii. According to the standard writing of semantic fusion rules (Fd, Fr), based on L, a set of specific semantics of A in the form of extended semantic sequence is calculated [R1, ..., Rn], one of which is denoted as Ri; iv. confirm that there is a specific semantics containing Ri and a paradigm semantics Fr, denoted by Ci; in this process, if Ci is generated, then the relevant operations required for generating new semantics are performed with Ci as a parameter, and the operation is the following item 6); v. Confirm that the semantic representation system has recorded the mapping relationship between A and Ci; in this process, if a new mapping relationship is recorded, the relevant operation required for recording the new mapping relationship is performed with the tuple (A, Ci) as a parameter, and the operation is the following item 7); 6) When the new semantics are generated, perform the following operations: record the newly generated semantics, that is, the parameter of this operation is A, This operation attempts to register the feature extraction task to be executed with the inference engine, which is recorded as (Ed, ?, A); Ed is the paradigm semantics of A, (Ed,?) represents all feature extraction rules with Ed as the domain semantics; 7) When the new mapping relationship is recorded, the following operation is performed: if the record of the new mapping relationship corresponds to calling the map function of the semantic representation system with (A1, A2) as the parameter, the parameter of this operation is recorded as (A1, A2), and this operation attempts to register the semantic fusion task to be executed with the inference engine, which is recorded as (F2,?[F1], A2); F2 is the paradigm semantics of A2, F1 is the paradigm semantics of A1, (F2,?[F1]) represents all semantic fusion rules that use F2 as the domain semantics and whose dependent semantic set includes F1; 8) As an optional improvement to improve computing efficiency, when registering pending tasks, the inference engine only retains one record for the same task, that is, only one record is retained for pending tasks with the same (Fd, Fr, A) triple. When the inference engine attempts to execute a semantic fusion task, let its semantic fusion rule be R. It first checks whether there is a feature extraction task to be executed, let its feature extraction rule be Q, and the value domain semantics of Q belongs to the dependent semantics of R. If such a feature extraction task to be executed exists, it is executed first.

10. The logic representation and reasoning engine method according to claim 9, characterized in that: When expressing feature extraction rules, the following conventions are used: 1) The value range semantics of feature extraction rules has a unified special paradigm semantics; 2) The domain semantics of the feature extraction rule has a specific semantics in the form of a semantic sequence. The first position of the semantic sequence is the domain semantics of the feature extraction rule. Starting from the second position, the position is numbered x. The semantic code at position x represents a number nx, which means that the semantic code at the (x-1)th position of the specific semantics in the semantic sequence form of the result semantics of the feature extraction task is the semantic code at the nxth position of the specific semantics in the semantic sequence form of the starting semantics of the feature extraction task. 3) When the domain semantics of feature extraction rules are expressed using the specifications in items 1) and 2) above, since the domain semantics has already explained how the feature semantics are generated, the inference engine only needs the name of the feature extraction rule, i.e., a tuple consisting of its domain semantics and range semantics, and no other information is required to complete the feature extraction task.

11. The logic representation and reasoning engine method according to claim 9, characterized in that: When expressing semantic fusion rules, the standard form of seven tuples is used, which is recorded as (Ad, Ar, Dep, Api, Par, Map1, Map2), where: 1) Ad is the domain semantics of the semantic fusion rule; Ar is the value domain semantics of the semantic fusion rule; therefore, the name of the semantic fusion rule with the standard form (Ad, Ar, Dep, Api, Par, Map1, Map2) is (Ad, Ar)； 2) Dep is the dependent semantic set of the semantic fusion rule; 3) Api is an application program interface that can be called by the inference engine, and its input is: i. the parameter semantic set L of the semantic fusion task described in item 5) of point ii; ii. the parameter Par passed to the application program interface as indicated by the canonical form of the semantic fusion rule; 4) The application program interface specified by Api outputs a set of semantic sequences; during the execution of a semantic fusion task, each semantic sequence output by Api is a specific semantic component in the form of a semantic sequence of the result semantics of the task; the semantic sequences output by this set of Api are denoted as [Rc1, ..., Rcn], and one of the semantic sequences is denoted as Rci; 5) Map1 is a set of correspondences of sequence positions, specifying the correspondence between the "specific semantics of the semantic sequence form of the result semantics" of a semantic fusion task and its "specific semantics of the semantic sequence form of the starting semantics": a position on the "specific semantics of the semantic sequence form of the starting semantics" of a semantic fusion task corresponds to zero, one or more specific semantic positions on the semantic sequence form of the result semantics of the task; 6) Map2 is a set of correspondences of sequence positions, specifying the correspondence between the specific semantics of the semantic sequence form of the result semantics of a semantic fusion task and the sequence position of the semantic sequence output by its API: a position on the semantic sequence output by an API corresponds to zero, one or more specific semantic positions on the semantic sequence form of the result semantics of the task; 7) Map1 and Map2 together specify the source of the semantics at each sequence position of the specific semantics in the semantic sequence form of the result semantics of the semantic fusion task without conflict; the inference engine thereby obtains the specific semantics in the semantic sequence form of the complete result semantics of the semantic fusion task, i.e., the specific semantics [R1,…,Rn] in the semantic sequence form of the extended semantics of A as described in point iii of item 5).

12. The logic representation and reasoning engine method according to claim 10 or 11, characterized in that: Further standardize the definition of mapping rules, requiring: 1) The domain semantics of any feature extraction mapping is not the range semantics of any feature extraction mapping; 2) The domain semantics of any semantic fusion mapping must be the value domain semantics of a feature extraction mapping; 3) The range semantics of arbitrary semantic fusion mapping is not the range semantics of arbitrary feature extraction mapping.

13. The logic representation and reasoning engine method according to claim 1 or 2 or 3 or 5 or 6 or 7 or 9 or 10 or 11, characterized in that: The following restrictions are imposed on the evidence-based working mode of the reasoning engine: when a user asks a question to the reasoning engine, the semantic screening condition given is recorded as (Aq, Sq), and Aq is not the value domain semantics of the feature extraction mapping; the principle of adding this restriction is that the essence of the semantic screening condition is to extract the features of a semantic sequence and determine whether it meets the requirements, and the semantic screening condition should not extract features from the specific semantics in the form of a semantic sequence of the feature semantics.

14. The logic representation and reasoning engine method according to claim 13, characterized in that: The specific way in which the reasoning engine handles evidence-based reasoning tasks is as follows: 1) Define a canonical form of an evidence-based reasoning task. On the basis of the core feature triple of the evidence-based reasoning task, add information indicating the task execution status, which can be specifically represented as a six-tuple (No, Aq, Sq, At, Prg, Chd); No is a task number; (Aq, Sq) constitute a semantic screening condition; At is a semantic code, which indicates obtaining a set of semantics that meet the semantic screening condition (Aq, Sq), the purpose of which is to execute a mapping rule named (Aq, At) with each of the semantics in the set as the starting semantic; Prg is the progress of acquiring semantics, reflecting the following progress status: "task known but not evaluated", "task executable and being executed", "task not executable", "task completed"; Chd is a set of task numbers, recording the numbers of the evidence-based reasoning tasks that the completion of the evidence-based reasoning task depends on; 2) The reasoning engine maintains a list of known evidence-based reasoning tasks; When the user starts the evidence-based reasoning working mode and proposes semantic screening conditions (Aq, Sq) to the reasoning engine, a standardized evidence-based reasoning task is registered: a six-tuple (a new task number, Aq, Sq, empty, "task known but not evaluated", empty set); 3) When there is an evidence-based reasoning task, denoted as X, its canonical form is (No, Aq, Sq, At, Prg, When the value of (Chd, Prg) is "the task is known but not evaluated", Chd is an empty set, At is empty, or the mapping rule named (Aq, At) is a feature extraction rule, the inference engine performs the following operations: i. Obtain a mapping rule set whose result semantics may meet the semantic screening condition (Aq, Sq), that is, obtain a mapping rule set named (?, Aq), where ? represents any semantic; denote such a rule in the set as (Ao, Aq), the range semantics of any feature extraction mapping cannot be the definition domain semantics of any feature extraction mapping, so (Ao, Aq) is not a feature extraction mapping, but must be a semantic fusion mapping; ii. For each (Ao, Aq), try to register a new evidence-based reasoning task (No1, Ao, So, Aq, Prg1, Chd1); No1 is a new evidence-based reasoning task number; So is the semantic pattern calculated by the reasoning engine according to the definition of the semantic fusion rule named (Ao, Aq), The semantic pattern and the semantic Ao form a semantic screening condition, so that each semantic that meets the semantic screening condition (Ao, So) is used as the starting semantic, and the semantic obtained by mapping (Ao, Aq) must contain all semantics that may be obtained by mapping (Ao, Aq) and meet the semantic screening condition (Aq, Sq); Prg1 is set to "task known but not evaluated"; Chd1 is set to an empty set; the inference engine records the task number returned by the registration operation into the Chd set; iii. If the Chd set is empty after completing the above steps i and ii, initiate an external evidence-based feasibility check with the triple (No, Aq, Sq) as a parameter. If the check returns "evidence-based", set Prg to "task executable and being executed", otherwise set it to "task not executable"; 4) When there is an evidence-based reasoning task X whose canonical form is (No, Aq, Sq, At, Prg, Chd), Prg is a known but not evaluated task, Chd is an empty set, and the mapping rule named (Aq, At) is a semantic fusion rule, the reasoning engine performs the following operations: i. According to the definition of the semantic fusion rule named (Aq, At), we get its dependent semantic set [D1, ..., Dn], let one of the semantics be Di, then there must be a defined feature extraction mapping (Di, Aq); ii. For each (Di, Aq), try to register a new evidence-based reasoning task (No1, Di, Sio, Aq, Prg1, Chd1); No1 is a new evidence-based reasoning task number; Sio is a semantic pattern calculated by the reasoning engine according to the definition of the feature extraction rule named (Di, Aq), and the semantic pattern and the semantic Di constitute the semantic screening condition, so that each semantic that meets the semantic screening condition (Di, Sio) is used as the starting semantic, and the semantic obtained by mapping (Di, Aq) must contain all possible semantics that meet the semantic screening condition (Aq, Sq) obtained by mapping (Di, Aq); Prg1 is set to "task known but not evaluated"; Chd1 is set to an empty set; the inference engine records the task number returned by the register operation into the Chd set; 5) The operation steps of the reasoning engine trying to register an evidence-based reasoning task are as follows: the evidence-based reasoning task to be registered is denoted as X, and its canonical form is (No, Aq, Sq, At, Prg, Chd); the reasoning engine searches whether there is a known evidence-based reasoning task, denoted as X1, and its canonical form is (No1, Aq1, Sq1, At1, Prg1, Chd1), so that Aq is the same as Aq1, Sq is the same as Sq1, and At is the same as At1; if it exists, Then do not register the evidence-based reasoning task X, and return No1 as the number of the registered evidence-based reasoning task; if it does not exist, register the evidence-based reasoning task X, and return No as the number of the registered evidence-based reasoning task; 6) The operation steps of the inference engine to perform the external evidence-based feasibility check are as follows, where the parameters of the operation are (No, Aq, Sq): i. As the working parameter of the inference engine, the inference engine can access a list of external evidence-based interfaces, each of which is represented by a triple (Aq, Pq, Api), where Aq is a semantic; Pq is a parameter, and the inference engine determines through the parameter: for any semantic screening condition composed of Aq, recorded as (Aq, Sq), whether the semantics that meet the semantic screening condition can be obtained by the external evidence-based interface; Api is an external program interface that can be called by the inference engine, and the external program interface accepts an execution instruction with (No, Aq, Sq) as a parameter, queries a specific data source or completes a specific calculation, and then obtains the semantics whose paradigm semantics are Aq and whose specific semantics in the form of semantic sequence meet the pattern indicated by Sq according to the query or calculation results; the semantics obtained by the external evidence-based interface are similar to the semantics obtained by the mapping task, and when the new semantics are generated, the operations required for the generation of the new semantics will be executed; ii. When performing an external evidence-based feasibility check with the triple (No, Aq, Sq) as a parameter, the reasoning engine scans all external evidence-based interfaces, and determines whether the external evidence-based interface can obtain semantics that meet the semantic screening conditions (Aq, Sq) through the Aq and Pq information of an external evidence-based interface; if such an external evidence-based interface is found, a command to start data transmission is sent to the external evidence-based interface with the triple (No, Aq, Sq) as a parameter, and this external evidence-based feasibility check immediately returns that it can be verified; iii. After the scanning in step ii above is completed, if no API of any external evidence-based interface is started, the external evidence-based feasibility check will return "not evidence-based"; iv. If an external evidence-based interface receives an execution instruction with parameters (No, Aq, Sq), the working method is as follows: through the semantic representation system, obtain the semantics of Aq and its associated semantics, the semantics in the Sq sequence and its associated semantics, and the data corresponding to the semantics, and based on this information, obtain or calculate the data outside the reasoning engine, and then use the function of the semantic representation system to convert these external data into semantics. Every time a semantic is obtained, it is reported to the reasoning engine, and the reasoning engine records the semantics. After the external evidence-based interface completes the acquisition or calculation of all data, it notifies the reasoning engine and sets the progress status of the acquisition semantics of the evidence-based reasoning task coded as No to "task completed"; 7) When there is an evidence-based reasoning task, denoted as X, its canonical form is (No, Aq, Sq, At, Prg, Chd), and Chd is a non-empty set: i. If Prg is "Task known but not evaluated", and the progress of the evidence-based reasoning task corresponding to any number saved in the Chd set is "Task executable and executing" or "Task completed", then set Prg to "Task executable and executing"; ii. If Prg is "Task known but not evaluated" or "Task executable and being executed", and there is at least one corresponding evidence-based reasoning task with the progress of "Task completed" among the numbers saved in the Chd set, and there is no evidence-based reasoning task with the progress of "Task executable and being executed" or "Task known but not evaluated", then set Prg to "Task completed"; iii. If Prg is "Task known but not evaluated", and the progress of all evidence-based reasoning tasks corresponding to the numbers saved in the Chd set is "Task not executable", then set Prg to "Task not executable"; 8) The reasoning engine stops when the progress of all evidence-based reasoning tasks is at "task completed" or "task cannot be executed".

15. The logic representation and reasoning engine method according to claim 14, characterized in that: The following modifications are made to the way the inference engine works to improve computational efficiency: 1) In the standard form of the evidence-based reasoning task, Prg can reflect the progress status of the evidence-based reasoning task, and add a state that can be reflected: "mapping task is being executed"; 2) Expand the canonical form of the mapping task to a four-tuple, that is, expand the canonical form of the mapping task to (Md, Mr, A, Dep), where Md and Mr are the domain semantics and range semantics of a mapping rule respectively, and their combination (Md, Mr) indicates a specific mapping rule, and A is the starting semantics of the mapping task; Dep is a numbered set of evidence-based reasoning tasks; this mapping task will not be executed by the reasoning engine before all the evidence-based reasoning tasks in the set have entered the task completion progress; if the set is an empty set, it can be executed by the reasoning engine; if any evidence-based reasoning task in the set enters the "task cannot be executed" state, this mapping task cannot be executed and should be deleted by the reasoning engine; 3) Extend the original reasoning engine's function of registering a mapping task when a new semantic is generated. Let the newly generated semantic be X, and its paradigm semantic be Xp. The reasoning engine searches whether an evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd), Xp is the same as Aq, and there is at least one semantic pattern in the specific semantics of the semantic sequence form of X that conforms to the semantic pattern specified by Sq, then: i. If (Aq, At) is a feature extraction mapping, register the mapping task (Aq, At, X, empty set); ii. If (Aq, At) is a semantic fusion mapping, register the mapping task (Aq, At, X, Dep); where the evidence-based reasoning task number table Dep is obtained by the following operations: the reasoning engine first obtains (Aq, At) has a set of dependent semantics [D1, ..., Dn], one of which is Di. The reasoning engine attempts to register an evidence-based reasoning task (No1, Di, Sio, Aq, Prg1, Chd1) for each Di, where No1 is the number of a new evidence-based reasoning task; Sio is a task created by the reasoning engine based on the name (Di, The semantic pattern is calculated by defining the feature extraction rule of (Di, Sio), and the semantic pattern and the semantic Di constitute the semantic screening condition, so that each semantic that meets the semantic screening condition (Di, Sio) is used as the starting semantic, and the semantic obtained by mapping (Di, Aq) must contain all the semantics that may be obtained by mapping (Di, Aq) to X; Prg1 is set to "task known but not evaluated"; Chd1 is set to an empty set; the inference engine records the task number returned by the registration operation into the Dep set; 4) Expanding the operation of registering a new evidence-based reasoning task of the original reasoning engine. When a new evidence-based reasoning task, denoted as (No, Aq, Sq, At, Prg, Chd), needs to be registered, the following operations are performed: the reasoning engine scans all known semantics and finds a group of semantics, the paradigm semantics of the group of semantics is Aq, and the specific semantics in the form of semantic sequence are in accordance with the semantic pattern specified by Sq; the reasoning engine regards this group of semantics as newly generated semantics and performs the operation described in the above item 3); after the above operations are completed, the reasoning engine registers the new evidence-based reasoning task; 5) Modify the working mode of the original external evidence-based interface. The working mode of the modified external evidence-based interface is as follows: if an external evidence-based interface receives an execution instruction with parameters (No, Aq, Sq), its working mode is: through the semantic representation system, obtain the semantics of Aq and its associated semantics, the semantics in the Sq sequence and its associated semantics, and the data corresponding to the semantics, and based on this information, obtain or calculate the data outside the reasoning engine, and then use the function of the semantic representation system to convert these external data into semantics. Every time a semantic is obtained, it is reported to the reasoning engine, and the reasoning engine records the semantics. After the external evidence-based interface completes the acquisition or calculation of all data, it notifies the reasoning engine to set the progress status of the acquisition of the semantics of the evidence-based reasoning task coded as No to "mapping task is being executed"; 6) Revoke the function of the original reasoning engine to register the semantic fusion task when a new mapping relationship is recorded; 7) Expand the operation of the original reasoning engine to change the progress status of the evidence-based reasoning task. Note that the standard form of the evidence-based reasoning task is (No, Aq, Sq, At, Prg, Chd). The expanded operation is: i. If Prg is "Task known but not evaluated", and the progress of the evidence-based reasoning task corresponding to any number saved in the Chd set is "Task executable and executing" or "Mapping task executing" or "Task completed", then set Prg to "Task executable and executing"; ii. If Prg is "Task known but not evaluated", and the progress of all evidence-based reasoning tasks corresponding to the numbers saved in the Chd set is "Task not executable", then set Prg to "Task not executable"; iii. If Prg is "Task known but not evaluated" or "Task executable and executing", and there is at least one corresponding evidence-based reasoning task with the progress of "Task completed" among the numbers saved in the Chd set, and there is no evidence-based reasoning task with the progress of "Task executable and executing" or "Task known but not evaluated" or "Mapping task being executed", then set Prg to "Mapping task being executed"; iv. If Prg is "mapping task in progress", the inference engine searches for the existence of a mapping task (Md, Mr, A, Dep), where Aq is the same as Md, At is the same as Mr, and A has a specific semantics in the form of a semantic sequence and conforms to the pattern specified by Sq; if there is no such mapping task, set Prg to "task completed"; if there is such a mapping task, try to execute each such mapping task: when the Dep set is an empty set or each evidence-based reasoning task in the Dep set enters the "task completed" state, the mapping task is executed immediately and deleted from the list of mapping tasks to be executed after execution; when there is an evidence-based reasoning task in the Dep set and the progress is "task unexecutable", the mapping task is not executed and is immediately deleted from the list of mapping tasks to be executed; when the Dep set is in other situations, the reasoning engine puts the mapping task on hold and processes the next mapping task; after all mapping tasks are processed, if there is no shelved mapping task, set Prg to "task completed", otherwise Prg is not changed, and this operation returns, Wait for the reasoning engine to process the evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) again later.

16. The logic representation and reasoning engine method according to claim 1 or 2 or 3 or 5 or 6 or 7 or 9 or 10 or 11 or 14 or 15, characterized in that: The semantic pattern representation method and the semantic pattern related calculation method are implemented in the following manner: 1) The following representation method of semantic patterns is used: the semantic pattern is represented as a special type of semantic sequence; a special semantic is used in the semantic pattern; when the code of the special semantic appears at a certain position of a semantic pattern, it indicates that the semantic pattern has no restrictions on the semantic sequence at the position; when the code at a certain position of a semantic pattern is not "a special semantic code indicating that the semantic pattern has no restrictions on the semantic sequence at the position", it indicates that the semantic pattern requires the same semantic code to appear at this position of the semantic sequence; 2) All mapping tasks have one and only one starting semantics; based on the standard definition of the mapping rules, there is a correspondence between the sequence position of the specific semantics in the semantic sequence form of the starting semantics and the sequence position of the specific semantics in the semantic sequence form of the result semantics. According to the correspondence, the semantic pattern conformed by the specific semantics in the semantic sequence form of the mapped result semantics is converted into the semantic pattern conformed by the specific semantics in the semantic sequence form of the mapped starting semantics, which is recorded as So; So is a sequence with the same length as the specific semantics in the semantic sequence form of the starting semantics; So is obtained by: for each position in the So sequence, recorded as np, If the specific meaning of the semantic sequence form of the starting meaning corresponds to the sequence position of the specific meaning of the semantic sequence form of the result meaning at position np, then the semantic code at the said position of the semantic pattern sequence that the specific meaning of the semantic sequence form of the result meaning conforms to is filled into the np position of So. If there is no corresponding relationship, Then fill in the np position of So with "the special semantic code indicating that the semantic pattern has no restrictions on the semantic sequence at the said position"; 3) The external evidence-based interface is represented as a triple (Aq, Pq, Api), where Aq is a semantic, Pq is a parameter, and the inference engine determines through the parameter: for any semantic screening condition composed of Aq, recorded as (Aq, Sq), whether the semantics that meet the semantic screening condition can be obtained by the external evidence-based interface; based on the representation method of the semantic pattern Sq, a method for representing the parameter Pq and the related judgment method are as follows: i. Use a sequence of three state symbols to represent Pq, and record these three state symbols as "0", "1", "2"; if a certain position of the Pq sequence is "0", it means that Pq has no restrictions on the said position of the Sq sequence; if a certain position of the Pq sequence is "1", it means that Pq requires the semantic code of the said position of the Sq sequence to be "a special semantic code indicating that the semantic mode has no restrictions on the semantic sequence at the said position"; If a position of the Pq sequence is "2", it means that the Pq requires that the semantic code of the position of the Sq sequence cannot be "a special semantic code indicating that the semantic mode has no restrictions on the semantic sequence at the position"; ii. The reasoning engine determines whether an external evidence-based interface can obtain the required semantics based on the Pq sequence and the Sq sequence and according to the rules of point i above.

17. The logic representation and reasoning engine method according to claim 1 or 2 or 3 or 5 or 6 or 7 or 9 or 10 or 11 or 14 or 15, characterized in that: The representation of semantics, the relationship between semantics, and the information in the standard form required by the reasoning engine can be achieved by both table-based implementation and semantic-gram-based implementation. The two implementation schemes can be converted equally to adapt to different software and hardware environments and achieve higher computing efficiency. The standard form information required by the reasoning engine is an n-tuple that can be understood as a sequence, and different types of n-tuples can be understood as semantics with different paradigm semantics. The semantics are created, and the specific semantics in the form of the semantic sequence are the n-tuples in the standard form required by the reasoning engine, and the paradigm semantics are the types of the standard form. The specific method is as follows: 1) Use tabular data structures to represent semantics, relationships between semantics, and information in a standardized form required by the inference engine: i. Use four tables, namely, the correspondence table between external semantics and semantic codes, the correspondence table between semantics and semantic sequences, the semantic definition table and the mapping relationship table; ii. Use the correspondence table between external semantics and semantic codes to record the correspondence between semantics and semantic codes outside the inference engine; iii. using a table of correspondence between semantics and semantic sequences to record the correspondence between a semantic code and the semantic sequence form of the semantic; that is, when a semantic has a semantic sequence form, there is a row of records in the table of correspondence between semantics and semantic sequences to indicate this correspondence; using a special semantic code to correspond to an empty sequence; iv. using a semantic definition table to record a semantic code, a paradigm semantic code of the semantic, and a relationship between the specific semantic code of the semantic; v. Use the mapping relationship table to record the relationship between the starting semantics and the result semantics of the mapping task. For example, if there is a mapping task with a starting semantics of X and a result semantics of [Y1, ..., Yn], one of the result semantics is Yi, and X has a paradigm semantics A, and Yi has a paradigm semantics B, then there is a row of records (A, X, B, Yi) in the mapping relationship table; vi. All functions of the semantic representation system can be realized based on the above data structure; 2) Use semantics data structures to represent the semantics of the table structure, the relationships between semantics, and the information in the canonical form required by the inference engine: i. For each row of data in the table of correspondence between external semantics and semantic codes, create a node in the semantic diagram; ii. For each row of data in the table of correspondence between semantics and semantic sequences, create a semantic structure corresponding to the semantic sequence according to the implementation of the seqToCode function; iii. For the data in the semantic definition table, create corresponding nodes representing the semantics according to the semantic structure specification, and connect the nodes to represent the relationship between a semantic and its abstract semantics and concrete semantics; iv. For the data in the mapping relationship table, create connections between corresponding nodes according to the specifications of the semantic structure to represent the mapping relationship between the semantics.

18. The logic representation and reasoning engine method according to claim 1 or 2 or 3 or 5 or 6 or 7 or 9 or 10 or 11 or 14 or 15, characterized in that: An optional special restriction is used: the sequence length of a specific semantic denoted as Vap in the form of a semantic sequence of a paradigm semantic denoted as Ap of a semantic denoted as A is made consistent with the sequence length of a specific semantic denoted as Va in the form of a semantic sequence of A; and the two semantics at corresponding positions in the two sequences have a class-instance relationship, the semantics at corresponding positions in the Vap sequence are class semantics, and the semantics at corresponding positions in the Va sequence are instance semantics.

19. The logic representation and reasoning engine method according to claim 1 or 2 or 3 or 5 or 6 or 7 or 9 or 10 or 11 or 14 or 15, characterized in that: The inference engine is abstracted into a set of standardized method calling interfaces as follows: 1) With function "set feature extraction mapping rule": setFeatureExtractionRule(Ed, Er), (Ed, Er) is the name of a feature extraction rule, where Ed is the semantic code of the domain semantics of the feature extraction rule, and Er is the semantic code of the range semantics of the feature extraction rule. The method confirms the existence of a feature extraction rule in the inference engine, and the method has no return value; 2) Has the function "Set semantic fusion mapping rules": setConstructFusionRule(Ad, Ar, Dep, Api, Par, Map1, Map2), (Ad, Ar, Dep, Api, Par, Map1, Map2) is a standard form of a semantic fusion rule, where Ad is the semantic code of the domain semantics of the semantic fusion rule; Ar is the semantic code of the value domain semantics of the semantic fusion rule; (Ad, Ar) is the name of the semantic fusion rule; Dep is the dependent semantic set of the semantic fusion rule; Api is an application program interface that can be called by the inference engine, It obtains a semantic sequence set based on the parameter Par and the parameter semantic set of a semantic fusion task. Each semantic sequence in the semantic sequence set, together with the specific semantics in the semantic sequence form of the starting semantic of the semantic fusion task, constitutes a specific semantic in the semantic sequence form of the result semantic of the semantic fusion task. The position correspondence between the semantic sequences in the semantic sequence set and the specific semantics in the semantic sequence form of the result semantic of the semantic fusion task is specified by Map2; the position correspondence between the specific semantics in the semantic sequence form of the starting semantic of a semantic fusion task and the specific semantics in the semantic sequence form of its result semantic is specified by Map1; the method has no return value; wherein, the parameter representation specification is as follows: i.Api: an application program interface called by the inference engine, which is described as a function name. The function receives two parameters, the first parameter is the parameter semantic set of the semantic fusion task, and the second parameter is Par, which is usually used to specify the behavior of the function; the function calls the semantic representation system to obtain relevant information about the semantics; the return value of Api is a semantic sequence set, and each semantic sequence in the semantic sequence set, together with the specific semantics in the semantic sequence form of the starting semantics of the semantic fusion task, constitutes a specific semantics in the semantic sequence form of the result semantics of this semantic fusion task; ii.Par: A parameter understood by the API, used to specify the behavior of the API function; to simplify the expression, The API of semantic fusion mapping is uniformly represented as a function posRecomb, wherein posRecomb is a position reorganization function of a semantic sequence, and one parameter of the function is a semantic extraction and rearrangement rule of a specific position of the semantic sequence described in natural language, and the parameter is Par; iii.Map1: a set of correspondences of sequence positions, specifying the correspondence between the specific semantics of the semantic sequence form of the result semantics of a semantic fusion task and the sequence position of the specific semantics of the semantic sequence form of its starting semantics; let the starting semantics of a semantic fusion task be A, the result semantic set R of the task be [R1, ..., Rn], let one of the result semantics be Ri, then the sequence position of the specific semantics of the semantic sequence form of Ri and the sequence position of the specific semantics of the semantic sequence form of A have the correspondence specified by Map1; the canonical form of the correspondence is a set, each element of the set is a tuple (x, y), where x and y are two numbers, and the tuple indicates that the semantic code at the xth position of the specific semantics of the semantic sequence form of Ri is the semantic code at the yth position of the specific semantics of the semantic sequence form of A; iv.Map2: a correspondence between a set of sequence positions, specifying the correspondence between the specific semantics of the semantic sequence form of the result semantics of a semantic fusion task and the sequence position of a sequence in the semantic sequence set output by its API; the semantic sequence set Rc output by the API of a semantic fusion task is denoted as [Rc1, ..., Rcn], one of which is denoted as Rci, the result semantic set R of the semantic fusion task is denoted as [R1, ..., Rn], one of which is Ri, the set Rc is equal to the set R in size, and Rci has a one-to-one correspondence with Ri, Map2 specifies the sequence position correspondence between Rci and the specific semantics of the semantic sequence form of Ri; the canonical form of the correspondence is a set, each element in the set is a tuple (x, y), where x and y are two numbers, and the tuple indicates that the semantic code at the xth position of the specific semantics of the semantic sequence form of Ri is the semantic code at the yth position of Rci; 3) having the function "register mapping task": registerMapTask(D, R, A, Dep), where (D, R) is the name of a mapping rule, A is the starting semantics of the mapping task, and Dep is the number set of the evidence-based reasoning tasks that the mapping task depends on; the method attempts to register a mapping task with the reasoning engine in the form of a four-tuple, and the method has no return value; 4) having the function "execute mapping task": executeMapTask(D, R, A), (D, R) is the name of a mapping rule, A is the starting semantics of the mapping task, and the triple (D, R, A) uniquely determines the four-tuple canonical form (D, R, A, Dep) of a mapping task; the method instructs the inference engine to try to execute the mapping task existing in the list of known mapping tasks, and the method returns a Boolean value: when the task is successfully executed or is judged to be unexecutable, the task will be deleted from the list, and the method returns True; when the task needs to be shelved, the method returns False; 5) It has the function of "asking questions to the reasoning engine": ask(Aq, Sq), (Aq, Sq) is a semantic screening condition proposed by the user, where Aq is a semantic code and Sq is a semantic pattern. The method starts the evidence-based reasoning working mode of the reasoning engine and creates a special evidence-based reasoning task to be completed (No, Aq, Sq, empty, Prg, Chd), where No is a new evidence-based reasoning task number, Prg is a task known but not evaluated, Chd is an empty set, and the method has no return value; 6) With function "register evidence-based task": registerConstructAcquisitionTask(Aq, Sq, At), Aq is a semantic code, Sq is a semantic pattern, (Aq, Sq) constitutes a standard form of a semantic screening condition, At is a semantic code; the method attempts to register an evidence-based reasoning task (No, Aq, Sq, At, Prg, Chd) to the reasoning engine, where No is a new evidence-based reasoning task number, Prg is a known but unevaluated task, Chd is an empty set, and the method returns the registered task number; 7) It has the function "evaluate evidence-based task": evaluateConstructAcquisitionTask(No), where No is an evidence-based reasoning task number, and the canonical form of the evidence-based reasoning task is (No, Aq, Sq, At, Prg, Chd); if At is empty or the mapping rule named (Aq, At) is a feature extraction rule, the inference engine obtains a set of mapping rules whose result semantics may meet the semantic screening condition (Aq, Sq), and attempts to register a new evidence-based task for each rule in the set; if the mapping rule named (Aq, At) is a semantic fusion rule, the inference engine obtains the defined feature extraction mapping based on its dependent semantic set, and attempts to register a new evidence-based task for each mapping rule; the method has no return value; 8) It has the function of "evaluating the feasibility of external evidence-based reasoning": examineExternalSource(No, Aq, Sq), where No is the number of an evidence-based reasoning task, and (Aq, Sq) is a semantic screening condition. The method takes the triple (No, Aq, Sq) as a parameter to initiate an external evidence-based feasibility check. If no external evidence-based interface API is started, the method returns "not feasible to verify". If any external evidence-based interface API is started, Then the return can be based on evidence; 9) It has the function of "evaluating new semantics": evaluateNewConstruct(code), where code is a newly generated semantic code. The reasoning engine scans the list of known evidence-based reasoning tasks. If code meets the semantic screening conditions of a certain evidence-based reasoning task, it tries to register a new mapping task. The method has no return value. 10) has the function "finish evidence-based task": finishConstructAcquisitionTask(No), where No is an evidence-based reasoning task number, and the canonical form of the evidence-based reasoning task is (No, Aq, Sq, At, Prg, Chd); the inference engine scans the list of known mapping tasks to find out whether there is a mapping task whose mapping rule name is (Aq, At), and the specific semantics of the starting semantics of the mapping task in the form of a semantic sequence conforms to the pattern specified by Sq; the method attempts to execute all mapping tasks that meet the conditions, and the method returns a Boolean value; when the mapping task is successfully executed, the method returns True; when the mapping task needs to be shelved, the method returns False; 11) Other functions of the inference engine are implemented on the basis of the above method call interface; in actual applications, when some of the above functions are not needed, the unnecessary functions are not implemented.

Images