JPH03269631A - Constitution processing system for rule base system - Google Patents

Abstract

PURPOSE:To facilitate a large scale and the maintenance of a rule base by providing a knowledge source list and a main function name designating part in a control block when the source of the rule base is once translated by a rule base compiler. CONSTITUTION:A control block 2 is previously provided with a knowledge source list 6, and this list 6 is translated by a rule base compiler. Thus a knowledge list can be produced for an inference engine and a rule base source 1 can be turned into plural files. At the same time, a main function name pointing the source 1 is stored in the block 2 and therefore an object program can be produced and a base system is constituted with inference engine. Furthermore a priority table 9 is contained in a knowledge source block 4, and the priority of rules can be changed just with the change of the table 9 only and without changing the bases, i.e., the rules 10 and 11 and the parts adjacent to these rules. A procedure evaluation part 13 is also provided for optimization of the processing.

Description

[Detailed Description of the Invention] [Summary] This invention relates to a configuration processing method for a rule-based system in which a rule-based source is once translated by a rule-based compiler.

The purpose is to increase the scale and facilitate maintenance.

It is constructed by combining and editing a rule base source written in a predetermined rule description language with a rule base compiler and a program in a predetermined language generated by the compiler, and an inference engine in the predetermined language using a linker. In a rule-based system, the rule-based source is composed of a control block and a plurality of knowledge source blocks, and a list of the plurality of knowledge source blocks included in the rule-based source is written in advance in the control block. A knowledge source list for the inference engine is generated by providing a knowledge TaS list consisting of a knowledge vhfl list and having the rule base compiler and the compiler translate the knowledge vhfl list.

(Industrial Application Field) The present invention relates to a rule-based system configuration processing method, and more particularly to a rule-based system configuration processing method using a method in which a rule-base source is once translated by a rule-base compiler.

A rule-based (or production) system is one of the means for realizing an expert system, and the knowledge in the expert system is separated from the program and stored as rules in a rule base, and these are sequentially called and executed from an inference engine to solve problems. It is something to be solved.

[Conventional technology]

Rule-based systems have been difficult to process using conventional algorithm-based general-purpose programming languages. A program that changes the system by trial and error,
It is widely used in programs that solve problems. Initially, rule-based systems were constructed as systems based on a symbolic processing language using the powerful interpreter of LISP, since it was not easy to write rules in a special grammar suitable for the rules and process them with a compiler language. was.

However, when using an interpreted language such as LISP, the processing speed is slow and the amount of memory used is large, making it impossible to construct a large-scale system. For this reason, a rule-based system using a compiler language was developed.

In such a rule-based system, the source of the rule-based system is written in a rule description language suitable for writing rules. - On the other hand, the inference engine is 9
For example, it is written in a compiler language such as C language. A rule-based source.

- Then, a rule-based compiler translates it into a base language, that is, C language in this case, to generate a source program. A rule-based system is constructed by translating this source program and an inference engine using a compiler and combining and editing them.

[Problem to be solved by the invention]

In the configuration of traditional rule-based systems.

There are problems as follows.

In traditional rule-based description methods, control information such as a list of knowledge sources required by an inference engine is required.

Since the entire rule base source is searched for when translating it, it was necessary to make the rule base source a single file. For this reason, it is difficult to translate a large-scale rule base that exceeds tens of thousands of lines and to maintain the rule base.

In addition, in systems whose purpose is to process large problems such as electronic circuit synthesis, rather than making the entire system rule-based, a rule-based processing method is adopted only for the parts that are suitable for the purpose, and other parts are processed faster by algorithms. In order to improve the performance of the entire system, it is necessary to improve the performance of the entire system. However, in conventional rule-based systems, this is difficult to achieve because the rule base itself is the main program of the system.

9 For example, when performing optimization processing on an electronic circuit at the base of the circuit, there are conflicting conditions such as the designer's desire to minimize the scale of the circuit and the desire to minimize the circuit delay time. There are some cases that must be met. However, due to the arrangement of rules within traditional rule-based knowledge sources,
Since the priority order is fixed, it is not possible to create a knowledge source that satisfies these two requirements at the same time.

