JPH01292537A - Rule inspection type information processing system - Google Patents

Abstract

PURPOSE:To expand the range of applications of the title system by using a means which replaces both rule and inspection files and a means which detects the discordance between a group of rules of the rule file and the output of the inspection file at replacement of both files. CONSTITUTION:When an input is received, a rule application part 3 applies the rule group to a rule file 6 and produces the corresponding output. In case the abnormality of a rule is detected under such conditions, a control part 1 registers said input into an inspection file 7 and at the same time informs the abnormality to a user via an error display part 15. Thus the user adds a new rule to the file for revision via a rule editing part 2. When the new rule is added, the user applies the replaced rule group to the input example of the file 7 to check whether the corresponding output is obtained or not. If so, the obtained output is registered into the file 7. Thus the contents of both files 6 and 7 are replaced and a rule inspecting part 4 applies the replaced rule group to the input example of the file 7 to check the coincidence with the registered output.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a rule verification type information processing system that selects processing rules that match an input string and generates an output string.
In particular, the present invention relates to a rule-verifying information processing system that can easily perform error-free processing according to the context as well as the individual syntax of an input string.

[Prior Art] Conventionally, as a rule learning system for experts, as described in, for example, Japanese Patent Application Laid-Open No. 60-272353, a system inspects whether a part of a sentence related to specialized information conforms to a predetermined grammar. It is known to economically create rules for expert systems by converting sentences into rules when they are completed. However, this system only guarantees grammatical consistency within a single rule description.

On the other hand, for information on how to create and select language conversion rules that take the context into account, please refer to the American magazine "Software Plasma."

