JPH04340626A - Processing method for succession hierarchical logic type language - Google Patents

Abstract

PURPOSE:To increase the question processing speed by reducing the frequency in unification processing of the question processing especially with respect to a rule section where basic substitution satisfying all fundamental expressions of a body part is known in the processing method of the logical language openly dealing with a succession hierarchy. CONSTITUTION:A fact section is provided with a mask flag indicating whether it can be referred or not, and a program section subjected to basic substitution is stored as the fact section in the head part of the rule section where this basic substitution satisfying all fundamental expressions of the body part is known. At the time of processing a question goal section, mask flags are released and set to limit the selection of fact sections subjected to basic substitution as an input section.

Description

[Detailed description of the invention]

0001

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for processing logical languages that explicitly handles inheritance hierarchies.

0002

2. Description of the Related Art Prolog is widely used as a logic language, but it only describes individual things. On the other hand, PAL is used to express and search inheritance hierarchies efficiently by including general concepts that semantically include individual things.
(Akama “PAL: Extended Prolog that handles inheritance hierarchies”
Information Processing Society of Japan Journal, Vol. 28, pp322
-329, 1987), LOGIN (Ait-K
aci & Nasr ”LOGIN:A Logic
Programming Language with
“Built-In Inheritance” Jo
Urnal of Logic Programmin
g, Vol. 3, pp185-215, 1986
), EPOS (Huber.M & Varsek
．． I”Extended Prolog for Or
der-SortedResolution” '87
International Symposium
on Logic Programming pp34
-43). Logic languages that explicitly handle inheritance hierarchies like this will be referred to as ``inheritance hierarchy logic languages.'' The description format for this differs depending on the language, but below, for ease of understanding, Prolog in Japanese is used.
We will use the wind description format.

[0003] The knowledge handled by the inheritance hierarchy logic language consists of an inheritance hierarchy, fact clauses, rule clauses, and goal clauses. The fact clause and the rule clause are collectively called the program clause. An example is shown below.

Example 1) ■John belongs to people.

■Bob belongs to humans.

■Mary belongs to people.

■cs1 belongs to the workplace.

■John works at cs1.

■The administrator of cs1 is Bob.

■If the manager of a person's workplace is X, then X is the person's boss.

■Bob is Mary's administrator.

■Who works at cs1 and who is their boss? for example,
If we express example 1 in inheritance hierarchy logic language, ■・■・■
・■・■・■・■・■・■ are respectively S1, S2, S
It is expressed as 3.S4.S5.S6.S7.S8.Q1. S1, S2, S3, and S4 are inheritance hierarchies. S5・S6
- S8 is a fact clause, S7 is a rule clause, and Q1 is a goal clause. The left side of each node is called the head, and the right side is called the body.

John<person

(S1) Bob<person

(S2) Mary<person

(S3)
cs1<workplace

(S4) Work (John,
cs1)←
(
S5) Administrator (cs1, Bob)←

(S6) Boss (person: X, person: Y) ← Work (person: Y, workplace: Z),
Administrator (
Workplace: Z, Person: X)
(S7) Boss (Bob, Mary)←

(S8)
← Working (person: V, cs1), boss (person: W, person:
V)
(Q1) Here, “John”, “Bob”, “Mar”
y" and "cs1" are constants, "person" and "workplace" are areas,"
"Worker", "Administrator", and "Boss" are predicates. When d is an area and x is a variable, "d:x" indicates that the variable x takes only constants belonging to d as values. d:
ohn, cs1)”・”Administrator (cs1, Bob)
"・"Boss (Person: If a3, then a1<a3, and a1<a2 and a2<a1 do not hold at the same time.

The question processing procedure will be explained using a specific example in which S1 to S8 are knowledge and Q1 is a question.

1) Select the basic formula "Work (person: V, cs1)" on the leftmost side of the body part of Q1. This is called a "selective method." Choose one clause from your knowledge that has the same predicate. This is called an "input clause." Here, S5's "Jo"
hn, cs1)←” is the input clause.
By replacing ``person: V'' with ``John'', the selection formula and the input clause become the same.This can be expressed as ``assignment {
``Human: V/John'' successfully unifies the selection formula and the input clause.'' An assignment that replaces all variables with constants is called a basic assignment.

The term t2 may be replaced by the term t1 in either of the following cases. However, c1 is a constant, d1 and d2 are areas, and x1 and x2 are variables.

- When t2 has the form d2:x2 and the term t1 has the form c1, c1<d2.

・t2 is d2:x2, term t1 is d1:x1
When the shape is d1<d2.

If the unification process is successful, the selection formula is removed from the goal clause, the body part of the input clause is added to the goal clause, the previous assignment is performed, and this is created as a new goal clause. shall be. This process is called "derivation." Here, by derivation, ← Boss (person: W, John)

(Q2) will be the new goal section.

2) "Boss (Person: W, John)" is a multiple choice, S7's boss (Person: X, Person: Y) ← Work (Person: Y, Workplace: Z)
, Manager (workplace: Z, person: X) is the input clause. The unification process is successful by assignment {person:X/person:W, person:Y/John}. The new goal clause is ← Work (John, workplace: Z), Manager (
Workplace: Z, Person: W) (
Q3).

3) Make “Work (John, Workplace: Z)” a multiple-choice option, and select “Work (John, cs1)” in S5 ←
” is the input clause. The unification process is successful by assignment {workplace: Z/cs1}. The new goal clause is ← Administrator (cs1, person: W)

(Q4).

4) Make "Administrator (cs1, Person: W)" a selection formula, and select "Administrator (cs1, Bob) ←" in S5.
Let be the input clause. The unification process is successful by assignment {person: W/Bob}. At this time, the content of the goal clause disappears, and this is called ``an empty clause is derived.'' Once the empty clause is derived, the previous assignment {person: V/John
}・{Person: X/Person: W, Person: Y/John}・{Workplace:
Z/cs1}・{Person: W/Bob} Assignment {Person: V/John, Person: X/Bob, Person: Y/John,
Workplace: Z/cs1, person: W/Bob}, find {person: V/John, person: W/Bob} regarding the variables in Q1. This assignment is called "correct assignment."

