JP6924461B2 - How to process logical programs that allow strings containing variables as literals, computer programs and devices - Google Patents

Description

The present invention relates to a method, a computer program and a device for processing a logical program that allows a character string including variables as a literal.

A logical program that allows a character string containing a variable as a literal and a processing system thereof have been researched and developed by the inventor (Patent Document 1). However, the fact that literals are variable depending on variables means that the possibility of unification is extremely wider than that of conventional PROLOG and the like, resulting in an increase in the amount of calculation and a delay in calculation.

Japanese Patent Application No. 2013-087008 Japanese Patent Application 2015-219007 Japanese Patent Application No. 2016-09327 Japanese Patent Application No. 2016-103010 Japanese Patent Application 2015-234356

In view of such a problem, the present invention has a problem.
The main task is to provide a method, a computer program and a device for processing a logical program that allows a character string containing a variable as a literal "at high speed".
Further, it is a further task to increase the speed corresponding to the dynamic reading of the logic program (the technique described in Patent Document 2).
Further, it is a further task to prevent the display of the grounds and the certification route and the procedural interpretation (including the question from the computer of Patent Document 3) from being impaired even when the speed is increased.

To solve this problem
The present invention (claim 1)
A way for a computer to process a logical program that allows a string containing variables as a literal.
When a computer finds the value of a variable that makes a literal containing a variable true in a logical program, the first step is to associate the literal with the value of the variable and store it.
It is characterized by including a second step of using the value of the variable stored in association with the literal in the first step when obtaining the value of the variable that makes the literal true in the same logical program. Provide a method of

The value of the variable that makes the literal (for example, "$ X likes $ Y") true is multiple (example "($ X, $ Y) = {(Taro, Hanako), (Jiro) according to the example on the left". , Sayuri)} ”, two) may be used.
"Associative storage" can be realized at high speed by using a conventional general open / closed hash algorithm or a (arranged) map type or built-in hash type capable of binary search.
In Patent Document 4, since there is less variation in the notation of questions from users, it becomes more and more advantageous to omit recalculation, and it is not only reused in processing one question by a single user, but also by multiple users. It can also be used to process multiple times of the same (same question / substantially the same, etc.) and similar (many common parts in the subquery set for answering the question, etc.).
It is possible to save the amount of calculation by dynamically referring to the result of the calculation comparing the degree in Patent Document 5 and the complicated calculation considering the sense of values by omitting the recalculation.
As a result, the same inference / solution search can be largely omitted, and the above-mentioned main problem can be solved.

The present invention (claim 2) also
When storing the literal and the value of the variable in association with each other, or when collating the literal stored in association with another literal.
The method according to claim 1, wherein the notation of variables included in the target literal is standardized.

As a standardization method, for example, if "$ X likes $ X because $ Y likes $ X", then in the order of appearance of variables, "\ 1 likes \ 2 because \ 1 likes \ 1" (same variable). When appears later, it can be mechanically standardized to (assign the order when it appeared earlier).
This makes literals with different variable names (static literals on a logical program, or literals dynamically generated in the middle of processing (to avoid confusion of variables with the same name, etc.)) as true. It is possible to make further speedup possible by more comprehensively utilizing the property that the values to be used are the same in the same logical program (even between literals in which only the variable names are different).

The present invention (claim 3) also
A way for a computer to process a logical program that allows a string containing variables as a literal.
When the truth of a literal that does not include variables is obtained in a logical program, the first step of associating the literal with the value (true or false) and memorizing it, and
Provided is a method including a second step of using the value stored in association with the literal in the first step when determining the authenticity of the literal in the same logic program.

A more specific method of "associating and storing" may be the same as for a literal containing a variable, but the value is the true or false of the literal rather than the value of the variable that makes the literal true.
Calculation of the truth of a constant literal that does not include variables can also be computationally expensive, and this cache saves a great deal of computational complexity.

The present invention (Claim 4) also
When storing the literal and the value of the variable in association with each other, or when collating the literal stored in association with another literal.
The method according to any one of claims 1 to 3, wherein the meaning of the literal is analyzed and the notation of the literal having the same meaning is standardized in the direction in which the notation is the same.
"Analyze the meaning of literals and standardize the notation in the direction that the notation of literals with the same meaning is the same" is the conventional morphological analysis, parsing, semantic analysis, directive analysis, translation into a predetermined language, etc. The results can be used and stored as JSON format (however, sorted by case type (nominative case, literal case ...)) or conventional PROLOG format, in addition to the predetermined natural language format. ..
Semantic analysis can be expected to be more accurate for literals that do not include variables (that is, fixed strings), but for literals that include variables, the results of semantic analysis that adopt the most likely (syntax) hypothesis (however, the variable part) It is also possible to standardize using (remaining) with a certain accuracy.
As a result, it becomes possible to substantially deal with notational fluctuations of natural languages having the same meaning (standardization by translation from a foreign language may be included depending on the standardization policy).

