JP2014211725A - Method, device, and computer program for processing knowledge or information - Google Patents

Abstract

PROBLEM TO BE SOLVED: To automatically process knowledge expressed in a form of natural language with an embedded variable by a computer in a same manner as PROLOG.SOLUTION: When a person inputs "fact", "rule", or "goal" as in PROLOG, a constant part and a variable part of contents which serve as "literal" of PROLOG are discriminated by a character type, a delimiter, or an escape character, and are inputted into a computer. While dealing with the variable as what may straddle boundaries, such as a subject and a predicate of a sentence, computer executes an automatic simplification processing, automatic derivation processing, or both on a sentence included in the input.

Description

  The present invention relates to a method for processing knowledge and information, and more particularly to a method, apparatus, and computer program for processing knowledge and information expressed in a natural language “as is” in the natural language.

As a method of processing knowledge and information, in particular, as a method of processing knowledge and information expressed in a natural language “as is” in the natural language, a logical programming language PROLOG based on the knowledge and information expressed in the natural language Predicate logic level deductions (such as answering a YES / NO question (so-called closed question form) by means of triple theory, etc.) or solution search (eg, a solution that matches a specified condition (so-called open question form)) ), Procedural interpretation, etc., automatic unification processing (unification) and automatic derivation processing (reverse inference with backtracking) similar to PROLOG. If the derivation process is displayed, automatic proof processing There is the following Patent Document 1 to be performed by:
Through the realization of the technical contents described in this patent document, users can create texts that they normally use in their own words (without considering the standardization of ontology and expression notation, and the order of appearance of cases) By simply quoting or referring to articles in natural language published by people on the network (for example, by copying and pasting, specifying URLs, etc.), the user can perform deductions and solutions in the original natural language. It becomes possible to use it as a knowledge source for searching or the like (that is, automatic unification processing, automatic derivation processing, etc.). Thus, according to this patent document 1, natural language level knowledge and information that are not formalized at all, for example, more than junior high school students who have been taught “variables” in mathematics classes, but information processing and knowledge processing Great progress has been expected in the use and application by non-experts).

  However, there are some difficulties in realizing the technology of Patent Document 1. That is, "verb (subject, object, when, where)" etc. and case structure are separated by "," (comma) (thus each role (case) is determined by the order of "arguments" ) Unlike conventional PROLOG, “X” (an example of a variable identifier using full-width capital letters (character type)), “$ X” (an example of a half-width or full-width escape character ($) and a variable identifier (X)), “ Variables expressed as “$ {acting entity}” (escape character ($), delimiter ({...}), Variable identifier “acting entity”, etc.) are embedded in a natural language sentence, and “$ X and $ When Y expresses $ Z, etc., the solution candidate for the variable pair ($ X, $ Y, $ Z) based on “Taro, Jiro, and Saburo like curry” "($ X, $ Y, $ Z) = (thick And Jiro, Saburo, Curry) and (Taro, Jiro and Saburo, Curry) "and other candidates, and if the possibility of each solution cannot be examined and verified, the computer will be comprehensive from the knowledge sources It is not a deduction or a solution search (that is, unification in PROLOG (automatic unification processing) or backward inference with backtracking (automatic derivation processing) is completely performed).

  In other words, for the fact that “Taro, Jiro, and Saburo like curry” and the like (the fact “FACT” in PROLOG), the point of interest in the above-mentioned Patent Document 1 (for the purpose of absorbing notation fluctuation) Different from (and naturally different from any point of focus necessary to cover multiple solution candidates by the normal backlog of PROLOG (to cover the range bound by the case structure)) In this respect, it is necessary for the computer to try all the unifications that have the possibility of multiple unifications.

This is a fact expressed in a natural language (a fact including a variable (for example, “$ X is $ X”) or a fact not including a variable (for example, “Taro, Jiro, and Saburo like curry”)). As well as unification with natural language expressions (ie, including variables to be bound in many cases) corresponding to the head part of the PROLOG horn clause (rule). , And the spillover of bound values (eg, X ← Taro and Jiro, etc.) to body variables (variables with the same scope) Since it becomes a more complicated problem due to the relationship with backtracking for automatic derivation processing, knowledge (facts (= facts, “FACT”), rules and goals) expressed in the form of embedding variables in natural language is similar to PROLOG. To automatically process It had to flame (referred to as the "difficulties A").
In addition, as described in Patent Document 1, applied implementation considering robustness against notation fluctuation (application of analogy to knowledge derivation process based on the surface / semantic similarity of sentences), and many current situations Hybrid knowledge representation (rewriting / inference rules, dictionaries (semantics, pragmatics, etc.), corpus analysis (n-gram statistics, co-occurrence frequency, co-occurrence probability representation) Etc.) is a combination of comprehensible / difficult intuitive display of the knowledge set that is the basis of the inference result and intuitive tracing of the derivation flow, and research on predicate logic learning applications, personal philosophy, policy, etc. For use, it was difficult to use.

JP 2006-024405 A

  Therefore, the problem to be solved by the present invention is the problem 1) Overcoming the above-mentioned “difficulty A” in realization, and automatically processing the knowledge expressed in the form of embedding variables in natural language in the same way as PROLOG. This makes it possible to implement comprehensive deductions and solution searches (automatic unification processing, automatic derivation processing, backward inference, backtracking, etc.) at the predicate logic level using natural language as a knowledge source. It is. Here, the automatic derivation process requires rewriting of the head part variable after unifying the body part. Furthermore, when performing procedural interpretation of the body part, a single “left” literal in the head part and body part is used. Depending on the unification, it may be necessary to rewrite the variables in the “more right” literal (and in the “command” when the command operation is performed by “procedural interpretation”).

  Another issue is that issue 2) takes advantage of the specifications that variables are not bound to case structure more widely, and task 3) is not bound to case structure (in a sense, it is harsh because it is free) (4) Displaying the basis (proof process, inference path, knowledge set used, etc.) in an easy-to-see manner for learning use and research use.