5) Use "Administrator (cs1, Person: W)" as a selection formula, and search for input clauses other than S5. If this exists,
Attempts to unify the selection formula and the input clause. Since it does not exist here, the process returns to step 3). This is called "backtracking."

6) Use "Work (John, Workplace: Z)" as a selection formula and search for input clauses other than S4. Since it doesn't exist,
Backtrack to the state in step 2).

7) Use "boss (person: W, John)" as a selection formula and search for input clauses other than S6. S8's "Boss (B)
ob, Mary)←” is obtained, but the unification process fails.

8) Use "boss (person: W, John)" as a selection formula and search for input clauses other than S6 and S8. Since it does not exist, backtrack to the state in step 1).

9) Use "Work (person: V, cs1)" as a selection formula and search for input clauses other than S5. Since it does not exist and there are no steps left to go back, the question processing ends.

[0028]

[Problem to be solved by the invention]

(∀X/d B(X)→A(X))∧(∃X/d B(
Consider a multi-sort logical expression of type X)). This means that for all variables X belonging to area d, B(X) → A
(X) holds true, which means that B(X) holds true for a certain variable X belonging to area d. (For example, "t
All computers purchased by the university were manufactured by Company A.
In the multi-sort logical formula, the proposition containing the adjunct modification is (∀X
/ Computer Purchased (T University, X) → Manufactured (
Company a, X)) ∧(∃X/computer purchased (University t, :X)←B(d:X)

(S9) B(c1)

(S10
). B(c1) is a Skolem version of ∃X/d B(X), and c1 is a constant belonging to region d. On the other hand, when d<d', ←A(d':Y)

When the query process (Q5) is executed, Q5 succeeds in unification with S9 by assignment {d':Y/d:X}, and "←B(d:X)" becomes a new obtained as the goal clause, then the assignment {d:X/c
1}, it is successfully unified with S10 and the empty clause is derived. As above, by unifying twice, the correct answer {d
':Y/cs1} can be obtained.

When B(X)=B1(X)∧...∧Bn(X), the knowledge is A(d:X)←B1(d:X),...,Bn
(d:X)
(S11), and when Q5 is a question, n+
A correct assignment can be obtained with one unification process. The present invention provides a processing method that allows correct assignments to be obtained by performing unification processing once or twice for both of the above cases.

[0030]

[Means for solving the problem] S9 and S10 are S11
・Since S12 is set to n=1, below,
Consider only S11 and S12.

It is assumed that S11 and S12 are given as a set of knowledge. Here, we will assume a new descriptive format in which the head and body parts are connected by the symbol "←^" and call this an adjunctive modifier clause. An adjunctive modification clause is also a program clause. S11・S1
2 is an adnominal modification clause, A(X)←^ B1(X),...,Bn(X)

(S13). first,
S13 is expanded internally as S11, S12, and S14.

A(c1)

(S14) At this time, A(
A pointer to A(c1) is held in the data area of d:X), and pointers to B1(c1) to Bn(c1) are held in the data areas of B1(X) to Bn(X). Hold. In the process of query processing, if S11 is selected as the input clause and the unification process is successful, then S
12. Mask S14 so that it is not selected as an input clause. When the processing of S11 as an input node is completed, the mask is removed.

In an inheritance hierarchical logical language processing system that processes program clauses having rule clauses and fact clauses, for a rule clause for which a basic assignment that satisfies the basic expression in the body of the rule clause is known, The fact clause whose basic substitution is made to each basic expression in the head part and body part of the rule clause and its referenceability information are stored in memory, and the rule clause selected as the input clause is processed while the goal clause is being processed. At the start, the referenceability information of the fact clause, which is a basic assignment example of each basic expression in the head and body parts of the rule, is set to non-referenceable, and at the end of processing of the rule clause, the referenceability information is reset to referenceable. However, a fact clause whose referenceability information is set to not be referenced is not selected as an input clause.

[0034]

[Operation] In the present invention, when the question processing is executed, if the selection formula is Q5, there is a possibility that S14 or S11 will be selected as the input clause. If S14 is selected as the input clause, the correct assignment can be obtained by one unification process by assignment {d':Y/c1}. Moreover, if S11 is selected as the input clause, the unification process of Q5 and S11 will succeed by assignment {d':Y/d:X}, but S12
are masked, so they are never selected as input clauses. That is, in the present invention, a correct assignment can be obtained by performing the unification process once or twice.

[0035]

DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention will be described in detail below with reference to the drawings.

FIG. 1 is a diagram showing a data structure for storing program clauses in an embodiment of the present invention, FIG. 2 is a diagram showing a data structure of a stack used in question goal clause processing, and FIG. FIG. 4 is a flowchart showing the details of the input clause selection process in question goal clause processing; FIGS. 5 to 7 are diagrams showing the state of the stack in the process of question goal clause processing; FIG. A diagram showing the data structure of a variable name table used when inputting a clause. FIG. 9 is a flowchart showing the input program clause storage process. FIG. 10 is a flowchart showing details of the adjunct modification clause storage process in the input program clause storage process. , FIG. 11 is a flowchart showing the details of the reified fact clause storage process in the adjunct modification clause storage process, and FIG.
1 is a diagram illustrating an example of an apparatus configuration for implementing the method of the present invention.

The storage format of program clauses will be explained with reference to FIG.

In this embodiment, a program clause is divided into an index cell storage area 101 representing the correspondence between the predicate name and the storage position of the program clause, a predicate cell storage area 102 that stores the head part of the program clause, and the body of the program clause. The body part predicate cell storage area 103 stores the body part predicate part.

The index cell storage area 101 is an area for storing an index cell 104 consisting of a predicate name field 105 and a predicate cell pointer 106. The predicate name field 105 stores the predicate name of the program clause. The predicate cell pointer 106 stores a single or multiple predicate cells 107 in which the head of a program clause having the predicate name stored in the predicate name field 105 is stored.
Stores the start address of.

The predicate cell storage area 102 is an area for storing a predicate cell 107 that is a set of a mask flag 108, a head clause field 109, a mask predicate cell pointer 110, and a body pointer 111. The mask flag 108 is information indicating whether selection is possible in the input clause selection process in the question goal clause process. In the following, it is assumed that selection is not possible when the value of the mask flag 108 is 1,
It is selectable when the value is 0. Also, mask flag 1
Setting the value of 08 to 1 is "setting a mask flag"
Setting the value to 0 is called "releasing the mask flag." The head section field 109 stores the head sections of fact clauses, rule clauses, and adjunct modifier clauses. When the clause stored in the head clause field of the predicate cell is the head part of an adnominal modifier clause, the mask predicate cell pointer 110 contains a value that is generated by constantizing the variable of the head part of the adnominal modifier clause at the time of storage. Stores the address of the predicate cell that stores the reified fact clause. When the clause stored in the head clause field of the predicate cell is the head part of a fact clause or a rule clause, the mask predicate cell pointer is NULL (representing an invalid pointer). When the clause stored in the head clause field of the predicate cell is the head part of a rule clause or the head part of an adjunct modification clause, the body part pointer 111 points to the body part predicate cell that stores the first clause of the body part. 11
Stores the address of 2.

The body part predicate cell storage area 103 includes a body part clause field 113 and a mask predicate cell pointer 1.
14 and a body part next clause pointer 115. The body part clause field 113 stores each clause constituting the body part of a rule clause and an adjunct modification clause, one by one. The mask predicate cell pointer 114 points to the body part predicate cell 11
When the clause stored in 2 is one of the clauses in the body part of an adjunctive modification clause, the predicate cell 107 stores the reified fact clause generated by constantizing the variable of the clause in the body part at the time of storage.
Stores the address of. The body part next clause pointer 115 stores the address of the body part predicate cell 112 that stores the next clause making up the body part.

Next, a question goal clause processing method will be explained, and a program clause storage processing method will be described later.

FIG. 2 is a diagram showing the data structure of the stack used in question goal clause processing. The stack 201 is an area for storing a stack cell 202 consisting of a goal clause field 203, an assignment field 204, and a predicate cell pointer 205. Below, each stack cell is listed in order from the beginning as the 0th stack cell, the 1st stack cell, and the 2nd stack cell.
Stack cell. ．． ．． , is called the n-th stack cell. 20
6 is a stack pointer pointing to the current position of the stack. In the following, the stack cell 202 pointed to by the stack pointer 206 will be referred to as the current stack cell. The goal clause field 203 stores the goal clause that is the target of question processing. The substitution field stores an assignment for unifying the first clause (selected clause) in the goal clause field and the input clause selected from the stored program clauses. The predicate cell pointer 205 stores the address of the predicate cell 107 that stores the head portion of the input clause.

The question goal clause processing will be explained in detail with reference to the flowchart of FIG.

First, in step 301, the stack is initialized. That is, the address of the 0th stack cell, which is the bottom of the stack, is stored in the stack pointer 206.

Next, in step 302, a question goal clause is input, the stack pointer 206 is advanced by one, and the input question goal is stored in the goal clause field 203 of the current stack cell 202. At this time, assignment field 2
04 is empty, and the predicate cell pointer 205 is set to NULL. Next, the process advances to step 303. In step 303, the first clause of the goal clauses stored in the goal clause field of the current stack cell is selected. Next, the process advances to step 304.

In the input clause selection process of step 304, an input clause having the same predicate as the selection formula is selected, and the address of the predicate cell 107 storing the head part of the selected input clause is transferred to the predicate cell pointer 205 of the stack cell. Store in. The input clause selection process is a point where the present invention differs from the prior art,
More details will be discussed later. Next, the process advances to step 305.

In step 305, it is determined whether a non-empty input clause was obtained in the input clause selection process in step 304. If the input clause is empty, that is, if the predicate cell pointer 205 of the current stack cell is NULL, the process proceeds to step 306; otherwise, the process proceeds to step 307.

In step 307, the selected clause and the input clause are unified, and an assignment for unification is obtained. If unification is not possible, proceed to step 304. Further, if unification is possible, the assignment for unification is stored in the assignment field 204 of the current stack cell, and the process proceeds to step 308.

In step 308, the input clause is applied to the goal clause stored in the goal clause field 203 to derive a new goal clause. In other words, if the input clause is a fact clause, remove the selection clause from the goal clause stored in the goal clause field of the current stack cell, apply the assignment stored in the assignment field, and push it onto the stack. . Also, if the input clause is a rule clause or an adjunctive modification clause, the selected clause is replaced with the body part of the input clause for the goal clause stored in the goal clause field of the current stack cell, and the assignment stored in the assignment field is Push it onto the stack. At this time, the assignment field 204 is empty and the predicate cell pointer 2
05 is set to NULL. Next, the process advances to step 309.

In step 309, the goal node field of the current stack cell is referred to, and if it is empty, step 31
0, and if it is not empty, proceed to step 303.

In step 310, the assignments stored in the assignment fields of the stack cells between the bottom of the stack and the current stack cell are combined and output to the display device. Next, the process proceeds to step 306.

Also, in step 306, the current stack cell is released. In other words, move the stack pointer back toward the bottom. Next, the process advances to step 311.

In step 311, it is determined whether the stack is empty. If the stack pointer points to the bottom of the stack (0th stack cell), the stack is empty and the question goal clause processing ends. If the stack pointer does not point to the bottom of the stack, the process returns to step 303.

Next, according to the flowchart of FIG. 4, input clause selection processing (step 304) in question goal clause processing is performed.
) will be explained in detail. First, in step 401, it is determined whether the predicate cell pointer of the current stack cell is NULL. If it is NULL, the process proceeds to step 402, and if not NULL, the process proceeds to step 403.

Step 402 is proceeded to if this is the first invocation of the predicate. In step 402, the index cell storage area is referred to to find the index cell for the predicate name of the selection formula, and the predicate cell pointer of the index cell is copied to the predicate cell pointer of the stack. Next, the process advances to step 405.

Further, in step 403, if the mask predicate cell pointer of the predicate cell pointed to by the predicate cell pointer of the current stack cell is not NULL, the mask flag of the predicate cell pointed to by the mask predicate cell pointer is canceled, that is, set to 0. At this time, if the body part pointer of the stack cell is not NULL, the body part predicate cells are followed and all mask flags of the predicate cells pointed to by the mask predicate cell pointer of each body part predicate cell are cleared. The next step 404 advances the predicate cell pointer of the current stack cell by one. Next, the process advances to step 405.

In step 405, it is determined whether the predicate cell pointed to by the predicate cell pointer of the current stack cell has a program clause having the same predicate as the selection formula. If there is such a program clause, proceed to step 407;
If there is none, the process advances to step 406.

In step 406, the predicate cell pointer of the current stack cell is set to NULL and the input clause selection process is terminated. This indicates that the input clause is empty.

In step 407, it is determined whether the mask flag of the predicate cell pointed to by the predicate cell pointer of the current stack cell is set. If the mask flag is set, that is, 1, the process proceeds to step 401. Also, the mask flag is not set, i.e. 0
If so, proceed to step 408. In this case, the program clause stored in the predicate cell pointed to by the predicate cell pointer of the current stack cell is selected as the input clause.

In step 408, it is determined whether the mask predicate cell pointer of the predicate cell pointed to by the predicate cell pointer of the current stack cell is NULL. If NULL
If so, the input clause selection process ends. If it is not NULL, the process advances to step 409 to set a mask flag.

In step 409, the mask flag of the predicate cell pointed to by the mask predicate cell pointer of the predicate cell pointer of the current stack cell is set to 1. In the next step 410, the address of the body part predicate cell is obtained from the body part pointer of the predicate cell. Next step 4
Proceed to step 11.

In step 411, the mask flag of the predicate cell pointed to by the mask predicate cell pointer of the body part predicate cell obtained in the previous step is set to 1. Next step 4
12, the body part next clause pointer of the predicate cell is NU
It is determined whether it is LL, and if it is NULL, the input clause selection process is ended. If it is not NULL, the process proceeds to step 413, where the address of the next body part predicate cell is obtained from the body part next clause pointer of the predicate cell, and the process returns to step 411.

The input clause selection process is realized by the procedure described above.

Next, a specific example of question goal processing will be shown using the question goal clause "← manufactured (company a, Y)" as an example.

FIG. 1 shows “Manufactured (company a, word processor 1
)”, “Purchased (T University, WS2050)”, and “More expensive (WS2050, 1 million yen)”, and “Manufactured (Company A, Computer: X)” ←
^Purchased (T University, Computer: X), more expensive (
A state in which the adjunctive modifier clause "Computer: X, million yen)" is stored is shown.

First, in step 301 of FIG. 3, the stack is initialized. Next, in step 302, the question goal clause "←Manufactured (company a, Y)" is stored in the goal clause field of the first stack cell. Next, in step 303, a selection formula is selected from the goal clauses. In this example, “manufactured (company a,
Y)" is a selection formula. Next, in step 304, input clause selection processing is performed. That is, the process advances to step 401 in FIG.

In step 401 of FIG. 4, the predicate cell pointer of the first stack is NULL, so step 40
Proceed to step 2, refer to the index cell storage area, and set 1 as the predicate cell pointer for the predicate "manufactured".
Obtain address 201 and store it in the predicate cell pointer of the first stack cell. In the next step 405, there is a program clause with the predicate "manufactured" at address 1201, so the process advances to step 407. At this time, since the mask flag is not set in the predicate cell at address 1201, the process advances to step 408. At this point, the fact clause "manufactured (company a, word processor 1)" has been selected as the input clause. In step 408, since the mask predicate cell pointer is NULL, the input clause selection process is ended and the process returns to step 305 in FIG.

Next, in step 305, the predicate cell pointer of the first stack cell is referred to, and if it is not NULL (12
01 address), the process advances to step 307. Here, the selection formula "manufactured (company a, Y)" and the input clause "manufactured (company a,
Word processor 1)". These are the assignments ``{
Y/word processor 1}", this assignment is stored in the assignment field of the first stack cell, and the process proceeds to step 308. In step 308, since the input clause is a fact clause, the selection formula is removed from the goal clause field of the first stack cell, and the result with the assignment in the assignment field is stored in the goal clause field of the second stack cell. If so, the empty clause will be stored. In the next step 309, the goal node is an empty node, so the process advances to step 310. The state of the stack at this time is as shown in FIG. In step 310, the assignment stored in the stack is referred to, and "word processor 1" is output as the solution to the variable Y in the question goal clause, and the process proceeds to step 306. In step 306, the stack pointer is returned by one. In this case, the stack pointer will point to the first stack cell. In the next step 311, the stack is not empty, so the process returns to step 303.