The present invention (Claim 5) also
Make a literal that contains a variable true The value of a variable or the truth of a literal that does not contain a variable,
The method according to any one of claims 1 to 4, wherein the method is stored or collated in association with information specifying a range of a logical program to be processed as well as the literal.
"In association with information that specifies the range of the logical program to be processed as well as the literal"
for example,
URI of "literal notation" and "referenced (s) logical program" as the key of the ordered map type to "the value of the variable that makes the literal including the variable true or the truth of the literal without the variable" You can use the concatenation with "a sorted path sequence" (here, the purpose of sorting is to avoid the literally the same literal program (URI path) set from crying out due to fluctuations in the description order).
For example, if ccash is an ordered map type variable, "ccash [" \ 1 likes \ 2 because \ 1 likes it ___ \\ internal sharing \ prospect list.txt___ https: // hoge1 .jp / love.txt ___ https://hoge2.jp/love.txt "] =" {(Taro, Hanako), (Jiro, Sayuri)} "" (In this case, "___" is a delimiter. Shows).
As a result, the logical program that is the basis for finding the value of the variable that makes the literal including the variable true or the truth of the literal that does not contain the variable is dynamically (= during the search / inference process (for example, the operation of Patent Document 2). Answers based on changes in the underlying logical program, even if it changes due to changes over time (in such cases, the URI path that specifies the revision number of the logical program may be adopted). It is possible to perform a sound speedup that correctly reflects the possibility of change in.

The present invention (claim 6) also
A way for a computer to process a logical program that allows a string containing variables as a literal.
Cache the results of subqueries (which may be the question text itself) and
Provided is a method characterized by using the corresponding cache without recalculation when substantially the same subquery occurs.
A "subquery" is, for example, a new query (a new query that can be made when the head of the horn clause of PROLOG (matching the query) is expanded one by one to each condition (constituent requirement) of the body part of the horn clause). It is also called a subgoal). Not limited to PROLOG, there are those that perform SLD derivation and logic programming languages that use configuration requirements that correspond to subqueries, and the present invention can be applied.
"Substantially the same" means that the same variable that appears in a literal is replaced with an escape character of the same number ("number" is the order in which it first appears (1, 2, ..., etc.)) to the same character string. To become, etc.
This will achieve the main tasks mentioned above,
In a logical program that allows a character string containing variables as a literal,
Compared to the cache of function values according to the arguments in a normal functional programming language,
Furthermore, cache of calculation results in a programming language that assumes a case structure such as PROLOG (however, it is inappropriate in a language in which procedural interpretation is clearly defined, and the inventor is aware of such prior art. Compared to (not)
Calls (calculation of truth or solution) of a narrow domain (“substantially the same” query) tend to be repeated (= recalculated) many times.
therefore,
In a logical program that allows a character string containing variables as a literal,
Compared to other programming languages, such a cache (query-> true / false or value (solution) set whose true value is a variable) is extremely effective.
On the other hand, such a cache mechanism is
Compared to the conventional disk cache (the domain is the physical address and the range is the fixed length), etc.
The domain format is extremely complex and novel (thus the discrete mathematical / collective nature is uncertain and identified as "literals that allow strings containing variables (allowing the same variable to appear multiple times)". The method (the method of calculating that they are substantially the same) is also a query format (the method of calculating that they are substantially the same), and the policy that the underlying PROLOG adopts the closed-world hypothesis and does not actively define false literals. Or because the recalculation could be controlled to some extent by the cut operator (!) Or fail, it is cached in the first place (it is memorized globally regardless of the context, including the fact that it was calculated and false). It was extremely difficult to come up with ideas (difficult to realize and difficult to come up with). In addition, conventional PROLOG etc. were developed in the era when memory was small, and it is difficult to create the idea of caching the value (solution) set (object that may become extremely large) of variables that make literals true. Sometimes.
Under such circumstances, the present invention makes it possible to realize a cache mechanism for variable-embedded literal queries, which was difficult to realize and conceive, by providing the above-mentioned standardization identification method for the first time, and its necessity, usefulness, and effectiveness ( In an experiment in which a logical program containing a lot of recursive processing was asked, the processing time was reduced to 1/60, etc.).

The present invention (Claim 7) also
It has a flag that indicates whether the literal calculation was mediated by a rule that required a procedural interpretation.
The method according to any one of claims 1 to 6, wherein the recalculation is performed when the flag is true.
Examples of procedural interpretations include the definition of global variables (including updates), the addition of logical programs (addition of context for each user (for example, "I am in good shape today"), the additional loading of external programs, etc.) / deletion. -Updates (users, situations, problems, customization for each date and time, etc.), display of print texts, graphic texts, generated texts, mail texts, etc., and other things that affect the output can be considered. As a complex, the computer dynamically asks questions as the inference progresses, and the user's answers temporarily add lines to the logical program, or update or delete the contents of existing lines. The so-called "reverse question sentence ("? I'm feeling well today ","? $ B is a friend ", etc.)" (see Patent Document 3) that is often asked can also be included in the procedural interpretation.
As a result, the necessary procedural interpretation (in some cases, the logical program itself changes and the value also changes (when the logical program itself changes, the hash value of the entire text is used as a map type variable or cache key after the literal. In addition, the speed can be increased while performing ())), which may be added before the URI path sequence.

The present invention (claim 8) also
It has a data structure that calculates whether the target logical program has changed since the last calculation.
The method according to any one of claims 1 to 7, wherein the recalculation is performed without using the stored value when there is a change.
As an example of "data structure", the cached (associately stored) date, time, minute, second, and millisecond / microsecond are stored together with the "solution set that makes the truth or variable true" and is targeted. If the change date / time / minute / second millisecond / microsecond of the logical program is stored, if the former is later than the latter, the cache (value stored in association) is used, and if not, it is recalculated. good. In this case, the date, time, minute, second, millisecond / microsecond are stored on the value side. This is because it is difficult to identify the millisecond as a key.
It is also possible to simply use the revision number for each user as the data structure instead of the date / time / minute / second millisecond / microsecond or the like (Fig. 6). In this case, the user ID and revision number are stored on the key side. This is because the user ID and revision number are obvious from the user ID and revision number stored in association with the forked logical program.
In any case, when there is a change or no change for each target logical program, it is possible to increase the speed without clearing the entire cache.

The present invention (Claim 9) also
When it is necessary to specify the rules, facts or contexts used to derive the truth or solution set
The method according to any one of claims 1 to 8 is provided, in which the calculation is intentionally performed for each authenticity proof path or for each solution included in the solution set.
A "context" is one in which some or all of the variables contained in a literal are filled by previous unification or binding (partial / total from the head variable to the body variable). The dynamic state in which the truth or solution set is calculated (again).
As a result, the so-called "different solution" proof and the tree display of the rules, facts, and contexts on which each solution is based can be carefully performed even when high speed is required.

The present invention (Claim 10) also
Provided is a computer program that implements such a method.

The present invention (claim 11) also
An apparatus using such a computer program is provided.

It is a figure which shows the redundant calculation amount of the logical program which allows a character string containing a variable as a literal. It is a figure which shows the efficient calculation (use of a cache) of a logical program which accepts a character string containing a variable as a literal. It is a figure which shows the example of the literal before normalizing the variable name, the literal without a variable, and the cache of each value. It is a figure which shows the example of the literal after normalizing the variable name, the literal without a variable, and the cache of each value. It is a figure which shows the example of the cache at the time of dynamically adding a plurality of logical programs (P1, P2). It is a figure which shows the example of the cache when a logical program is dynamically changed or added. It is a figure which shows the example of the cache at the time of standardizing meaning other than a variable name by using semantic analysis. It is a figure which shows the example which suppresses a cache because a procedural interpretation (eg, WRITE for a transitor) is required. It is a figure which shows the example which suppresses a cache in order to obtain the basis in a tree shape for each solution.

In some examples described below, the above-mentioned functions peculiar to the present invention are additionally implemented in the embodiment of the following patent specification (above, excerpt from Patent Document 1) by the same inventor. Can be implemented. In addition, the following citation of Patent Document 1 also includes a supplementary purpose 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. 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.
Detects whether the fixed character string in the pattern is included in the character string in the process of removing the longest matching solution, and speeds up.
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 / corrections 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 logical 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 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, referencing, etc.
In addition, "the computer treats variables as those that can cross the main part, predicate, subject, predicate, object, particle, conjunctive modifier, conjunctive modifier, or sentence boundary of a sentence" means Japanese, etc. It can only straddle the boundaries (explicit delimiters) of case structures (including those that correspond to the hierarchical structure of parsing results and semantic analysis results) with explicit delimiters via particles, etc. and predicates such as English. Instead, it can straddle the boundaries between S and V, the boundaries between V and O, the boundaries between V and C, etc. Includes modes that are treated as possible (conversely, some modes 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 composes 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 it is a case where "sentence boundaries" are 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 PROLOG's knowledge processing procedure (and underlying knowledge interpretation policy). By following this, the risk of reduced precision (solution accuracy) that can occur due to hybrid knowledge processing procedures (and complex knowledge interpretation policies corresponding to the hybrid processing procedures) as in other processing systems is avoided. At the same time, by "treating variables as those that can straddle the main part, predicate, subject, predicate, object, complement, conjunctive modifier, conjunctive modifier, or sentence boundary of a sentence", the delimiter expression of natural language ( Unjustified disagreement (regular expression) caused by the appearance of crying of specified patterns by reading points, punctuation points, parentheses, commas, periods, etc.) and modifier phrases (advocacy phrases, complement phrases, non-essential case expressions, 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, it is possible to perform integrated and continuous quoting / 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, 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 the case structure (and you don't have to know about the rules of the case structure (such as the order of appearance) and you don't have to worry that the order of the arguments may be wrong). Allows you to cut.
Since the first object of the present invention is Japanese (the amount of information in one character is large and there is no space between words), there are many contents in which characters are used as processing units and delimiter units, 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 is a sentence 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 Jiro> 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">"Thick 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, which is characterized in that instead of gradually cutting until it becomes an empty string, it gradually cuts only to the shortest matching solution obtained separately.
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) 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 of Patent Document 1, wherein the substring 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. offer.
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 bound information when the product set of each bound information 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 that indicates one binding method for 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 specifying an AND / OR combination instead of ",". It can be expressed in the form of a combination, or in the standard form of conjunctive words or the standard form of selection, which 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 pattern on the right side of the rule. 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 (completeness 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 requesting 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 that becomes the "goal". 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 combinations to 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 to 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. offer.
As a result, the search can be performed simply and quickly.
When "facts that do not include variables" include multiple sentences separated by punctuation marks. The "match as a character string" may 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 a sound mechanical interpretation, a seamless, easy-to-understand, simple and unified processing mechanism, and an explanation of the corresponding inference process.
(0018)
Further, claim 10 of Patent Document 1 is
In the automatic unification process or the automatic derivation process
When unifying patterns with variables and facts without 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 case variables) between the pattern and the (static) facts are identified and returned as "results", 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)
Further, 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 existing 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 part containing variables,
When the pattern matches the fixed characters for the number of characters existing at the head and tail of the head part,
Each 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 contain 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 are included. 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 a "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)", it is simply converted into a partial problem with the same structure that is simpler and recursive (or mutual recursion), so that the inference process is visualized and verified (completely). 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, wherein the 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 the variables in all the sentences 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 contain 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,
The processing method according to any one of claims 1 to 13 of Patent Document 1, which is performed by obtaining and returning a set of solutions which is a minimum as a fixed character string, 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 = <free>)}. 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 being bound independently between strings (or, 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 stoppage (finiteness of calculation).
(0028)
Further, claim 20 of Patent Document 1 is
Not the two strings themselves, which consist 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 common to 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 degree 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." Delete the common part of "$ A is $ B"
And "$ C is also $ D ice cream"
Then, by full search, all 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 (substringing 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 When 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", $ C = "$ A is", $ D = "$ D")} or a set of partial substitutions for each assignment set (eg, $ D = "$ D")} {
($ 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 how the constraints (regular expression form) of the infinite number of solutions (character strings) should be. (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. When asking
When a variable is included in the substring to be assigned to 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 $ Yu"}, it is necessary to be able to enumerate ($ X = "say", $ Y = "uye") as solution candidates). It is possible to improve the completeness of the solution candidate enumeration 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 in 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 even, 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 (ensuring stoppage and response speed that are 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 character 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 with 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 (completely searched)" 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 are
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 further the branch goes), 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 being bound independently between strings (or, 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 to find a set of solutions by recursively substituting a fixed character string (including an empty string) or a character string containing a variable into each variable.
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 being bound independently between strings (or, 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 to find a set of solutions by recursively substituting a fixed character string (including an empty string) into each variable.
Binds the binding information that can be created using only the fixed character types (character types excluding variable identifiers and delimiters) in both character strings that can be created by excluding the common fixed characters for the number of characters that exist at the beginning and end of each character string. The processing method according to claim 16 or 17 of Patent Document 1, which is obtained by enumerating the values in ascending order from the one having the smallest total character string length.
As a result, problems with certain properties can be efficiently reached and listed.
(0033)
Further, 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". There is also a unification policy (for example, in the case of the last assignment set above) in which the constraint that it can be unified only by being bound (assigned) by a character string works), in 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 is
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 (one or more) and a set of appropriate answers (or hypotheses) that can be filled in the variables (for example) It is possible to search for a solution in an efficient manner 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 is
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 all kinds of computers connected / not connected to a network (cloud server, large general-purpose machine, desktop PC, notebook PC, mobile terminal, dedicated machine of the present invention), but it is general. 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 most effectively implements the present invention, 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 priorities according to a predetermined policy may be used. The user PC2 inputs and stores 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 a 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 way of the dialogue protocol (format) with the user.
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 by 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 division 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 Patent Document 1 of the main function common to the 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. 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 specification 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 the 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 only from 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 that has a structure (the horn clause identifier being confirmed, the current variable binding condition) as a member,
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 of Patent Document 1 ★
{
If P does not contain a variable {
If B is a fact {
If P = B, it returns true.
Otherwise, 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.
Otherwise, 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.
Otherwise, 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 (head of P, B, C1) and the function D (body of B, E) is true, then all such C1s are added to C. Returns true.
Otherwise, it returns false.
}

When the head part of B contains a variable {
★ When implementing the invention of claim 12 of Patent Document 1 ★
// Start of speed-up device (option) When the fixed characters for the number of characters existing at the head and tail of the heads of P and B do not match {
Returns false.
}
// End of speed-up device (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, the function F (the head part of P and B is bound by G (should be a fixed character string)). , C1) If there is a C1 that is true
Add all such C1s to C and return true.
If such C1 does not exist, false is returned.
}
}
}
}
}
(0046)
■ Enumeration algorithm specification of solution set of body part of horn clause (or inquiry of compound 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 inquiry of compound sentences sharing variables), E: solution set): ★ Example 1-2A of Patent Document 1 of the function used in the invention of claim 6 of Patent Document 1 ★
* 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. 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 When 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.
* 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. Take out the next sentence M'in J. 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 When M'does not contain a variable
do nothing.
When M'contains a variable
Let the new C be the intersection of the set C'of the binding information that can be taken to make M'true and the memorized set 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.
* 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 compound sentences sharing variables), E: solution set): ★ Another Example 1-2B of Patent Document 1 of the function used in the invention of claim 6 of Patent Document 1. (The speed is increased by spreading the binding information to other statements using the recursive call of the function) ★
{
1. 1. Take out the first sentence M in J. Returns true if M does not exist.
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, it returns true. If it is true, 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 possible binding information is stored in E, and if true is returned, the possible binding information 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. Returns false if it has never been true for each K, and returns true (E) if it has never been true}