Cutis and Experience, Vol. 14, No. 4 J (1984), pp. 347-364 (M
-Ganapathi;
Linear Intermed-iate Rep
reservations for RetarBet
able Code Generators, Softw
are-Practice, and Experience
ce.

vol, 14. No, 4. (8 pr, 1984)
, pp. 347-364). this is,
An intermediate language element with an attribute value appended to the syntax element name is used as a unit for collation, and the correspondence of the conversion results for each of the many patterns of this intermediate language element string is entered into a conversion table as a language conversion rule, and the input program The intermediate word element string created from L A L R (Look a
(head, left to right) syntactic analysis method, and the input program is repeatedly rewritten according to the matching rules to obtain a machine language string as an output program. There is no rewriting of the rules here. The attribute-attached syntax element described above is expressed as one string (character string), and pattern matching of the intermediate language element takes the form of seeking a match as a character string.

[Problem to be solved by the invention]

The conventional technology disclosed in the above-mentioned Japanese Patent Laid-Open Publication No. 2003-120037 regarding the rule learning method for experts only checks whether a single rule matches its descriptive grammar, but does not take into account the point of examining the interrelationships between the rules. Therefore, when rules were added, there was a risk that consistency with other rules would not be maintained. Furthermore, this method does not take any context-dependent processing into consideration; each input is processed independently, and there is a problem that processing cannot be performed in accordance with the interrelationship of inputs or the structure of the input string. there were.

The conventional technology shown in the above-mentioned American magazine about language conversion that takes context into account suggests that the context dependence of the preceding and following sentences should be taken into account, but it always treats attributes as attached to syntactic elements. In some cases, it is not possible to select rules based only on attributes created in an internal processing process, and there is a problem in that the method for selecting rules is narrowly limited. In addition, since syntactic elements with attributes are treated as one string, it is difficult to write matching conditions such that if a certain attribute satisfies a predetermined condition, the value of another attribute can be any value, and language conversion using such rules is difficult. 'The problem was that it was difficult to carry out.

Furthermore, in this prior art, the rule group is completely described and provided from the beginning, and the gradual expansion of the rule group is not considered, nor is it possible to detect inconsistencies that occur when adding or modifying rules. This was not taken into account, and the problem was that language conversion rules could only be written after thoroughly examining the target and understanding every detail.

Therefore, an object of the present invention is to solve the above-mentioned problems of the prior art, and to recognize the entire object in a rule-verifying information processing system that obtains output from input using a group of conversion rules, such as a language conversion system or an Exbar system. Even if it is not possible to do so, it is possible to write rules for the parts that are known, and gradually expand the set of rules based on those rules while maintaining consistency with other rules, thereby expanding the range that can be handled. It is in. Furthermore, an object of the present invention is to, in the above-mentioned rule verification information processing system, not treat each input separately;
The purpose is to enable different processing even for the same input pattern depending on the structure of the input and the order in which it is given.

[Means for Solving the Problems] In order to achieve the above object, the rule verification type information processing system of the present invention is configured as shown in (1) to (5) below.

(1) A rule file containing a group of data processing rules,
In a rule verification type information processing system having a rule application unit that searches the rule file for a rule that matches a given input and processes the input, the system particularly stores many typical input examples and their corresponding output pairs. A verification file, an updating means (rule editing department) that updates either or both of the rule file and the verification file, and each of the input examples stored in the verification file when the update occurs. a verification means (checking) which applies (verifies) the updated rule group of the rule file and compares it with the corresponding output stored in the verification file to detect a mismatch;
(rule verification section).

(2) When input that does not conform to the rule group of the rule file (incorrect input) is given, the user is notified of the mismatch between the rule file and the input, and the human power is automatically added to the verification file. The method further includes a means for prompting revision of the rule file by storing the rule file as an input example.

(3) A result is obtained when the expected result is not obtained for the rule group of the rule file, the input example of the verification file to which the rule group is applied, and the input given by the user. or until the regulation ceases to apply.
Provide a means to display the rule application process.

(4) Each rule stored in the rule file is configured to be specified as a combination of a planing application condition based on a pattern description of a syntax element with attribute specification and a data processing operation when applying the rule.

(5) When specifying application conditions for rules in the rule file, the attribute specifications of syntax elements are limited to those directly related to the selection of the rule, and the attribute specifications are used for pattern matching. It is constructed so that it is treated as a target in the same way (without discrimination) as the specification of syntactic elements.

Note that syntactic elements are not limited to those with attributes;
By adding a rule specification function to the above functions that enables pattern matching against attributes based on past history apart from syntax elements, and pattern matching that focuses only on a certain attribute without regard to the values of other attributes. , it is possible to gradually expand the rule set and perform conversions tailored to the context with even higher precision.

[Effect]

The effects based on the above configuration will be explained, particularly focusing on the configurations (1) and (2) above.

A rule is expressed by a pair of a context-dependent pattern of constituent elements consisting of syntax elements and attributes, and an action portion representing a process for the pattern. The verification file contains many typical input examples and their corresponding output pairs in various cases.

Given an input, the rule application section applies a set of rules in a rule file to the input to generate a corresponding output. At this time,
If a rule anomaly (such as a mismatch between the input and the rule) is detected, such as a rule corresponding to the input not being found, (the control unit) registers (stores) the human input in the verification file as a test input example. At the same time, the error display section notifies the user of the occurrence of an abnormality (error, inconsistency). Therefore,
The user adds and revise (updates) new rules to the rule file using the rule editing department. When a rule is added (updated), the user applies the updated rule set to the input example of the verification file, checks whether the corresponding (appropriate) output is obtained, and also performs error handling. The department will request confirmation. If a proper output is obtained as a result, this output is officially registered in the verification file as an output corresponding to the input example (test input example). On the other hand, if an appropriate output is not obtained, the user uses the error processing unit to apply a new set of rules to the test input example, and if an appropriate output is obtained as a result, the user applies the new rule group to the test input example. Officially register the output in the verification file as (appropriate) output corresponding to the human test example. When the contents of the rule file and verification file are updated in this way, the rule verification unit is automatically started and applies the updated rule group to the input example of the verification file to match the registered output. Find out whether or not (verify and confirm).

In this way, the consistency of the rules stored in the rule file is always guaranteed for typical input examples, so
The rule group can be gradually expanded without fear of causing malfunctions. In addition, if an incorrect output is given when a certain input is given, that input is automatically registered in the verification file, and the output is also registered after the rule group is corrected, so that the verification items can be corrected naturally. It can be expanded and it is easier to maintain consistency. That is, it is possible to expand the rule set while maintaining consistency between rules, and at the same time, it is possible to perform context-dependent conversion.

Furthermore, by representing the context information and past history of the syntax element being input as an attribute, it is possible to write rules that perform conversion according to the context and history, rather than a uniform conversion. Advanced information processing becomes possible.

〔Example〕

An embodiment of the present invention will be described below with reference to the drawings.

FIG. 1 is a functional configuration diagram of an embodiment of the present invention, which includes a control unit 1 that controls input/output and program startup, and updates (additions/modifications) of rules to a rule file (rule collection) 6 and rules. Contained in the rule editing unit 2 which performs conversion into internal representation, the rule application unit 3 which applies the rules of the rule file 6 to the execution manual 13 to obtain the output result 14, and the verification file 7. When applying the rules of the rule file 6 to an input example, a rule verification unit 4 checks whether the output registered in the verification file is obtained for the input example (of the verification unit);
When an error is found in the rule application section 3 or rule verification section 4,
It includes an error processing section 5 that outputs an error display 15, a correction prompt 16, or a history display 17 leading to the error. The rule verification unit 4 reads the verification input/output example 12 and registers the input example and the corresponding output in the verification file.

It is checked whether the result calculated by the rule verification unit from the input registered in the verification file matches the output registered in the verification file, and if a discrepancy is found, the user is notified to that effect.

FIG. 2 shows how to write rules in this embodiment. The notation is 13 pJ F ([1ackus
This is a syntactic description format generally called NaurForm, in which a description of attributes and a description of the action sentence taken when an input matching the rules is given are added.

Attributes mainly indicate what kind of properties a certain syntax element has, and are written as a pair of syntax element name and attribute name, but sometimes the attribute name is written alone to indicate changes in status due to past input history, etc. . Attributes are used to enable selection of which rule to apply to which input, not only based on the format of the input symbol string but also under what conditions the input symbol string is given. For example, even the same number has different meanings and readings depending on which digit it is in. When handling it in this way, it is necessary to indicate the digit position and number of digits in the number or number string as a syntactic element of the input. Add the attribute to represent. Attributes have values determined during input parsing for rule selection, and they are typically attached to syntactic elements. For example, in a description example of a rule group shown in 33 in FIG. 3, which will be described later, the leading Digits"° indicates a component, and the following "[pos2]" indicates an attribute.

The description of the object to which the rule applies is given as a pattern of input components (a combination of syntax elements and attributes). Each component of the input is represented by an entry symbol, a syntactic element name, or an attribute enclosed in [ ], but the attributes generated during input parsing are expressed as a single input symbol, as if they were input symbols. It may also be a component. The attributes that should satisfy the pattern of the input component are specified in [ ], but there may be more than one attribute. Furthermore, when it is necessary to focus on only one of the attributes in a certain pattern for a syntax element that has multiple attributes, it is only necessary to write the condition for that attribute, and there is no need to write for the other attributes.

The action statement describes input conversion, attribute value calculation, etc. that are performed when a rule matching one input or a part of human power is found. One of the action sentences is the attribute value setting statement syntax element/attribute name knee expression, which indicates that the value of the attribute of the syntax element specified on the left side of the assignment symbol knee should be the value indicated by the expression on the right side. . The expression on the right side is a constant or other attribute value, or an arithmetic operation (+, -, *, /) on them. Figure 3 shows the rules for reading numbers of three digits or less in English according to the writing style shown in Figure 2. This is an example of what I wrote.

Using this rule, 1 is one, 10 is ten, I
11 one hundred and elevated
It can be converted as n. Here, the Number that starts with a capital letter, Digit.

Digits and Digitlo are syntax element names, p OS is an attribute name representing the digit position of the first digit, and out is an attribute name representing the conversion result of these syntax elements.

out of the syntax element Number that represents one entire input
An attribute represents the result of converting that input. The attribute pos indicating the digit position of the input number is generated during input analysis, and in this rule example, pos=1. POS=2
．． It is used to select the corresponding rule depending on one of pO3=3.

Rule group 31 shows the rules for the component Number, which represents the entire number from 1 to 3 digits, rule group 32 shows the rules for the component D1g1t, which represents the first digit, and rule group 33 shows the rules for the component D1g1t, which represents the whole number from 1 to 3 digits. Component D1 representing the number of eyes
g1ts [The rules for pos・21 are shown, and the rule group 34 is the component Di (BitIO
Rule group 35 shows rules for the component representing the third digit number.

In this example, the attribute of the syntax element is r, which represents the number of digits.
There is pOsJ. In rule groups 31 and 33.35, the attribute p
Since what is in the os determines whether or not the rule set is selected or which rule in the rule set is selected, 7 those attributes are written explicitly. . However, in rule group 32.34, the pos attribute does not affect the selection of rules, so it is not explicitly written on the rules. In this way, when writing a rule, it is only necessary to write attribute specifications that are directly related to the selection of the rule.

In each rule of rule group 31, posl, pos2゜pos
The attribute specification 3 is syntactic element specification D 1g1t or Di
It is treated as a specification for pattern matching in the same way as gits.

Figure 4 shows the rule group in Figure 3 for easy internal processing.
The internal representation created by reorganization by the rule editing section 2 is shown. In this example, the symbol inside the circle frame is 51°53.55,57
．． 59 represents the name of the syntax element on the left side of the rule, and the connection line 52.
54. 56. 5B, 60°62.64, etc. represent case classification based on input. The symbols on the connections represent the input symbols corresponding to each case, and the sentences in parentheses 71, 72, 73,
74, 75, 76° 77.78, 81, 82, 83.8
4 and the like are action sentences that represent the processing when the corresponding rule is applied. The underlined symbols 61, 63, 65.66 represent that a component defined in another portion 53.55 comes at that position as input. As a concrete representation inside the computer, a connection is a pointer that indicates the location of the information connected to it, an action sentence is a pointer that indicates the position of the internal representation of the action sentence, a syntax element name is a character string, and components inside a circle are the It is represented by a pointer indicating the position of the rule group relative to the component.

FIG. 5 shows an input example registered in the verification file 7 for verifying the rule group shown in FIG. 3 and the corresponding output.

Application of a rule group starts with matching the rule whose left side is the syntactic element name representing the entire input with the first part of the input. In this example, we start by matching the input with a rule whose left side is Number.

By the rule group in Figure 3 expressed as in Figure 4, the fifth
We will specifically explain how the human input example in the figure is converted into the corresponding output. When inputting the number 1, the first digit position is 1, so it is compared with the rule that connects to the connection 52 with pos=1 out of the rule group with Number as the left side, that is, the rule group that connects under Number 51, Rule 71 with the input symbol as 1 is applied, and D
1g1t, the value of out becomes one'', which is Dig
Number out by act sentence 81 for it
It is propagated to the attribute and the output "one" is obtained. For inputting the number 10, the first digit position is 2, so N
We will narrow down the matching to the rule group connected to the branch 54 of pos = 2 under amber, but since the first character is 1, Digit
A set of rules 59 for lO is selected. Since the next input symbol is O, rule 73 is selected and DiHitl O9o u
t - “t e n” and that is DiI! Its
, o u 5 Number, and o u t to obtain the final output "ten".

Similarly, for the input examples 11゜12, ------------, 19, the outputs are "eleven", "
twe l ve", -, "n1neteen" is obtained. For the input of the number 21, pos=
Digits connected to branch 54 of 2 (pos=2)
After the rule group 55 is selected, the first input symbol is 2, so the connection 60 for 2 is traced, and the next input symbol is D.
Apply the rule for component 61: 1g1t. Also, D
From the rule group 53 of 1g1t, select rule 71 by looking at the next input symbol 1, and first Digit.

o u t-”one” Okay, 75 formula D 1g1t
s, out and propagates it to Number, out to obtain the output "twentyone". Similarly, for the inputs 32, 43, =----298, "thirty two" respectively.

tourty three"l '-"-"l"n1n
ety eight" is obtained. For the input 111, the first digit position is 3, so pos = 3 technique 56
, select the rule group 57 of D 1g1ts [pos-31, trace the technique 62 whose input is 1 because it is the first character, and select Digits (pos
The rule group 55 for the component 63 with =2) is applied. DigitDigits (po
It is also possible to apply the rules for the connection 64 of s=2], but these rules specify that the first character is D jgi t, which matches any of 1 to 9. Since the rule for connection 62 more clearly stipulates that the first human character is 1, priority is given to the rule for connection 62. Second
For ~3 characters, select 74 from rule group 55 of Digits (pos=2) to get "eleyen", D 1g1ts, 1. out: Number it
, out to become the final output.

Here, Digits, 1 represents the first Digits that appears in the description of this rule, and D 1g1t
s, 2 represents the second occurrence.

Next, when the user inputs 200, the rule application unit 3 first inputs Digits (pos=3]::=Di
Select the rule 64 of gitDigits (pos=2) and try to apply the rule group 53 of Digit to the first character and the rule group 55 of Digits (pos=2) to the second and third characters, and in D1g1t, the first character is 2, so according to rule 72, Digits.

Let out be "two". However, D 1g1ts
In rule group No. 55 of [pos=2], an abnormality is detected in which an option corresponding to the second character O is not found. Therefore, the control unit 1 starts the error display unit 5 and
After registering this input in the verification file 7, the process from the start of rule selection to the stop is displayed to the user as shown in Figure 6, indicating that there is a defect in the rule group,
Promote amendments to the rules. Seeing this, the user starts the rule editing section 2 and creates two rules DLgits (pos=2).
::= ODigit ;do; Digits, o
ut:= Digit, out; end; Digit
::= O; do; Digit, out:=””;
Add end; Applying this revised set of rules to a pending input of 200 results in the output "
Two hundred 'and'' is obtained, and the error processing unit 5 asks for confirmation whether this is correct.The user notices that there is still an abnormality and adds two more rules.
its (pos=3) ::-100;do;
D 1g1ts, out:=″0(,6hundred
”;end;Digits (pos=3) ::
=Digit, 00; is added (updating the rule file). The error processing unit 5 applies a new set of rules to the pending input 200, and outputs "'two h
undreds" and asks for confirmation of correctness. If the user gives a correct answer, "two hundreds" is obtained.
ds" is registered in the verification file 7 as the output for 200. Also, the user thinks that there should be no similar error for inputs such as 20.30, and so the user registers 20 as an input example and its output " “twenty” is registered in the verification file (verification file update).

When the contents of the rule file 6 or the verification file 7 are updated, the control section 1 activates the rule verification section 4'. The rule verification section 4 includes a main part of a confirmation means, and this confirmation means is configured so that the control section 1 supports the rule verification section 4 by the rule application section 2 to confirm the result. ing. The rule verification unit 4 applies the rule group of the rule file to each input example of the verification file 7, and checks whether the output registered in the verification file is obtained.
Since no discrepancy occurs with the above updated contents, no warning is given to the user. When adding or modifying the contents of the rule file 6, if no errors are detected as a result of automatic verification by the rule verification unit 4, a message is displayed to the user stating that ``the updated rules do not contradict the verification input/output example.'' Do it automatically.

Next, if another user gives 0 as input, D 1g1
t:: = O;do; D 1g1t, out:=”
”;end; rule is selected and the output is blank. When the user notices the abnormality and gives an instruction that there is an error, the error processing unit 5 is activated and 0 is input as an example of the verification file. The process of applying the rules that led to the answer is displayed as shown in Figure 7.The user sees this and uses Digi.
Among the rules for t, I think that the rule for input O is wrong, so I write that rule as Digi t: : = 0 ;d
o; D 1 (Bit, out: = “zero”; en
Suppose you change it to dH. The error handler applies the rules to O as the pending input, and outputs "ze" as the output.
Get ro"". When the user gives an instruction that it is correct, 'zero' is registered in the verification file 7 as an output for 0 (verification file update).

Since the contents of the rule file and the verification file have been updated, the rule verification unit 4 is automatically started, but the output for input example 20 is "twenty zero", and the 8th Display as shown.

Then, the user realized that it would not work if the rules for D 1g1t for single-digit numbers and D 1g1t for numbers in multiple digits were the same, and Number::= p
os=L DigitO; doHNumbe'r, o
ut:=DigitO, out; end; D 1g1
t O: :=0;do; Digi to, out
:=″ze,ro”;end;DigitO::=D
igit; 'do; Digito, Out:=Di
git, outHend; and correct the rule (update the rule file). This means that Di for numbers in multiple digits.
git rules are applied, but for single digit numbers Di
This indicates that the gitO rule group is applied, and the DigitO rule group sets the output to zero when the input is O, but applies the D1g1t rule group for other inputs.

Since the rule file 6 has been updated, the rule verification unit 4 is started again, but for all the input examples registered in the verification file, the output at the time of rule verification and the output registered in the verification file are It is confirmed that there is no discrepancy between the two. FIG. 9 shows the resultant set of English reading conversion rules for numbers up to three digits created in this way, and FIG. 10 shows the result converted into an internal representation format. By comparing FIGS. 9 and 10 with FIGS. 3 and 4, added and modified parts will be apparent.

FIG. 11 is a diagram showing the configuration of an information processing device equipped with this embodiment. This is done by the control section 1 and the rule editing section 2. Rule application part 3. Rule verification section 4. A central processing unit 191 that executes the processing of the error processing unit 5, and a main storage device 192 used to store information in the process. It consists of an input/output terminal 193 that performs an output function.

FIG. 12 is a flowchart 1 showing the processing contents of the rule application section which is the core of the processing in this embodiment. Given a set of rules written in the form shown in FIG. 2, the process of applying these set of rules in the rule file will be described below. Among the input component names shown in the rule group, the component name (Number in FIG. 10) representing the entire input is first stacked into the stacker provided in the rule application section (step 201), and the first symbol of the input is stacked. (step 202).

Then, select the symbol at the top of the stacker (step 203), and select whether it represents an input symbol (in this example, a number) or the component name (Number,
Digit, Digits, etc.)), step 204), and the component name (for example, Num
ber), mark it as visited (Step 21OL). Stack the configuration pattern representing the lower configuration of that component, that is, the right side of the symbol UNI in FIG. Calculate the attributes to be passed (step 212). If the top symbol of the stacker is an input symbol, check whether it matches the current input entry (step 205), and if it does not match, perform error handling and step 209), and if they match, calculate the attributes of the input symbol (step 206), and then remove the input symbol from the stacker (step 20).
7), the next input symbol is taken out (step 208).

Next, if the top symbol of the stacker is the name of a component with a visited mark (step 213L, calculate its attributes, step 214), remove that component from the stacker (step 215).

This is repeated until the stacker is empty (step 216).
).

According to this embodiment, even if you do not create a complete set of rules assuming all cases, you can easily execute the process by creating a set of rules that correspond to input conditions within a known range, and cases that cannot be handled well. When a problem occurs, the rule group can be expanded accordingly, which has the effect of making it easy to refine and expand the information processing system step by step. In addition, each time a new rule or input example is registered, it automatically checks whether there are any inconsistencies in the rule group or the input side as a whole, and requests correction if there is an error, which improves the consistency of rule-based information processing systems. This has the effect of retaining and improving reliability. Inputs in which an abnormality has been detected are automatically subject to inspection when adding or modifying rules thereafter, which has the effect of preventing similar errors. When an abnormality is detected, the rule application process up to the point where an abnormal result is obtained is displayed, which has the effect of making it easier to correct the rule group so that the abnormality does not occur.

By specifying not only the syntactic pattern of the input but also its attributes, rules for processing input can change the processing method depending on what kind of input structure and under what conditions the input pattern is used. This has the effect of making it possible to specify context-sensitive processing that incorporates not only syntax but also semantic information. In addition, by treating a syntax element with an attribute or an attribute specification as the same as a single syntax element and performing pattern matching, context-dependent pattern matching can be achieved in the same way as syntax analysis.
This has the effect of simplifying the processing system for applying rules.

When specifying the attributes of a syntax element, it is necessary to specify only the attributes necessary for identifying each pattern for each pattern, rather than all the attributes that the syntax element has, which has the effect of avoiding unnecessary fragmentation of rules. .

〔Effect of the invention〕

As described in detail above, according to the rule verification type information processing system of the present invention, in addition to the rule file, there is provided a verification file that stores pairs of various typical input examples and their corresponding outputs. means for updating one or both of the verification files, and applying a rule group of the rule file to each of the input examples stored in the verification file at the time of updating and comparing with the corresponding output stored in the verification file; However, we have provided a means to detect and confirm inconsistencies, so you can execute processing by creating a rule group that corresponds to a known range of input conditions, without having to create a complete rule group from the beginning, and you can eliminate nonconforming examples. If errors occur, the rule group is updated (added/enhanced), and the updated rule group and input examples are automatically checked for consistency as a whole, and if errors are found, corrections are prompted to make the process more comprehensive. It has excellent effects, such as encouraging the rewriting of rule groups while maintaining consistency, allowing the creation of a more thorough, highly accurate, and wide-ranging system.

[Brief explanation of the drawing]

FIG. 1 is a block diagram of an embodiment of the rule verification type information processing system of the present invention, FIG. 2 is a diagram showing the expression format of rules applied to the embodiment of FIG. 1, and FIG. A diagram showing a group of English reading rules for numbers as an example of a group of rules written according to the rules of
Figure 4 is a diagram showing an example of internal representation of the rule group in Figure 3, Figure 5 is a diagram showing an example of the contents of a verification file, and Figure 6 is a diagram showing an example of a warning for mismatch between the rule group and input. , Figure 7 shows an example of displaying the rule application history, Figure 8 shows an example of defect detection based on the verification file, and Figure 9 shows the revised rule group for the third rule group. 10 is a diagram showing an example of internal representation in FIG. 9, FIG. 11 is a block diagram of a computer system equipped with the rule verification type information processing system of the present invention, and FIG. 12 is a flowchart of the rule application section. . 1-----1 control section, 2-1--rule editing section, 3.--rule application section, 4-----1 rule verification section, 5
---1--Error processing unit, 6-----Rules file, 7
------Verification file, 11-----Revision of rules manually, 12-----1 Verification input/output example, 13-----
--- Input for execution, 14 --- One output result, 15 ---
---Error display, 16-----Prompt for correction, 17--
----- History display, 31-35-1 ----- Rules for reading numbers in English, 51, 53. 55. 57.
59----One component and its rule group, 52, 54
, 56, 58, 60, 62゜64-11---Connection showing applicable rules for manual case classification, 61. 63.
65. 66. ----One predefined component, 71~
78.81~811--Formula showing action sentence accompanying rule application, 191--Central processing unit, 192
-----One main storage device, 193---One output terminal. Agent: Patent attorney Kenjibu Take (1 other person) (Figure 1, No. 2)

Claims (1)

[Claims] 1. Rule verification type information processing that includes a rule file that stores a group of rules for data processing, and a rule application unit that searches the rule file for a rule that matches a given input and processes the input. In the system, a verification file storing pairs of various typical input examples and their corresponding outputs; updating means for updating either or both of the rule file and the verification file; and confirmation means for applying a rule group of the rule file to each input example stored in the verification file and comparing it with a corresponding output stored in the verification file to detect a discrepancy. A rule verification type information processing system characterized by: 2. When an input that does not conform to the rule group of the rule file is given, means for notifying the mismatch between the rule file and the input that does not conform, and means for storing the input that does not conform to the verification file. 2. The rule verification type information processing system according to claim 1, wherein the rule verification type information processing system is configured to prompt revision of the rule file. 3. A rule group of the rule file, an input example of a verification file to which the rule group is applied, and when the expected result is not obtained for the given input, until the result is obtained, or, Claim 1 or 2 characterized by comprising means for displaying the rule application process until the application of the rule is stopped.
The described rule verification type information processing system. 4. Each rule stored in the rule file includes a rule application condition based on a pattern description of a component with attribute specification;
4. The rule verification type information processing system according to claim 3, wherein the rule verification type information processing system is configured to be specified by a combination of data processing operations when rules are applied. 5. When specifying the rule application conditions of the rule file,
Attribute specifications of syntax elements are limited to those directly related to the selection of the rule, and the attribute specifications are treated as objects for pattern matching in the same manner as syntax element specifications. 5. The rule verification type information processing system according to claim 4.