In step 303, the goal node field of the first stack cell is referred to, and "manufactured (company a, Y)
” is again selected as a multiple choice. Next step 304
Now, the input clause selection process shown in FIG. 4 is performed. That is, in step 401, the predicate cell pointer of the first stack cell is referenced, and since it is not NULL (address 1201), step 403
Proceed to. Since the mask predicate cell pointer of the predicate cell at address 1201 is NULL, there is no predicate cell whose mask flag should be canceled, so the process directly proceeds to step 404. In step 404, the predicate cell pointer of the first stack cell is advanced by one to address 1202. next step 40
In step 5, there is a program clause with the predicate "manufactured" at address 1202, so the process advances to step 407. 1202
Since no mask flag is set in the address predicate cell, the process advances to step 408. At this point, the adjunctive modifier clause “manufactured (company a, computer: X) ←^purchased (university t, computer: It turns out. In the next step 408, the mask predicate cell pointer of the predicate cell at address 1202 points to address 1203 and is not NULL, so the process advances to step 409. In step 409, the mask flag of the predicate cell at address 1203 is set. In the next step 410, the body pointer of the predicate cell at address 1202 is referenced to obtain address 1301. In the next step 411, the mask flag of the predicate cell at address 1211 pointed to by the mask predicate cell pointer at address 1301 is set. In the next step 412, 13
Since the body section next clause pointer at address 01 is address 1302 and is not NULL, the process advances to step 413. Next, 13
The process of step 411 is performed for the body part predicate cell at address 02. In other words, the mask predicate cell pointer of the body part predicate cell at address 1302 points to 1221.
Set the mask flag of the address predicate cell. In the next step 412, since the body part next clause pointer of the body part predicate cell at address 1302 is NULL, the input clause selection process is ended and the process proceeds to step 305 in FIG.

In step 305, the predicate cell pointer of the first stack cell is referenced, and since it is not NULL (address 1202), the process advances to step 307. Here, the selection formula "manufactured (company a, Y)" and the head part of the input clause "manufactured (a company, Y)" are used.
company, computer: X)". These can be unified by the assignment "{Y/computer:X}", so this assignment is stored in the assignment field of the first stack cell and the process proceeds to step 308.