Function D3 (J: body part (or inquiry of compound sentences sharing variables), E: solution set): ★ Example 1-3 of Patent Document 1 of the function used in the invention of claim 5 of Patent Document 1.
{
1. 1. Take out the first sentence M1 in J. Returns true if the first sentence does not exist.
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 When M1 does not contain a variable
do nothing.
When M1 contains a variable
Stores a set C1 of possible binding information.
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. The intersection C is obtained for the remaining C1, C2, C3 ... Cn, and true (C) is returned.
}

(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 of Patent Document 1 (however, "(or last)" and "or before" Example 1-4A of Patent Document 1 of the function used in the omitted implementation example)
{
(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 when P originally does not contain variables)
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.
* The unification itself can be performed as a match with the regular expression (if the same variable appears more than once, there is a postscript reference).

4. 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 The solution set as a matching solution is output

5. 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.

6. When R1'is one or more characters (★ When it is larger than the number of characters of the shortest matching solution 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)
end.
}

(0048)
Function F (P: pattern that can include variables, S: constant character string, C: variable binding information): ★ Examples 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 when P originally does not contain variables)
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
The solution tried to match all variables (N1 (= N), N2, ...) In the longest match mode and all variables (N1 (= N), N2, ...) Match in the shortest match mode. When the solution is the same (N1 = R1, N2 = R2, ...) ⇒ The only solution is output as "C and N1 = R1 and N2 = R2 and ..." and ends. If you didn't
⇒ Return false and finish.
When they are not the same ⇒ Continue to 5

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 The solution set as a matching solution is output

