JPS60134349A - System for executing inferring process at high speed - Google Patents

Abstract

PURPOSE:To execute an inferring process at high speed without requiring an overall coincidence collation, when collating a premise part of each inference rule and a present condition knowledge, by holding to which condition each present condition knowledge coincides. CONSTITUTION:A discriminating net part 2 is an m-ary tree for executing a lot of branch judgment at each node. Matching of an initial element of a working memory and a condition is executed, and a condition stack is set to a condition stack part 3. An interpreter checks the contents of its condition stack part 3 at every rule, and in case when no variable is contained in the rule, an element of the uppermost part of each condition stack becomes a matching element group of its rule, and its group is inputted to a rule stack part 4. The new one of the element of the highest rank of each rule stack of the rule stack part 4 becomes an execution rule.

Description

[Detailed Description of the Invention] [Field of Application of the Invention] The present invention uses a computer to estimate the future situation expected from the current situation or the factors that brought about the current situation, based on preset inferential knowledge. Regarding the method of making
In particular, the present invention relates to a method for speeding up the inference process, which is suitable when the inference knowledge consists of many inference rules.

[Background of the invention]

Conventionally, inferential knowledge is expressed as a pair of premises and conclusion, a conclusion is derived from the premise of the inferential knowledge and the current situation, and the derived conclusion is expressed as a pair of premises and a conclusion from another inferential knowledge that has the conclusion as the premise. A method of giving computers reasoning ability by drawing new conclusions has been devised as a methodology for artificial intelligence. This reasoning method is used, for example, in Shigenobu Kobayashi: Knowledge Engineering; Measurement and Control, VoL, 22 AX pI) 146~
152 (January 1982), it is called a production system and is used for applications that require reasoning by numerous computers (for example, 3hortliff, E, H
:Computer-J3ased Medical
CoHsul tatiolls -MYCIN;
AmericaHelsevier, New York
l (1976).

′! ! ,The general overview of the production system is as follows.
For example, tools for knowledge pace systems: Shigenori Hirai.

Measurement and Control vol, 22A9pp761-766 (1
983, 9).

By the way, when this inference method is used for inference involving a large amount of inference knowledge, the problem of ``combinatorial explosion'' occurs, as pointed out in the aforementioned Kobayashi: Knowledge Engineering, and the inference rules (premises) that make up the inference knowledge and conclusion pairs) and the number of current knowledge (
As the number of conclusions drawn from the current situation and the inference rules increases, the inference time increases, and it may eventually become unusable. This is due to the fact that when the inference mechanism applies inference knowledge, it uses a method of exhaustively checking the consistency between the inference rule and the current knowledge for each inference rule. This is because the amount of calculation required for inference is proportional to the product of the number of inference rules and the number of current state knowledge, and an increase in the number of inference rules and current state knowledge results in a dramatic increase in matching time.

As a way to avoid this, the inference rules are divided into several knowledge sources, and (1) knowledge source selection and (2)
A method has been devised to proceed with inference in two steps, in which only inference rules related to the selected knowledge source are matched as active inference rules.
efice Manual, AGE-1:Qcl 1
981 Heuristic programHypr
ojeCt, C0nputer 5eieHce ])
epartmeHt+5taHford Univer
city) has been effective.

However, even with this method, there are problems, such as when the rules within one knowledge source become large, it becomes consuming 9 hours, and it is powerless to increase the current state of knowledge.

[Purpose of the invention]

The purpose of the present invention was to solve the above problem, and in an inference process that has a large amount of inference knowledge and current state knowledge, matching of the inference rules and current state knowledge depends on the number of inference rules and the number of current state knowledge. The purpose of this invention is to provide a method for speeding up the inference process that uses a non-intrusive inference method.

[Summary of the invention]

In order to achieve the above object, the present invention focuses on the following general points.

(1) An inference rule has a plurality of conditions in its premise, and when all the conditions are met, the premise of the inference rule is satisfied.

(2) Each inference rule is independent of each other, but the conditions of each inference rule are not necessarily mutually exclusive, and some of the conditions of each inference rule are equal to the conditions of other inference rules.