In step 308, since the input clause is an adnominal modification clause, the selection formula is replaced with the body part of the adjunction modification clause for the goal clause stored in the goal clause field of the first stack cell, and the substitution field is The substituted result is stored in the goal node field of the second stack cell, but in this case, "←Purchased (T university, computer: X)
, higher (computer: X, 1 million yen)" is stored. Next step 309
Then, since the goal node field of the second stack cell is not an empty node, the process proceeds to step 303.

In step 303, the first goal clause "←Purchased (t university, computer: X), more expensive (computer: X, 1 million yen)" stored in the goal clause field of the second stack cell is ``Purchased (t university, computer: X)'' is selected as a multiple-choice option. Next, in step 304, input clause selection processing is performed. That is, the process advances to step 401 in FIG.

In step 401 of FIG. 4, the predicate cell pointer of the second stack is NULL, so step 40
Proceed to step 2, refer to the index cell storage area, and set 1 as the predicate cell pointer for the predicate "purchased".
The address 211 is obtained and stored in the predicate cell pointer of the second stack cell. In the next step 405, there is a program clause with the predicate "purchased" at address 1211, so the process advances to step 407. At this time, the mask flag is set in the predicate cell at address 1211, so step 4
Proceed to 01.

In step 401, the predicate cell pointer of the second stack cell is referenced, and if it is not NULL (1211
address), so the process advances to step 403. Since the mask predicate cell pointer of the predicate cell at address 1211 is NULL, there is no predicate cell whose mask flag should be canceled, so the process directly proceeds to step 404. In step 404, the predicate cell pointer of the second stack cell is advanced by one to address 1212. In the next step 405, there is a program clause with the predicate "purchased" at address 1212, so step 4
Proceed to 07. Since no mask flag is set in the predicate cell at address 1212, the process advances to step 408. At this point, the fact clause "Purchased (T University, WS2050)" has been selected as the input clause. In step 408, the mask predicate cell pointer of the predicate cell at address 1212 is NULL, so the input clause selection process is terminated.
Returning to step 305 in FIG.