6. 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 at 7 is the solution R2 of N2 The first character of)
When fixed characters continue ⇒ Process after 7

7. One character C, which is a fixed character immediately after the variable N1 first appears in P (when immediately after another variable N2, the first character C of R2) is
When it is included in the longest matching solution R1 ⇒ 1) R1'← A character string in which the substring from the end of the character string of R1 to its C is deleted ⇒ 2) All N in P with P''← R1' ⇒ 3) Execute recursive call F (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 list of shorter solutions is complete, so the process ends.

8. Return to 7 as R1 ← R1'.
}
================================================== ================================================== =================

Some examples of the present invention will be described with reference to the drawings.

FIG. 1 is a diagram showing a redundant calculation amount of a logical program that allows a character string including variables as a literal.
When calculating without using the PROLOG cut operator or ASSERT statement (I do not want to use programming for elementary schools because simplicity is important), the same calculation (literal) is performed many times (5 times for many) as shown in Fig. 1. Calculation (including simple character string matching) for finding the true / false or true variable value (solution) of is performed. Since the same calculation is performed up to 5 times even in a program with only 4 lines, in order to prevent a larger combinatorial explosion in a larger program, a cache as shown in Fig. 3 and Fig. 4 is introduced as shown in Fig. 2. I will limit the amount of calculation to such.