From these two points, if it is maintained which condition each current state knowledge matches, there is no need to perform an exhaustive consistency determination when comparing the premise of each inference rule with the current state knowledge.

Based on the above consideration, the present invention is characterized by the following inference method.

(1) Store each condition of the premise of the inference rule in the form of this structure. The node node of this tree is a procedure for determining the consistency of each element in the condition (the condition consists of a string of elements), and the lowest leaf node contains a string of node nodes on the route that reaches this leaf node. The name of the inference rule that each condition corresponding to is a member of is written.

(2) When each piece of current state knowledge is generated, it is determined which of the conditions of the inference rule this current state knowledge matches by checking the consistency of each node of this tree structure.

(3) Each piece of current state knowledge is stored in a stack corresponding to the inference rule and condition with which it is matched.

[Embodiments of the invention]

Hereinafter, the drawings (Fig. 1 to Fig. 15) will show a simple embodiment of the present invention.
This will be explained in detail using . Here, prior to explaining the embodiment, the following paraphrases will be made in accordance with the general terminology of production systems.

Rule: Inference rule.

Working Memo IJ 1%L element (or simply element): Current knowledge.

Interpreter: Reasoning mechanism.

Matching: Matching or dispersion judgment.

Fireable: The premise of the inference rule is satisfied.

In addition, in this embodiment, the following are set as rule syntax formats, working memory element formats, matching methods, and execution rule selection rules when several rules simultaneously satisfy the prerequisites. This setting is compatible with general-purpose production systems and does not result in loss of film quality.

(1) Rule syntax format (a) A rule is a list of the form:

(p<production name> condition 1> condition 2>...
<Condition m> → <Action i><Action2>...
Action m>) (b) <Production name> is an arbitrary atom.

(C) <Condition i> is an arbitrary list.

(d) <Action J> is a system function.

(e) <Condition i><Actionj> may include variables. Identical variables within one rule must have the same value.

(2) Element format of working memory (a) Elements are lists of the following form. Working memory is defined as a collection of elements.

(time tag>pattern) (b) The <time tag> is a number representing the order in which this element was added to the working memory, and is unique for each element.

(C) <Pattern> C. Any list that is the same as the condition. However, variables are not allowed.

(3) Matching method The overlapping patterns in the working memory and the conditions i for each rule are considered to have been matched only in the following cases.

(a) <Condition i> and pattern> have the same format, and the parts excluding variables completely match.

(b) Variables in <condition i> are bound to constants in pattern in corresponding positions, and the same variables in condition i> have the same value.

A rule is one in which all its conditions match a pattern of any element in working memory in the above sense,
And when all the same variables in a rule can be bound to the same value, it can fire.

(4) Selection rule If a plurality of rules become capable of firing at a certain point, the following rule is applied to select an execution rule.

Rule 1: If the rule executed last time can be executed with the same matching as last time, that rule is not executed. According to this exclusion rule, if there are no more ignitable rules, the system will stop.

Rule 2: Among the first conditions of each rule, select the rule that matches the element most recently added to the working memory. If there are multiple rules in which the first condition matches the same element, the latestness of the element that matches the second condition is compared. A comparison regarding the third and fourth conditions will be made below.

Rule 3: If multiple rules remain after applying Rule 2, select the one with the most conditions.

Rule 4: If the number cannot be narrowed down even with Rule 3, select the one with the largest number of non-variable atoms in the condition part.

Rule 5: Choose one at random from those that survive after applying the above.

Let us now consider an inference mechanism, that is, an interpreter, which executes at high speed the inference process by a computer described in the above format.

The information required by the interpreter to perform the inference process includes the following:

(11 Which working memory element does the condition part of each rule match?

(2) If there are j elements that match, which element is the latest?

(3) Which rule matches all condition parts including variable binding?

(4) Among the rules that can be fired, which execution rule satisfies the selection rule?

In order to obtain this information efficiently, an interpretive structure as shown in FIG. 1 is used. In FIG. 1, the interpreter includes a function execution unit 1. Discrimination net section 29 condition stack section 3. Rule stack part 4
and an action gathering section 5. Of these, the respective roles and configurations of the discrimination net section 29, condition stack section 31, and rule stack section 4 will be explained first.

In addition, in FIG. 1, R1+ R2+ ”'+ Rn
indicates the name of the rule, and ci + C2r...
.

Crl1 indicates the type of condition.

(1) Discrimination net section The conditions of each rule are maintained in the form of a discrimination net by pre-compilation. Discrimination nets were developed in cognitive psychology, and refer to binary decision trees as shown in Figure 2, which serially describe the human cognitive process. In order to use this for rule condition matching, two branches are created from each test node that judges the condition and determines the branch destination.
Considering the multi-ary decision system described above, each node judges the length of the condition list and the element name at each position, and branches. Further, the image node corresponding to the final conclusion includes the rule salt containing the condition, the condition number, and the variable list included in the condition. Therefore, when a certain working memory element is passed through a discrimination net, branches occur one after another according to the values assigned to each position of the element, and finally, a rule salt containing a condition that matches that working memory element and its You can get the rule number of the condition.

(2) Condition stack section A stack is provided for each rule condition.

The contents of the stack are the working memory element that matches the condition (or a pointer to it) and the value of the bound variable (or a pointer to it) for that element. The stack is of the pirst-In/I, ast-Qut type, and the top of the stack always contains the latest working memory element that matches the conditions.

(3) Rule stack section A rule stack is provided for each rule. At each point in time, the rule stack maintains the most recent set of working memory elements that match the seven rules.

Next, the function execution unit 1 will be explained. The function execution unit 1 is composed of the following four functional modules.

Match The generated working memory element and the rule condition are matched using the information of the discrimination net unit 2, and matching information is placed in the corresponding position in the condition stack unit 3.
ing function 11, each rule stack in the condition stack unit 3 is sequentially scanned, a group of rules that can be fired is selected, and a set of working memory elements that match the rule that can be fired is stored in the rule stack.
et Qc41eratio1 function 12, Conflict gesol which determines the execution rule that has the highest priority from among the rules that can be fired among the rule stacks of the rule stack unit 4 according to the aforementioned selection rule.
utio(1 function 13 and an ActioH function 14 that executes the action collection part 5 of the selected execution rule.
The inference is executed in the order indicated by the arrows in the figure.

Figure 3 ■, ■, 0 shows the operation of the interpreter.
(Prot)lem AHal)'sis])ia
gram) is expressed in a diagram. 3rd section, Q
3) In (C), the simple box (b) represents the execution of the process described in the box, and the double-lined box (x) represents the execution of the process described in the box. Indicates that the process to the right of the box is repeated (until~, do~) until the box is displayed.