Next, in step 305, the predicate cell pointer of the second stack cell is referenced, and if it is not NULL (12
12), the process advances to step 307. Here, the multiple choice "Purchased (T university, computer: X)" and the input clause "
Purchased (T University, WS2050)". These can be unified by the assignment "{X/WS2050}", so this assignment is stored in the assignment field of the second stack cell and the process proceeds to step 308. In step 308, since the input clause is a fact clause, the selection formula is removed from the goal clause stored in the goal clause field of the second stack cell, and the result obtained by assigning the substitution field is added to the third stack cell. It is stored in the goal clause field, but in this case, the goal clause ``← Higher (WS20
501 million yen)" will be stored. In the next step 309, the goal clause is not an empty clause, so step 3
Proceed to 03.

In step 303, "Higher (WS2050, 1 million yen)" is selected as a selection formula from the goal clauses stored in the goal clause field of the third stack cell. Next, in step 304, input clause selection processing is performed. That is, the process advances to step 401 in FIG.

In step 401 of FIG. 4, the predicate cell pointer of the third stack is NULL, so step 40
Proceed to step 2, refer to the index cell storage area, and set 1 as the predicate cell pointer for the predicate "higher".
Obtain address 221 and store it in the predicate cell pointer of the third stack cell. In the next step 405, there is a program clause with the predicate "higher than" at address 1221, so the process advances to step 407. At this time, the mask flag is set in the predicate cell at address 1221, so step 4
Proceed to 01.

In step 401, the predicate cell pointer of the third stack cell is referenced, and if it is not NULL (1221
address), so the process advances to step 403. Since the mask predicate cell pointer of the predicate cell at address 1221 is NULL, there is no predicate cell whose mask flag should be canceled, so the process directly proceeds to step 404. In step 404, the predicate cell pointer of the third stack cell is advanced by one to address 1222. In the next step 405, there is a program clause with the predicate "higher than" at address 1222, so step 4
Proceed to 07. Since no mask flag is set in the predicate cell at address 1222, the process advances to step 408. At this point, the fact clause "More expensive (WS2050, 1 million yen)" has been selected as the input clause. In step 408, the mask predicate cell pointer of the predicate cell at address 1222 is NULL, so the input clause selection process is ended and the process returns to step 305 in FIG.

Next, in step 305, the predicate cell pointer of the third stack cell is referred to, and if it is not NULL (12
22), the process advances to step 307. Here, the selection formula "Higher (WS2050, 1 million yen)" is unified with the input clause. These are the same and can be unified by identity assignment. An identity assignment is represented by emptying the assignment field of the third stack cell. In the next step 308, since the input clause is a fact clause, the selection formula is removed from the goal clause field of the third stack cell.
The substituted field is stored in the goal clause field of the fourth stack cell, but in this case an empty clause is stored. In the next step 309, the goal node is an empty node, so the process advances to step 310. The state of the stack at this time is as shown in FIG. In step 310, the assignment stored in the stack is referred to, and "WS2050" is output as the solution to variable Y in the question goal clause, and the process proceeds to step 306. In step 306, the stack pointer is returned by one. In this case, the stack pointer will point to the third stack cell. In the next step 311, the stack is not empty, so the process returns to step 303.

