JPH01166223A - Information processing system - Google Patents

Abstract

PURPOSE:To improve the efficiency of unification by giving priority to the unification of the arguments having no reference to a structure memory part and holding over the unification of the structure data regardless of the order of the arguments contained in the predicates. CONSTITUTION:When the unification is carried out between the arguments of predicates (a) and (b), the initialization is executed for the unification between arguments 1 with each other. Then the check is carried out to decide whether the argument shows the structure data or not. When the argument does not show the structure data and shows an integer or an atom, the unification is carried out between arguments with not reference to a structure memory part 110. When the argument shows the structure data, the pointer information is obtained to point the structure data 111 and 112 of the part 110. Then the unification between the structure data is held over and the next unification between the arguments is carried out. In such a way, the efficiency of unification is improved.

Description

[Detailed Description of the Invention] [Field of Industrial Application] This invention is used in the field of knowledge information processing to process information using the logical language Prolog, which has inference functions such as unification and non-deterministic control as a language. This is related to the processing method.

[Conventional technology]

In general, a unified function corresponds to the operation of assigning a value to a variable in a conventional language, but rather than a simple assignment, a unified function (a pattern of creating two data structures containing a variable),
This is a function to create the same pattern by giving (combining) appropriate values to the variables therein.

Conventionally, in an information processing device that processes such unification, an argument of a predicate refers to a structure memory section.
Unification was performed for each argument in the order in which it appeared, regardless of whether it was or not.

Therefore, when unification is executed in which large-scale and complex structure data appears as an argument in the first half, if unification of the arguments in the second half fails, the data is stored in the structure memory in the first half. The time required to unify structure data is wasted.

FIG. 3 is an example of conventional unification processing between arguments, which is shown in the literature 'Prolog Jinmon' (written by Hitoshi Goto, published by Science Publishing).

Here, as shown in FIG. 4, when unification is executed between the arguments of predicate a and predicate In step (301), unification between arguments is performed, and if this is successful, in step (302), the count is increased and unification is performed in order up to argument n, and in step (3
When it is determined in step (303) that the count exceeds n, the execution of unification ends successfully in step (304). If the execution of unification fails in step (301), the process is immediately stopped and ends in failure in step (305).

From this, it is clear that if the unification of the arguments fails in the second half, the time required for unification in the first half is wasted.

[Problem that the invention seeks to solve]

As mentioned above, in conventional unification, unification is performed for each argument in the order in which the arguments appear for predicates with multiple arguments, so large-scale and complex structure data appears in the first half. In this case, it becomes necessary to frequently access the structure data stored in the structure memory, which increases processing time.

At this time, there is a problem in that if the subsequent unification of the arguments fails, the unification of the arguments of the structure data executed in the first half is all wasted.

This invention was made in order to solve the above problems, and it is possible to efficiently execute unification processing even in inference processing that handles a large amount of large-scale and complex structured data. The purpose is to obtain a processing method.

[Means for solving problems]

The information processing method according to the present invention, when executing unification of a predicate having multiple arguments, gives priority to unification that does not require reference to structure data stored in a structure memory section, and Only when all unifications are successful, unification that requires reference to the structure memory section is started.

[Effect]

In this invention, regardless of the order of arguments in a predicate, unification of arguments that do not refer to the structure memory section is performed with priority, and structure data that requires a lot of processing time due to the need to refer to the structure memory. Efficient unification is possible because it has a delayed unification function that postpones unification.

(Embodiment) FIG. 1 shows an example of the configuration of an information processing device implementing the present invention, which includes an inference processing section (100) and a structure memory section (110).
), and the inference processing unit (100) has a structure memory unit (
A control signal (120) is given to the control signal (110).

The operation of the inference processing unit (ioo) will be described below according to the flowchart of FIG. 2 showing a specific processing procedure.

When unification is performed between the arguments of predicate a (101) and predicate b (102), the first stellar 7'
In step (200), initialization is performed to perform unification of argument 1, and then in step (201
) checks whether the argument is structure data. This check ensures that the argument is not structure data and
For Integer and Atom, the structure memory part (
110), unification between arguments is executed in step (202). This unification between arguments basically consists of arguments n in order from the left side of the diagram.
Unification between arguments is performed until the count is counted up in step (204) and the condition in step (205) is satisfied.

If the result of the check in step (201) is that the data type of the argument is structure data as shown in FIG. 1, the structure data stored in the structure memory section (110) (111) becomes pointer information pointing to (u2), the process of step (203) is executed, argument number i (i.2 in the case of Figure 1) is held, and
The unification IA filling of the structure data is not executed and is postponed, and the unification between the next arguments is executed.

Similarly, when structure data appears as an argument, the argument number is held, unification of structure data is postponed, unification is performed among arguments one after another, and unification of the last argument n is performed.

Next, it is checked in step (206) whether or not there is a pending argument number, and if there is, it is checked in step (207).
In step (208), unification of the structure data is executed while referring to the structure memory, and if this is successful, the process ends successfully in step (208).

Here, if the execution of argument unification fails in step (202), the execution of unification ends immediately and ends in failure in step (209). In this case, since the unification process for the structure data is deferred, the failure of these processes becomes known before they are executed at all, so the time required for the unification process can be shortened.

In particular, since the unification of structure data refers to the structure memory section (110), it is generally
Delayed unification is very effective because it takes more time than argument unification such as er or Aton+.

Note that the above embodiment is based on a normal single processor with one inference processing unit (100), but it can also be applied to a multiprocessor system with a plurality of inference processing units in the same manner as described above. Efficient unification can be performed.

〔Effect of the invention〕

As is clear from the above description, according to the present invention, unnecessary unification processing between structure data can be reduced as much as possible, thereby enabling efficient unification IA filling.

[Brief explanation of the drawing]

Fig. 1 is a block diagram showing an example of the configuration of an information processing device implementing the present invention, Fig. 2 is a flowchart showing a specific processing procedure of this information processing device, and Fig. 3 is a block diagram showing an example of the configuration of an information processing device that implements the present invention. A flowchart showing a specific processing procedure of the information processing apparatus, and FIG. 4 is an explanatory diagram showing arguments of a predicate to be processed. (100): Inference processing unit (101), (102): Predicate (110): Structure memory unit

Claims (1)

[Claims] In an information processing device that combines and controls an inference processing unit that executes a logical language having a built-in inference function as a machine language and a structure memory unit that has functions of storing, managing, and manipulating structure data, When the inference processing unit executes unification, it gives priority to unification that does not require reference to the structure data stored in the structure memory unit, and only if all of these executions are successful, the above structure is An information processing method characterized by starting unification that requires reference to a body memory section.