Additionally, rule-based rules are generally in the form of "if...then...". On the other hand9, for example, when multiple m rules are established out of n rules, such as minimization of electronic circuits, it is better to select the most effective rule among them to improve the quality of the generated circuit. You can improve. However, the general form of the rule described above cannot satisfy this requirement.

SUMMARY OF THE INVENTION An object of the present invention is to provide a rule-based system configuration processing method that enables scale-up and easy maintenance.

Another object of the present invention is to provide a rule-based system configuration processing method that makes it possible to call a rule-based system as a subprogram.

Another object of the present invention is to provide a rule-based system configuration processing method that makes it possible to create knowledge sources that meet various requirements.

[Means to solve the problem]

FIG. 1 is a diagram showing the principle configuration of the present invention.

In FIG. 1, 1 is a rule-based source 2 is a control block, and 3 and 4 are knowledge source blocks.

5 is a main function name specification section, and 6 is a knowledge source list.

7 is a priority control section, 8 is a size specification section, 9 is a priority table, 10 and 11 are rules, 12 is a procedure selection section, 1
3 is a procedure evaluation section.

Is rule-based source 1 one system? I Flori 2
and one or more knowledge blocks 3 and 4.

The control block 2 is a knowledge source list list that describes a list of one or more knowledge source blocks 3 and 4 included in the source l of the rule base.

a main function name specifying section 5 that stores a main function name pointing to the source 1 of the rule base (corresponding to 1:l);
Prepare in advance.

Knowledge source blocks 3 and 4 are composed of (1) or a plurality of rules. Multiple rules are arranged in order of priority.

The knowledge source blocks 3 and 4 (for example 4) are provided with a priority order table 9 as required. The priority order table 9 describes the priority order of a plurality of rules independently of the priority order determined by the order in which they are arranged. That is, the priority order based on the array is changed.

One rule (e.g. 11) as needed.

Consists of multiple detailed rules. Furthermore, when including a plurality of detailed rules, rule 11 may include, as necessary,
It includes a procedure evaluation section 13 for evaluating detailed rules and a procedure selection section 12 for selecting one detailed rule.

[For production]

Since the control block 2 is provided with a knowledge source list list in advance, the rule base compiler (and compiler) can translate this to produce a knowledge source list for the inference engine. Therefore, the rule base compiler does not need to search the rule base source l and create the list 6 when translating a. This allows the rule base source 1 to be made up of multiple files, making it possible to increase the scale of the rule base and facilitate maintenance.

Also, since the control block 2 stores the main function name pointing to the source 1 of the rule base.

The rule base source corresponding to the main function name specified from the upper system side is translated by the rule base compiler (and the compiler) to create an object program, and this and the inference engine can configure the rule base system. can. That is, since one rule-based system can be called as a subsystem by the main function name, it is possible to make a rule-based system part of one large [I system] or to create a system that integrates five to three [number of rule-based systems]. It becomes possible to configure.