In step 303, ``Higher (WS2
0,501,000,000 yen)" is again selected as a multiple choice. In the next step 304, the input node selection process shown in FIG. 4 is performed. That is, in step 401, the predicate cell pointer of the third stack cell is referenced, and since it is not NULL (address 1222), the process proceeds to step 403. Since the mask predicate cell pointer of the predicate cell at address 1222 is NULL, there is no predicate cell whose mask flag should be canceled, so the process directly proceeds to step 404. In step 404, the predicate cell pointer of the third stack cell is advanced by one to address 1223. In the next step 405, there is no program clause with the predicate "higher than" at address 1223, so step 406
Proceed to. In step 406, the predicate cell pointer of the third stack cell is set to NULL. The input clause selection process ends in failure and returns to step 305 in FIG.

In step 305, since the predicate cell pointer of the third stack cell is NULL, step 30
Proceed to step 6. In step 306, the stack pointer is returned by one. In this case, the stack pointer will point to the second stack cell. In the next step 311, the stack is not empty, so the process returns to step 303.

In step 303, the first goal clause "←Purchased (t university, computer: X), more expensive (computer: X, 1 million yen)" stored in the goal clause field of the second stack cell is ``Purchased (t university, computer: X)'' is again selected as a multiple-choice option. Next, in step 304, input clause selection processing is performed. That is, the process advances to step 401 in FIG. In step 401, the predicate cell pointer of the second stack cell is referred to, and NUL
Since the address is not L (address 1212), the process advances to step 403. The mask predicate cell pointer of the predicate cell at address 1212 is N.
Since it is ULL, there is no predicate cell whose mask flag should be canceled, so the process directly advances to step 404. Step 40
4, the predicate cell pointer of the second stack cell is advanced by one to address 1213. 121 in the next step 405
Since there is no program clause with the predicate "purchased" at address 3, the process advances to step 406. In step 406,
Set the predicate cell pointer of the second stack cell to NULL. The input clause selection process ends in failure and returns to step 305 in FIG.

In step 305, since the predicate cell pointer of the second stack cell is NULL, step 30
Proceed to step 6. In step 306, the stack pointer is returned by one. In this case, the stack pointer will point to the first stack cell. In the next step 311, the stack is not empty, so the process returns to step 303.

[0085] In step 303, "manufactured (company a,
Y)" is again selected as a selection formula. Next step 3
In step 04, the input clause selection process shown in FIG. 4 is performed. That is, in step 401, the predicate cell pointer of the first stack cell is referenced, and since it is not NULL (address 1202), step 4 is performed.
Proceed to 03.

In step 403, the predicate cell (120
3)'s mask flag. Then, for the series of body part predicate cells pointed to by the body part pointers, that is, the body part predicate cells at addresses 1301 and 1302, the predicate cells pointed to by each mask predicate cell pointer (the predicate cells at addresses 1211 and 1221) are Clear the mask flag. In the next step 404, the first
The predicate cell pointer of the stack cell is advanced by one to address 1203. In the next step 405, there is a program clause with the predicate "manufactured" at address 1203, so the process advances to step 407. Since no mask flag is set in the predicate cell at address 1203, the process advances to step 408. At this point, the fact clause "manufactured (company a, computer #1)" has been selected as the input clause. In step 408, the mask predicate cell pointer is set to NUL.
Since it is L, the input clause selection process is ended and step 3 in FIG.
Return to 05.

Next, in step 305, the predicate cell pointer of the first stack cell is referred to, and if it is not NULL (12
03 address), the process advances to step 307. Here, the selection formula "manufactured (company a, Y)" and the input clause "manufactured (company a,
computer #1)". These can be unified by the assignment "{Y/computer #1}", so this assignment is stored in the assignment field of the first stack cell and the process proceeds to step 308. In step 308, since the input clause is a fact clause, the selection formula is removed from the goal clause stored in the goal clause field of the first stack cell, and the result obtained by assigning the substitution field is added to the second stack cell. It is stored in the goal section field, but
In this case, the empty clause will be stored. Next step 3
In step 09, the goal node is an empty node, so the process advances to step 310. The state of the stack at this time is as shown in FIG. In step 310, the assignment stored in the stack is referred to, and "computer #
1'' is output as the solution and the process proceeds to step 306. In step 306, the stack pointer is returned by one. In this case, the stack pointer will point to the first stack cell. In the next step 311, the stack is not empty, so the process returns to step 303.

[0088] In step 303, "manufactured (company a,
Y)" is again selected as a selection formula. Next step 3
In step 04, the input clause selection process shown in FIG. 4 is performed. That is, in step 401, the predicate cell pointer of the first stack cell is referenced, and since it is not NULL (address 1203), step 4 is performed.
Proceed to 03. Since the mask predicate cell pointer of the predicate cell at address 1203 is NULL, there is no predicate cell whose mask flag should be canceled, so the process directly proceeds to step 404. In step 404, the predicate cell pointer of the third stack cell is advanced by one to address 1204. next step 40
In step 5, since there is no program clause with the predicate "manufactured" at address 1204, the process advances to step 406. In step 406, the predicate cell pointer of the first stack cell is set to N
Make it ULL. The input clause selection process ends in failure and returns to step 305 in FIG.

In step 305, since the predicate cell pointer of the first stack cell is NULL, step 30
Proceed to step 6. In step 306, the stack pointer is returned by one. In this case, the stack pointer is at the bottom of the stack (0th
stack cell). Next step 311
Then, the question goal clause processing with an empty stack ends.

