JP6799731B2 - Methods, computer programs and devices for computers to infer interactively - Google Patents

Description

The present invention relates to methods, computer programs and devices for computers to infer interactively.

In such a field, an interactive inference system (originally from MYCIN or the like) has been conventionally used.
However, in an inference system based on full-scale predicate logic such as PROLOG, the control of the dialogue is
A logical program (PROLOG source, etc.) or a knowledge-based programmer (a user who has the authority to edit knowledge), which is the basis for making inferences,
To control input (questions and prerequisites) by users (especially general users who ask questions for conclusions, options and rationale) (prompts for free input, presentation of options, etc.)
Output commands such as print statements and input commands such as input statements, etc.
I had to enter a lot of code.
Further, in a processing system that adopts a closed-world hypothesis such as PROLOG (hereinafter, the system of Patent Document 1)
It was difficult to cover all the facts that were true (or even false facts when using NOT), which increased coding costs and hampered integrity and soundness.
Further, in the interactive system that allows the input of free sentences, a mismatch between the input contents and the prepared knowledge format has been a problem due to notational fluctuations and the like. In the system of Patent Document 1 below, it was possible to avoid the crying of knowledge due to the explicit notational fluctuation absorption rule, but it cannot be avoided at the stage when the notational fluctuation absorption rule is not prepared. The cost of preparing a notational fluctuation absorption rule was not small.

Japanese Patent Application No. 2013-8708

Therefore, the present invention 1) streamlines knowledge-based coding for operating an interactive expert system (for example, no separate coding is required to ask the user whether the proposition that is the goal or subgoal is true or false. To be). 2) While reducing the burden of pre-editing knowledge and improving operational efficiency, such as coverage of facts that are true in inference systems that can handle predicate logic such as PROLOG (under the closed world hypothesis or other interpretation policies) Do not compromise health (below). 3) In general, the purpose is to improve the efficiency of input and prevent notational fluctuations from becoming a problem.

For that purpose
(1) The present invention

Some or all parts of the functions of PROLOG to allow format with embedded variable to a string as a literal
It is a computer program that can execute <br />
Ask the user at runtime the truth of the literal or the value of a variable that makes the literal true for the literal that is the condition of the head or body of the rule.
Provide a computer program that performs subsequent processing according to the answer from the user.

here,
What is a "literal that is a condition of the head or body of a rule"?
It may include what is substantially a goal or a subgoal.

Also,
A "user" is a user who asks a question about a PROLOG logic program.
Users who have the authority to edit logical programs (original copyright holder, editing copyright holder,
Secondary copyright holder, etc.),
A user or auxiliary user who entered the prerequisites (temporarily necessary rules and facts) just before asking a question (use assistant or expert (doctor, lawyer, etc.) when using as an expert system), etc. including.
If the "user" is a "user who has the authority to edit the logical program", there may be a time lag before the user can easily answer.
"Subsequent processing" is a mail notification after the time lag to "the user who asked the question to the logical program" (the fact that the logical program was edited (knowledge added) was newly made possible by the editing. It may include the content of the inference, the answer, the fact that the dialogue can be continued by editing it, etc.).
Also,
"Ask" means, for example, a dialog box, a console waiting for input, or a prompt waiting for voice.
It may be a format that is newly displayed and output to the terminal used for inputting the question.
Or you can display it from another terminal via the network,
It may be displayed / output via a physical interface such as a humanoid robot, and then the original question is asked after waiting for the answer input (mouse operation such as control buttons, keyboard operation, screen touch, etc.) and voice. It may be returned to the control context (for example, one point of the SLD derivation process or one point of the inference process in other inference methods).

In the case of a processing system that follows PROLOG, the added knowledge (facts and character strings) can be obtained by simply adding a line after the last line of the original logical program.
It is possible to utilize the dynamically added knowledge for subsequent inference (processing of the question, etc.).

The knowledge added dynamically in this way depends on the user's choice.
It can also be a temporary context (also called a precondition) just for that question or for a set of questions that will be asked within a certain amount of time thereafter.
It is also clearly possible to make it knowledge of the preserved version (eg, dealing with common typical problems) that should be referred to permanently afterwards.

This will
It enables sounder and more complete semi-automatic inference processing (derivation, proof, solution search, etc.) that reflects the facts that the user is aware of (detailed, new, favorable to the user, etc.).
Most typically
When a given symbol (for example, "?") Is present before and after a literal, after normal automatic confirmation (backward reasoning), is it really not true only if it is false (that is, a common harmful effect under the closed-world hypothesis)? Ask if it is not enough to list the facts).
In another embodiment, it can be designed to ask true / false again in any case of true / false.
It also allows users to dynamically add and remove true solutions (whole / subset of solution candidates) by displaying a modal dialog when the literal contains variables. You can also design a computer program in (for example, ($ X, $ Y) = (Taro, Hanako) and ($) as solution candidates when adding.
Of course, it is also possible for the computer program to automatically check that X, $ Y) = (Taro, Hanako)) do not overlap).

Here, the set of solution "candidates" is
For example, provisional variable bound information (a set of bound values for multiple variables (1) that satisfies the conditions in the middle of the body of the rule (consisting of a series of multiple conditions) that has the semantics equivalent to the horn clause of PROLOG. One or more)).


(2) The present invention also

A computer program that asks the user is provided only when the literal has a predetermined format.

For example, in the case of a logical program with a "?" At the beginning of a literal, it will be as follows, but it may be at the end.
===
$ A and friends:-Good friends with $ A ,? I have a long relationship with $ A. I am on good terms with Taro. I am on good terms with Jiro ===

This will
If the programmer thinks that all the true cases can be defined (covered) in the logical program (according to the closed-world hypothesis), the programmer thinks that the true cases are not covered without adding a question mark. If so, add a "?"
It is possible to control "questions (to the user or the outside) from the program" according to the degree of completion (coverage) of the logical program.

If you do not adopt the closed-world hypothesis,
===
1. 1. Allow the value "Unknown" (in this case, allow the fact "! Today is rain" or "? Today is rain" as a line of the logic program,
For "? Today's rain", the specification is to ask the user whether it is true or false, as if there is a "?" In the head above),
2. 2. Allow the user to answer "Unknown" and uniformly consider it as the false side or the true side,
===
It is also possible to interpret it as such.

In addition, by selecting options (GUI etc.) by the user,
Forcing you to "ask" about all the literals that appear in your program,
On the other hand, you can force a literal that has a "?" At the beginning to "don't care".
It is also possible to do so, and both have a certain degree of usefulness.

In the above example, "?" Is included in the body, but if there is a "?" At the beginning of the head,
For example
"After" the solution candidate set of each variable in the head (only $ A in the above example) that satisfies the body condition is automatically obtained.
It is said that the computer can ask the user about the solution candidate set (health (whether it is wrong) and completeness (whether it is insufficient)) of each variable in the head again and manually add it (logic). It may be a program interpretation.


(3) The present invention also

Ask the above question
It also provides a computer program that is performed before the computer program automatically confirms it by backward inference.

As a result, a mode that omits backward inference of propositions that are found to be true, etc.
Computational cost savings may be realized.


(4) The present invention also

Ask the above question
It also provides a computer program that is performed after the computer program automatically confirms it by backward inference.

This makes it possible to show default solution candidates that are closer to proper by inference.
It is possible to save the editing cost (adjustment operation of solution candidates) of the questioned user.


(5) The present invention also

When asking the above question
We also provide a computer program that can automatically check and delete the obtained solution candidates.

This will
It is possible to manually eliminate the solution due to the error of the logic (facts and rules) used for confirmation after the fact.


(6) The present invention also

When asking the above question
We also provide a computer program that allows you to add new solution candidates while automatically checking and looking at the obtained solution candidates.

This saves editing costs with default solution candidates while
It is possible to visually prevent duplication of solution candidates to be added.


(7) The present invention also

We also provide a computer program that has a function to automatically generate a control that can ask a question asked by a user or a frequently asked question with one or more operations at a lower cost than inputting the entire question text.
"One operation" refers to a simple operation using one click of a mouse, [ENTER] of a keyboard, or other physical input device. It also includes the case where automatic compression (subsequent character string interpolation) can be performed from a single character (by literal set analysis of the entire logical program, etc.).
"Operations that cost less than inputting the entire question text for one or more operations" include perfect compression when two or more characters are input and a tree-style complementary character string selection UI.
"Automatic generation" can be clarified by log analysis of processing logs.
The "controls" may be displayed side by side in a ranking format or the like based on the frequency of questions asked.

This makes it easier to eliminate notational fluctuations, reduce the input burden, and reduce the cost of new knowledge (proposal of preconditions, permanent storage (for disks, etc.), etc.).


(8) The present invention also