This invention is made | formed in view of this subject, Claim 1 is
A method in which a computer automatically performs part or all of the functions of a logic programming language PROLOG,
When a human inputs "facts", "rules", or "goals" in PROLOG, the constant part and the variable part of the content (hereinafter referred to as "sentence") in PROLOG are referred to as the character type, delimiter or escape character. According to the input to the computer,
While the computer treats the variable as a sentence main part, predicate, subject, predicate, object, complement, conjunctive modifier, conjunctive modifier, or something that can cross sentence boundaries, the above "facts", "rules" or Performing automatic unification processing, automatic derivation processing, or both of sentences included in the input of “goal”;
A processing method is provided.
Here, “a human being inputs a constant part and a variable part into a computer by distinguishing them by a character type, a delimiter or an escape character” means that a human is in an input field of application software (processing system) according to the present invention. Input directly after command prompt (via or without front-end processor), copy paste or cut paste from internet browser or text editing software, etc. Including reading, quoting, referencing, etc.
In addition, “the computer treats variables as if they can cross the sentence main part, predicate, subject, predicate, object, complement, continuous modifier, joint modifier, or sentence boundary” It can only cross the boundaries (explicit delimiters) of case structures with explicit delimiters via prepositions such as particles and English (including those that fall under the hierarchical structure of syntax analysis results and semantic analysis results) Instead, it can cross the boundary between S and V in English, for example, SV format, SVO format, SVOO format, and SVOC format, V and O boundaries, V and C boundaries, etc. Includes a mode that is handled as possible (in contrast, there may be a mode that is not handled). In these cases, as candidate solutions that can be included in a variable, an arbitrary partial character string is extracted by ignoring the delimiter unit by the grammatical structure as a sentence from the whole sentence or the character string that constitutes the whole sentence, and the hierarchy The entire compound sentence / heavy sentence with a typical reference structure, a longer paper, etc., and any substrings of those are also targeted (note that it is treated as something that can straddle a sentence boundary, When handling a set of knowledge sources (for example, reading, writing, referencing, etc., a set of knowledge sources collectively in a file), it is necessary to separate the knowledge sources at a boundary other than the sentence boundary Therefore, for example, a line feed code or a tab code can be used as such a delimiter).
As a result, knowledge and information expressed in the form of embedding variables in natural language as well as knowledge and information in ordinary sentence format are fully integrated with the possibility of practical interoperability between them. As a source, it is possible to perform automatic processing by a computer without particularly distinguishing between the two (overcoming of the above “difficulty A”).
In order to open the possibility of “realistic” interaction “sufficiently”, automatic processing by a computer should be provided as a search processing system 1) simplicity of a search expression (expression specifying a pattern), 2) sufficient The accuracy (accuracy of the solution) and 3) sufficient reproducibility (exhaustiveness in extracting solution candidates) must be provided, but in the present invention, free (ie, grammar and meaning Basically in the PROLOG knowledge processing procedure (and the underlying knowledge interpretation policy) while allowing the embedding of variables (which may be multiple types or multiple times) in places (not limited to delimiters) By doing so, the risk of precision (solution accuracy) degradation that can be caused by hybrid knowledge processing procedures (and complex knowledge interpretation policies corresponding to the hybrid processing procedures) as in other processing systems is reduced. Avoiding natural language delimiters by handling variables as "sentences, predicates, subjects, predicates, objects, complements, collocation modifiers, collocation modifiers or sentences that can cross sentence boundaries" Unfair disagreement (regular expression) caused by crying appearance of specified patterns by expressions (reading marks, punctuation marks, parentheses, commas, periods, etc.) and modifier phrases (adjective phrases, adverb phrases, non-essential case expressions, etc.) (Unmatched), and a certain level of reproducibility (exhaustiveness in extracting solution candidates) between superficial character string expressions (between search formulas and knowledge sources) with no case structure specified. Yes. In addition, integrated and continuous citation and extraction (as candidate solutions to variables) that make it difficult to damage the exact context (character strings before and after) of the natural language that became the source of knowledge are possible. Simplicity makes it easy and easy to check and verify the substantial soundness of reasoning (the basis and justification of reasoning), and provides users with a real sense of security that the basis is always clear. Take full advantage of the specifications that variables are not bound to case structure (and you don't have to know about case structure rules (appearance order, etc., and there is no fear that the order of arguments may be wrong)) It is possible to come.
Since the present invention is primarily intended for Japanese (the amount of information for one character is large and there is no space between words), there are many contents that use characters as processing units and delimiters. (The amount of information of one character is small, the number of characters of one sentence is large, but there is a space between words), the same processing can be performed in units of words separated by spaces.

Claim 2
In the automatic unification process,
Unification of a pattern that can contain variables (constant part and variable part separated by character type, delimiter or escape character) and constant 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) Each new pattern (eg, Taro and Jiro> Taro and Next> Taro and>Taro>Taro> Sky) is substituted into the pattern by cutting the character string from the back (or front) until it becomes an empty character (example: : "Taro and Jiro and $ Y like $ Z">"Taro and next and $ Y like $ Z">"Taro and $ Y like $ Z">"Taro and $ Y like $ Z ”>“ Thick and $ Y like $ Z ”and“ and $ Y like $ Z ”), each state of the solution of the scraping process ($ X = Taro and Jiro> Taro and Next> Taro and>Taro>Tha> Sky)
Repeat recursively until there are no more variables,
The state of each intermediate solution that is unified when there are no more variables (eg, true ($ X = Taro and Jiro, $ Y = Saburo), true ($ X = Taro, $ Y = Jiro and Saburo)) Combined to obtain each unification answer (example: answer 1 = ($ X = Taro and Jiro, $ Y = Saburo), answer 2 = ($ X = Taro, $ Y = Jiro and Saburo)) A processing method according to claim 1 is provided.
Here, “(or last)” corresponds to “(or previous)”, and means that when starting from the variable that appears last, it is necessary that the beginning of cutting be from the front.
In this way, it is possible to verify the status of each candidate solution that covers all the possibilities from the longest match solution to the shortest match solution, and to provide a comprehensive answer (a set of narrower solution candidates). It becomes possible.

In addition, claim 3
3. The processing method according to claim 2, wherein instead of gradually cutting until an empty character is reached, 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.

In addition, claim 4
When scraping gradually until it becomes an empty character,
1 character C (immediately after (or immediately before)) is another variable immediately after (or immediately before) the variable appears first (or last) in the pattern. When the first (or last) character C) of the solution candidate assigned as the solution candidate is included in the longest matching solution,
4. The processing method according to claim 2, wherein a part character string from the last (or first) of the character string of the longest matching solution to the first C is deleted including the C. 5.
Here, “(or last)” corresponds to “(or immediately preceding)”, and means that when starting from the last appearing variable, it is necessary to start from the front.
This saves enumeration of solution candidates that do not match a fixed character immediately after (or immediately before) a variable and a search based on the solution candidates, and may speed up automatic processing.

In addition, claim 5
In the automatic unification process or automatic derivation process,
When obtaining binding information for the “goal” (including “subgoal”, the same applies hereinafter)
5. The binding information is independently obtained for each sentence constituting the “goal”, and the return value true and the product set are returned when the product set of the binding information is not empty. 5. A processing method is provided.
Here, the binding information is information indicating whether or not such a solution candidate is assigned to each variable at the same time. Binding information indicating one binding method for each variable is obtained by interpreting “,” as an AND combination, “variable name 1 = value 1, variable name 2 = value 2,..., Variable name N = While it can be expressed in the form of a list such as “value N”, multiple binding methods can be expressed as a set of such lists, or by specifying an AND / OR combination instead of “,”. It can be expressed in the form of enclosing and the conjunction standard form or disjunctive standard form that standardizes the whole of multiple bindings.
Thereby, there are a plurality of patterns (sentences) to be satisfied at the same time, and in the case of a problem form that the same solution should enter the same name variable between patterns (sentences) (for example, such an AND join query from the user, When there is more than one sentence in the body of the rule), it is unlikely that the full-text search process for the pattern on the right side of the rule is wastefully repeated for each unification result of the pattern on the left side. 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 a natural language), and to simplify the processing for each pattern to be satisfied at the same time. In addition, display and verify the inference process (completeness and soundness) in an easy-to-understand manner. Further, it is possible to prevent the orderness (between sentences in the body part), which is unnecessary for the intuition necessary for the meaning of the rule and should not be defined, from giving side effects to the inference process.

In addition, claim 6
In the automatic unification process or automatic derivation process,
When seeking binding information to be the “goal”,
Empty the existing binding information first,
The sentence set included in the “goal” is automatically calculated with respect to whether or not the sentence can be true under the application of the existing binding information, and additional binding information for the sentence, and the additional binding information is converted into the existing binding information. While adding this sentence, recursively reduce it,
The processing method according to any one of claims 1 to 4, wherein existing binding information when the sentence set becomes an empty set while being true is used as binding information that becomes a "goal".
Here, “recursively reduce” means that as the recursion becomes deeper, the sentence set becomes smaller and the binding information becomes more complex (more variables are bound and the range of values to be bound is narrowed down). For example, equivalent recursive processing is realized by processing for recursively calling in C language or a stack structure for depth-first search (structure array and stack pointer, etc.) declared and defined independently.
This simplifies the problem of automatically processing open questions consisting of AND combinations of multiple patterns that should be satisfied at the same time, expressed in the form of embedding variables in natural language, into simpler and recursive partial problems with the same structure. Transform and facilitate inference process display and verification (completeness and soundness).