FIG. 2 is a diagram showing efficient calculation (using cache) of a logical program that allows a character string including variables as a literal.
This is a case where the calculation of the same literal is omitted by using the cache (using the cached value), and it can be clearly seen that the amount of calculation is saved.
In another embodiment, a question sentence listing all literals (fixed character strings) that can be proved as "$ A" may be asked. In the logical programs of FIGS. 1 and 2, the three facts and the contents that can be proved by one rule are all in the form of "$ A is the brother of $ B", so the answer format is different. , The result of "$ A" and the result of "$ A is $ B's brother" in Fig. 2 are substantially the same, and both are "Taro is Jiro's brother", "Jiro is Saburo's brother", and "Saburo is Shiro's brother". "Taro is Saburo's older brother,""Taro is Shiro's older brother," and "Jiro is Shiro's older brother." Only my brother's three "$ X" will be answered).
However, as another example, if the logic program contains facts such as "Taro is Hanako's husband", the question "$ A" will include this in the answer, but "$ A is $ B". It will not be included in the answer to the question "My brother".
The contents cached in this way differ greatly depending on the question sentence, but if the total number of fixed character strings that can be proved by the logical program is a finite number, the fixed character string set that is the answer to "$ A" is calculated in advance. Remember and store each question as a regular expression (see variables as (. +), (. *), Postfix references (\ 1) (\ 2) ..., etc.) and find them by matching. Good (high speed).
Also, in order to take the difference of how the whole that can be proved by the logical program changes when an arbitrary fact is added to the logical program, the processing system automatically "is open during the open time when the question sentence is not processed. You may ask for "$ A". In addition, the cache ("$ A") memorized at this time is not the only key, but various more specific literals are used as the key to cache and the subgoal is calculated, and the value of $ A (proof). (The whole fixed character string that can be created) is required) may be diverted in the subsequent question sentence processing. In the basic semantics of PROLOG and the intelligent system of the above-described embodiment, the logical program and the question sentence () If the subquery) does not change, the value (the set of variable values (solutions) that make the truth or literal true) does not change either.