The above-mentioned "perform subsequent processing according to the answer from the user"
The user can temporarily or permanently add facts and rules to the logical program itself as prerequisites or contexts for processing.
It also provides computer programs.

In this way, you can draw conclusions (when temporarily added) according to the facts and rules that represent the temporarily assumed scene.
A logical program with added facts and rules representing typical situations can be stored and shared (assetized) as a library that is a derivative version of the original logical program.

(9) The present invention also

When the character string entered by the user matches some reserved words
Do not interpret the question from the user, the precondition or the context,
Performs the processing defined for the reserved word,
It also provides computer programs.

As a result, it is possible to easily, efficiently, or at low cost to realize a standard response ( for example, greeting, fixed opinion, belief, procedural processing, etc.) when the system is realized as an interactive system.

In addition, the responsiveness and hospitality of the interactive system and the trust of users will be increased.
To reduce the bluntness of the system
Regarding the input (especially the question text) from the user who is in the position of asking a question, the content that could not be answered by the logical program
Automatically indicate to "users who have the authority to edit logical programs", etc.
It is particularly advantageous in this case to provide means for the computer program to automatically prompt the logical program to edit and add to the logical program in favor of knowledge that makes the unresponsive content responsive.


(10) The present invention also

Detects that the character string input by the user is an expression expressing a question in 5W2H format (when, where, who, why, what, how, how much) by collating with a predetermined reserved word. And
Variables that are bound (assigned) so that they can be bound (assigned) only by the corresponding value type ( for example, the type of content, the format is a character string format, a numerical format, a pointer to an object, a URI format, etc.) It also provides a computer program that replaces the name with the name and performs the subsequent processing.

As a result, when it is realized as an interactive system,
The range and type of values that bind variables
Makes it easy for general questioners who are not familiar with logic programming to specify.

An example of explicitly defining a predetermined reserved word conversion rule in a logical program is shown below.
===
Who ⇒ $ {who} who ⇒ $ {who} who ⇒ $ {who} is why = $ {why}
===

b. An example of character string conversion based on the above reserved word conversion rules is shown below.
===
Who fed the dog? ⇒ $ {who} fed the dog?
===

c. An example of explicitly defining the rules for bindable values (contents) in a logical program is shown below.
===
$ {Who} ← {Taro | Hanako | Home Robot | ...}
$ {Why} ← {Because it's a warm winter | Because it's emotions | Because the other party greeted me first | ...}
===


(11) The present invention also

Provided is a computer program characterized by automatically showing a user a fact that can be automatically proved to be true by the knowledge added by the user.

The advantageous effects of this are listed below.
===
・ It becomes easier to establish a general dialogue format.
・ It becomes easier to establish active consulting that does not require explicit questions from clients.
-The user asks each new fact that can be proved, and the user asks the difference between the fact set (which can prove to be true) before adding knowledge and the set after adding knowledge. You can save the trouble of explicit analysis.
・ Side effects and points to be noted by adding / adding (= admitting / admitting) knowledge by asking a question from a computer (guided cross-examination in a sense) ・ TODO (technical, accuracy assurance, application, examination It is possible to easily and concisely show the above) etc. to the user (along with the truth and solution).

A simple example of this is shown below.
===
<Original knowledge>
$ A and friends:-Good friends with $ A ,? I have a long relationship with $ A and I am on good terms with Taro

<Contents added by the user as a prerequisite (context)>
Long relationship with Taro

<Contents automatically shown to the user>
Is it "Taro and friends"?
===


Hereinafter, a simple method for realizing the above invention using the system shown in the embodiment will be shown.
===
Step 1) $ A you asked for without adding knowledge? Seek the answer (the whole set of provable facts).
Step 2) $ A obtained after adding knowledge? Seek the answer (the whole set of provable facts).
Step 3) Display the difference X between the two answers as "X, isn't it?"
===


(12) The present invention also
About literals with a mark that you can ask the user for authenticity
Provided is a computer program that provides a set of solutions assumed to be true regardless of the user (for example, a set of "... (assumed content) if ~ (conclusion content)").

This is equivalent to providing a solution of the subjunctive mood form "... if ...", and it is better to provide the knowledge itself including the case classification than to make a conclusion after confirming the facts in terms of communication cost. It is advantageous when the degree of conviction of the person is also excellent.

Here, the "hypothesized solution set" is, for example, "If it is sunny tomorrow, you should go fishing."
It can be expressed as a set (or list) in the form of "... if ...".

As a result, the knowledge, information, conclusions, and grounds necessary for the user can be substantially obtained without extracting the knowledge (which may include personal information in some cases) from the user (while reducing the risk of being intercepted). It is possible to provide it and lead to problem solving.


(13) The present invention also

It is advantageous that the computer program provides the dialogue service in cooperation with the WEB server.

As a result, it is possible to efficiently operate an interactive expert system or the like that is scalable and has a short service downtime.

In addition, personal beliefs, knowledge, information, priorities (including values), etc. can be shared via the Internet.
It enables interactive, wide-ranging, inexpensive, and permanent communication.

In addition, it is linked and complemented with the mail system, and has log management of the results of dialogue, analysis of knowledge that was insufficient to answer questions (may be a set of questions that could not be answered), and logic program editing rights. It is advantageous to automatically notify the user.


(14) The present invention also

Degrees of a given point of view ( eg, default may be number or quantity) ( eg, "how much?", "How much XX?", "How much XX?", Etc.)
Same extent as any of one of the series which represents the degree of sequence relationships for a given viewpoint for a given question (default may be a number or amount),
Degree of any one or more items,
To a degree less than or equal to any one item,
To the extent that it exceeds any one item,
Provided is a computer program that defines and returns a degree less than any one of the terms or a combination thereof based on input from a user, memory by a computer, or both.

This will
"Order"
It is possible to express knowledge about the degree in the form with the largest amount of information (after interpretation) per description amount.
The amount of description per meaning (information) can be saved, and at the same time,
It can be described in a format in which the semantic contradiction of knowledge is unlikely to occur (it depends on the fact that it is easy to check the semantic contradiction of knowledge (if the number of items is N, it is about O (N ^ 2) in order calculation)).

For example, an example of how to define and answer the answers to the following questions is shown.
===
(Questions from users)
How heavy is the water?

(Definition in a logical program (performed by a user who has the authority to edit the logical program))
<Heavy iron sand Mizuki air> Heavy

(Answer of a computer program according to the present invention with reference to the above logic program)
→ Heavier than wood → Lighter than sand

An answer as described above can be clearly obtained and displayed by a person skilled in the art with reference to the present invention by executing the linear search algorithm twice.


(15) The present invention also

A method using such a computer program is provided.


(16) The present invention also

A device using such a computer program is provided.

FIG. 1 is an example of a logic program according to an embodiment of the present invention. FIG. 2 is an example of a screen in which a link is displayed based on the logical program of FIG. 1 and a question from a general user is correctly answered by a reverse question.