In addition, claim 7
In the automatic unification process or automatic derivation process,
If you want to unify a pattern that does not contain a variable with a fact that does not contain a variable,
The processing method according to any one of claims 1 to 6, wherein true is returned when the pattern and fact match as a character string, or false is returned when the pattern and fact do not match as a character string.
Thereby, it can search simply and rapidly.
Note that “facts that do not include variables” include multiple sentences separated by punctuation marks. The “matching as a character string” may be provided with a mode in which the character string of the pattern may match the portion of the actual character string.
As a result, a plurality of pieces of information of the same type can be expressed together as one fact and can be searched. Moreover, it becomes easy to express some sort of order (for example, size, preciousness, oldness, etc.) between a plurality of elements.

In addition, claim 8
In the automatic unification process or automatic derivation process,
When unifying a pattern that does not include a variable and a head that does not include a horn clause variable,
When the pattern and the head portion are matched as a character string, the result of applying the processing method according to claim 5 or 6 is returned with the body portion of the horn clause as a subgoal,
A false method is returned if they do not match. The processing method according to claim 1 is provided.
As a result, sound mechanical interpretation when the head of a rule that expresses variables in a form embedded in natural language does not include variables, a seamless, easy-to-understand, simple and uniform processing mechanism, and explanation of the corresponding inference process Can be given.

In addition, claim 9
In the automatic unification process or automatic derivation process,
When unifying a pattern that does not contain a variable and a horn clause that has a head that contains a variable,
Each binding information obtained by processing using the pattern as a "constant character string" in the processing method according to any one of claims 2 to 4 and using the head unit as a "pattern" in the processing method ,
Returns true if there is a true result of processing as a “subgoal” of the processing method according to claim 5 or 6 when applied to the body part of the horn clause, or returns false if it does not exist A processing method according to any one of claims 1 to 8 is provided.
As a result, if the head of a rule that expresses a variable in the form of embedding it in a natural language includes a variable, and the pattern that triggered this rule does not include a variable, the bound range of the variable in the body part is limited in advance, and true It is possible to speed up the process of false determination.
It can also provide a sound mechanical interpretation, a seamless, easy-to-understand, simple and uniform processing mechanism, and an explanation of the corresponding inference process.

In addition, claim 10
In the automatic unification process or automatic derivation process,
When unifying a pattern that contains a variable with a fact that does not contain a variable,
A result of processing using the pattern as a “pattern” in the processing method according to claim 2 and using the fact as a “constant character string” in the processing method is returned.
A processing method according to any one of claims 1 to 9 is provided.
As a result, all the solution candidates (to the case variable) between the pattern and the (static) fact are identified and returned as “results”, so that the basics for overcoming the above “difficulty A” This makes it easy not only to visualize and verify the inference process, but also to facilitate learning through the user's hand, such as rule correction.

In addition, claim 11
In the automatic unification process or automatic derivation process,
When unifying a pattern containing a variable and a horn clause with a head that does not contain a variable,
Binding information that uses the pattern as a "pattern" in the processing method according to any one of claims 2 to 4 and that uses the head portion as a "constant character string" in the processing method to make the result true If (C) is present, and if the result of processing the body part of the horn clause as a “subgoal” of the processing method according to claim 5 or 6 is true, true with the binding information (C) return,
A processing method according to any one of claims 1 to 10 is provided.
As a result, all the solution candidates (to each variable) between the pattern including the variable and the head (static including no variable) are identified and returned as a “result”. "The basic mechanism for overcoming can be provided simply, and not only visualization and verification of the inference process, but also learning through the user's hand, such as rule correction, is facilitated.
In addition, it is simply converted into a partial problem with the same structure that is simpler and more recursive (or mutually recursive), facilitating the display and verification (completeness and soundness) of the inference process.
In addition, a sound mechanical interpretation when the head of a rule expressing variables embedded in a natural language does not include a variable, a seamless, easy-to-understand, simple and unified processing mechanism, and the inference process corresponding to these An explanation can be given.

In addition, claim 12
In the automatic unification process or automatic derivation process,
When unifying a pattern containing variables and a horn clause with a head containing variables,
Returns false if the pattern does not match the number of fixed characters in the head, head or both of the head part,
A processing method according to any one of claims 1 to 11 is provided.
As a result, the calculation amount can be significantly reduced and the processing speed can be improved as compared with the uniform search.

In addition, claim 13
In the automatic unification process or automatic derivation process,
When unifying the first pattern containing variables and the horn clause with the head containing variables,
If the pattern and the fixed characters for the number of characters in the head and tail of the head part match,
Each 2nd pattern obtained by constraining the head part of the said horn clause by each constraining information in which the result of applying the body part of the said horn clause is true as a "subgoal" in the processing method according to claim 5 or 6 about,
If the second pattern contains no variables,
A result of processing using the first pattern as the “pattern” in the processing method according to claim 2 and using the second pattern as the “constant character string” in the processing method is returned.
A processing method according to any one of claims 1 to 12 is provided.
Here, “when the second pattern does not include a variable” means that in the horn clause (rule), all the variables included in the head part are also included in the body part “all”. As a result of the variable being bound with a constant (fixed character string), all the variables in the head part are also bound (assigned) with the constant (fixed character string), so the head part variable disappears and the head part becomes a constant character string. It means that it can be considered.
As a result, unification of a pattern including a variable and a horn clause (rule) having a head including a variable can be mechanically and automatically performed by a simple calculation model in a flow that is easy for a user to trace.
That is, all the solution candidates (those that should be assigned to each variable of the pattern) between the pattern including the variable and the head portion (= constant character string) that no longer includes the variable (by each binding information) are identified. The basic mechanism for overcoming the above “Difficulty A” is simplified by reducing (transforming the problem) the original more complex problem (unification of variables vs. variables) into a form that is returned as a “result”. It is made easy to express as a thought process. In addition, in this “reduction (transformation of problem)”, since it is simply transformed into a partial problem with the same structure that is simpler and recursive (or mutually recursive), visualization and verification of the inference process (completely) (Such as sexuality and soundness) as well as learning through the user's hands, such as modifying rules.
After all, sound mechanical interpretation when the head of a rule that expresses variables in the form of embedding them in natural language includes variables, seamless, easy-to-understand, simple and unified processing mechanism, and explanation of the inference process corresponding to these Can be given easily.