Furthermore, the box with a wavy line (b) indicates a decision branch, and when the description in the box is true, the upper right branch is set to 5a1se.
indicates branching to the lower right branch. For example, a box with a wavy line (protection [
For example, if the memory element contains a variable, the box 303 is executed, and if the variable is not included, the box below 303 is executed. This P.A.
Diagram D replaces the conventional flowchart, and the following explanation will be made using the same PAD diagram.

(1) When the system starts, the input rule set is precompiled to generate the discrimination net unit 2 and action set unit 5 (301). The discriminator net section 2 is a multi-ary tree in which many branch decisions are made at each node, and an example of its specific configuration is as shown in FIG. Further, the generation of this discrimination net section 2 is performed in accordance with the procedure shown in the PAD diagram of FIG. FIGS. 4 and 5 will be explained in detail in "Example Problems" below.

(2) Matching the initial element of the working memory and the condition is performed (302), and the condition stack is set in the condition stack unit 3 (303). This procedure is the same as that described in the execution of the action collection section 5, which will be described later. The initial settings are now complete, and the interpreter settings are as follows (3) to (5).
) continues until there are no more execution rules or a halt action is executed (304).

(3) The interpreter first examines the contents of the condition stack section 3 for each rule (305).

(i) Condition stack unit 30 If any of the condition stacks is empty, go to the next rule (306).

(11) If a rule does not include a variable, the top element of each condition stack is used as a matching element set for that rule, and the set is placed in the rule stack section 4. If the rule includes a variable, the variable binding condition is met (
307), performs a variable comparison in the stack. At this time, the variables included in the conditions with the lowest numbers are fixed and compared, and only when the conditions are not satisfied, the variables are changed. For example, when the variable <X> is included in the first and fourth conditions, the value of <X> is bound to the value of the topmost element of the stack in the first condition, and
Checks whether there is an element with that value in the condition stack. When the variable binding conditions are satisfied (307), the set is placed in the rule stack section 4 (308), and when the variable binding conditions are not satisfied, the process goes to the next rule without doing anything. This is repeated until all rules have been examined (305).

(4) Compare the latestness of the topmost element of each rule stack in the rule stack unit 4, and set the latest one as the execution rule (309). If they are the same, compare the next element.

This comparison continues until one of the stacks is empty,
At that point, the rule with the remaining number is selected. If they become empty at the same time, the one with the larger number of atoms is selected according to selection rule 4, and if it still cannot be decided, random selection is performed.

The execution rule selection is completed with the above operations. However, since this does not satisfy the exclusion provisions of Selection Rule 1, separately,
Save the rule salt and matching element set of the previous execution, and make sure that the previous matching element set is not selected when selecting matching elements of the rule in the procedure of (31(i+)) (310). In the procedure of 31(i+), if the contents of each rule stack section 4 are retained as they are, except for those whose condition stacks have changed due to the previous rule execution, it is possible to save a large amount of selection time. This can be easily realized by adding a flag to the rule stack.

(5) Execute the selected rule (311). The most common executions of the action collection section 5 of the rule are the MAKE action, which adds or removes elements to the working memory, and the REMOVE action, which removes elements, and these are the only two that change the contents of the working memory. (3
12). By the way, the elements that change due to one execution of a rule are (usually) only a small part of all the elements in the working memory, and many elements do not change. Therefore, it is sufficient to consider matching only the changed elements with the conditions.

For this reason, the discrimination net section 2 is used. As mentioned above, the discrimination net section 2 is a network with atoms of each condition as branches, and by passing newly added elements through this discrimination net section 2, it is possible to determine which rule and in which order the added element is placed. It can be seen whether the conditions are satisfied (313). For example, in the first node, the first atom of the element branch is investigated, and the node at the end of the branch corresponding to that atom becomes the next investigation target. There the second atom is examined,
A node corresponding to the third atom is found. In this way, nodes are examined one after another, and when all the atoms of the elements are found, the rule salt written in the node reached and its condition number match the key points. Therefore,
The element is bushed down to the condition stack (if there are multiple matches, all the condition stacks) corresponding to the rule name 9 condition number (314). On the other hand, in the case of element deletion, the relevant stack is examined in order and the relevant element is extracted from the stack.

Next, the operation of the interpreter will be explained in detail using an example.

〔example〕

Rule (PR1(A) (DE)--1→(make (B
K) ) ) (P FL2 (A) (NP)-1--
c (make (CN) ) ) (PR3(A) (
ON) (BK)-mrnatce (ABC)))(
PR4(A)(BK)(aN)-+make (AB
C)) (make (B))) (PR5(<X>)(AC<X>)-mwrite
(AC's)) (P 几6 (B) (ACB) (BO
)-Hamake (ACC) )(make (C)) (Bemove 3) ) (P R7(<X>) '(Remove 1)(P
R8(A<X×Y>)-n(Write (A) )(
haxt) ) Here, mal(e(・) adds the list (・) to the working memory. 几em0veN adds the working memory element that currently matches the Nth condition of the rule. Delete.Write (.) starts 1 nost (.). (halt) is a system function that stops a system function. Also, <X> represents a variable named X.

For example, the initial state of working memory or 1 (Bob
, 2 (DE), 3 (NPJ, 4) The rule execution order when (A) is as follows.Here, 1゜2.3.4 is the time tag.At this time, R2゜R1, R4 ,R6,R
, 5, 几7. R8's output is (ACC) (A)
It is.

The natural order of the rules in this case will be explained below.

1. First, consider Rule 2 in this example. Among the conditions of rules R, 1 to R8, the independent ones are (A) (DE) (NP) (BK) (CN) (AC
<X>) (<X>) (H) (ACB) (BO) (A<X
><Y>).

Therefore, according to the procedure shown in FIG.
By configuring , something like the one shown in FIG. 4 is obtained, which can represent each condition, the rule containing it, and its position.

Hereinafter, with reference to FIGS. 4 and 5, the discrimination net section 2
We will explain the generation of . In addition, FIG. 5 shows the above-mentioned P
AD diagram representation is used.

In FIG. 5, when generating a T0P node (501) is executed, the test node shown in FIG. 13 is generated,
TOP as the node name.

0 is set as the number of branches N. At this time, the judgment branch conditions, branch node pointers, etc. in FIG. 13 are undefined.

Next, in (502), the processes of (503) to (516) are executed until all the conditions of the rule set, that is, the 17 conditions on the left side of rule R1-几8, are processed.
Control is passed to (503). At (503), the first condition A of rule 1, which is the top of the unprocessed conditions, is placed in the condition comparison stack shown in FIG. Here, 2) is set. In (504), the separately defined search position pointer points to the TOP node, and the 15th
The value is set so that the comparison pointer in the diagram points to the first condition element (here, the pointer value is 1 for A).
. After (505), steps (50G) to (516) are executed until the comparison target pointer exceeds the element end pointer. In (506), the content A of the stack pointed to by the comparison target pointer is compared with the element end symbol $; in this case, A
Since it is a key $, the process branches to (507).

(507) checks whether there is a judgment branch regarding comparison target A in the TOP node pointed to by the search position pointer. In this case, the number of branches is 0, and there is no judgment branch regarding A. ) control is transferred to (510)
Now, create a new node (corresponding to N2 in FIG. 4) for A as shown in FIG. The branch number N is incremented by 1 at the same time. Next, the new node is set in the search position pointer (512), and the comparison target pointer is incremented so that the next condition element $ becomes the comparison target. Thereafter, (506) is re-executed, and since the current comparison target is the element end symbol, the process branches to (514). At this time, the search position is a new node related to A. Since no image node has been generated yet for this node N2, (51
In step 5), an image node as shown in FIG. 14 (corresponding to 14 in FIG. 4) is generated, and the address of node E4 is written in the image node pointer of node N2 shown in FIG. Image node 4 shown in FIG.
is generated in step (516), where 1 is set in rule salt 1, 1 is set in condition position 1, and the number of rule conditions is set to 1. Up to this point, the discrimination net of the first condition leading to I4 shown in FIG. 4 has been formed, and the processing of the first condition of Rule 1 is completed.