Also, since the knowledge source block (for example 4) is equipped with the priority table 9, the rule base (rule 10.11
The priority order of the rules can be changed only by changing the priority order table 9 without changing the rules (and the sequence thereof). That is,
The rule-based compiler evaluates rule 10.11 according to the description in priority table 9. This allows the order of evaluation of rules to be easily changed, making it possible to perform optimization processing even for problems in which various conditions are set.

In addition, the rule 11 is a plurality of detailed rules, the procedure evaluation unit 1
3 and a procedure selection unit 12, the rule base compiler translates the rule 11, the two procedure evaluation units 13 evaluate each detailed rule, and based on this, the procedure selection unit 12 You can select two advanced rules.

Therefore? The optimal one for solving one problem can be selected from among the detailed rules of the number j[, based on the evaluation, and optimization processing becomes possible.

〔Example〕

FIG. 1 will be further explained.

FIG. 1 shows the structure of a rule-based source l. The rule base source 1 is written in a rule description language suitable for writing rules.

Control block 2 describes control information for procedures such as initialization and termination of the rule-based system. Control block 2 is provided at the beginning of rule-based source 1,
A main function name designation section 5 and a knowledge source list list are provided as one of the control information.

A plurality of knowledge source blocks 3 and 4 are provided within the rule-based source l. Hereinafter, a block including the priority table 9, a procedure selection unit 121, and a procedure evaluation unit 13 will be referred to as a knowledge source block 4, and a block without such a block will be referred to as a knowledge source block 3.

In the knowledge source block 4, the priority table 9 is provided in the priority control unit 7 together with the size designation unit 8. The priority control unit 7 stores information for controlling the priority order of evaluation of rules in the knowledge source block 4, and is provided at the head of the knowledge source block 4 for this purpose. The size specifying unit 8 has a function of specifying the table size of the priority table 9. By changing the table size using the size specifying unit 8, the description in the priority order table 9 can be changed, and the priority order of rules can be changed without substantially changing the priority order table 9 or the rule base.

A plurality of rules 10 and 11 are provided in the knowledge source block 4 (and 3). below,? Rules that include detailed rules for numbers are designated as rule 11, and rules that do not include rules are designated as rules 10.

In rule 11, each of the detailed rules (cases) that are grouped together is a rule that is evaluated using the same scale and whose evaluation can be expressed numerically. That is, the procedure evaluation section 13 obtains numerical evaluations from the evaluation results for each of them.

Based on this, the procedure selection unit 12 selects the optimal one.

For example, select the detailed rule with the maximum (minimum) evaluation value.

Note that the priority control unit 7 and the rules 11 do not need to exist in the same knowledge source block 4.

FIG. 2 is an explanatory diagram of the rule-based system configuration process.

In Figure 2, 15 is a rule-based compiler, 16
is the source program, and 17 is the compiler.

18 is an object program, 19 is an inference engine,
20 is a linker, and 21 is a load module.

A predetermined rule description language (e.g. Li5p, Prolo
A rule base source 1 written in a computer program (e.g., g, etc.) is first translated into a source program 16 in a predetermined language by a rule base compiler 15. This language is the language in which the inference engine 19 is written, and is usually a compiler language, such as the C language.

This source program 16 is translated by a compiler 17 to generate a rule-based object program 18.

And the inference engine (object program) 1
9 and the rule-based object program 18 by the linker 20, a load module (executable program) of the rule-based system is created.
21 is generated.

Since the rule base source 1 has the configuration shown in FIG. 1, the rule base compiler 15 converts the knowledge source list (description in the source program 16) for the inference engine into the knowledge source list list when translating the rule base source 1. Generate from. Also.

The main function name held in the main function name designation section 5 is used as the name of the source program 16 (that is, the main program of the rule base). That is, a function with the specified name is generated.

Also, when the load module 21 is executed.

The inference engine 19 orders rules 1 in order in the priority table 9 according to the configuration of the rule base source l.
0.11 etc., execute and evaluate. Also, according to the evaluation of rule 11, the optimal procedure (detailed rule) is selected.

Next, details of the configuration of the rule-based source 1 will be explained using FIGS. 3 to 6.

Figure 3 shows the rule-based source countries.

FIG. 3 shows the structure of the rule-based source 1, and shows the structure corresponding to FIG. 1 as a description in an actual rule description language.

In the figure, r$cONTROL'' indicates the start of control block 2 (and essentially the source 1), and r$cONTROL''
END-CONTROL indicates the end of control block 2.

Next to r$cONTROL, a main function name designation section 5 is provided as 'func nowbe', and an appropriate function name is written from outside.

Also, as control information, the function name rinit that should be called for initial settings when the rule base is started.
'func', the name of the function to be called to check the termination condition of inference by the inference engine 'term f
unc", "rpost func", the name of the function to be called for post-processing when the rule base ends.

Function name for event selection reventselector
J is provided.

Further, after r$KsLIsT, a knowledge source list list is provided such as rksname-L ksname-2+ -. rksname-1" indicates the name of one knowledge source 1, for example, the knowledge source block 3.

r$KS and r$END-KSJ, respectively.

0, e.g. r, indicating the start and end of knowledge source blocks 3 and 4
$K S ksnaa+e-I J is knowledge source block 0
For example, 1 shows the beginning of 7 and 3 and the definition of its name.

r$RULE1” indicates the start of rule 1, “$END
-RULEJ indicates the end of the array of rules.

Knowledge source block 3 is based on rule 1. Rule 2. ..., etc., and its selection strategy is designated as rS IN (1; LJ. rsINGLJ indicates that only the procedure part (THEN part) of the rule that is established first is executed.

Therefore, knowledge! Ik? l [In block 3, the first rule in the array is evaluated in order.

That is, the arrangement of rules has a meaning as a priority order.

In the first rule, "r$IF; Condition 11" says, "If condition 11 is met, execute 1 procedure division."
This is established as a rule.

Here, the description rP in the procedure division (THEN division)
ROPO3EJ indicates issuance of an event.

The event is rPROPO5E (“ksname-2
For the 0 issued event, which is to trigger a knowledge source block, in this case knowledge source block 4, following the data indicated by XXXX, in a queue called the event queue, The name of the knowledge source block to be activated and the pointer (xxxx) to the data to which the knowledge source block is applied are registered. The registered event is selected by the event selection function (eventselect) defined in control block 2.

r) is selected after the processing of the currently executing knowledge source block is completed, and thereby a new knowledge source block is activated. Inference in a rule-based system refers to this repetition, and the inference engine section controls this.

Knowledge source block 4 has its name r ksname-2
), and its selection strategy is rMULTI.

Including rules 10 and 11, the priority control unit 7
It is provided as PRI O(size, table) J.

rMULTIJ executes the procedure parts of all established rules.

The priority control unit rPRIOJ specifies a variable name indicating the priority table 9 that stores the priority order of rules as rtable J, and a variable name that stores the size thereof as ``rsize''. Priority control unit' PRI O(size.

Table) Due to the description of J, the priority order of the rules in the rule 11 is controlled from the outside.

That is, "rsize" and rtable J can be specified from the outside. Therefore, "raize" corresponds to the size specification section 8, and rtable J corresponds to the priority order table 9, but in reality, only variable names are stored in the priority control section 7.

FIG. 4 shows an example of the priority order table 9. When n rules exist in the corresponding knowledge source block, the rule numbers of the rules from priority order 1 to n are stored in that order. Therefore, the rules are executed and evaluated in accordance with the order in the table 9, irrespective of the arrangement order of the rules in the knowledge source block, that is, the order of priority according to the arrangement is changed. Here, if we reduce '5ize' from 'n' to e.g. 'n-1', the one rule with the lowest priority will be masked (to the inference engine) and its evaluation will not take place. That is, it is possible to substantially delete the rule without changing the knowledge source block.

For example, in a 9-circuit integration system, this process creates a common rule base for circuit technologies such as 0M03 circuits and ELC circuits, and some rules are used in CMOS circuits but not in ECL circuits. It is valid. Note 9: If this is not possible, use the ECL circuit and CM
Rules for OS circuits must be created separately, and similar knowledge sources must be created for each technology. Therefore.

This process is very effective in streamlining development by unifying the rule base.

Note that the order of masking may be from the higher priority side.

Rule 11 has a different configuration from rule 10, which has a configuration of "r$IF...$T)(EN...". As a premise, rule 11 is configured by combining multiple detailed rules (cases), A configuration is adopted in which one of the most suitable detailed rules is executed.

r$5ELEcT'' and r$END-3ELECTJ indicate the start and end of the 1-procedure selection section 12, respectively. “$EvAL” and r$END-EVALJ indicate the start and end of one procedure evaluation unit 13, respectively.

r$CASEJ and r$END-CASE each indicate the start and end of one detailed rule (case).

rMAX2J indicates that the one with the maximum evaluation value (rMAXJ) is executed among the "two" cases.
If it is rMiNJ, the one with the smallest evaluation value is executed.

The evaluation values for the procedure divisions of CASEl and 2 are given to each rvar J and compared to 0 e.g. CASE
When the evaluation value of I is the maximum, the $WHENI procedure is executed. At this time, if the evaluation value is other than that, the procedure division cannot be executed. If all evaluation values are "0", no procedure division is executed and that rule is not executed. At this time, if the rule selection strategy of the knowledge source block to which the rule belongs is S I NGL, 1
When the next rule is evaluated and one procedure is executed, the execution of that knowledge source block ends.

Such rule processing is effective for, for example, a rule for compressing the gate of an electronic circuit as shown in FIG. That is, it is assumed that the detailed rules (cases) shown in FIGS. 5(A) and 5(B) are applied to the compression of the gate shown in FIG. 5(C).

In this case, both cases 1 and 2 hold, but applying case 2 increases the number of inverters that can be deleted by one. This may be reversed if the circuit to which it is applied changes. Therefore, in such a case, r$IF...$
Optimization is not possible depending on the configuration of "THEN...".

Therefore, the two detailed rules shown in FIGS. 5(A) and 5(B) are combined into one rule as shown in FIG. 6. Note that this rule corresponds to rule 11 of knowledge source block 4 in FIG. 3. If you do this,
After actually evaluating two detailed rules, the optimal detailed rule can be selected based on the results.

Regarding rule base source 1 with the above configuration.

A rule base compiler 15 translates and generates a source program 16. This generation will be explained according to FIGS. 7 to 11.

FIG. 7 shows the flow of translation processing of the control block 2 by the rule base compiler 15. That is, r
$cCONTROL” or “$END-CONTROL”
From the sentence J, r$cONTROL func na
Generates a function (program) with the main function name specified by "me".

■ Variable INITIALIZOR, TERMINATO
R, PO5T PROCESSOR, EVENTSELE
CTOR to '$INTT' in control block 2.
1nit func”, r$TERMterm f
urlc”, r$PO3T post fun
c”.

r$EVENT 5ELECT eventsel
This is the address of the function specified by ector J.

■ r $ K S L I S T
A KS table is created from the KS (knowledge source block) name specified by ksna+5e-1 and ksnawe-2-J and the corresponding function address. This KS table is essential for the inference engine 19 to process events.

■ Call the inference engine 19.

FIG. 8 shows the structure of the KS table.

A pointer to the first KS table is stored in the variable KSLIST. Furthermore, each KS table consists of a pointer to the primary table, the name of the KS in the KS table, and the address of the function (program) corresponding to the KS.

This KS table can be generated by the description of ``$KSLISTJ'' in control block 2 without searching the source 1 of the rule base.

Further, function names for initialization and termination processing are also written in the control block 2.

All the information necessary to generate the main program that operates the rule base in this way can be found in the $C0NTR0L
~ By organizing the programs into $END-CONTROLJ, it is possible to eliminate the need to search for rule-based source files that were necessary to generate the main program. As a result,
Since knowledge and sources may be described in separate files, it is possible to construct a large-scale rule-based system.

Further, the main program can be given a name designated by the main function name designation section 5. Therefore, the rule base system operated by this main program can be called as one subprogram.

911-III2 illustrate the translation of the knowledge source block (KS) 3.4 by the rule-based compiler 15. That is, one function (program) is generated for each knowledge source block 3.4 r$KS and Lr$ENDKSJ. This function name is equal to the name of the knowledge source block. In the knowledge source block, different procedure functions are generated depending on the rule selection strategy and whether or not the priority order of the rules is specified.

In FIG. 9, the selection strategy 9 is rSINGL, and the priority control unit 7
This example shows the case where there is no priority order control.

In this case, since there is no priority control, the arrangement order of rules in the knowledge source block 3.4 is 1, for example, rule 1.
Rule 2. ...In the order of rule n, whether or not the conditions of the rules are met is evaluated. and.

Since the selection strategy is rs and INGLJ, when one rule is established, a function is generated to execute the procedure of that rule, and the processing for that knowledge source block is completed.

FIG. 10 shows a case where the 1 selection strategy is rMULTIJ and there is no priority order control by the priority control unit 7.

In this case, the evaluation layer of the rules is the same as in FIG. Since the 1-selection strategy is rM (JLTr), a function is generated that repeatedly evaluates all rules and executes the procedure for all rules that satisfy tc.

FIG. 11 shows a case where the 1 selection strategy is rsINGLJ and the priority order is controlled by the priority control unit 7.

■ Clear control variable i.

(2) After counting up i by +1, compare it with the table size '5ize' specified by the size specifying section 8.

If i >'5ize', the process ends even if rules remain. As a result, the remaining rules cannot be known from the inference engine 19.

■ If it is not "i >rsize", check which rule has the i-th order in the priority table 9,
Evaluate the applicable rules.

If the evaluated rule holds true, the first selection strategy is rsING.
Since L, a function that executes the procedure of the rule is generated and the process ends.

If the evaluated rule does not hold, repeat the following process.

FIG. 12 shows a case where the 3 selection strategy is "rMULTI" and the priority order is controlled by the priority control section 7.

Processes (1) and (2) are performed in the same manner as in the case of FIG.

Since the 2-selection strategy in process (2) is rMULTI, all rules in the case where i > rsrze4 are not satisfied are also evaluated, and a function is generated to execute the procedure of the rule that holds true.

Regarding the source program 16 obtained as above,
The inference engine 19 performs inference, which will be explained with reference to FIGS. 13 and 14.

FIG. 13 shows the flow of inference processing performed by the inference engine 19.

■ After performing initialization processing such as emptying the event key, the variable INITIAL I of the source program 16 is
This function, which calls the function at the address stored in ZEH, stores the name of the knowledge source block 3 to be executed first, and returns this to the inference engine 19.

■ Search the KS table by the name of the knowledge source block 30, find the address of the corresponding number, and call the function (corresponding to starting the knowledge source);
The knowledge source block 3 is the one that is executed first and issues an event, ie.

A knowledge source containing rPROPO3EJ.

The called function (knowledge source block or program) executes the process according to its description, and processes rPROPOs.
An event is registered in the event queue by EJ.

Here, the structure of the event queue is shown in FIG. 14, and the address of the first event table is stored in the variable EVENTLIST. Furthermore, each event table stores a pointer (address) of the 9th order table, the name of the knowledge to be executed (S<block), and data serving as an argument.

■ Check whether there is an event in the event queue.

If it is empty, predetermined termination processing is performed.

■ If it is not empty, call the function whose address is stored in the variable TERMINATOR.

The called function checks whether inference should be terminated according to its description.

If it should be terminated, predetermined termination processing is performed.

■ If the end is not completed, the variable EVENTSELECTOR
Calls the function stored in , which retrieves the next event to be processed from the event queue.

(2) Search the KS table using the name of the source of the knowledge 11 to be executed stored in the event table of the event to find the address of the function corresponding to the knowledge #i source to be activated. Then, the function is called and executed using the data stored in the event table as an argument.

Thereafter, processes ① to ② are repeated until the event queue is empty or until it is determined that the inference has ended.

■ To end the process, set the variable POSTPROCESS
The function stored in OR is called, finalization processing is performed, and inference is ended.

〔Effect of the invention〕

As explained above, according to the present invention, in the rule-base system configuration process in which the rule-base source is once translated by the rule-base compiler, by providing the knowledge source list and the main function name specification section in the control block, .

Rule bases can be made larger and easier to maintain, and can be called based on the rule base. Also, Chii! By providing a priority control section in i'FA (block). You can change the valuation amount of a rule without changing the rule base. Optimization processing becomes possible. Furthermore, by providing a procedure selection section and a procedure evaluation section in the rule, it is possible to evaluate the rule and then select the optimal rule based on the result, thereby enabling optimization processing.

[Brief explanation of drawings]

FIG. 1 is a diagram showing the principle configuration of the present invention. FIG. 2 is an explanatory diagram of the rule-based system configuration process. Figure 3 is a rule-based source configuration diagram. FIG. 4 is a diagram showing an example of a priority order table. FIG. 5 is a diagram showing an example of rule optimization. FIG. 6 shows the configuration of rules suitable for optimization. FIG. 7 shows the flow of translation processing. FIG. 8 shows the configuration of the KS table. 9 to 12 are diagrams showing the flow of translation processing. FIG. 13 is a diagram showing the inference processing flow. FIG. 14 is a diagram showing the configuration of an event queue. 1 is the rule-based source, 2 is the control block. 3 and 4 are the knowledge vh'rA blocks, and 5 is the main function name specification section. 6 is a knowledge source list list, 7 is a priority control section 8 is a size specification section. 9 is a priority table, 10 and 11 are rules, 12 is a procedure selection section, and 13 is a procedure evaluation section.

Claims (4)

[Claims] (1) A program (18) in a predetermined language generated by translating a rule base source (1) written in a predetermined rule description language using a rule base compiler (15) and a compiler (17); In a rule base system configured by combining and editing an inference engine (19) in a language using a linker (20), the rule base source (1) is connected to a control block (2).
and a plurality of knowledge source blocks (3, 4), and the control block (2) includes the plurality of knowledge source blocks (3, 4) included in the rule-based source (1) in advance.
4), a knowledge source list list (6) is provided, which includes the list of the rule base compiler (15) and the compiler (
17) generates a knowledge source list for the inference engine (19) by translating the knowledge source list (6). (2) A program (18) in a predetermined language generated by translating a rule base source (1) written in a predetermined rule description language using a rule base compiler (15) and a compiler (17); In a rule base system configured by combining and editing an inference engine (19) in a language using a linker (20), the rule base source (1) is connected to a control block (2).
and knowledge source blocks (3, 4), and the control block (2) is provided with a main function name specification section (5) that stores a main function name pointing to the source (1) of the rule base. A rule-based system configuration, characterized in that a rule-based system is configured by a program (18) generated from the rule-based source (1) corresponding to the main function name, and the inference engine (19). Processing method. (3) A program (18) in a predetermined language generated by translating a rule base source (1) written in a predetermined rule description language using a rule base compiler (15) and a compiler (17); In a rule base system configured by combining and editing an inference engine (19) in a language using a linker (20), the rule base source (1) is connected to a control block (2).
and a knowledge source block (4), the knowledge source block (4) is configured by arranging a plurality of rules (10, 11) in their priority order, and the knowledge source block (3, 4) is configured by arranging a plurality of rules (10, 11) in priority order.
) is a priority order table (
9), and the rule base compiler (15) compiles the rules (10,
11) A configuration processing method for a rule-based system characterized by evaluating. (4) A program (18) in a predetermined language generated by translating a rule base source (1) written in a predetermined rule description language using a rule base compiler (15) and a compiler (17); In a rule base system configured by combining and editing an inference engine (19) in a language using a linker (20), the rule base source (1) is connected to a control block (2).
and a knowledge source block (4) including at least one rule (11), the rule (11) is configured by a plurality of detailed rules, and the detailed rule is evaluated within the rule (11). a procedure evaluation unit (13) for selecting one detailed rule according to the evaluation, and a procedure selection unit (12) for selecting one detailed rule according to the evaluation, and the rule base compiler (15)
11), the procedure evaluation unit (13) is translated.
), and the procedure selection unit (12) selects one detailed rule.