In addition, claim 14
The processing method according to any one of claims 1 to 13, wherein the computer restricts input of facts including variables.
Here, the facts including variables (knowledge sources that are not rules) are, for example, “$ X is $ X” (a fact that is tautologically true) or “$ X is $ Y” ( There is a fact that there is no reason to be true if only the superficial sentence pattern matches.
By restricting these to be input to the computer, calculation of automatic unification processing of patterns (statements that can include variables) and facts (statements that do not include variables (= fixed character strings)) is simplified. Fast response by automatic processing is possible. It also makes it difficult to mix unfounded facts into knowledge sources.

In addition, claim 15
The processing method according to any one of claims 1 to 14, wherein the rule is in a format similar to a so-called horn clause, and the computer restricts that the head portion includes a variable that does not appear in the body portion. I will provide a.
Here, “the computer restricts that the head part includes a variable that does 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 the variables ($ Y and $ Z in this example) are bound (assigned) in all sentences in the body part, such as "Z-friendly, $ Z is a child, $ Y is smart" (In this example, it means that the computer restricts a rule such that $ X) remains unbound from being input, stored, or activated as a knowledge source. As in the case of the fact, such a rule leads to leaving a variable that is not bound to the head part, so that an unreasonable inference result is likely to be generated, and the inference speed is reduced.
By restricting such rules to be input to the computer, patterns (sentences that can contain variables) and head parts (which can be reduced to a set of sentences (= fixed character strings) that do not contain variables according to claim 13). The calculation of the automatic unification process is simplified, and a high-speed answer by the automatic process becomes possible. It also makes it difficult to produce unreasonable inference results.

In addition, claim 16
In the automatic unification process or automatic derivation process,
Automatic unification of patterns and heads or facts with unbound variables remaining in each other,
It is performed by obtaining and returning a set of minimal solutions as a fixed character string,
A processing method according to any one of claims 1 to 13 is provided.
Here, as an example of “a set of solutions that are minimal as fixed character strings”, as a result of automatic unification between “$ A is $ B” and “$ C is also $ D”, {($ A = ”also”, $ 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 (particularly the smallest simple example) even when an infinite number of solutions exist.

In addition, claim 17
In the automatic unification process or automatic derivation process,
Automatic unification of patterns and heads or facts with unbound variables remaining in each other,
It is performed by obtaining and returning a minimal solution set as a character string including variables,
A processing method according to any one of claims 1 to 13 is provided.
Here, as an example of “a set of solutions that are minimal as fixed character strings”, as a result of automatic unification between “$ A is $ B” and “$ C is also $ D”, {($ A = “$ C”, $ B = <free>, $ C = <free>, $ D = “$ B”), ($ A = <free>, $ B = “$ D”, $ C = “$ A is”, $ D = <freedom>)}, and so on. It is considered that the sum of the string length of the value that binds the variable (the value assigned to the variable) (however, if the variable is included, one character per occurrence of the variable) (through the assembly) is minimized be able to.
This makes it possible to provide a general form of a solution even when an infinite number of solutions exist.

In addition, claim 18
If the fixed characters for the number of characters that exist in common at the beginning and tail of each character string in the pattern and the head part or the fact that the unbound variables remain in each other do not match,
It is characterized by returning false,
A processing method according to claim 16 or 17 is provided.
Thereby, it is possible to save the automatic search without the possibility of unification and to speed up the automatic processing.

In addition, claim 19
When obtaining a set of solutions that are minimal as a character string including the fixed character string or variable,
Variables included in both character strings (the first character string and the second character string) consisting of the pattern and the head part or the fact that unbound variables remain in each other are commonly bound in each character string. And while being bound independently between strings (or while the scope that binds the same name variable in common is only within each string (or between the strings is outside the scope of the variable))
For each variable, any substring (<empty>) and the other character string (the second character string for the variable in the first character string, the first character string for the variable in the second character string) (Including the entire character string), or by substituting itself and searching for a case where both character strings match, a search for a minimal solution is obtained by a full search,
A processing method according to claim 16 or 17 is provided.
“Or substitute yourself” means that “$ X” itself is assigned to “$ X” in the character string, and happens to be in both the first and second character strings. When $ X (the scopes of each other are different) is included, the $ X of the first character string and the $ X of the second character string can be distinguished from each other (for example, “$ X1” and “$$”). Substantial calculations can also be done by substituting (as X2 ", etc.).
As a result, it is possible to ensure a certain level of completeness of the solution set (completeness depending on the nature of the problem (pattern pair)) while ensuring soundness and stopping (finiteness of calculation).

In addition, claim 20
It is not both strings consisting of patterns and heads or facts where unbound variables remain in each other,
Both character strings corresponding to the two character strings remaining after removing the fixed characters corresponding to the number of characters existing in common at the head and tail of each character string of the pattern and the head part or the fact that the variables that remain unbound remain. about,
A processing method for performing the processing according to claim 19 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 likes $ D ice", instead of searching for a solution as it is, Delete the common part of "$ A is $ B"
And "$ C is also $ D ice"
In addition, all the partial character strings of “$ C and $ D ice” for each of “$ A” and “$ B” by full search (this is a variable such as $ C or $ D ($ {•• .} Variable is also the same as 6 characters, so 6 × (6 + 1) / 2 + 1 (<empty> minutes) +1 (substituting itself) = 23 types) Similarly, all the partial character strings of “$ A is $ B” for each of “$ C” and “$ D” (since this is also three characters, 3 × (3 + 1) / 2 + 1 + 1 = 8 ways When all the character strings (23 × 23 × 8 × 8) that can be obtained by substituting (A) are matched (for example, (
"Momo ice",
"Hamo ice",
"$ A is also iced",
"$ C is ice cream",
"$ A is $ D ice"
* By the way, “$ C is not the same as $ B ice”))
($ 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", $ B = "ice", $ C = "$ C", $ D = "")
($ A = “$ A”, $ B = “also $ D ice”, $ C = “$ A is”, $ D = “$ D”)
} Or a set of partial assignments for each assignment pair (e.g. {
($ A = "" and $ B = "ice"),
($ A = <empty>, $ B = "also ice"),
($ A = “$ A”, $ B = “also ice”),
($ A = "$ C", $ B = "ice"),
($ A = "$ A", $ B = "also $ D ice")
})
Can be answered as a solution.
Note that $ A = “$ A” and $ B = “$ D ice” are free to $ A and $ D, and can be unified by substituting any character string (that is, It is possible to show that there is an infinite solution and the constraint (regular expression form) of the infinite number of solutions (character strings).

In addition, claim 21
Substitute all the substrings (including <empty> and the whole string) of the other party's character string for each variable, or try to find a case where both character strings match, and find a minimal set of solutions by full search When seeking
When a variable is included in a substring to be assigned to a variable, the same assignment to the new variable is performed while replacing the variable included in the substring with a new variable that did not exist in both strings. 21. The processing method according to claim 19 or 20, further comprising performing a full search to search for a case where both character strings match while performing recursively thereafter.
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 partner character string (for example, both character strings = { In the case of “$ X is $ X” and “$ Y”, it is necessary to be able to enumerate solution candidates ($ X = “say”, $ Y = “Yes”)). The completeness of enumerating solution candidates can be further improved while maintaining soundness. In the above example, both character strings (also referred to as “pattern pairs”) = {“$ X is $ X”, “yes $ Y”} ($ X = “say”, $ Y = ”yes”) That the solution candidates can be listed recursively according to the present invention ($ X = ”$$ {Y1}”) → ($ {Y1} = <empty>) → ($ Y = “Yes”) It can be shown by being able to generate branches (which are part of the search tree and can be generated in a finite number of times in the case of breadth-first search according to the present invention).
“Recursively ... full search” means, for example, an assignment sequence that matches each possible assignment to each variable (same as the previous claim) while performing a breadth-first search that recursively repeats (for example, the above-mentioned ($ X = “yes $ {Y1}”) → ($ {Y1} = <empty>) → ($ Y = “yes”), etc.). Variations of the first assignment are 2 and 3 variable types in both strings, respectively, and the string length is 6 and 7 characters respectively (variables are counted as 1 character) 2 × (7 × (7 + 1) / 2 + 1 + 1) + 3 × (6 × (6 + 1) / 2 + 1 + 1) = 60 + 69 = 129. When a breadth-first search is performed so that the longest depths of further branches derived from these branches are equal, a limiter based on the number of substitutions (program step for comparing with the upper limit value, etc.) is provided, so that each search is performed once. Can be limited to an appropriate amount of computation (ensuring stoppage and response speed that are no longer guaranteed by recursiveness). Even in the case of depth-first search, the amount of calculation can be limited by depth limitation, the number of substitutions, and the like. In each case, an infinite loop due to self-recursion or mutual recursion, a stack structure (array of structures) that manages recursive function calls, etc. are provided, and call parameters for the branches that become ancestors (more root direction) This may be avoided by comparing the state expression of both character strings according to (assignment context) with the current call parameter. Further, depending on whether or not the fixed character strings existing at the head and tail of both character strings match the number of characters existing in common, it is possible to perform pruning of branches that cannot be unified. If no solution is found by searching for a limited amount of calculation (for example, substitution 1 million times or search depth 20 or less), it is found as “no solution (accuracy: substitution 1 million times and search depth 20 or less)”. "($ X =" say ", $ Y =" yes "), (...), ... (however, accuracy: millions of substitutions and search depth within 20)" etc. It is also possible to answer the user while specifying the search accuracy. In addition, when the full search can be clearly performed within the limited number of substitutions and within the limited search depth (when there is completeness), “no solution (all searched)” or “($ X =”) It can also be answered to the user by clearly saying “, $ Y =“ Yes ””, (...),.

In addition, claim 22
As for the result assigned to the variable, the two character strings remaining by removing the fixed characters corresponding to the number of characters existing in common at the head and tail of each character string,
Each time the search progresses, it is present at the head or tail of the character string as the “other character string” that is the target of “any substring of the other character string (including <empty>” and the entire character string). Featuring fewer fixed characters,
The processing method as described in any one of Claims 19-21 is provided.
As a result, the number of branches is reduced each time the search is advanced (as it goes to the previous branch), and the calculation amount can be saved.

In addition, claim 23 is
When obtaining a set of solutions that are minimal as a character string including the fixed character string or variable,
Variables included in both character strings (the first character string and the second character string) consisting of the pattern and the head part or the fact that unbound variables remain in each other are commonly bound in each character string. And while being bound independently between strings (or while the scope that binds the same name variable in common is only within each string (or between the strings is outside the scope of the variable))
A processing method for obtaining a set of solutions by recursively assigning a fixed character string (including an empty character) or a character string including a variable to each variable,
Limit the variable to be substituted to the corresponding head or tail variable of the subject string whose head or tail is a fixed character,
The substitution value is a new variable or <empty> following the initial fixed character or fixed character string if it is the head, or the fixed character or fixed character string following the new variable if it is the tail. Or <empty>
For the result of assigning to the variable, it is repeated to remove the fixed number of characters common to the head and tail of each character string from both,
The processing method according to claim 16 or 17, characterized in that:
This makes it possible to significantly limit the enumeration range of solutions (without impairing the comprehensiveness of search) by focusing on the presence of fixed characters at the head and tail, enabling significant computational savings and speedup. Become.

In addition, claim 24
When obtaining a set of solutions that are minimal as a character string including the fixed character string or variable,
Variables included in both character strings (the first character string and the second character string) consisting of the pattern and the head part or the fact that unbound variables remain in each other are commonly bound in each character string. And while being bound independently between strings (or while the scope that binds the same name variable in common is only within each string (or between the strings is outside the scope of the variable))
A processing method for recursively assigning a fixed character string (including an empty character) to each variable to obtain a set of solutions,
Binds binding information that can be generated using only fixed character types (character types excluding variable identifiers and delimiters) in both character strings that can be generated by removing common fixed characters for the number of characters existing at the beginning and tail of each character string. Obtained by enumerating in order from the smallest total string length of values.
A processing method according to claim 16 or 17 is provided.
As a result, problems with a certain property can be efficiently reached and enumerated.

In addition, claim 25
Based on the calculated “a set of solutions that are minimal as strings containing variables”
The processing method according to any one of claims 19 to 24, wherein the search is continued by a horn clause that can be temporarily rewritten by a character string including the variable.
As a result, the constraint calculated in order to unify the pattern and the head part of the horn clause (rule) (in the above example, the variable “$ C” is in the form of “$ A is”). There is also a unification policy (for example, in the case of the last assignment set above) that can be unified only by being bound (assigned) with a character string. It can be propagated to the search process, and the search can be made efficient.

In addition, claim 26
Based on the calculated “a set of solutions that are minimal as strings containing variables”
A set of fixed character string sets made by substituting each element of the set of fixed character string sets defined in advance as a set of solution sets of the “facts including variables” to the variable portion of “character strings including variables” return,
The processing method as described in any one of Claims 19-25 is provided.
Thus, a database (for example, “word equation (registered trademark)”, “VLANK (registered trademark)) that associates a fact including variable (s) and a set of appropriate answers (or hypotheses) that can be embedded in the variable. It is possible to perform a solution search efficiently linked 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.

In addition, claim 27
In the automatic unification process or automatic derivation process,
When performing automatic unification of a first pattern containing variables and a second pattern containing variables:
If the fixed characters for the number of characters in the head and tail of both patterns match and the same variable appears only once in each pattern,
Returns information indicating the existence of an infinite number of solutions,
A processing method according to any one of claims 1 to 26 is provided.

In addition, claim 28
An apparatus for performing the method of any one of claims 1 to 27 is provided.

In addition, claim 29
A computer program for causing a computer to execute the method according to any one of claims 1 to 27 is provided.

  The effects of the present invention are as described above for each claim.

FIG. 1 is an overall view of a network system that most effectively implements the present invention. Example 1 FIG. 2 is an explanatory diagram showing the hardware configuration of a computer that implements the present invention. Example 1 FIG. 3 is an explanatory view showing an example of screen display in a terminal embodying the present invention. Example 1

The present invention can be implemented in any kind of computer (cloud server, large general-purpose machine, desktop PC, notebook PC, portable terminal, dedicated machine of the present invention) connected / not connected to the network. A description will be given of a mode realized by a PC connected to the Internet having a multitask function and a window function.
FIG. 1 is an overall view of the network system that most effectively implements the present invention. A content management apparatus 1 is used for content (rules and facts) handled by a user PC 2 or a user / manager PC 2 in the present invention. It may be a known file sharing server that accepts posts and distributes content while controlling sharing access rights and content provision priority according to a predetermined policy. For each user, the user PC 2 inputs and stores contents (rules and facts) expressing the believed contents (or contents to be examined) in a natural language according to the method of the present invention, and stores them. A computer to be processed, a portable terminal, and the like.
FIG. 2 is an explanatory diagram showing the hardware configuration of a computer used in the present invention. This is a general computer configuration, and the feature of the present invention is that the CPU 2e uses natural laws in accordance with instructions and descriptions of the program 3 and content data 4 stored in the nonvolatile memory 2h. And the way of the interaction protocol (format) with the user.
FIG. 3 is an explanatory view showing an example of screen display in a terminal embodying the present invention. In the figure, in response to the question “Do not do $ A” (open question format), “$ A =” is made by using the fact that “does not do as much as possible” in the first line of the stored list L (not shown). In addition, the answer of “1/1 / as much as possible” is enumerated, and similarly, “$ A = bullying / 9 /” is answered using the fact that “not bullying” on the ninth line of the list L.

  In such an embodiment, the computer (manufactured by a PC, etc.) can perform all possible operations by a computer program manufactured via a C ++ language or the like. Therefore, well-known basic operations of computers using natural laws (register / memory / storage / storage, four arithmetic operations, comparison, etc.) and general functions that are already standard libraries for development environments, etc. (Assignment / comparison / copy to variables and N-dimensional arrays, manipulation / comparison / display of character strings and numerical values, operations such as list structure / queue structure / hash structure / vector type, binary search, sort operation, regular expression The method for realizing pattern matching operation, network communication operation, etc.) is different from the essence of the present invention (unique configuration leading to novelty and inventive step), and is well known to those skilled in the art, so will not be described in detail. . On the other hand, in what operation sequence and storage method (algorithm and data structure) the processing unique to the present invention is realized by combining such general functions will be described in detail below. By providing a description of this algorithm and the like, a description of the above problem solving means, and a description of the drawings of the present invention for reference of development, if a professional programmer at a standard level, a standard application program development technique ( It is clearly possible to cause a computer to implement the method of the present invention using a GUI application integrated development environment using C ++, etc., and it is also possible to create an apparatus and a program for this method.

  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 a function call is performed. 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 function below (or by coding a function group as it is in accordance with the specifications shown below) And a computer) can be realized.

■ Processing algorithm specification of knowledge list L for query P
================================================== ================================================== =================
Function Q1 (P: pattern that can include variables, L: knowledge list): Example 1 of main function common to all claims
{
1. Take the contents B (facts or horn clause) of the first line of L.
However, if L is empty (if the first line could not be fetched), output false and end.

2. The initial value of the variable binding information C is emptied, and the following function H (P, B, C) is called to output true (= match) binding information (= solution set) C.
If true (= matched), true (yes) is output (the line number of the matched content B is also output).
If false, do nothing.

3. When there is a content B 'on the next line of L-B ← B' and move to 2.
If there is no-If you have never output true in step 2, output false (no).
・ End.
}

■ Processing algorithm specification of knowledge list L for query P (pre-fixed character string version)
================================================== ================================================== =================
Function Q2 (P: pattern that can include variables, L: knowledge list): Example 2 of main function common to all claims (pre-fixed character string version)
{
(Prefixed string conversion in advance)
1. A fixed character string text T having {rows of all characters that can be deduced only from L / line number set of L used as a basis for deducting each character string} is obtained.
Specifically, a text T obtained by merging the elements of the output series (A = solution 1 / foundation 1, A = solution 2 / reason 2,...) Of the function Q1 (“$ A”, L) as each line. Ask.
In the case of an infinite loop in the middle of the search, the deduction is partially omitted by the infinite loop detection function using an explicit call management stack or the like.
・ For example, whether or not the computer is checking the truth of a horn clause under a certain variable constraint condition,
Manage the call management stack whose members are the structure (the horn clause identifier being confirmed and the current variable binding condition)
When calling, an infinite loop is detected by performing a linear search for the same combination toward the root of the stack.

(Since it is only a fixed character string, a solution set is obtained by a simpler method than Q1 (function F))
2. For each line t of the text T, all Cs for which the following function F (P, t, C) is true are output.

(Final result output)
3. If there is even one C, true is output, otherwise false is output.
}

■ 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 the query P
================================================== ================================================== =================
Function H (P: pattern including variable, B: one fact (fixed character string) or Horn clause, C: variable binding information): Example 1 of function used in inventions of claims 1 to 15 1 *

{
If P contains no variables {
If B is true {
Returns true if P = B.
Otherwise it returns false.
}
If B is a horn clause {
When the head of B does not contain a variable {
In the case of the head portion of P = B, the true / false of the function D (B body portion, E) is returned.
Otherwise it returns false.
}
When the head of B contains variables {
For each C1 in which F (head part of B, P, C1) is true,
If there is C1 for which the result of the function D (the body part of B applied with C1, E) is true,
Returns true.
Otherwise it returns false.
}
}
}
If P contains a variable {
If B is true {
If there is C1 for which F (P, B, C1) is true, add all such C1 to C and return true.
If no such C1 exists, return false.
}
If B is a horn clause {
When the head of B does not contain a variable {
If C1 with F (P, B head, C1) is true and if function D (B body, E) is true, then add all such C1 to C Returns true.
Otherwise it returns false.
}
When the head of B contains variables {

★ When carrying out the invention of claim 12 ★
// Start device for speeding up (optional) When fixed characters for P and B heads and tails do not match {
Returns false.
} // Speed-up device (option) finished

★ Implementation of Claim 13 of the Invention ★
When the fixed characters corresponding to the number of characters in the head and tail of the head part of P and B match {
For any binding information G in E for which the result of the function D (B body part, E) is true,
If there is C1 that makes the function F (the head part of P, B bound by G (should be a fixed character string), C1) true, add all such C1 to C and return true.
Returns false if no such C1 exists.
}
}
}
}
}

■ Specification of enumeration algorithm for solution set of body part of Horn clause (or query of heavy sentence sharing 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 query of heavy sentence sharing variables), E: solution set): ★ Example of function used in invention of claim 6 1-2A ★
* However, the entire knowledge source L can be stored in a global variable for reference {
1. Take the first sentence M in J. Returns true if the first sentence does not exist.

2. The function Q1 (M, L) or Q2 (M, L) is called for the entire knowledge source L.
If the result is false, return false.
When true If M does not contain a variable Do nothing.
When M includes a variable, a set C of binding information that can be taken to make M true is stored.
* Variables that do not need to be bound to be true can be explicitly indicated.
* When a certain condition is required to be true while the bound value is an infinite set, the condition can be added.

3. Take out the next sentence M ′ in J. If not, return true (E = binding information set C).

4). The function Q1 (M ′, L) or Q2 (M ′, L) is called for the entire knowledge source L.
If the result is false, return false.
When true If M 'does not contain a variable, do nothing.
When M ′ includes a variable A new set C is a product set of a set C ′ of binding information that can be taken to make M ′ true and a stored set C.
However, when the original set C is not an empty set but a product set and becomes an empty set, false is returned.
* Variables that do not need to be bound to be true can be explicitly indicated.
* When a certain condition is required to be true while the bound value is an infinite set, the condition can be added.

Return to 5.3.

}

Function D2 (J: body part (or query of heavy sentence sharing variables), E: solution set): ★ Another embodiment of the function used in the invention of claim 6 1-2B (binding using recursive function call) Speeding up by spreading information to other sentences) ★
{
1. Take the first sentence M in J. Returns true if M does not exist.

2. Q1 (M, L) or Q2 (M, L) is called for the entire knowledge source L.
If the result is false, return false.
When true If M does not contain a variable Return true if there is no statement following J. If it is true, return the next sentence as a new M and return to 2.
If M contains a variable If there is no statement following J, the possible binding information is stored in E, and if true is returned, the possible binding information is stored as a set C.


3. E is emptied, and for each binding information K in set C, recursive call D2 (body part J ', E' formed by binding the next sentence after J with K) is executed. Add that K and E 'that became true

4). Returns false if each K has never been true, returns true (E) if it has never been true}

Function D3 (J: body part (or query of heavy sentence sharing variables), E: solution set): ★ Example 1-3 of function used in invention of claim 5 ★
{
1. Take the first sentence M1 in J. Returns true if the first sentence does not exist.

2. Q1 (M1, L) or Q2 (M1, L) is called for the entire knowledge source L.
If the result is false, return false.
When true If M1 does not contain a variable Do nothing.
When M1 includes a variable, a set C1 of possible binding information is stored.

3. Similarly, C2, C3... Are obtained for M2, M3.
If false, return false.

4). The product set C is obtained for the remaining C1, C2, C3... Cn, and true (C) is returned.
}

■ Enumeration algorithm specification of multi-length coincidence solution (s) of fact S for query P
================================================== ================================================== =================
Call example-> Function F ("$ A and $ B are friends", "Taro and Jiro and Saburo are friends", "");

Function F (P: pattern that can contain variables, S: constant character string, C: variable binding information): ★ Invention of claim 2 (however, “(or last)” and “or previous” are omitted) 1-4A of the function used in
{
(Preparation)
1. The number of types V of variables in P and the names of appearing variables N1, N2,.

(Corresponding to the case where P originally does not include a variable)
2. When V is 0,
⇒ When P = S, return true and end.
⇒ If P ≠ S, return false and end.

(output)
3. When V is 1, no matter how many times N1 appears in P, there is only one solution R1 for unifying P and S.
⇒ If there is a match, output the only solution as “C and N1 = R1”, return true, and end.
⇒ If there is no match, return false and exit.
* 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)

4). When V is 2 or more Execute recursive call F (P ', S, C and N1 = R1) for P' which can fill all N1 in P with longest matching solution R1 for variable N1 ⇒ Longest for N1 A solution set that matches is output

5. R1 ′ ← R1 is a character string excluding the last character. For P ″ in which all N1s in P are filled with R1 ′, a recursive call F (P ″, S, C and N1 = R1 ′) is made. Execution ⇒ For N1, a solution set is output as a solution candidate R1 ′ obtained by removing one character from the longest matching solution

6). When R1 'is 1 character or more (In case of ★ 3, the number of characters of the shortest matching solution is larger)
⇒ Return to 5 as R1 ← R1 '.
In the case of 0 characters (in the case of the number of characters of the shortest matching solution in claim 3)
End.
}