Control moves again to (503), where the second condition (D
E) is written into the condition comparison stack shown in FIG.
D is processed first, then E.

In the process of D, (504), (,505), (506).

The process proceeds in the order of (507). (5'07) then TO
The existing judgment branches A and D of the P node are compared, and since A and D, the node related to D, that is, N in FIG.
3 is generated, D is entered into the judgment branch condition 2 of the TOP node shown in FIG. 13, and the address of node N3 is entered into the branch node pointer 2.

After that, the process moves to E through (512) and (513), and the same process ((506) and (507)).

Node NIO is generated through (510), (511), (512), and (513), and further (506).

An image node corresponding to 16 in FIG. 4 is generated by steps (514), (515), and (516).

This completes the rule 10 condition processing, and the discrimination net portion 2 of the first condition leading to steps 4 and 6 shown in FIG. 4 is formed.

Similar processing is performed for rule 2 and subsequent rules, but if there is an existing image node, that is, in the case of the first condition A of rule 2, the processing procedure is (503).

(504), (505), (506), (507).

(508), (509), (506), (514).

(516), and ends by simply writing the rule salt and condition position to the existing node without creating a new node. This operation is performed under the conditions of 17 metalworks, and the discrimination net section 2 as shown in FIG. 4 is constructed.

Next, the elements in the initial state are sequentially added to the discrimination net section 2.
Pass it through. (BO), it reaches the node N12 from the T0P node via N4. Therefore, it is clear that the third condition of (BO)i-J rule 6 is satisfied, and this (BO)
) is placed in the appropriate condition stack.