FIG. 3 is a diagram showing an example of a literal before normalizing a variable name, a literal without a variable, and a cache of each value.
In the programming language of the above-described embodiment, which has the same scope rules as the basic PROLOG syntax, if the variables are arranged in the same order, the answer is essentially the same even if the variable names are different. , A common cache should be fine, but if that is not the case (that is, in the case of "Taro is the brother of $ Z" and "Taro is the brother of $ Y" in Fig. 3, the variable names are normalized (unified). ), This would use a lot of memory (and amount of computation). Therefore, as shown in FIG. 4, an option for speeding up by normalizing the variable name is prepared.

FIG. 4 is a diagram showing an example of a literal after normalizing a variable name, a literal without a variable, and a cache of each value.
It can be seen that the amount of memory required for the cache and the corresponding amount of calculation can be significantly saved as compared with FIG. 3 by normalizing by giving names corresponding to the order of appearance of the variables in this way.

FIG. 5 is a diagram showing an example of a cache when a plurality of logical programs (P1, P2) are dynamically added.
R is an arrow indicating a dynamic citation. In this example, two logical programs (P1 and P2) are recursively additionally loaded (temporarily additionally loaded and deleted after the question is completed). For technical details, refer to Patent Document 2, but "Req <URI path>" can be described at any position in the body part, and the query (or subquery) and the head match and before that in the body part. Only when all the conditions of , The effect of the additional program loaded (for example, the number of solutions of variables increases).
P1 ... in the figure is for omission, and is actually "\\ internal sharing \ P1.jpl", and similarly P2 is "http://hoge.jp/P2.jpl". be. The former is a logical program that is referenced only within the company in the shared folder of the file server in the company virtual VPN, and the latter is a logic program that is published via http on the entire Internet (= for the entire human race). The former is updated by the person in charge within the company to share know-how only within the company, and the latter is updated by volunteer groups to disseminate specific knowledge and information.
The contents of the logical program P1 are shown graphically so that the reference relationship can be understood, but the contents shown as an example are "$ X can be supplied to $ A:-Req" \\ internal sharing \ P1. jpl "; $ X can be eaten; $ A likes $ X;", and P2 is "$ Y can be eaten:-Req" http://hoge.j/P2.jpl "; $ Y Can be eaten; ".
As a result of reading P1 and P2 in the cache C1, is the value of the variable "¥ 1" that makes the literal (normalized) "¥ 1 is food" in the original logical program P0 true "curry"? It shows that it is "ramen". This is a different expression if P1 is not loaded, P2 is not loaded, or another P3 is loaded and "is", and corresponds to the possibility that the associated value will change. doing. Here, the key is that the result is that only P1 (\\ internal sharing \ P1.jpl) and P2 (http://hoge.jp/P2.jpl) are read. It is expressed as "\ P1.jpl_http://hoge.jp/P2.jpl". Since the read URI path is sorted according to a predetermined sorting rule, even if P1 is read after P2, it is aligned as described above so as not to cry.
The cache C2 is about a literal that appears in the logic program P1 and does not appear in P2, "¥ 1 can be eaten", but the body headed by this literal is "Req" http://hoge.jp/JP. Since it contains jpl "" (Req P2 ...), not only P1 but also P2 is included in the key. Actually, curry and ramen that exist only in P2 are stored as values.
In cache C3, the range of the above "Req P2 ..." is limited to that rule and extends to "$ Y is food", so it is necessary to consider P2 because "$ Y is" in P1. Only "Eatable" and "$ Y is food", and "Chinese people like firecrackers" and "Indians like curry" correspond to "¥ 1 likes ¥ 2" as a literal cash key P2 Will not be included.
The cache C4 is a literal that can only be found in P0, but since it caches the value as a result of recursively reading P1 and P2, the key is "¥ 2 can be replenished to ¥ 1_P1 ..._P2 .. . ". If there is a clause that has the same head and does not dynamically read P1, the key "¥ 2 can be replenished for ¥ 1" and its value (variable value that makes the truth or literal true (solution) A cache (not shown) that associates and stores (sets)) may be provided for that clause.

FIG. 6 is a diagram showing an example of a cache when a logical program is dynamically changed or added.
This is an example of dynamic change by the reverse question function of Patent Document 3. For details, refer to the same document, but the computer has the knowledge from the beginning by dynamically adding knowledge based on the answer that the computer asked the user about the value of the variable that makes the literal true in the middle of the inference. It is a system that makes up for the lack of knowledge and information that exists, and in the case of a simple addition method, it will be added in the form of a fact at the end of a logical program (ibid.).
As a result, the truth of other literals and the set of values (solutions) that make variables true may change, so it is necessary to change the cache key according to the dynamic addition. In this example, the system is configured so that the fact that it is added dynamically for each user can be different. The user ID (U01 in this case) and its revision number (REV001) are added to the key, and which cache is which revision. It manages whether it corresponds to the logical program of.

FIG. 7 is a diagram showing an example of a cache when semantically standardizing other than variable names by using semantic analysis.
In FIG. 5, although "¥ 1 is food" and "¥ 1 can be eaten" are synonymous, they are different cash. By using a known normalization / standardization technique that uses semantic analysis, the number of keys is clearly reduced by preventing notation fluctuations from occurring as "things with the same meaning have the same notation" (nouns are also named). You can save cache.
In the upper right of the figure, simple semantic analysis & standardization rules are described, but in reality, many morphological analysis techniques, parsing techniques, and semantic analysis techniques that have been developed mainly in the 1990s and are already publicly known. , Indicator analysis technology, etc. can be used.
Further, in FIG. 5, the same result can be obtained without the rule “$ Y is edible: − $ Y is food;” used for absorption of the notational fluctuation in P1.

FIG. 8 is a diagram showing an example of suppressing the cache because procedural interpretation (eg, WRITE for the intermediary) is required.
WRITE ($ Y), which is a procedural interpretation, is added to the logical program of FIG. This is a built-in function that displays the value binding $ Y. In order for this to function reliably, it is necessary to regard the body part as a procedure that also requires side effects (display, etc.) and execute it without omitting it. In FIG. 8, as compared with FIG. 2, the rule on the fourth line including the procedure is surely executed (not replaced by the cache). Therefore, although the amount of calculation is increased as compared with FIG. 2, the amount of calculation is saved as compared with FIG. 1, and it is possible to process without omitting the necessary procedure (here, WRITE). This is made possible by distinguishing rules that include procedural interpretations (those that contain certain reserved words) from rules that do not.

FIG. 9 is a diagram showing an example of suppressing the cache in order to obtain the basis in a tree shape for each solution. The tree-shaped graph on the right shows the proof path, and the numbers show the line numbers of the logical program.
In this case as well, the rationale for the solution (for example, circle 5 with the largest argument path, that is, ($ A, $ B) = (Taro, Shiro)) (two trees including another solution) is shown without omission. In this case, instead of relying on the cache already obtained, I recalculate the derivation process that proves the truth of the fixed string literal "Taro is Shiro's older brother" and follow the path of the argument.
In such a case, it is necessary to suppress the cache, and it is also dealt with by clearing the cache entirely or only the part related to a specific solution. By clearing only the cache related to a specific solution, other caches can be used for other caches (unless the logical program is changed).
In addition, in the process of processing the original question text, each question text is written after the solution is obtained, rather than the algorithm that associates the facts and rules necessary to support each solution (candidate) with the solution candidate and makes a note of it. The fact that it is easier to calculate each rationale tree with an algorithm that finds each rationale tree by substituting the solution to create each fixed string literal and then recalculating each derivation process (not necessarily one). Has been discovered by the inventor.
It is better to first list the solution candidates for each conditional statement with width priority instead of the depth-priority backtrack, and narrow down the solution candidates with the subsequent conditional statements to cover the various possibilities of string matching. Since it can be completed in (in the conditional statement of the rule), it is recursive from the state in the middle of the match (there are multiple possibilities that the regular expression matches and each one is calculated as another candidate). Reduces search function calls (with context switching) and backtracking to reduce stack swelling (which is often caused by stacking regular expression data structures that would have to be automatic variables to enable function reentrants). This is because the speed can be increased, and in a processing system that allows a character string including variables as a literal, there is a great merit in doing so because regular expression matching is used more frequently than in traditional PROLOG and the like.
Also, in this way, in the case of a policy (breadth-first) that enumerates all the value (solution) sets of variables whose true is a literal, which is a condition of each body part of the rule, at once for each literal, all of them are obtained as a cache. It is extremely advantageous to keep it, and it becomes a combination of calculation policies (breadth-first x cache) that most effectively achieves the object of the present invention.

The intelligent system targeted by the present invention (acceleration and suppression thereof) includes classification, organization, and management of knowledge itself, automatic application of the managed knowledge to new facts (automatic reasoning), and a wide range of ideas themselves. It can be used for searching / searching, combining / detailing / embodying ideas, and automatically sharing / disseminating / updating / refining knowledge and research results in humankind, communities, companies and groups. It also makes it easy to develop your own intelligence system at low cost and easily in the form of quoting external knowledge.

C1, C2, C3, C4 Example of cache contents Qr Example of reverse question sentence (statement in which the computer asks the user for the true / false or true variable value (solution) and the result is added to the end of the logical program)
Qr1 Example of sentence added as a result of reverse question sentence R Example of dynamic quoting (quoting the program before the original program of the arrow)

Claims (10)

A way for a computer to process a logical program that allows a string containing variables as a literal.
The first step in associating and storing the literal and the value of the variable when the computer finds (hereinafter referred to as "calculate") the value of the variable that makes the literal including the variable true in the logical program. When,
It is a method including a second step of using the value of the variable stored in association with the literal in the first step when obtaining the value of the variable that makes the literal true in the same logical program. hand,
The value of a variable that makes a literal containing the variable true,
A method characterized in that it is stored in association with information that specifies a range of a logical program to be processed as well as the literal. When storing the literal and the value of the variable in association with each other, or
When collating a literal that you have associated and remembered with another literal
The method according to claim 1, wherein the notation of variables included in the target literal is standardized. A way for a computer to process a logical program that allows a string containing variables as a literal.
When the truth of a literal that does not include variables is obtained in a logical program (hereinafter, this is also called "calculation"), the first step of associating the literal with the value (true or false) and memorizing it, and
A method including a second step of using the value stored in association with the literal in the first step when determining the authenticity of the literal in the same logic program.
A method characterized in that the truth of a literal that does not include a variable is stored in association with information that specifies the range of a logical program to be processed as well as the literal. When storing the literal and the value of the variable in association with each other, or
When collating a literal that you have associated and remembered with another literal
The method according to any one of claims 1 to 3, wherein the literal meaning is analyzed and the notation of literals having the same meaning is standardized in the direction in which the notation is the same. A way for a computer to process a logical program that allows a string containing variables as a literal.
Cache the calculation result of the subquery (which may be the question text itself) and
The method according to claim 1 or 3, wherein when substantially the same subquery occurs, the corresponding cache is used without calculation. It has a flag that indicates whether the literal calculation was mediated by a rule that required a procedural interpretation.
The method according to any one of claims 1 to 5, wherein the calculation is performed when the flag is true. It has a data structure that calculates whether the target logical program has changed from the time of calculation.
The method according to any one of claims 1 to 6, wherein the calculation is performed without using the stored value when there is a change. When it is necessary to specify the rules, facts or contexts used to derive the truth or solution set
The method according to any one of claims 1 to 7, wherein the calculation is performed for each authenticity proof path or for each solution included in the solution set. A computer program that causes a computer to perform the method according to any one of claims 1 to 8. A device using the computer program according to claim 9.

Images