Function F (P: pattern that can include a variable, S: constant character string, C: variable binding information): Example 1-4B of a function used in the invention of claim 4
// Function F with the first device for speeding up, focusing on the first character C in the fixed character string immediately after the variable first appears in P
{
(Preparation)
1. The number of types V of variables in P and the names of appearing variables N1, N2,.

(Corresponding to the case where P originally does not include a variable)
2. When V is 0,
⇒ When P = S, return true and end.
⇒ If P ≠ S, return false and end.

(output)
3. When V is 1, no matter how many times N1 appears in P, there is only one solution R1 for unifying P and S.
⇒ If there is a match, output the only solution as “C and N1 = R1”, return TRUE and end.
⇒ If there is no match, return false and exit.

4). (Device 2 for speeding up. This process may be omitted since it is covered by 5 or later. ★ Device 2 is not claimed)
When V is 2 or more,
Match all the variables (N1 (= N), N2,...) In the longest match mode and match all variables (N1 (= N), N2,...) In the shortest match mode. If the solution you tried is the same (N1 = R1, N2 = R2,...) ⇒ Output the only solution as “C and N1 = R1 and N2 = R2 and. If not,
⇒ Return false and finish.
If not identical ⇒ Continue to 5

5. When V is 2 or more Execute recursive call F (P ', S, C and N1 = R1) for P' which can fill all N1 in P with longest matching solution R1 for variable N1 ⇒ Longest for N1 A solution set that matches is output

6). When variable N1 (self) continues immediately after variable N1 in P ⇒ Process after 7 When another variable N2 follows ⇒ Process after 7 (However, in 7 one character C is the solution of N2 R2 The first character of
When fixed characters continue ⇒ Process after 7

7). When the longest matching solution R1 contains 1 character C, which is a fixed character immediately after the first occurrence of variable N1 in P (or the first character C of R2 when it is another variable N2 immediately after) 1) R1 '← R1 character string from which the partial character string from the end of the character string to the C is deleted ⇒ 2) Pattern that can be filled with all N in P with P''←R1' ⇒ 3) Recursive call F (P ″, S, C and N1 = R1 ′)
⇒ Should be output if there is a short solution for N1, if it is not included in the longest matching solution R1 ⇒ Since N1 has finished enumerating shorter solutions, it ends.