At this time, in the determination of the T0P node, <X> is also not a matching candidate, and X is bound to B, but since there is no branch corresponding to O, it is ignored. Next, when (DE) is passed, N3 is passed to -1 (NIO's) - and time tag 2 is placed in the second condition stack of rule 1. Similarly, the sixth
The condition stack contents will be as shown in the figure (/l).

Also, rice is placed in the flag of the rule whose stack contents have changed (mark (b) in Figure 6). In addition, in Figure 6,
(a) is the condition stack, (b) is the working memory, (
(c) and (c) are diagrams showing the rule stack, and the same applies to the following FIGS. 7 to 12. Here, (A) is N1
Matches both node and N2 node 7/-I7:,
fckb, rule 1. Rule 2. Rule 3. A time tag 4 is placed in the condition stack for each first condition of rule 4, and a variable binding value is placed together with time tag 4 in the condition stack of each first condition of rules 5 and 7 that includes the number 7'CJm. .

Next, check the condition stacks of the flagged rules in order starting from 几1. R1 has the fourth element and the second condition in the first condition.
The second element matches the condition and does not include a variable, so (4
, 2) enters the rule stack 81 in the rule stack unit 4. Similarly for R2°R7, (4,3)(4) are placed in each rule stack. However, other rules R3゜)I4. R5 and 6 all have empty stacks and are not capable of firing. After this, the flags for each rule are erased.

Furthermore, the contents of the rule stack part 4 are examined, and since the elements of the first condition part R1, R2, and fl7 are all opposite to (4), R1 and R2 with many good conditions become candidates, and the second Rule 2 (contact 2), which is the latest element that matches the conditional part, is set as the execution rule (Figure 6 (c)).
, to)).

After the execution of rule 几2, the element (CN) is added to the working memory. When this element (CN) is passed through the discrimination net section 2, it reaches the node N14 via N6, and the node 4.
The contents of the condition stack of R3 are rewritten (Figure 7 (
b) (b)). At this time, only the fourth and third conditions are flagged, so the interpreter examines only these two condition stacks.

In this case, since each rule has an empty stack, nothing is actually done, and the rule stack section 4 is then checked. Since the contents of the rule stack part 4 are unchanged from the last time, R2 will be selected again, but since it has the same matching element as the previous execution rule, it will be removed, and the next new element from the condition stack of 几2 will be selected. The set is put into the rule stack section 4 (FIG. 7(c)). However, in this case, there is no match other than (4, 3), and the rule stack of R2 is cleared. At this time, rice is placed in the condition stack flag of 几2. This is a necessary action to reset the R2 rule stack next time.

Then, the rule stack section 4 is checked again, and 几1 is set as the execution rule (see FIG. 7).

几1 adds (BK) to working memory, so R
1, R2, 几3.几4 and 几7 can be ignited, and 几4 becomes the execution rule (see Figure 8 (a), (b), and (c)).
). By executing R4, the added (ACB) (B) is 5. 6. 7. Change the condition stack of 几8, R6
is executed. This is because R6 has more conditions than R5 (see Figure 9 (a), (b), and (c)). Rule R
6 adds (ACC) (C) and removes Bo), so the same <R5, R, 6°87, and 几8 change. Here, (C) matches only <X>. Here, in the condition stack of R5, the elements of 10.9 are the first condition and the second condition, respectively.
The condition is met and the variable <X> at that time is C,
This shows that elements with lengths of 8 and 7 also become fireable pairs due to the binding of the variable <X>=H, but the elements at the top of the stack (10,
The group 9) is selected. Rule R6 is no longer able to fire due to the removal of (BO), and 几5 becomes the execution rule from the state of the rule stack section 4 (Fig. 10 (a) and (b)).
(c) to)). Since this rule FL5 only performs a write operation, there is no change in the condition stack section 3 and the rule stack section 4 (see (A), (B), and (C) in FIG. 11). Therefore, R5 with the element set (10, 9) is set as the execution rule again, but since this is the same as last time, the set (8, 7) is newly entered in the rule stack section 4 from the condition stack of 几5. . Therefore, since 几7 is not an execution rule, (C) is deleted.