In the embodiment of the following patent specification (above, excerpt from Patent Document 1) by the same inventor,
It shall be carried out by additionally implementing the function peculiar to the present invention.
The following references also include supplementary purposes in terms of feasibility and inventive step of the present person.
===
<Problems of Patent Document 1> It is possible to automatically process knowledge expressed in the form of embedding variables in natural language on a computer in the same way as PROLOG, and comprehensive deduction and solution search (automatic unification processing) at the predicate logic level. , Automatic derivation processing, backward inference for that, backtrack).
Make full use of the advantage that variables are not tied to the case structure, speed up processing, and display the results in an easy-to-read manner for proof and learning.
<Solutions for Patent Document 1 (Overview)>
When a human inputs a "fact", "rule" or "goal" in PROLOG, the constant part and the variable part of the content corresponding to "literal" in PROLOG are input to the computer separately by the character type, delimiter or escape character.
The computer treats variables as being able to straddle boundaries such as the main part and predicate of a sentence, and performs automatic unification processing, automatic derivation processing, or both of the sentences included in the input.
The pattern, which is a statement that can contain variables, and the constant character string, which is a statement that does not contain variables, are unified, and the longest matching solution of the variable that first appears in the pattern is obtained, and the character string of the longest matching solution is obtained. For each new pattern that can be created by substituting the process of scraping from the back until it becomes an empty character, each state of the solution of the scraping process that was the premise that the new pattern can be created is stored in the same way recursively. Repeat until there are no variables, and combine the states of each intermediate solution that was unified when there are no variables to obtain the answer for each unification.
It speeds up by detecting whether the fixed character string in the pattern is included in the character string in the process of removing the longest matching solution.
Pattern-to-pattern unification is accelerated by focusing on the matching of the beginning and end of words. A concrete method of full search is also provided.
<Solutions for Patent Document 1 (full text, but some additions and amendments so as not to be confused with the present invention)>
(0009)
The present invention has been made in view of such a problem, and claim 1 of Patent Document 1 is set forth in claim 1.
A method in which a computer automatically performs some or all of the functions of the logic programming language PROLOG.
When a human inputs a "fact", "rule" or "goal" in PROLOG, the constant part and variable part of the content corresponding to "literal" in PROLOG (hereinafter referred to as "sentence") are character types, delimiters or escape characters. Input to the computer separately by
The above "facts", "rules" or, while the computer treats the variables as being able to cross the sentence's main part, predicate, subject, predicate, object, complement, conjunctive modifier, conjunctive modifier or sentence boundary. Performing automatic unification processing, automatic derivation processing, or both of the sentences included in the input of "goal",
Provide a processing method characterized by.
Here, "human beings input the constant part and the variable part into the computer by distinguishing them by the character type, the delimita or the escape character" means that the human beings input in the input field of the application software (processing system) according to the present invention. Input directly after the command prompt (with or without a front-end processor, etc.), copy-paste or cut-paste from an Internet browser, text editing software, etc., or a text file that has been input and saved separately. Etc. are included in reading, quoting, and referencing.
In addition, "the computer treats variables as those that can cross the subject, predicate, subject, predicate, object, complement, conjunctive modifier, conjunctive modifier, or sentence boundary" means Japanese, etc. It can only straddle the boundaries (explicit delimiters) of case structures with explicit delimiters (including those that correspond to the hierarchical structure of parsing results and semantic analysis results) via predicates such as assistants and English. Instead, it can straddle the boundaries between S and V, the boundaries between V and O, the boundaries between V and C, etc. in SV format, SVO format, SVOO format, and SVOC format, such as English, and the boundaries between compound sentences and compound sentences. Includes modes that are treated as possible (conversely, there may be modes that are not treated). In these cases, as solution candidates that can be included in variables, an arbitrary sub-character string is extracted from the entire sentence or the character string that constitutes the entire sentence, ignoring the unit of delimiter by the grammatical structure as the sentence, and further, the hierarchy The whole of compound sentences / double sentences with a typical reference structure, longer papers, etc., and any substrings of them are targeted (note that "sentence boundaries" can also be treated as possible. When dealing with a set of knowledge sources (for example, reading, writing, referencing, etc., a set of knowledge sources in a file), it is necessary to separate the knowledge sources at "other than" the sentence boundary. Therefore, for example, a line feed code, a tab code, or the like can be used as such a delimiter).
As a result, knowledge and information expressed in the form of embedding variables in natural language and knowledge and information in the ordinary sentence format are unified knowledge that opens up the possibility of realistic mutual utilization between them. As a source, it becomes possible to automatically process the two by a computer without distinguishing between them (overcoming the above-mentioned "difficulty A").
In order to open up the possibility of "realistic" interaction "sufficiently", automatic processing by a computer should be provided as a search processing system. 1) Convenience of search formulas (expressions that specify patterns), 2) Sufficient The precision rate (accuracy of the solution), 3) the sufficient recall rate (comprehensiveness in extracting solution candidates) must be provided, but in the present invention, the sentence is free (that is, the grammar and meaning). While allowing the embedding of variables (multiple types or multiple times) in places (not limited to delimiters) (ensuring convenience), it is basically based on the PROLOG knowledge processing procedure (and the underlying knowledge interpretation policy). By following, the risk of deterioration of the precision rate (solution accuracy) that may occur due to the hybrid knowledge processing procedure (and the complicated knowledge interpretation policy corresponding to the hybrid processing procedure) as in other processing systems is avoided. At the same time, by "treating variables as being able to cross the sentence's main part, predicate, subject, predicate, object, complement, conjunctive modifier, conjunctive modifier, or sentence boundary", a delimiter expression in natural language ( Unjustified disagreement (regular expression) caused by the appearance of crying of specified patterns by reading points, punctuation points, parentheses, commas, periods, etc. Unmatching) is prevented, and a certain degree of reproducibility (comprehensiveness in extracting solution candidates) can be ensured between superficial character string expressions (between search expressions and knowledge sources) where the case structure is not specified. In addition, integrated and continuous inference / extraction (as a solution candidate to a variable) that does not easily impair the exact context (character strings before and after) of the natural language that became the source of knowledge becomes possible, and in the end, its transparency. The simplicity makes it easy and easy to confirm and verify the substantial soundness of the reasoning (the validity of the grounds and the reasoning process), and gives the user a realistic sense of security that the grounds are always clear. Take full advantage of the specification that variables are not tied to a case structure (and you don't have to know about case structure rules (such as the order of appearance) and you don't have to worry that the order of arguments may be wrong). Allows you to cut.
Since the first target of the present invention is Japanese (a large amount of information in one character and no space between words), many contents use characters as a processing unit and a delimiter unit, but English and the like. (The amount of information in one character is small, the number of characters in one sentence is large, but there is a space between words), it is possible to perform the same processing in units of words separated by spaces.
(0010)
Further, claim 2 of Patent Document 1 is
In the automatic unification process
Unification of a pattern that can contain variables (a constant part and a variable part are distinguished by a character type, a delimiter, or an escape character) and a constant character string that is a sentence that does not contain variables.
Find the longest matching solution (eg Taro and Jiro) of the variable (eg $ X) that appears first (or last) in the pattern (eg $ X and $ Y like $ Z) and find the longest matching solution. Each new pattern (example: Taro and Jiro> Taro and Jiro> Taro and> Taro and>Taro>Ta> Sky) that can be created by substituting the process of cutting the character string from the back (or front) to the empty string : "Taro and Jiro and $ Y like $ Z">"Taro and Jiro and $ Y like $ Z">"Taro and Jiro and $ Y like $ Z">"Taro and $ Y like $ Z""Ilike">"Taro and $ Y like $ Z">"and $ Y like $ Z"), each state of the solution of the shaving process that was the premise that the new pattern can be created ($ X = While memorizing Taro and Jiro> Taro and Jiro> Taro and>Taro>Ta> Sky)
Recursively repeat until there are no more variables,
The state of each solution that was unified when the variables disappeared (example: true ($ X = Taro and Jiro, $ Y = Saburo), true ($ X = Taro, $ Y = Jiro and Saburo)) Characterized by combining and obtaining answers for each unification (example: answer 1 = ($ X = Taro and Jiro, $ Y = Saburo), answer 2 = ($ X = Taro, $ Y = Jiro and Saburo)) The processing method according to claim 1 of Patent Document 1 is provided.
Here, "(or last)" corresponds to "(or before)", and when substituting from the variable that appears last, it means that the start of scraping must be from the front.
This makes it possible to verify the state of each solution candidate that reliably covers all possibilities from the longest matching solution to the shortest matching solution, and to provide a comprehensive answer (a set of further narrowed solution candidates). It will be possible.
(0011)
Further, claim 3 of Patent Document 1 is
The processing method according to claim 2 of Patent Document 1, characterized in that, instead of gradually cutting until it becomes an empty string, only the shortest matching solution obtained separately is gradually cut.
As a result, it is possible to save the calculation of the solution search from the length less than the shortest matching solution to the "empty" character, and it may be possible to speed up the automatic processing.
(0012)
Further, claim 4 of Patent Document 1 is
When gradually scraping until it becomes an empty string
If one character C (immediately after (or immediately before)), which is a fixed character immediately after (or immediately before) the variable first appears (or last) in the pattern, is another variable and the solution is not an empty string, the variable is changed to the other variable. When the first (or last) one letter C) of the solution candidate assigned as the solution candidate is included in the longest matching solution,
The processing method according to claim 2 or 3 of Patent Document 1, wherein the sub-character string from the end (or the beginning) of the character string of the longest matching solution to the first character string corresponding to the C is deleted including the C. provide.
Here, "(or last)" corresponds to "(or just before)", and when substituting from the variable that appears last, it means that the start of scraping must be from the front.
As a result, it is possible to save the enumeration of solution candidates that do not match the fixed characters immediately after (or immediately before) the variable and the search based on the solution candidates, and it may be possible to speed up the automatic processing.
(0013)
Further, claim 5 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When requesting binding information that becomes the "goal" (including "sub-goal"; the same applies hereinafter)
Any one of claims 1 to 4 of Patent Document 1 that independently obtains binding information for each sentence constituting the "goal" and returns the return value true and the intersection of the binding information when the product set is not empty. The processing method described in the section is provided.
Here, the binding information is information indicating whether or not such a solution candidate has been assigned to each variable at the same time. The binding information indicating one binding method to each variable is "variable name 1 = value 1, variable name 2 = value 2, ..., variable name N =" by interpreting "," as an AND combination. While it can be expressed in a list format such as "value N", multiple bindings can be expressed as a set of such lists, or as a common part between multiple bindings by explicitly indicating an AND / OR combination instead of ",". It can be expressed in a conjunctive normal form or a disjunctive normal form that standardizes the whole of multiple bindings.
As a result, in the case of a problem form in which there are multiple patterns (sentences) to be satisfied at the same time, and variables with the same name should have the same solution among the patterns (sentences) (for example, such an AND join query from the user, When there are multiple sentences in the body part of the rule), there is less possibility that a large amount of full-text search processing will be unnecessarily repeated for each unification result of the pattern on the left side of the rule, and the body It is possible to avoid the inefficiency of depth-first search while backtracking the part (more remarkable inefficiency in the form of embedding variables in natural language), and to simplify the processing for each pattern to be satisfied at the same time. It also makes the display and verification (integrity and soundness) of the inference process easy to understand. In addition, it is possible to prevent the ordering (between sentences in the body part), which is unnecessary for the intuition required as the meaning of the rule and should not be defined, to have a side effect on the inference process.
(0014)
Further, claim 6 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When seeking the binding information that is the "goal"
Empty the existing binding information first,
The sentence set contained in the "goal" is automatically calculated for whether the sentence can be true under the application of the existing binding information and the additional binding information for the possible binding information, and the additional binding information is used as the existing binding information. While adding, the sentence is recursively reduced except for the sentence,
The processing method according to any one of claims 1 to 4 of Patent Document 1 is provided in which the existing binding information when the sentence set becomes an empty set as it can be true is used as the binding information as the "goal". To do.
Here, "recursively reduce" means that the deeper the recursion, the smaller the statement set and the more complicated the binding information (more variables are bound, and the range of bound values is narrowed). For example, it means to realize equivalent recursive processing by a process of making a recursive call in C language or a stack structure (structure array and stack pointer, etc.) for depth priority search originally declared and defined.
This simplifies the problem of automatically processing an open question consisting of multiple patterns of AND binding that must be satisfied at the same time, expressed in the form of embedding variables in natural language, into a simpler and recursive partial problem with the same structure. Transform and facilitate the display and verification (completeness and soundness) of the inference process.
(0015)
Further, claim 7 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When unifying the non-variable pattern with the non-variable fact
The processing method according to any one of claims 1 to 6 of Patent Document 1, which returns true when the pattern and the fact match as a character string, or returns false when the pattern and the fact do not match as a character string. provide.
As a result, the search can be performed simply and quickly.
In addition, when "fact not including variable" contains multiple sentences separated by punctuation marks. "Match as a character string" can also be provided with a mode in which the character string of the pattern may match a part of the actual character string.
As a result, a plurality of pieces of information of the same type can be collectively expressed as one fact and used as a search target. It also makes it easier to express some order between multiple elements (eg, size, preciousness, antiquity, etc.).
(0016)
Further, claim 8 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When unifying the pattern that does not include variables and the head part that does not include variables in the horn clause,
When the pattern and the head portion match as a character string, the result of applying the processing method according to claim 5 or 6 of Patent Document 1 with the body portion of the horn clause as a subgoal is returned.
The processing method according to any one of claims 1 to 7 of Patent Document 1, which returns false if they do not match, is provided.
This explains the sound mechanical interpretation when the head of the rule that expresses the variable in the form of embedding it in natural language does not include the variable, the seamless, easy-to-understand, simple and unified processing mechanism, and the corresponding inference process. Can be given.
(0017)
Further, claim 9 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When unifying a pattern that does not contain variables and a horn clause that has a head that contains variables,
Obtained by processing using the pattern as the "constant character string" in the processing method according to any one of claims 2 to 4 of Patent Document 1 and using the head portion as the "pattern" in the same processing method. About each binding information
If there is a true result of processing the one applied to the body portion of the horn clause as a "subgoal" of the processing method according to claim 5 or 6 of Patent Document 1, the true value is returned or exists. Provided is the processing method according to any one of claims 1 to 8 of Patent Document 1, which returns false if not.
As a result, when the head of the rule that expresses the variable in the form of embedding it in natural language contains the variable and the pattern that invokes this rule does not contain the variable, the bound range of the variable in the body part is limited in advance, and it is true. The processing of false judgment can be speeded up.
It can also provide sound mechanical interpretations, seamless, easy-to-understand, simple and unified processing mechanisms, and explanations of the corresponding inference processes.
(0018)
In addition, claim 10 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When unifying patterns that include variables with facts that do not contain variables
The result of processing using the pattern as the "pattern" in the processing method according to any one of claims 2 to 4 of Patent Document 1 and using the fact as the "constant character string" in the same processing method. return,
The processing method according to any one of claims 1 to 9 of Patent Document 1 is provided.
As a result, all solution candidates (to the case variable) between the pattern and the (static) fact are identified and returned as the "result", which is the basis for overcoming the above "difficulty A". A simple mechanism can be given, facilitating not only visualization and verification of the inference process, but also learning through the user's hands such as rule modification.
(0019)
In addition, claim 11 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When unifying the pattern containing variables and the horn clause having a head part not containing variables,
The result of processing using the pattern as the "pattern" in the processing method according to any one of claims 2 to 4 of Patent Document 1 and using the head portion as the "constant character string" in the same processing method. The binding information (C) is true, and the binding information is true when the result of processing the body portion of the horn clause as a "subgoal" of the processing method according to claim 5 or 6 is true. Return true with (C),
The processing method according to any one of claims 1 to 10 of Patent Document 1 is provided.
As a result, all solution candidates (for each variable) between the pattern containing variables and the head (static without variables) are identified and returned as "results". Therefore, the above "difficulty A" The basic mechanism for overcoming it can be simply given, facilitating not only visualization and verification of the inference process, but also learning through the user's hands such as modifying rules.
It also simply transforms into a simpler and recursive (or mutual recursion) subproblem with the same structure, facilitating the display and verification (completeness and soundness) of the inference process.
In addition, a sound mechanical interpretation when the head of the rule that expresses the variable in the form of embedding it in natural language does not include the variable, a seamless, easy-to-understand, simple and unified processing mechanism, and the inference process corresponding to these. An explanation can be given.
(0020)
In addition, claim 12 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When unifying the pattern containing variables and the horn clause having a head part containing variables,
Returns false if the number of fixed characters in the pattern and the head, tail, or both of the head does not match.
The processing method according to any one of claims 1 to 11 of Patent Document 1 is provided.
As a result, compared to a uniform search, it is possible to clearly save a large amount of calculation and improve the processing speed.
(0021)
In addition, claim 13 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When unifying the first pattern containing variables and the horn clause having a head containing variables,
If the pattern matches the fixed characters for the number of characters existing at the head and tail of the head part,
Each of the binding information obtained by binding the head portion of the horn clause with each binding information for which the result of applying the body portion of the horn clause as a "subgoal" in the processing method according to claim 5 or 6 of Patent Document 1 is true. About the second pattern
If the second pattern does not contain variables
Processing was performed using the first pattern as the "pattern" in the processing method according to any one of claims 2 to 4 of Patent Document 1 and using the second pattern as the "constant character string" in the same processing method. Returns the result,
The processing method according to any one of claims 1 to 12 is provided.
Here, "when the second pattern does not include variables" means that in the horn clause (rule), all the variables included in the head part are also included in the body part "also", and all the variables in the body part. As a result of the variables being bound by constants (fixed character strings), all the variables in the head part are also bound (assigned) by constants (fixed character strings), so the variables in the head part disappear and the head part becomes a constant character string. It means that it can be regarded.
As a result, the unification of the pattern including variables and the horn clause (rule) having a head portion including variables can be mechanically and automatically performed in a flow that is easy for the user to trace by using a simple calculation model.
That is, all solution candidates (those that should be assigned to each variable of the pattern) between the pattern containing the variable and the head part that does not include the variable (by each binding information) (= constant character string) are identified and " By reducing the original more complicated problem (variable-to-variable unification) (transforming the problem) into the form returned as "result", the basic mechanism for overcoming the above "difficulty A" is simplified. It is made easy to express as a giving and thinking process. In addition, in this "reduction (conversion of the problem)", the inference process is visualized and verified (completely) because it is simply converted into a sub-problem with the same structure that is simpler and recursive (or mutual recursion). It facilitates learning through the user's hands, such as modifying rules as well as (of sexuality and soundness).
After all, a sound mechanical interpretation when the head of the rule that expresses the variable in the form of embedding it in natural language contains the variable, a seamless, easy-to-understand, simple and unified processing mechanism, and an explanation of the inference process corresponding to these. Can be easily given.
(0022)
In addition, claim 14 of Patent Document 1 is
The processing method according to any one of claims 1 to 13 of Patent Document 1, characterized in that a computer restricts the input of facts including variables.
Here, the facts including variables (knowledge sources that are not rules) include, for example, "$ X is $ X" (tautologically tautological fact) and "$ X is $ Y" (. There is no basis for truth if only the superficial sentence patterns match).
By limiting the input of these to the computer, the calculation of the automatic unification process of patterns (sentences that can contain variables) and facts (sentences that do not contain variables (= fixed character strings)) becomes simple. , High-speed answer is possible by automatic processing. It also makes it difficult to mix unfounded facts into knowledge sources.
(0023)
In addition, claim 15 of Patent Document 1 is
The rule has a form similar to the so-called horn clause, and any one of claims 1 to 14 of Patent Document 1 is characterized in that the computer restricts the head portion from including a variable that does not appear in the body portion. The processing method described is provided.
Here, "the computer restricts the head part from including variables that do not appear in the body part" means that the head part is "$ X is nice" and the body part is "$ Y is strong, $ Y is $". Even if all the variables in the body part ($ Y and $ Z in this example) are bound (assigned), such as "Z-friendly, $ Z is a child, $ Y is smart", the variables in the head part In this example, it means that the computer restricts the input, storage, and activation of rules that leave ($ X) unbound as a source of knowledge. Such a rule leads to leaving unbound variables in the head, as in the case of facts, which tends to produce unhealthy inference results and slows down inference.
By restricting the input of such rules to the computer, the pattern (sentence that can contain variables) and the head part (sentence that does not include variables (= fixed character string) according to claim 13 of Patent Document 1) can be combined. The calculation of the automatic unification process with (reducible) is simplified, and high-speed answering by the automatic process becomes possible. It also makes it difficult to produce unfounded inference results.
(0024)
In addition, claim 16 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
Automatic unification of patterns and heads or facts with unbound variables remaining in each other,
It is characterized by finding and returning a set of solutions that are minimal as a fixed character string.
The processing method according to any one of claims 1 to 13 of Patent Document 1 is provided.
Here, as an example of "a set of solutions that are minimal as a fixed character string", {($) as a result of automatic unification between "$ A is $ B" and "$ C is also $ D". A = "mo", $ B = <empty>, $ C = <empty>, $ D = "is"), ($ A = empty, $ B = "also", $ C = "is", $ D = Empty)} may be provided.
This makes it possible to provide an example of a solution (especially the smallest simple example) even when there are an infinite number of solutions.
(0025)
In addition, claim 17 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
Automatic unification of patterns and heads or facts with unbound variables remaining in each other,
It is characterized by finding and returning a set of solutions that is the minimum as a character string containing variables.
The processing method according to any one of claims 1 to 13 of Patent Document 1 is provided.
Here, as an example of "a set of solutions that are minimal as a fixed character string", {($) as a result of automatic unification between "$ A is $ B" and "$ C is also $ D". A = "$ C also", $ B = <free>, $ C = <free>, $ D = "is $ B"), ($ A = <free>, $ B = "also $ D", $ It may provide two solutions such as C = "$ A is" and $ D = <freedom>)}. It is considered that the total (through the solution) of the character string length of the value that binds the variable (the value assigned to the variable) (however, if the variable is included, it is regarded as one character per occurrence of the variable) is minimized. be able to.
This makes it possible to provide a general form of a solution even when there are an infinite number of solutions.
(0026)
In addition, claim 18 of Patent Document 1 is
When the fixed characters for the number of characters that are common to the beginning and tail of each character string of the head part or fact and the pattern in which unbound variables remain are not the same.
Characterized by returning false,
The processing method according to claim 16 or 17 of Patent Document 1 is provided.
As a result, automatic search that cannot be unified can be saved, and automatic processing can be speeded up.
(0027)
In addition, claim 19 of Patent Document 1 is
When finding a set of solutions that is minimal as a character string containing the fixed character string or variables,
Each variable contained in both character strings (the first character string and the second character string) consisting of a pattern and a head part or a fact in which unbound variables remain in each other is bound in common within each character string. And while assuming that the strings are bound independently (or that the scope for binding variables with the same name in common is only within each string (or between strings is outside the scope of the variable)).
For each variable, any substring (<empty>) of the other string (the second string for the variable in the first string, the first string for the variable in the second string) and It is characterized by finding a set of solutions that is the minimum by a full search to find a case where both character strings match by substituting itself (including the entire character string).
The processing method according to claim 16 or 17 of Patent Document 1 is provided.
"Or substitute yourself ..." means to substitute "$ X" itself for "$ X" in the character string, and it happens to be in the first character string or the second character string. When $ X (the scopes of each are different) is included, the first character string $ X and the second character string $ X can be distinguished (for example, "$ X1" and "$". Clearly sound calculations can also be made by substituting (as X2 ”, etc.).
As a result, it is possible to secure a certain degree of completeness of the solution set (completeness depending on the nature of the problem (pattern pair)) while ensuring soundness and halting property (finiteness of calculation).
(0028)
Further, claim 20 of Patent Document 1 is
Not both strings themselves, consisting of patterns and heads or facts with unbound variables remaining in each other
Both character strings corresponding to the two character strings that remain after excluding the fixed characters for the number of characters that are commonly present at the beginning and tail of each character string of the pattern and the head part or fact where unbound variables remain in each other. about,
A processing method for performing the processing according to claim 19 of Patent Document 1 is provided.
As a result, the space for the entire search can be reduced while maintaining a certain level of completeness (in some cases, completeness) of the solution set, and the processing speed is increased.
For example, as a process of automatic unification between "Ishikawa's $ A likes $ B" and "Ishikawa's $ C also likes $ D ice cream", instead of searching for a solution as it is, Delete the common part of "$ A is $ B"
And "$ C is also $ D ice cream"
Then, by full search, all the substrings of "$ C is also $ D ice" for "$ A" and "$ B" (this is a variable such as $ C and $ D ($ {...) (The same applies to variables in the form of}) is 6 characters if it is 1 character, so while substituting 6 x (6 + 1) / 2 + 1 (<empty> minutes) + 1 (substitute itself) = 23 ways) , Similarly, all substrings of "$ A is $ B" for "$ C" and "$ D" respectively (since this is also 3 characters, 3 x (3 + 1) / 2 + 1 + 1 = 8 ways For all the character strings (23 x 23 x 8 x 8 ways) that can be created by substituting (existing), if both character strings match (for example, (for example)
"Moha ice cream",
"Hamo ice cream",
"$ A is ice cream",
"$ C is also ice cream",
"$ A is also $ D ice cream"
* By the way, the set of substitution sets when "$ C and $ B ice" do not match) {
($ A = "also", $ B = "ice", $ C = <empty>, $ D = "is"),
($ A = <empty>, $ B = "also ice", $ C = "is", $ D = <empty>),
($ A = "$ A", $ B = "also ice", $ C = "$ A is", $ D = <empty>),
($ A = "$ C also", $ B = "ice", $ C = "$ C", $ D = "is"),
($ A = "$ A", $ B = "also $ D ice cream", $ C = "$ A is", $ D = "$ D")
} Or a set of partial assignments for each assignment set (eg {{
($ A = "also", $ B = "ice"),
($ A = <empty>, $ B = "also ice"),
($ A = "$ A", $ B = "also ice cream"),
($ A = "$ C also", $ B = "ice"),
($ A = "$ A", $ B = "also $ D ice cream")
})
Can be answered as a solution.
Note that $ A = "$ A" and $ B = "also $ D ice" can be freely $ A and $ D, and can be unified by substituting any character string there (that is,). It is possible to show that there are infinite solutions and the constraints (regular expression form) of the infinite number of solutions (character strings).
(0029)
In addition, claim 21 of Patent Document 1 is
Substitute any substring (including <empty> and the entire string) of the other string for each variable, or try to find a case where both strings match. A set of solutions that is minimized by a full search. When asking
If the substring to be assigned to a variable contains a variable, the variable contained in the substring is replaced with a new variable that did not previously exist in both strings, and the same assignment to the new variable is made. The processing method according to claim 19 or 20 of Patent Document 1, further comprising performing a full search for a case where both character strings match while performing recursively.
As a result, it is necessary to search for a solution in which a fixed character in the own character string is reflexively assigned to a variable in the own character string via a variable in the other character string (for example, both character strings = { In the case of "$ X is $ X", "i $ Y u"}, it is necessary to be able to enumerate ($ X = "say", $ Y = "u yes") as solution candidates). The completeness of the solution candidate enumeration can be improved while maintaining the soundness. In the above example, both character strings (also called "pattern pair") = {"$ X is $ X", "i $ Y u"} to ($ X = "say", $ Y = "u yes") According to the present invention, it is possible to recursively search for the solution candidates ($ X = "i $ {Y1} u") ⇒ ($ {Y1} = <empty>) ⇒ ($ Y = "uye"). It can be shown by being able to generate branches (which are part of a search tree and can be generated a finite number of times in the case of breadth-first search according to the present invention).
“Recursively ... full search” means, for example, a matching substitution sequence while performing a breadth-first search that recursively repeats each possible assignment to each variable (same as the claim of the previous patent document 1). (For example, the above ($ X = "i $ {Y1} u") ⇒ ($ {Y1} = <empty>) ⇒ ($ Y = "uye"), etc.) are listed. The first variation of the assignment is if the types of variables in both strings are 2 and 3 respectively and the length of the string is 6 and 7 characters respectively (variables are collectively counted as 1 character). 2 pieces x (7 x (7 + 1) / 2 + 1 + 1) + 3 pieces x (6 x (6 + 1) / 2 + 1 + 1) = 60 + 69 = 129 ways. When performing a breadth-first search so that the maximum depths of further branches derived from these branches are equal, a limiter (program step to compare with the upper limit value, etc.) is provided according to the number of substitutions, etc., so that each search is performed once. Can be limited to an appropriate amount of calculation (ensure of stopping and response speed that is no longer guaranteed by reflexivity). Even in the case of a depth-first search, the amount of calculation can be limited by limiting the depth, the number of substitutions, and the like. In each case, an infinite loop by self-recursive or mutual recursion is provided, and a stack structure (array of structures) that manages recursive function calls is provided, and call parameters (its substitution series) of branches that are ancestors (more root direction). (It may include the state representation of both strings according to (assignment context)) can be avoided by comparing it with the current calling parameter. In addition, it is possible to prun the branches that cannot be unified depending on whether or not the fixed character strings existing at the beginning and the end of both character strings match the number of characters existing in common. If a solution is not found by searching for a limited amount of calculation (for example, 1 million substitutions or search depth within 20), it is found as "no solution (accuracy: 1 million substitutions and search depth within 20)". In that case, as "($ X =" say ", $ Y =" yes "), (...), ... (However, accuracy: 1 million substitutions and search depth within 20)" etc. It is also possible to answer the user while clearly indicating the search accuracy. In addition, if the entire search can be clearly performed within the limit number of substitutions and within the limit search depth (when there is completeness), "no solution (complete search completed)" or "($ X =") to that effect. It is also possible to answer the user by clearly stating ", $ Y =" yes "), (...), ... (all searched)".
(0030)
In addition, claim 22 of Patent Document 1 is
As for the result of assigning to the variable, the two character strings that remain after removing the fixed characters for the number of characters that are common to the beginning and end of each character string from both
As the "other party's character string" that is the target of "any substring of the other party's character string (including <empty> and the entire character string)", it exists at the beginning or end of the character string as the search progresses. Characterized by reducing the number of fixed characters,
The processing method according to any one of claims 19 to 21 of Patent Document 1 is provided.
As a result, the number of branches decreases as the search progresses (the more the branch goes to the tip), and the amount of calculation can be saved.
(0031)
In addition, claim 23 of Patent Document 1 is
When finding a set of solutions that is minimal as a character string containing the fixed character string or variables,
Each variable contained in both character strings (the first character string and the second character string) consisting of a pattern and a head part or a fact in which unbound variables remain in each other is bound in common within each character string. And while assuming that the strings are bound independently (or that the scope for binding variables with the same name in common is only within each string (or between strings is outside the scope of the variable)).
It is a processing method that recursively substitutes a fixed character string (including an empty string) or a character string containing a variable into each variable to obtain a set of solutions.
Limit the variables to be assigned to the variables at the beginning or end of the own character string whose head or tail is a fixed character.
The substitution value is a new variable or <empty> following the fixed character or fixed character string of the head if it is the head, and a fixed character or fixed character string of the tail following the new variable if it is the tail. Or <empty>
For the result of assigning to the variable, the fixed characters for the number of characters that are common to the beginning and the end of each character string are repeatedly removed from both.
The processing method according to claim 16 or 17 of Patent Document 1 is provided.
This makes it possible to significantly limit the enumeration range of solutions (without impairing the completeness of the search) by focusing on the existence of fixed characters at the beginning and tail, which enables significant computational complexity savings and speedup. Become.
(0032)
In addition, claim 24 of Patent Document 1 is
When finding a set of solutions that is minimal as a character string containing the fixed character string or variables,
Each variable contained in both character strings (the first character string and the second character string) consisting of a pattern and a head part or a fact in which unbound variables remain in each other is bound in common within each character string. And while assuming that the strings are bound independently (or that the scope for binding variables with the same name in common is only within each string (or between strings is outside the scope of the variable)).
It is a processing method that recursively substitutes a fixed character string (including an empty string) into each variable to find a set of solutions.
Binds binding information that can be created using only fixed character types (character types excluding variable identifiers and delimiters) in both character strings that can be created by excluding common fixed characters for the number of characters that exist at the beginning and end of each character string. Obtained by enumerating in ascending order from the one with the smallest total value string length.
The processing method according to claim 16 or 17 of Patent Document 1 is provided.
As a result, problems with certain properties can be efficiently reached and listed.
(0033)
In addition, claim 25 of Patent Document 1 is
Based on the obtained "set of solutions that is the minimum as a character string containing variables"
The processing method according to claims 19 to 24 of Patent Document 1 is provided, in which the search is continued by the horn clause that can temporarily rewrite the variable of the horn clause with a character string including the variable.
As a result, it is calculated that the pattern and the head part of the horn clause (rule) are required to be unified (in the above example, the variable "$ C" is in the form of "$ A is". The unification policy (for example, in the case of the last assignment set above) that has a constraint that it can be unified only by being bound (assigned) by a character string is applied to the body part of the horn clause. It can be propagated to the search process and the search can be streamlined.
(0034)
In addition, claim 26 of Patent Document 1
Based on the obtained "set of solutions that is the minimum as a character string containing variables"
A set of fixed character strings that can be created by substituting each element of the set of fixed character strings defined in advance as the set of solutions of the "facts containing variables" into the variable part of the "character string containing variables". return,
The processing method according to any one of claims 19 to 25 of Patent Document 1 is provided.
As a result, a database (for example, "word equation (registered trademark)" and "VLANK (registered trademark)" that links facts containing variables (s) and a set of appropriate answers (or hypotheses) that can be filled in the variables It is possible to search for a solution efficiently in cooperation with the knowledge source in "". In addition, a large number of facts having similar sentence patterns can be efficiently managed in cooperation with the framework of the present invention.
(0035)
In addition, claim 27 of Patent Document 1 is
In the automatic unification process or the automatic derivation process,
When performing automatic unification between the first pattern containing variables and the second pattern containing variables,
When the fixed characters for the number of characters existing at the beginning and tail of both patterns match, and the same variable appears only once in each pattern.
Returns information that means the existence of an infinite number of solutions,
The processing method according to any one of claims 1 to 26 of Patent Document 1 is provided.
(0036)
In addition, claim 28 of Patent Document 1
Provided is an apparatus for carrying out the method according to any one of claims 1 to 27 of Patent Document 1.
(0037)
In addition, claim 29 of Patent Document 1
Provided is a computer program for causing a computer to execute the method according to any one of claims 1 to 27 of Patent Document 1.
(Effect of Invention of Patent Document 1)
(0038)
The effects of the present invention are as described above with respect to the claims of each Patent Document 1.
(Brief description of drawings of Patent Document 1)
(0039)
(Fig. 1) Fig. 1 is an overall view of a network system in which the present invention is most effectively implemented. (Example 1)
FIG. 2 is an explanatory diagram showing a hardware configuration of a computer for carrying out the present invention. (Example 1)
FIG. 3 is an explanatory diagram showing an example of screen display in a terminal for carrying out the present invention.
(Example 1)
(Form for carrying out the invention of Patent Document 1)
(0040)
The present invention can be carried out on any kind of computer (cloud server, large general-purpose machine, desktop PC, notebook PC, mobile terminal, dedicated machine of the present invention) connected / not connected to the network, but is generally used. The description will be given in a form realized by a PC connected to the Internet, which has a multitasking function and a window function.
FIG. 1 is an overall view of the network system that implements the present invention most effectively, and the content management device 1 is a content (rule or fact) handled by the user PC2 or the user / administrator PC2 in the present invention. A well-known file sharing server that accepts posts and distributes content while controlling sharing access rights and content provision priority according to a predetermined policy may be used. The user PC2 inputs and stores the content (rules and facts) expressing the content (or content to be examined) in natural language for each user according to the method of the present invention, and stores the content (rules and facts) according to the method of the present invention. Computers, mobile terminals, etc. that process.
FIG. 2 is an explanatory diagram showing a hardware configuration of a computer used in the present invention. This is a general configuration of a computer, and a feature of the present invention is a process processed by the CPU 2e using the natural law according to the instructions and descriptions of the program 3 and the content data 4 stored in the non-volatile memory 2h. It is in the content of and the ideal way of dialogue protocol (format) with users.
FIG. 3 is an explanatory diagram showing an example of screen display in a terminal for carrying out the present invention. In the figure, in response to the question "? $ A not done" (open question format), "$ A =" is used by using the fact that "do not do anything unpleasant" in the first line of the memorized list L (not shown).
I enumerate the answers "as much as possible / 1 /" and answer "$ A = bullying / 9 /" using the fact that "do not bully" on the 9th line of the list L.
(0041)
In such an embodiment, a computer program manufactured via C ++ language or the like can cause a computer (PC or the like) to perform all possible operations. Therefore, known basic operations of computers using the laws of nature (storage / retrieval to registers, memory, and storage, four-rule operations, comparison, etc.) and general functions that have already become standard libraries for development environments, etc. (Assignment / comparison / copy to variables and N-dimensional arrays, operation / comparison / display of character strings and numerical values, operations such as list structure / queue structure / hash structure / vector type, binary search and sort operations, by regular expression The method of realizing the pattern matching operation, network communication operation, etc.) is different from the essence of the present invention (unique configuration leading to novelty and progress) and is well known to those skilled in the art, and will not be described in detail. .. On the other hand, what kind of operation order and storage method (algorithm and data structure) is used to realize the processing peculiar to the present invention by combining such general functions will be described in detail below. By providing an explanation of this algorithm, etc., an explanation of the above-mentioned problem-solving means, and an explanation of the drawings of the present invention for reference in development, a standard-level professional programmer can use standard application program development techniques ( It is possible to make a computer carry out the method of the present invention by using a GUI application integrated development environment using C ++, etc., and it is also possible to create a device or a program for this method.
(0042)
The algorithm shown below is an algorithm based on standard structured programming in which a desired "function" is newly defined using C language / C ++ language or the like and then a function call is made. A processing means (program) corresponding to the solution means of the present invention while performing input / output and function separation according to the function sharing of each of the following functions (or by coding the function group as it is according to the specifications shown below). And a computer) can be realized.
(0043)
■ Processing algorithm specifications of knowledge list L for inquiry P
================================================== ================================================== =================
Function Q1 (P: pattern that can include variables, L: knowledge list): ★ Example 1 of a main function common to all claims of Patent Document 1 ★
{
1. 1. Extract the content B (fact or Horn clause) of the first line of L.
However, if L is empty (if the first line could not be retrieved), a false output is output and the process ends.
2. 2. The initial value of the variable binding information C is emptied, the following function H (P, B, C) is called, and the true (= matching) binding information (= solution set) C is output.
When true (= matched) True (yes) is output (the line number of the matched content B is also output).
If false, do nothing.
3. 3. If there is a content B'on the next line of L-Set B ← B'and move to 2.
If not ・ If true is never output in 2, false (no) is output.
・ End.
}
(0044)
■ Processing algorithm specifications of knowledge list L for inquiry P (pre-fixed character string version)
================================================== ================================================== =================
Function Q2 (P: pattern that can include variables, L: knowledge list): ★ Example 2 of the main function common to all claims of Patent Document 1 (pre-fixed character string version) ★
{
(Pre-fixed character string)
1. 1. Find the fixed character string text T with {all character strings that can be deduced from only L / the line number set of L used as the basis for deducing each character string} as each line.
Specifically, the text T obtained by merging the elements of the output series (A = solution 1 / rationale 1, A = solution 2 / rationale 2, ...) of the above function Q1 ("$ A", L) as each line is used. Ask.
In the case of an infinite loop in the middle of the calculation, the deduction is partially omitted by the infinite loop detection function using an explicit call management stack or the like.
-For example, whether the computer is trying to confirm the authenticity of the same horn clause under the same variable binding condition while the computer is performing the confirmation of the authenticity of the horn clause under the same variable binding condition.
Manages the call management stack whose members are structures (the horn clause identifier being confirmed, the current variable binding condition),
Detect an infinite loop by linearly searching for the same combination towards the root of the stack at the time of the call.
(Since it is only a fixed character string, the solution set is obtained by a simpler method (function F) than Q1) 2. For each line t of the text T, all Cs for which the following function F (P, t, C) is true are output.
(Output of final result)
3. 3. If there is at least one C, it outputs true, otherwise it outputs false.
}
(0045)
■ Processing algorithm specification of one fact (fixed character string) or horn clause B (however, all variables included in the head also exist in the body) for inquiry P
================================================== ================================================== =================
Function H (P: pattern that can include variables, B: one fact (fixed character string) or horn clause, C: variable binding information): ★ Of the functions used in the inventions of claims 1 to 15 of Patent Document 1. Example 1-1 ★
{
If P does not contain a variable {
If B is a fact {
If P = B, it returns true.
If not, it returns false.
}
If B is the horn clause {
When the head part of B does not contain a variable {
In the case of the head portion of P = B, the truth of the function D (body portion of B, E) is returned.
If not, it returns false.
}
When the head part of B contains a variable {
For each C1 whose true F (B head, P, C1)
If there is C1 for which the result of the function D (C1 applied to the body part of B, E) is true, the true is returned.
If not, it returns false.
}
}
}
If P contains a variable {
If B is a fact {
If there is a C1 for which F (P, B, C1) is true, then all such C1s are added to C and the truth is returned.
If such C1 does not exist, it returns false.
}
If B is the horn clause {
When the head part of B does not contain a variable {
If there is a C1 whose true F (P, B head, C1) and the function D (B body, E) is true, then all such C1s are added to C. Returns true.
If not, it returns false.
}
When the head part of B contains a variable {
★ When implementing the invention of claim 12 of Patent Document 1 ★
// Ingenuity for speeding up (option) Start If the fixed characters for the number of characters existing at the head and tail of the heads of P and B do not match {Return false.
} // End of device for speeding up (option) ★ Implementation of the invention of claim 13 of Patent Document 1 ★
When the fixed characters for the number of characters existing at the head and tail of the head of P and B match {
For any binding information G in E for which the result of the function D (body part of B, E) is true
If there is a C1 whose true function is the function F (the heads of P and B bound by G (which should be a fixed character string), C1), all such C1s are added to C and the true value is returned.
If such C1 does not exist, false is returned.
}
}
}
}
}
(0046)
■ Algorithm specification for enumerating solution sets of the body part of the horn clause (or an important cultural property query that shares a variable)
================================================== ================================================== =================
Call example → Function D ("$ A and $ B are friends, $ A is human, $ B is human", E);
Return example ← True (E = ((A = Hanako, B = Taro), (A = Taro, B = Jiro), (A = Jiro, B = Saburo)))
================================================== ================================================== =================
Function D (J: body part (or inquiry of an important cultural property sharing a variable), E: solution set): ★ Example 1-2A of the function used in the invention of claim 6 ★
* However, the entire knowledge source L is stored in a global variable so that it can be referenced {
1. 1. Take out the first sentence M in J. Returns true if the first sentence does not exist.
2. 2. The function Q1 (M, L) or Q2 (M, L) is called for the entire knowledge source L. If the result is false, false is returned.
When true If M does not contain a variable Do nothing.
When M contains a variable Stores a set C of binding information that can be taken to make M true.
* Variables that do not need to be bound to be true can be explicitly indicated to that effect.
* If a certain condition is required to make it true even though the binding value is an infinite set, that condition can be added.
3. 3. The next sentence M'in J is taken out. If it does not exist, it returns true (E = set of binding information C).
4. The function Q1 (M', L) or Q2 (M', L) is called for the entire knowledge source L.
If the result is false, false is returned.
When true If M'does not contain a variable, do nothing.
When M'contains a variable The intersection of the set C'of binding information that can be taken to make M'true and the memorized set C is the new C.
However, if the original set C is not an empty set but an intersection and becomes an empty set, false is returned. * Variables that do not need to be bound to be true can be explicitly indicated to that effect.
* If a certain condition is required to make it true even though the binding value is an infinite set, that condition can be added.
Return to 5.3.
}
Function D2 (J: body part (or inquiry of an important cultural property sharing a variable), E: solution set): ★ Another embodiment 1-2B of the function used in the invention of claim 6 (constrained using recursive call of function) Speeding up by spreading information to other sentences) ★
{
1. 1. Take out the first sentence M in J. Returns true if M does not exist.
2. 2. Call Q1 (M, L) or Q2 (M, L) for the entire knowledge source L.
If the result is false, false is returned.
When true If M does not contain a variable If there is no sentence next to J, then true is returned, then the next sentence is set as a new M and returns to 2.
When M contains a variable If there is no sentence following J, the binding information that can be taken is stored in E, and if the truth is returned, the binding information that can be taken is stored as a set C.
3. 3. Empty E and execute recursive call D2 (body part J', E'that can be bound after the next sentence of J by K) for each binding information K in the set C. If the result is true, set to E. , Add that K and E'that became true 4. If it is never true for each K, it returns false, and if it is true even once, it returns true (E)}
Function D3 (J: body part (or inquiry of an important cultural property sharing a variable), E: solution set): ★ Example 1-3 of the function used in the invention of claim 5 ★
{
1. 1. The first sentence M1 in J is taken out. Returns true if the first sentence does not exist.
2. 2. Call Q1 (M1, L) or Q2 (M1, L) for the entire knowledge source L.
If the result is false, false is returned.
When true If M1 does not contain a variable Do nothing.
When M1 contains a variable, a set C1 of possible binding information is stored.
3. 3. Similarly, C2, C3 ... Are obtained for M2, M3 ... As long as they are not false.
If it becomes false, false is returned.
4. Find the intersection C for the remaining C1, C2, C3 ... Cn and return true (C). }
(0047)
■ Enumeration algorithm specification of multiple-length matching solution (s) of fact S for inquiry P
================================================== ================================================== =================
Call example → Function F ("$ A and $ B are friends", "Taro, Jiro and Saburo are friends", "");
Function F (P: pattern that can include variables, S: constant character string, C: variable binding information): ★ Invention of claim 2 (however, implementation example omitting "(or last)" and "or before" Example 1-4A of the function used in)
{
(Preparation)
1. 1. Find the number of types V of variables in P and the names N1, N2, ... of the variables that appear in the order of appearance (correspondence to the case where P originally does not include variables)
2. 2. When V is 0,
⇒ When P = S, return true and finish.
⇒ When P ≠ S, return false and finish.
(output)
3. 3. When V is 1, no matter how many times N1 appears in P, there is only one solution R1 for unification of P and S.
⇒ If there is a match, the only solution is output as "C and N1 = R1", and the truth is returned and the process ends.
⇒ If there is no match, return false and finish.
* Unification itself can be performed as a match with a regular expression (if the same variable appears more than once, there is a postscript reference). When V is 2 or more, the longest matching solution R1 for the variable N1 executes the recursive call F (P', S, C and N1 = R1) for P'that can fill all N1 in P. A set of solutions that are in agreement is output. R1'← Recursive call F (P'', S, C and N1 = R1') for P'' which can be a character string excluding the last character of R1 and all N1 in P can be filled with R1'. Execution ⇒ For N1, a solution set with solution candidate R1'excluding one character from the longest matching solution is output. When R1'is one or more characters (★ When the number of characters of the shortest matching solution is larger in claim 3 of Patent Document 1)
⇒ Return to 5 as R1 ← R1'.
In the case of 0 characters (★ When the number of characters of the shortest matching solution in claim 3 of Patent Document 1)
Finished.
}
(0048)
Function F (P: pattern that can include variables, S: constant character string, C: variable binding information): ★ Example 1-4B of the function used in the invention of claim 4 ★
// Function F that focused on the first character C of the fixed character string immediately after the variable first appeared in P and made a device for speeding up part 1
{
(Preparation)
1. 1. Find the number of types V of variables in P and the names N1, N2, ... of the variables that appear in the order of appearance (correspondence to the case where P originally does not include variables)
2. 2. When V is 0,
⇒ When P = S, return true and finish.
⇒ When P ≠ S, return false and finish.
(output)
3. 3. When V is 1, no matter how many times N1 appears in P, there is only one solution R1 for unification of P and S.
⇒ If there is a match, the only solution is output as "C and N1 = R1", TRUE is returned, and the process ends.
⇒ If there is no match, return false and finish.
4. (Ingenuity for speeding up # 2. This process is covered in 5 or later and may be omitted. ★ This ingenuity 2 is not claimed in Patent Document 1 ★)
When V is 2 or more
Matched the solution in the longest match mode for all variables (N1 (= N), N2, ...) And matched in the shortest match mode for all variables (N1 (= N), N2, ...) When the solution is the same (N1 = R1, N2 = R2, ...) ⇒ Outputs the only solution as "C and N1 = R1 and N2 = R2 and ..." and ends. Match in the first place. If you didn't
⇒ Return false and finish.
When they are not the same ⇒ Continue to 5. When V is 2 or more, the longest matching solution R1 for the variable N1 executes the recursive call F (P', S, C and N1 = R1) for P'that can fill all N1 in P ⇒ longest for N1 A set of solutions that are in agreement is output. When variable N1 (self) follows immediately after variable N1 in P ⇒ When another variable N2 continues to process after 7 ⇒ Process after 7 (However, 1 character C in 7 is the solution R2 of N2 The first character of)
When fixed characters continue ⇒ Process after 7 7. When the longest matching solution R1 includes one character C (the first character C of R2 when immediately after another variable N2), which is a fixed character immediately after the variable N1 first appears in P ⇒ 1) R1'← A character string in which the partial character string from the end of the character string of R1 to its C is deleted ⇒ 2) P'' ← A pattern that can fill all N in P with R1'⇒ 3) Recursive call F Execute (P'', S, C and N1 = R1')
⇒ It should be possible to output if there is a solution that is one step shorter for N1. If it is not included in the longest matching solution R1 ⇒ For N1, the enumeration of shorter solutions is complete, so the process ends.
8. Return to 7 as R1 ← R1'.
}
================================================== ================================================== =================

An example shows an example of a question answering system actually constructed to improve the turnout of young voters (system users who are in a position to ask questions and, in some cases, make recommendations to candidates).
This system provides election candidates' beliefs (basic mindset), policies (ideas), their priorities (last 6 lines in Figure 1) and prerequisites (rationale, 2nd line in Figure 1). Regarding (third line), the election candidate himself (a user who can edit a logical program to respond to voters on his behalf) posts to the system, and the computer program according to the present invention posts the posted content (logic). Based on the program), it answers questions from various voters (2 in Figure 2 and, in some cases, recommendations). Recommendations are emailed to each candidate by a program not shown. The results of automatic responses to voters (including response details and statistics) will also be emailed.

The present invention can be clearly used in expert systems for diagnosis, design, consultation, etc., chatbots, games, interactive knowledge acquisition systems, and the like.

1 Click link that reflects the logical program part for the fixed response sentence for dialogue 2 Question sentence by general users such as voters 3 Reverse question sentence for asking the user the facts during computer inference for the question

Claims (16)

Some or all parts of the functions of PROLOG to allow format with embedded variable to a string as a literal
It is a computer program that can execute <br />
Ask the user at runtime the truth of the literal or the value of a variable that makes the literal true for the literal that is the condition of the head or body of the rule.
A computer program that performs subsequent processing according to the answer from the user. The computer program according to claim 1, which asks the user only when the literal has a predetermined format. Ask the above question
The computer program according to claim 1 or 2, which is performed before the computer program automatically confirms by backward inference. Ask the above question
The computer program according to claim 1 or 2, which is performed after the computer program automatically confirms by backward inference. When asking the above question
The computer program according to claim 4, which can automatically delete the solution candidates obtained by checking. When asking the above question
The computer program according to claim 4 or 5, wherein a new solution candidate can be added while looking at the solution candidates obtained by automatically checking. Any one of claims 1 to 6 having a function of automatically generating a control that can ask a question asked by a user or a frequently asked question with one or more operations and an operation that is less costly than inputting the entire question text. The computer program described in the section. Carrying out the subsequent processing according to the answer from the user
The user can temporarily or permanently add facts and rules to the logical program itself as prerequisites or contexts for processing.
Computer program according to <br/> claim 1 is. When the character string entered by the user matches some reserved words
Do not interpret the question from the user, the precondition or the context,
Performs the processing defined for the reserved word,
The computer program according to any one of claims 1 to 8 . Detects that the character string input by the user is an expression expressing a question in 5W2H format (when, where, who, why, what, how, how much) by collating with a predetermined reserved word. And
Corresponding bound by only the value species such (substituted) and a computer program according to any one of claims 1 to 9, the subsequent processing by replacing bound limit the variable names performed as can. The computer program according to any one of claims 1 to 10, wherein the computer program is characterized by automatically showing the user a fact that can be automatically proved to be true by the knowledge added by the user. About literals with a mark that you can ask the user for authenticity
Computer program according to any one of claims 1 to 11 to provide assumed solutions current If true regardless the user. The computer program according to any one of claims 1 to 12, which provides an interactive service in cooperation with a WEB server. Ru good to the representation of the degree of for the given view point
Same extent as any of one of against the Jo Tokoro in question in a sequence representing the order relationship of the degree of information on a predetermined view point,
Degree of any one or more items,
To a degree less than or equal to any one item,
To the extent that it exceeds any one item,
The computer program according to any one of claims 1 to 13, which defines and returns a degree less than any one of them or a combination thereof based on input from a user, memory by a computer, or both. A method using the computer program according to any one of claims 1 to 14. A device using the computer program according to any one of claims 1 to 14.

Images