8). Return to 7 as R1 ← R1 ′.
}

================================================== ================================================== =================

  The present invention teaches predicate logic itself from junior high school to adults, organizes, exchanges and shares general knowledge and information, and the validity of a set (philosophy and mindset) consisting of facts (including claims) and rules. Can be used for verification.

1 Content management device 2 User PC or user / administrator PC
3 Program according to the present invention 4 Content data (a set of rules and facts)

Claims (29)

A method in which a computer automatically performs part or all of the functions of a logic programming language PROLOG,
When a human inputs "facts", "rules", or "goals" in PROLOG, the constant part and the variable part of the content (hereinafter referred to as "sentence") in PROLOG are referred to as the character type, delimiter or escape character. According to the input to the computer,
While the computer treats the variable as a sentence main part, predicate, subject, predicate, object, complement, conjunctive modifier, conjunctive modifier, or something that can cross sentence boundaries, the above "facts", "rules" or Performing automatic unification processing, automatic derivation processing, or both of sentences included in the input of “goal”;
A processing method characterized by the above. In the automatic unification process,
Unification of a pattern that can contain variables (constant part and variable part separated by character type, delimiter or escape character) and constant 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) Each new pattern (eg, Taro and Jiro> Taro and Next> Taro and>Taro>Taro> Sky) is substituted into the pattern by cutting the character string from the back (or front) until it becomes an empty character (example: : "Taro and Jiro and $ Y like $ Z">"Taro and next and $ Y like $ Z">"Taro and $ Y like $ Z">"Taro and $ Y like $ Z ”>“ Thick and $ Y like $ Z ”and“ and $ Y like $ Z ”), each state of the solution of the scraping process ($ X = Taro and Jiro> Taro and Next> Taro and>Taro>Tha> Sky)
Repeat recursively until there are no more variables,
The state of each intermediate solution that is unified when there are no more variables (eg, true ($ X = Taro and Jiro, $ Y = Saburo), true ($ X = Taro, $ Y = Jiro and Saburo)) Combined to obtain each unification answer (example: answer 1 = ($ X = Taro and Jiro, $ Y = Saburo), answer 2 = ($ X = Taro, $ Y = Jiro and Saburo)) The processing method according to claim 1. The processing method according to claim 2, wherein instead of gradually cutting until an empty character is reached, only the shortest matching solution obtained separately is gradually cut. When scraping gradually until it becomes an empty character,
1 character C (immediately after (or immediately before)) is another variable immediately after (or immediately before) the variable appears first (or last) in the pattern. When the first (or last) character 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, wherein a partial character string from the last (or first) of the character string of the longest matching solution to the first corresponding to the C is deleted including the C. In the automatic unification process or automatic derivation process,
When obtaining binding information for the “goal” (including “subgoal”, the same applies hereinafter)
5. The binding information is independently obtained for each sentence constituting the “goal”, and the return value true and the product set are returned when the product set of the binding information is not empty. 5. Processing method. In the automatic unification process or automatic derivation process,
When seeking binding information to be the “goal”,
Empty the existing binding information first,
The sentence set included in the “goal” is automatically calculated with respect to whether or not the sentence can be true under the application of the existing binding information, and additional binding information for the sentence, and the additional binding information is converted into the existing binding information. While adding this sentence, recursively reduce it,
The processing method according to any one of claims 1 to 4, wherein the existing binding information when the sentence set becomes an empty set while being true is used as binding information that becomes a "goal". In the automatic unification process or automatic derivation process,
If you want to unify a pattern that does not contain a variable with a fact that does not contain a variable,
The processing method according to any one of claims 1 to 6, wherein true is returned when the pattern and fact match as a character string, or false is returned when the pattern and fact do not match as a character string. In the automatic unification process or automatic derivation process,
When unifying a pattern that does not include a variable and a head that does not include a horn clause variable,
When the pattern and the head portion are matched as a character string, the result of applying the processing method according to claim 5 or 6 is returned with the body portion of the horn clause as a subgoal,
The processing method according to any one of claims 1 to 7, wherein false is returned when they do not match. In the automatic unification process or automatic derivation process,
When unifying a pattern that does not contain a variable and a horn clause that has a head that contains a variable,
Each binding information obtained by processing using the pattern as a "constant character string" in the processing method according to any one of claims 2 to 4 and using the head unit as a "pattern" in the processing method ,
Returns true if there is a true result of processing as a “subgoal” of the processing method according to claim 5 or 6 when applied to the body part of the horn clause, or returns false if it does not exist The processing method according to any one of claims 1 to 8. In the automatic unification process or automatic derivation process,
When unifying a pattern that contains a variable with a fact that does not contain a variable,
A result of processing using the pattern as a “pattern” in the processing method according to claim 2 and using the fact as a “constant character string” in the processing method is returned.
The processing method according to any one of claims 1 to 9. In the automatic unification process or automatic derivation process,
When unifying a pattern containing a variable and a horn clause with a head that does not contain a variable,
Binding information that uses the pattern as a "pattern" in the processing method according to any one of claims 2 to 4 and that uses the head portion as a "constant character string" in the processing method to make the result true If (C) is present, and if the result of processing the body part of the horn clause as a “subgoal” of the processing method according to claim 5 or 6 is true, true with the binding information (C) return,
The processing method according to any one of claims 1 to 10. In the automatic unification process or automatic derivation process,
When unifying a pattern containing variables and a horn clause with a head containing variables,
Returns false if the pattern does not match the number of fixed characters in the head, head or both of the head part,
The processing method according to any one of claims 1 to 11. In the automatic unification process or automatic derivation process,
When unifying the first pattern containing variables and the horn clause with the head containing variables,
If the pattern and the fixed characters for the number of characters in the head and tail of the head part match,
Each 2nd pattern obtained by constraining the head part of the said horn clause by each constraining information in which the result of applying the body part of the said horn clause is true as a "subgoal" in the processing method according to claim 5 or 6 about,
If the second pattern contains no variables,
A result of processing using the first pattern as the “pattern” in the processing method according to claim 2 and using the second pattern as the “constant character string” in the processing method is returned.
The processing method according to any one of claims 1 to 12. The processing method according to claim 1, wherein the computer restricts input of facts including variables. The processing method according to any one of claims 1 to 14, wherein the rule is in a format similar to a so-called horn clause, and the computer restricts that the head portion includes a variable that does not appear in the body portion. . In the automatic unification process or automatic derivation process,
Automatic unification of patterns and heads or facts with unbound variables remaining in each other,
It is performed by obtaining and returning a set of minimal solutions as a fixed character string,
The processing method according to any one of claims 1 to 13. In the automatic unification process or automatic derivation process,
Automatic unification of patterns and heads or facts with unbound variables remaining in each other,
It is performed by obtaining and returning a minimal solution set as a character string including variables,
The processing method according to any one of claims 1 to 13. If the fixed characters for the number of characters that exist in common at the beginning and tail of each character string in the pattern and the head part or the fact that the unbound variables remain in each other do not match,
It is characterized by returning false,
The processing method according to claim 16 or 17. When obtaining a set of solutions that are minimal as a character string including the fixed character string or variable,
Variables included in both character strings (the first character string and the second character string) consisting of the pattern and the head part or the fact that unbound variables remain in each other are commonly bound in each character string. And while being bound independently between strings (or while the scope that binds the same name variable in common is only within each string (or between the strings is outside the scope of the variable))
For each variable, any substring (<empty>) and the other character string (the second character string for the variable in the first character string, the first character string for the variable in the second character string) (Including the entire character string), or by substituting itself and searching for a case where both character strings match, a search for a minimal solution is obtained by a full search,
The processing method according to claim 16 or 17. It is not both strings consisting of patterns and heads or facts where unbound variables remain in each other,
Both character strings corresponding to the two character strings remaining after removing the fixed characters corresponding to the number of characters existing in common at the head and tail of each character string of the pattern and the head part or the fact that the variables that remain unbound remain. about,
A processing method for performing the processing according to claim 19. Substitute all the substrings (including <empty> and the whole string) of the other party's character string for each variable, or try to find a case where both character strings match, and find a minimal set of solutions by full search When seeking
When a variable is included in a substring to be assigned to a variable, the same assignment to the new variable is performed while replacing the variable included in the substring with a new variable that did not exist in both strings. Is also performed recursively thereafter to perform a full search to find a case where both character strings match,
The processing method according to claim 19 or 20.
As for the result assigned to the variable, the two character strings remaining by removing the fixed characters corresponding to the number of characters existing in common at the head and tail of each character string,
Each time the search progresses, it is present at the head or tail of the character string as the “other character string” that is the target of “any substring of the other character string (including <empty>” and the entire character string). Featuring fewer fixed characters,
The processing method according to any one of claims 19 to 21. When obtaining a set of solutions that are minimal as a character string including the fixed character string or variable,
Variables included in both character strings (the first character string and the second character string) consisting of the pattern and the head part or the fact that unbound variables remain in each other are commonly bound in each character string. And while being bound independently between strings (or while the scope that binds the same name variable in common is only within each string (or between the strings is outside the scope of the variable))
A processing method for obtaining a set of solutions by recursively assigning a fixed character string (including an empty character) or a character string including a variable to each variable,
Limit the variable to be substituted to the corresponding head or tail variable of the subject string whose head or tail is a fixed character,
The substitution value is a new variable or <empty> following the initial fixed character or fixed character string if it is the head, or the fixed character or fixed character string following the new variable if it is the tail. Or <empty>
For the result of assigning to the variable, it is repeated to remove the fixed number of characters common to the head and tail of each character string from both,
The processing method according to claim 16 or 17, characterized in that: When obtaining a set of solutions that are minimal as a character string including the fixed character string or variable,
Variables included in both character strings (the first character string and the second character string) consisting of the pattern and the head part or the fact that unbound variables remain in each other are commonly bound in each character string. And while being bound independently between strings (or while the scope that binds the same name variable in common is only within each string (or between the strings is outside the scope of the variable))
A processing method for recursively assigning a fixed character string (including an empty character) to each variable to obtain a set of solutions,
Binds binding information that can be generated using only fixed character types (character types excluding variable identifiers and delimiters) in both character strings that can be generated by removing common fixed characters for the number of characters existing at the beginning and tail of each character string. Obtained by enumerating in order from the smallest total string length of values.
The processing method according to claim 16 or 17. Based on the calculated “a set of solutions that are minimal as strings containing variables”
The processing method according to any one of claims 19 to 24, wherein the search is continued by a horn clause that can be temporarily rewritten by a character string including the variable. Based on the calculated “a set of solutions that are minimal as strings containing variables”
A set of fixed character string sets made by substituting each element of the set of fixed character string sets defined in advance as a set of solution sets of the “facts including variables” to the variable portion of “character strings including variables” return,
The processing method according to any one of claims 19 to 25. In the automatic unification process or automatic derivation process,
When performing automatic unification of a first pattern containing variables and a second pattern containing variables:
If the fixed characters for the number of characters in the head and tail of both patterns match and the same variable appears only once in each pattern,
Returns information indicating the existence of an infinite number of solutions,
The processing method according to any one of claims 1 to 26.   28. Apparatus for carrying out the method of any one of claims 1 to 27.   A computer program for causing a computer to execute the method according to any one of claims 1 to 27.

Images