Therefore, in the state shown in FIG. 12 (A), (B), and H), by executing R8, (A) is output and the process is stopped.

In this embodiment, the stack is li"1rst-In
/I, ast-Qut type, but pirs
t-In/l;"1rst-Qut type or the like may be used.

〔Effect of the invention〕

As is clear from the above description, the present invention has the following effects.

fl) Rules are stored in the form of a discriminatory net so that matching is easy, and an increase in the number of rules does not affect matching speed.

(2) Since the results of matching each condition and working memory element are stored in the form of a stack, matching can be easily performed on added or deleted elements, and the execution speed is independent of the number of working memory elements. .

(3) With the stack function, the latest matching elements are always at hand, making it easy to apply selection rules.

(4) By introducing a rule stack, matching for rules that have not changed can be omitted, further improving execution speed.

[Brief explanation of the drawing]

FIG. 1 is an overall configuration diagram of an interpreter showing an embodiment of the present invention, FIG. 2 is an explanatory diagram of the general concept of a discrimination net in the present invention, and FIG. 3 is a functional diagram of an interpreter showing an embodiment of the present invention. Figure 4 is an explanatory diagram of an example discrimination net in the present invention, and Figure 5 is an explanatory diagram of the creation procedure of an example discrimination net in the present invention, expressed in a PAD diagram. Figures 6 to 12 are explanatory diagrams of changes in the contents of the stack during the execution process of the example problem in the present invention. Figure 6 is the initial state, Figure 7 is after the execution of rule 2, and Figure 8 is after the execution of rule 1. , Figure 9 is after executing rule 4, Figure 10 is after executing rule 6, Figure 11 is after executing rule 5, and Figure 12 is after executing rule 5.
The figure shows the contents of each stack before the final state, Figure 13 is an explanatory diagram showing a test node of an example discrimination net in the present invention, and Figure 14 shows an image node of an example discrimination net in the present invention. The explanatory diagram, FIG. 15, is a conceptual diagram of a condition comparison stack for example condition processing in the present invention. 1...Function execution section, 2...Discrimination net section, 3...
Condition Nutatsu section, 4... Rule stack section, 5...
Action gathering section, 11-MatChing function, 12
-・・（：onflict Set QeHerati
on function, 13...CoHf1ict) jesol
ution Function, 14-ActioH\yt Figure (A) '\J7 Figure (A) Figure B (Ino'4 q m (Ijinijijima lρ Figure (A) l Town Yosho Figure 11 (4) Old 12 Fig. 73 〉7/4 Biri-Kaya Fig. 75

Claims (1)

[Range of patent claims] 1, a table that holds the reasoning knowledge as a set of inference rules as a pair of prerequisites and conclusions, and multiple conclusions derived from the phonematic status and the inference rules. and a table that holds current state knowledge as a set, and determining whether the previous state of the inference rule matches the current state knowledge, and adding the matching conclusion of the inference rule to the current state knowledge table. , compare the added conclusion with the premise of the Zenmushi inference rule, and if the premise matches the added conclusion, store information on the correspondence between the matching inference rule and the conclusion. A method for speeding up the inference process characterized by having steps. 2. The method for accelerating the inference process according to claim 1, wherein the premises of the inference rules are stored in a tree structure. 3. The method for accelerating the inference process according to claim 1 or 2, wherein the step of storing the correspondence information uses a stack.