[0090] In the above question goal clause processing process, the variable Y included in the question goal clause "← Manufactured (company a, Y)"
We were able to correctly find three solutions {word processor 1, WS2050, computer #1}. Also,
By input clause selection processing with reference to the mask flag, 121
It was possible to eliminate unnecessary unification processing twice, once for each of the predicate cells at addresses 1 and 1221. The solution that should be obtained by the reduced unification process is 1
It is stored in advance as a fact in the predicate cell at address 203, and can be obtained by one unification process using this as an input clause. That is, in this specific example, one unification process can be saved.

In general, if the number of reified fact clauses stored for an adnominal modification clause is n, there is an effect that n-1 unification processes can be saved.

Next, a method for storing program clauses will be explained.

FIG. 8 is a diagram showing the data structure of the variable name table used when inputting program clauses. The variable name table 801 is an area that stores a combination of a variable name field 802 and a variable identification number field 803. The variable name field 802 stores a character string representing a variable name. The variable identification number field 803 stores variable identification numbers given to each variable. The variable name counter 804 stores the maximum value of the variable identification numbers used. The variable name counter is set to 0 only once before entering the first program clause. The variable name table 801 is emptied every time one program clause is input. When a new variable appears in one program section, the value of the variable name counter is first incremented by 1, the new value of the variable name counter is given to that variable as a variable identification number, and the variable is registered in the variable name table. This allows a unique variable identification number to be assigned to each variable that appears in the input program section.

A method for storing input program clauses will be explained with reference to the flowchart of FIG.

In step 901, the variable name counter 80
Initialize 4. That is, the value of the variable name counter is set to 0. Next, the process advances to step 902.

In step 902, a variable name table is initialized. In other words, there is no registered variable. Next, the process advances to step 903.

In step 903, program clauses are input from the input device. Proceed to step 904. Step 9
In step 04, it is determined whether or not there is an input clause. If there is an input clause, the process proceeds to step 905; if there is no input clause, the program clause storage process ends.

In step 905, it is determined by referring to the index cell storage area 101 whether a program clause having the same predicate in the head part as the predicate in the head part of the input program clause has already been stored. If there is an index cell whose content matches the predicate name field, the process advances to step 906; if there is no such index cell, the process advances to step 907.

In step 907, an index cell corresponding to the new predicate name is allocated. Create a new index cell at the end of the index cell in use. The predicate name is stored in the predicate name field 105 of the new index cell. Next, the process advances to step 908.

In step 908, a predicate cell is allocated to store the head of the input program clause. Creates a new predicate cell at the end of the predicate cells in use. Proceed to step 909.

In step 909, the predicate cell pointer 106 of the index cell assigned in step 907 is set to
The address of the predicate cell assigned in step 908 is stored. Next, the process proceeds to step 910.

Further, in step 906, a predicate cell is allocated to store the head portion of the input program clause. From the predicate cell pointed to by the predicate cell pointer of the index cell detected in step 905, the end of the program clause having that predicate is found and a new predicate cell is created. Next, the process proceeds to step 910.

In step 910, it is determined whether the input program clause is a rule clause, and if so, the process proceeds to step 912; otherwise, the process proceeds to step 911.
Proceed to.

In step 912, the head of the rule clause input in the head clause field 109 of the predicate cell assigned in step 906 or step 908 is stored. Next, the process advances to step 913.

In step 913, a body part predicate cell is allocated to store the body part clause of the input rule clause. New body part predicate cells are created for the number of body part clauses, and these are connected using body part next clause pointers to form a list. Enter the address of the first cell in the list in step 90.
6 or stored in the body part pointer of the predicate cell allocated in step 908. Proceed to step 914.

In step 914, the body part clause field 11 of the body part predicate cell allocated in step 913 is
3, each clause in the body part of the input rule clause is stored one by one. At this time, the mask predicate cell pointer of each body part predicate cell is set to NULL. Next step 90
Return to 2.

In step 911, it is determined whether the input program clause is an adjunctive modification clause. If not, the process proceeds to step 915; if so, the process proceeds to step 916.

In step 915, the fact clause input in the head clause field 109 of the predicate cell assigned in step 906 or step 908 is stored. Mask predicate cell pointer 110 and body part pointer 111 are set to NULL. Next, the process returns to step 902.

In step 916, the input adjunct modifier clause is stored, and the process returns to step 902.

Next, this adnominal modification clause storage process will be explained with reference to the flowchart of FIG.

First, in step 1001, a variable name table is created. The input adjunctive modification clause is scanned, and the variable name table is referenced each time a variable appears. Then, only if the variable name is not already in the variable name table, the value of the variable name counter is incremented by 1, the new value of the variable name counter is given to the variable as a variable identification number, and the variable name is registered in the variable name table. When the input adjunct modifier clause is scanned, the process advances to step 1002.

In step 1002, the head part of the adjunct modifier clause inputted in the head part clause field 109 of the predicate cell assigned in step 906 or step 908 is stored. In the next step 1003, by the same process as steps 905 to 909,
Assign predicate cells. In the next step 1004, a reified fact clause in which the head variable of the input adjunct modification clause is made into a constant is stored in the predicate cell allocated in step 1003. This concrete fact clause storage process will be described later. Next, the process advances to step 1005.

In step 1005, body part predicate cells are allocated. Create a new body part predicate cell at the end of the body part predicate cell in use. Next step 1
In step 006, the address of the body part predicate cell assigned in step 1005 is sent to step 906 or step 9.
Predicate cell body pointer 11 allocated in 08
Store in 1. Proceed to step 1007.

In step 1007, one clause of the body part of the input adjunct modification clause is stored in the body part clause field 113 of the assigned body part predicate cell. In the next step 1008, a predicate cell is assigned to the body section stored in step 1007 by the same process as step 1003. In the next step 1009, a concrete fact clause obtained by converting the variable of the clause of the body section stored in step 1007 into a constant is stored in the predicate cell allocated in step 1008 by a concrete fact clause storage process described later. Proceed to step 1010.

[0115] In step 1010, it is determined whether or not there are any clauses in the body part that have not yet been stored for the input adnominal modifier clause. If there are no clauses remaining, the adjunctive modifier storage process is terminated and the process returns to step 902. return. If there are any remaining, the process advances to step 1011.

In step 1011, step 1005
The body part predicate cells are allocated using the same process as . In the next step 1012, the address of the body part predicate cell assigned in step 1011 is transferred to step 10.
It is stored in the body part next clause pointer 115 of the body part predicate cell allocated in step 07. Next, the process advances to step 1007.

[0117] When the processing of the last clause of the body part is completed, the adjunct modification clause storage process is ended in step 1010.

Next, details of the reified fact clause storage processing in steps 1004 and 1009 will be explained with reference to the flowchart in FIG.

First, in step 1101, the head clause field 109 of the predicate cell that has already been assigned is
Stores the predicate part of the clause that is to be reified and stored. Next, the process advances to step 1102.

In step 1102, it is determined whether one of the argument terms has the form "area name:variable name". If the format is "area name: variable name", the process advances to step 1104; otherwise, the process advances to step 1103.

[0121] In step 1103, step 1001
An argument term is additionally stored in the head clause field 109 of the predicate cell in which the predicate part is stored. Next, step 11
Proceed to 06.

In step 1104, the variable name table is referred to to find the variable identification number assigned to the variable name of the argument term. In the next step 1105, a constant in the format "area name#variable identification number" is additionally stored as an argument term in the head clause field 109 of the predicate cell in which the predicate part was stored in step 1001. Next, the process advances to step 1106.

[0123] In step 1106, it is determined whether there are any unstored argument terms remaining. If there are any remaining argument terms, the process advances to step 1102; if not, the concrete fact clause storage process is terminated.

By the program clause storage processing method described above, fact clauses, rule clauses, and adjunctive modification clauses can be stored in the data structure shown in FIG.

FIG. 12 is a diagram showing an example of an apparatus configuration for carrying out the method of the present invention. 1201 is a storage device that stores program means and program sections for implementing the method of the present invention. 1022 is a CPU, and 1023 is an input device for inputting program sections and question goal sections. Reference numeral 1024 is a display device for outputting solution assignments that are the results of question goal processing.

[0126]

[Effect of the Invention] A set of knowledge SS is assumed. SS to S1
A comparison will be made between the processing process according to the conventional question processing method for knowledge obtained by adding S1 and S12 to the knowledge obtained by adding S13 to SS.

When the selection formula is other than Q5, there is no difference in the processing process between the conventional question processing method and the question processing method of the present invention. On the other hand, when the selection formula is Q5, in the conventional question processing method, unification processing (unification) for predicate A and unification processing for predicates B1 to Bn is performed a total of n+1 times. Assign the correct answer {d': Y/c1
} is found. According to the question processing method of the present invention, when storing the adnominal modifier clause S13, S13 is expanded into the rule clause S11 and fact clauses S12 and S14 and stored. Therefore, for selection formula Q5, 1 with S14 as the input clause
The same correct assignment can be obtained by unification processing. Furthermore, when the rule clause S11 is selected as an input clause, the fact clause S12 is masked, so redundant processing for duplicating correct assignments does not occur.

[0128] As described above, according to the question processing method of the present invention, it is possible to reduce the number of times of unification processing to obtain the correct answer assignment, and thus has the effect of speeding up the question processing.

[Brief explanation of the drawing]

FIG. 1 is a diagram representing a data structure for storing program clauses.

FIG. 2 is a diagram showing the data structure of a stack used in question goal processing.

FIG. 3 is a flowchart showing question goal processing.

FIG. 4 is a flowchart showing details of input clause selection processing in question goal processing.

FIG. 5 is a flowchart showing details of input clause selection processing in question goal processing.

FIG. 6 is a flowchart showing details of input clause selection processing in question goal processing.

FIG. 7 is a diagram showing the state of the stack in the process of question goal processing.

FIG. 8 is a diagram showing the data structure of a variable name table used when inputting program clauses.

FIG. 9 is a flowchart illustrating input program section expansion processing.

FIG. 10 is a flowchart showing details of adjunctive modification clause storage processing in input program clause expansion processing.

FIG. 11 is a flowchart showing details of the reified fact clause storage process in the adnominal modification clause storage process.

FIG. 12 is a diagram illustrating an example of an apparatus configuration for implementing the method of the present invention.

[Explanation of symbols]

101... Index cell storage area, 102... Predicate cell storage area, 103... Body part predicate cell storage area, 1
04... Index cell, 105... Predicate name field, 1
06...Predicate cell pointer, 107...Pointer predicate cell,
108...Mask flag, 109...Head part clause field, 110...Mask predicate cell pointer, 111...Body part pointer, 112...Body part predicate cell, 113...Body part clause field, 114...Mask predicate cell pointer, 1
15...Body part next clause pointer.

Claims (2)

[Claims] 1. In an inheritance hierarchical logical language processing system that processes a program clause having a rule clause and a fact clause, the rule clause has a known basic assignment that satisfies a basic expression in the body of the rule clause. , the fact clause whose basic substitution has been made to each basic expression in the head part and body part of the rule clause and its referenceability information are stored in memory, and during the processing of the goal clause, the fact clause is selected as an input clause. At the start of processing of a rule clause, the referenceability information of the fact clause, which is a basic substitution example of each basic expression in the head and body parts of the rule clause, is set to non-referenceable, and at the end of processing of the rule clause, the referenceability information is set to non-referenceable. A method for processing an inheritance hierarchical logical language, characterized in that information is reset to be referenceable, and fact clauses whose referenceability information is set to be not referenceable are not selected as input clauses. 2. When storing the program clause in which basic substitutions have been made to each basic expression in the head part and body part of the rule clause as the fact clause, the data areas of the head part and body part of the rule clause are holds a pointer to the fact clause, which is an example of its basic assignment, and determines whether or not the fact clause pointed to by the pointer can be referenced at the start of processing of the rule clause selected as the input clause during processing of the goal clause. The inheritance hierarchy logic according to claim 1, characterized in that the information is set to be unreferenceable, and the referenceability information of the fact clause pointed to by the pointer is set to be referenceable when the processing of the rule clause for the goal clause is completed. How to handle type languages.