KR101354978B1 - Rule-based Inference Engine with Temporal Reasoning - Google Patents

Abstract

Disclosed are a rule-based reasoning system and method that takes time representation into account. An inference system according to an embodiment of the present invention includes a user interface, a parser, a working memory, a rule base, and an inference engine. Information required for inference is entered into the user interface. The parser analyzes and outputs the input information. The working memory stores facts of the above information. The rule base stores the rules of the above information. The inference engine sends the facts and the rules of the information to the working memory and the rule base, respectively, and uses the rules stored in the information and facts stored in the working memory and the rules based on the rules. Infer whether they are satisfied. The facts then include time facts, and the inference engine further uses the time facts to infer whether the rules are satisfied. Inference system can provide time inference through time index and network, and can use intenet network to speed up inference, so that reasoning can be made suitable for ubiquitous environment, and it can be used for various applications to improve the performance of the whole system. There is an advantage.

Description

Rule-based Inference Engine with Temporal Reasoning}

BRIEF DESCRIPTION OF THE DRAWINGS A brief description of each drawing is provided to more fully understand the drawings recited in the description of the invention.

1 is a diagram illustrating a result of configuring a Rete network using a generation rule in OPS5.

2 is a diagram representing seven time relationships on the time axis.

FIG. 3 is a diagram for describing a process of making inference using the time relationships of FIG. 2.

4 is a block diagram of an inference system according to an embodiment of the present invention.

FIG. 5 is a diagram for explaining inferences about a time relationship that occurs when two time relationships exist between three nodes.

FIELD OF THE INVENTION The present invention relates to inference engines, and more particularly to rule-based reasoning systems and methods that take time representation into account.

BACKGROUND ART [0002] Ubiquitous computing is rapidly emerging as a result of the rapid development of electronic communication technology. In such ubiquitous computing, services such as well-being care, medical, and the like are considered important, and in order for these services to be intelligently provided, user needs must be deduced.

In a ubiquitous environment, a system for recognizing and reasoning about a given situation is essential to provide a service suited to the needs of the user. Such cognition and reasoning are the basis for intelligently providing services such as efficient operation and communication of devices in the ubiquitous space as well as coping with urgent situations such as emergence of emergency patients.

Reasoning for intelligent service delivery is based on user profiles and contextual information, and can sometimes take a lot of time. For example, medical services are urgently needed to provide services through fast reasoning, as time-consuming events can occur, such as car accidents, heart attacks, and shock conditions caused by a lack of blood sugar in diabetics. Furthermore, these time-quarning tasks should be useful not only for quick reasoning, but also for the representation of time about some knowledge.

Rule-based systems and time inference are used as important factors to enable these services. Rule-based systems derive new facts defined by rules by representing facts with predefined production rules and actual phenomena as facts, and comparing facts with the conditions of predefined rules. Or applications using the system take arbitrary actions based on this result.

On the other hand, such a rule-based system is mainly used for building expert systems, and it is a forward inference system. An expert system is a computer program that mimics an expert's problem-solving process that solves problems that occur within a specific field of scope. In other words, the expert system is a computer advisory system in which experts in a specific field collect and organize expertises, and use a computer's reasoning ability to solve a problem related to a given specific area of expertise.

Such rule-based systems are used in many fields, such as making automated decisions in intelligent agent systems, or planning a set of services to achieve goals by inferring human needs in ubiquitous computing.

On the other hand, knowledge including time is required for time inference. In general, time is one of the most important factors in knowledge expression, because an event can be defined as a change of state with changes in time and space. In other words, since the aspect of a fact may change with time, it is necessary to discuss the expression of time and reasoning.

The most time consuming part of inference in rule-based systems is the comparison of facts and rules, and as the number of facts and rules increases, the length of time decreases reasoning efficiency. In other words, the most computing time required in a rule-based system is a matching part of a working memory and a rule base. The working memory is a space for storing facts, declarations that represent facts, and the rulebase is a space for storing rules, knowledge of how to deal with facts.

In order to shorten the comparison time, an algorithm called Rete network has been proposed, and the time required to match the working memory with the rule base is reduced by the Rete network. The Late network shortens the matching time by organizing all the rules existing in the system into the network and remembering the facts satisfying the nodes present in the network.

To define facts, rules, and time expressions, on the other hand, you need a clear grammar that can represent the environment your system is in charge of and an easy-to-use language. For this purpose, the JRM system defines and uses a language that can make forward inference. In addition to defining the basic facts and rules, the language provides features for indexes and time relationships between facts, function definitions, file-related operations, and so on.

One way to express time is to infer the context between different events using an index of time and to infer time relationships that do not exist through time relationships between events.

However, there is a problem in that an index is used to search all indexes every time an index is added. Also, there is a problem that the method using the time relation between events can not know the exact time.

Therefore, by using both methods, it is necessary to compensate for the shortcomings of each method by inferring the correct time using the index and inferring the time relationship through the network.

An object of the present invention is to provide a rule-based reasoning system in consideration of time representation.

Another technical problem to be achieved by the present invention is to provide a rule-based reasoning method in consideration of the time representation.

An inference system according to an embodiment of the present invention for achieving the above technical problem includes a user interface, a parser, a working memory, a rule base, and an inference engine. Information required for inference is entered into the user interface. The parser analyzes and outputs the input information. The working memory stores facts of the above information. The rule base stores the rules of the above information. The inference engine sends the facts and the rules of the information to the working memory and the rule base, respectively, and uses the rules stored in the information and facts stored in the working memory and the rules based on the rules. Infer whether they are satisfied. The facts then include time facts, and the inference engine further uses the time facts to infer whether the rules are satisfied.

Meanwhile, the information may further include variables and functions.

The reasoning engine also includes a time network and a rete network. A time network uses the time facts to infer the time relationship of the facts. The Late network infers whether the rules are satisfied using the facts stored in the working memory, the rules stored in the rule base, the input information, and the inferred time relationship.

In this case, the time facts preferably include a time point and a time relationship.

On the other hand, when the rules are satisfied, the inference engine outputs the results from the satisfied rules as a collision set.

At this time, the inference system according to the embodiment of the present invention receives the conflict set, determines the priority of the received conflict set based on the degree or order of detail of the rules, and outputs the results according to the determined priority. It may further include an agenda.

The inference system according to an embodiment of the present invention may further include an execution engine that receives the output results according to the priority and executes the received results.

Inference method according to an embodiment of the present invention for achieving the other technical problem, the step of inputting the information required for inference, the fact (fact) of the information and the step of storing the information, the information and the stored Inferring whether the rules are satisfied using facts and rules, and inferring further infers whether the rules are satisfied using further time facts included in the facts.

The inferring may also include inferring a time relationship of the facts using the time facts, and the facts stored in the working memory, the rules stored in the rule base, the input information, and the inferred. Inferring whether the rules are satisfied using a temporal relationship.

In addition, the inferring may further include outputting results from the satisfied rules as a collision set when the rules are satisfied.

At this time, the inference method according to an embodiment of the present invention receives the conflict set, determining a priority for the received conflict set based on the degree or order of detail of the rules, and according to the determined priority The method may further include outputting the results.

In addition, the inference method according to the embodiment of the present invention may further include receiving the output results according to the priority and executing the received results.

In order to fully understand the present invention, operational advantages of the present invention, and objects achieved by the practice of the present invention, reference should be made to the accompanying drawings and the accompanying drawings which illustrate preferred embodiments of the present invention.

BEST MODE FOR CARRYING OUT THE INVENTION Hereinafter, the present invention will be described in detail with reference to the preferred embodiments of the present invention with reference to the accompanying drawings. Like reference symbols in the drawings denote like elements.

1-1. Reasoning Technology

In general, the process of inducing new facts with knowledge of a given situation is a very familiar process in real life. In fact, it is no exaggeration to say that all the scientific facts we know come from a certain framework of reasoning. Inference is the process of deriving a new proposition based on a known proposition, dealing with the logical relationship between the premise and the conclusion. The conclusion here refers to a newly derived proposition and the premise refers to a known proposition that provides the basis for the conclusion.

Types of inferences include deduction, assumption, and induction. Deduction, well known as three-stage reasoning, is a way of drawing conclusions from the premises. For this purpose, major premise and minor premise should be described. The following is the process of inference by deduction.

Main theme: if X = father, then X = man

Subtitle: Jin Ho is the father.

Conclusion: Jin Ho is a man.

In general, the result of deduction is always true, which is called the soundness of reasoning. Production rules, semantic nets, logic, etc. all belong to the deduction method.

Assuming argument is to guess the condition of a rule. In Deduction Law, the conclusion is to guess the conditions in the main premises, so the result can be false. Assumptions are a kind of conjecture, and therefore are right in many cases but not always right. The assumptions are therefore also called pseudo inferences.

Induction is a way to draw general conclusions from concrete facts and derive hypotheses from proof. That is, the conclusion is inferred from the facts obtained. Since concrete facts cannot show all the cases, the result can be false. Thus the derived conclusions may not be accurate and may change when new facts are known.

A representative reasoning strategy is forward chaining. Forward reasoning is a reasoning method that compares the pattern between the premise of the rule and the working memory and changes the state of the working memory according to what is indicated in the conclusion. That is, when the rule 'If A is B' exists, B is executed if the same pattern as the condition A exists in the working memory.

This forward reasoning is a kind of reasoning, and it is called deduction law and also called antecedent driven reasoning. Prospective reasoning systems are rule-based systems, and representative rule-based systems include OPS5, CLIPS, and JESS.

Progress in the backward direction is due to the efficiency of inference to find and perform a rule that satisfies the condition without performing all of the many rules. Progression in the reverse direction is logically close to the assumption theory due to the inverse direction. However, the assumption is to derive A from B in 'If A is B', which is fundamentally different from reverse progression.

1-2. Expert systems

In 1972, Newell and Simon proposed a rule-based system that included a rule base, an inference engine, and working memory. The system uses rules of the form A, B, and B to infer the knowledge represented by the production rule and solve the problem.

Rule-based systems fall into two major parts. That is, a rule-based system includes a knowledge base that stores knowledge of a specific field and an inference engine that stores knowledge that solves a problem using the knowledge base. The inference engine includes a pattern matcher and agenda, and the knowledge base includes a working memory (WM) for storing facts and a rule base for storing rules.

The pattern matcher uses the WM and rule base to tell the agenda which rules have been met. The agenda selects a rule according to a predetermined policy or rule priority.

The rule includes a conditional part and a result part that is performed when the condition is met. The agenda checks whether any of the rules satisfy the conditional condition in the WM, selects one of the satisfied rules, and modifies the WM while performing the result. Thus, while the rule-based system is operating, the WM will be constantly changing.

1-3. Knowledge representation

The key to AI is knowledge. Therefore, how to express knowledge about how to systematically store and use it efficiently is very important. In addition, depending on how the knowledge is expressed, a problem solving method that is suitable for the problem area and has good performance may be produced.

Knowledge expression refers to the representation of knowledge in a form that computers and people can understand at the same time. If knowledge is expressed only in human language, that is, natural language, the processing of natural language by computer is not perfect and such expression of knowledge cannot be realized. On the other hand, if knowledge is represented only by algorithms and data structures of computer language, it is difficult for humans to understand this expression of knowledge. Thus, the method of expression is a compromise between the human and computer language structures.

Knowledge representations resulting from these compromises include rules, frames, semantic networks, graphs, and transpositional forms. Also, languages like LISP and PROLOG have been developed as specialized computer languages for this eclectic representation of knowledge.

There are five major roles of knowledge expression. First, the knowledge representation is a surrogate. Incomplete substitutes inevitably lead to incomplete inference. Next, knowledge representation is a series of ontological commitments. Thus, the promise is chosen at the earliest and accumulates step by step. That is, knowledge representation is not a data structure. Next, knowledge representation is a fragmentary theory of intelligent reasoning. Next, knowledge representation is a means for efficient computation. Finally, knowledge representation is a means of human expression.

1-4. Rete algorithm

If a large amount of patterns or objects are involved, the system can slow down. A typical rule-based system maintains a list of rules while continuously testing the predicates of the rules in the list and executing the result of the satisfied rule. These tasks are inefficient because they run tests that produce the same results as in the last task.

가 된다. Once the knowledge base has stabilized, most of the tests will be repeated. In this case, when the number of rules is R, the number of facts is F, and the average number of conditional patterns is P, the time complexity is

.

에 가까워진다. In the Rete network algorithm, the results of past tests are stored in the form of a network. Thus, in the Rete network algorithm, the inefficiency of repeating the same test is reduced. Tests on predicates only test the predicates of the rules involved when a new fact is declared. So the time complexity is

Getting closer to

Representative rule-based systems using the Latte algorithm include the OPS series, CLIPS, and JESS. Table 1 and FIG. 1 show the results of configuring a Rete network using a generation rule in OPS5.

As shown in FIG. 1, the two generation rules in Table 1 share a node that checks a class, a node that checks a type, and a node that checks Arg1. The expression of the generation rule using the network saves space for expressing knowledge and reduces the comparison time by preventing repeated execution of inspection while each node stores its inspection results.

1-5. Temporal reasoning

Temporal reasoning is the reasoning for the change of state with temporal properties. State changes and spatial movements that occur over time are defined as events, and are expressed in terms of "what happened", namely time information and facts. The time information may be represented by a time indicating an accurate moment and a length of time indicating a maintained time, a time interval representing a time maintained from a specified start time, and a periodic representation for periodic time. In order to infer using the time the fact occurred, we need a time event integration expression that can refer to the event occurrence time in the name of the fact.

James F. Allen made 13 definitions of the temporal relationship of certain events and proposed reasoning using the defined temporal relationship. Among these time relationships, 12 relations except two occurred at the same time express two inverse pairs. Therefore, when constructing knowledge in inference system and making inferences about temporal relations through this, seven kinds of relations except inverse relations can be sufficiently expressed.

FIG. 2 is a diagram illustrating seven time relationships on a time axis, and FIG. 3 is a view for explaining a process of making inference using the time relationships of FIG. 2. Using the temporal relationship representation shown in FIG. 2, the context of events can be inferred. For example, when events A, B, and C exist, it can be inferred that A and C are Before relationships when A and B are Meets and B and C are Finishes.

Reasoning based on time intervals or lengths of time requires reasoning for all different facts. That is, if there are N facts, N (N-1) inferences are needed. However, reasoning based on time relationships does not require reasoning between all the different facts. For example, when A and B are in a Meet relationship, it can be inferred that all facts with Before, Meets, Overlaps, During, and Finishes with B are Before. Allen calls this a reasoning by relative time relationship. This saves computing time compared to inference by other time representation methods.

4 is a block diagram of an inference system according to an embodiment of the present invention. The reasoning system 400 of FIG. 4 is a reasoning system considering a time representation, and is a rule-based reasoning system. The inference system 400 includes a user interface 410, a parser 420, an inference engine 430, a working memory 440, a rule base 450, and an agenda. (agenda, 460), and execution engine (470). Inference engine 430 also includes a rete network 431 and a time network 433.

Referring to the operation of the inference system 400 according to an embodiment of the present invention, the contents (ie, rules and facts) input through the user interface 410 are analyzed by the parser 420 and the working memory 440. ) Or the rule base 450 or may be modified and stored. In this case, the stored content is reflected in the network 421 and modified, and if certain rules are satisfied, the agenda 460 delivers the satisfied rules to the execution engine 470 at a predetermined priority, thereby satisfying the satisfied rules. To be executed. Hereinafter, the structure and operation of an inference system according to an embodiment of the present invention will be described in detail with reference to FIG. 4.

The user inputs information necessary for inference, for example, rules, facts, variables, functions, etc. using the user interface 410. The parser 420 analyzes the information input through the user interface 410, and passes the analyzed information to the inference engine 430 so that the information may be transferred to the working memory 440 from the working memory, rule base 450, or variable. Pass to another module (not shown) for processing functions.

In an embodiment of the present invention, facts are stored in the working memory 440 and rules are stored in the rule base 450. However, the configuration in which the information shown in FIG. 4 is stored is for convenience of description, and those skilled in the art may store the input information, that is, rules, facts, variables, functions, and the like. It will be appreciated that it may be implemented to be stored in an operating module such as a module or an inference engine.

The inference engine 430 uses input information (ie rules, facts, variables, functions, etc.) transmitted from the parser 420, facts stored in the working memory 440, and rules stored in the rule base 450. Infer whether the rule is satisfied. As shown in FIG. 4, in addition to the existing rule-based reasoning (ie, the rete network 431), inference taking into account the time representation (ie, the time network 433) is performed together.

The inference engine 430 includes a rete network 431 and a time network 433. Latte network 431 is a rule-based reasoning system, and time network 433 is a reasoning system for time representations. Before explaining the specific operations of the Rete network 431 and the time network 433, the configuration of the Rete network 431 and the time network 433 used in the embodiment of the present invention will be described, information for inference Ie rules, facts, variables, functions, time, etc. are described in the present invention.

In the embodiment of the present invention, the following nodes are used to configure the Lete network 431.

In an embodiment of the invention, one pattern consists of a series of one input nodes. A rule consisting of several patterns combines two patterns into one using two input nodes.

First, the expression of one pattern will be described. The table below is an example of expressing a single pattern in the network 431.

Next, the expression of a rule composed of several patterns will be described. The table below is an example of expressing a pattern bounded by an AND operation in the network 431.

The table below is an example of expressing the pattern bound by the OR operation in the network 431.

Unlike the patterns enclosed in AND, in the patterns enclosed in OR, the terminal condition is added to each pattern because only one of the cases is satisfied.

In addition, in the embodiment of the present invention, the following node structure is used to construct the time network 433.

In the absence of sufficient inference information, the time relationship between two different nodes can appear in many ways. FIG. 5 is a diagram for explaining inferences about a time relationship that occurs when two time relationships exist between three nodes. As shown in Fig. 5, in the present invention, a data structure for recording a plurality of time information is used to express the possibility that there may be various relations when there is not enough information necessary for inference.

As discussed above, in a rule-based system, the rules stored in the rulebase and the facts stored in the working memory are treated as knowledge, so a language is needed to express the knowledge in a form suitable for inference. In order to express knowledge, the present invention uses BNF as a meta-expression for expressing language. The following table shows the BNFs used in the present invention.

Hereinafter, the method of expressing knowledge will be described in more detail with reference to the above table.

In the present invention, elements, numbers, strings, and variables should be basically expressed. The expression of the element used by this invention is as follows.

<digit> :: = 0 | 1 | ... | 9

<letter> :: = a | b | ... | z | A | B | ... | Z

<punctuation> :: = _ | -| # | $ | = | + | * | > | <| ? | . | , | / | % | @ | !

<char> :: = <digit> | <letter> | <punctuation>

<symbol> :: = <letter> <char> *

<null> :: = NULL

<true> :: = TRUE

<false> :: FALSE

<ascii> :: = \ <positive-integer>

 | \ <letter>

<white-space> :: = \ 32

The representation of numbers and strings used in the present invention is as follows.

<integer> :: = <positive-integer>

| <negative-integer>

<positive-integer> :: = <digit> ⁺

<negative-integer> :: =-<digit> <digit> *

<float> :: = <integer>. <digit> ⁺

<number> :: = <integer>

| <float>

<string> :: = "<char> ⁺ "

In addition, the expression of the variable used in the present invention is as follows.

<variable> :: =? <symbol>

As you can see from the expression above, the variable starts with a question mark (?). In addition, in order to declare a local variable, the present invention uses a function called 'defvariable' as follows.

(defvariable? a)

In order to assign a value to the declared variable, the present invention uses the function 'bind' as follows.

(bind? a "abc")

Meanwhile, in the present invention, the values assigned to the variables are expressed as follows.

<value> :: = <integer>

 | <float>

 | <number>

 | <string>

 | <symbol>

Next, the expression of the fact used in the present invention is as follows.

<fact> :: = <ordered-fact>

| <unordered-fact>

<ordered-fact> :: = (<fact-name> <term> *)

<fact-name> :: = <symbol>

<term> :: = <value>

 | <variable>

 | : <function-call>

 | = <function-call>

<unordered-fact> :: = (<fact-name> <valued-slot> *)

<valued-slot> :: = (<slot-name> <term>)

(deftemplate <slot-definition> *)

<template-name> :: = <symbol>

<slot-definition> :: = (slot <slot-name> <slot-value> *)

<slot-name> :: = <symbol>

<slot-value> :: = <value>

| <default-value>

| <type-value>

|

<default-value> :: = (default <null>)

| (default <value>)

<type-value> :: = (type <type-specification>)

<type-specification> :: = <allowed-type> ⁺

| <variable>

<allowed-type> :: = SYMBOL | STRING | INTEGER | FLOAT

| NUMBER | <fact-name>

<allowed-constraint-attribute> :: = (allowed-symbols <symbol-list>)

(allowed-strings <string-list>)

| (allowed-integers <integer-list>)

floats <float-list>)

| (allowed-numbers <number-list>)

| (allowed-values <value-list>)

<symbol-list> :: = <symbol> ⁺

<string-list> :: = <string> ⁺

<integer-list> :: = <integer> ⁺

<float-list> :: = <float> ⁺

<number-list> :: = <number> ⁺

<value-list> :: = <value> ⁺

Next, the expression of the rule used in the present invention is as follows.

<defrule> :: = (defrule <rule-name> [<rule-priority> | 0]

<conditional-element> *

=>

<action> *)

<rule-priority> :: = (priority <integer>)

<conditional-element> :: = <template-pattern>

| <not-pattern> | <and-pattern> |

<template-pattern> :: = (<deftemplate-name> <single-LHS-slot> *)

<single-LHS-slot> :: = (<slot-name> <constraint>)

<constraint> :: = <connected-constraint>

<connected-constraint> :: = <single-constraint> |

<single-constraint> & <connected-constraint> |

<single-constraint> | <connected-constraint>

<single-constraint> :: = <term> | ~ <term>

<term> :: = <value> | <variable> | : <function-call> |

<function-call> :: = (<function-name> <argument> *)

<argument> :: = <term> | ~ <term>

<not-pattern> :: = (not (<conditional-element>))

<and-pattern> :: = (and (<conditional-element>) (<conditional-element>))

<or-pattern> :: = (or (<conditional-element>) (<conditional-element>))

Next, the expression of time used in the present invention is as follows.

<month-digit> :: = 0 | One

<day-digit> :: = 0 | 1 | 2 | 3

<hour-digit> :: = 0 | 1 | 2

<minute-digit> :: = 0 | 1 | ... | 6

<time-point> :: = (At (<fact-id> (<start-time> <end-time>)))

<fact-id> :: = <integer>

<start-time> :: = <time>

<end-time> :: = <time>

<time> :: = <year> <month> <day> <hour> <minute>

<year> :: = <digit> <digit> <digit> <digit>

<month> :: = <month-digit> <digit>

<day> :: = <day-digit> <digit>

<hour> :: = <hour-digit> <digit>

<minute> :: = <minute-digit> <digit>

<time-relation> :: = (<relation-expression> (<fact-id> <fact-id>))

<relation-expression> :: = Before | Meets | Starts | Finishes | Overlap | During | Equal | InverseBefore | InverseMeets | InverseStarts | InverseFinishes | InverseOverlap | InverseDuring

The time expressions required for time inference are classified into two types: time point and time relation. The point of view includes information about exactly when and when an event occurred. On the other hand, as described above, the time relationship expresses about 13 time relationships of different events.

Inference about time as well as inference about time need to express time relationship. From the seven time relationships of Meets, Starts, Finishes, Equal, InverseBefore, InverseMeets, InverseStarts, and InverseFinishes, it can be inferred that one or both of the start and end times of the two different events were at the same time. . This allows us to deduce information about facts that have not yet been declared for the exact time.

Allen's proposal did not consider the timing. Similarly, inference to viewpoint would be difficult if the representation of the viewpoint was separated from the temporal relation or if the representation of the inverse relation was not provided in the temporal relation used for viewpoint inference.

Contrary to Allen's suggestion that seven time relationships are sufficient to infer time, the present invention declares all thirteen time relationships, including the Inverse relationship, to provide inference about the viewpoint.

Referring back to FIG. 4, the time network 433 is the time of all facts based on time facts (specifically, 13 time relationships based on time index based on time index) among the facts input from the parser 420. Infer the relationship. Let's network 431, a rule-based reasoning system, infers whether facts satisfy a rule. At this time, the network 431 is inferred from the facts stored in the working memory 440, the rules stored in the rule base 450, the variables and functions input from the parser 420, and the time network 433. Inference is performed considering all time relationships.

When the inference is performed to satisfy the rule, the result from the inference engine 430 (specifically, the network 431 included in the inference engine 430) is transmitted to the agenda 460. Since there may be a plurality of results from the satisfied rule, in the embodiment of the present invention, it is preferable to output the results from the Let network 431 satisfied rules to a conflict set.

Agenda 460 receives the conflict set and determines priorities for the received conflict set based on the degree or order of detail of the rule. Once the priority is determined, the agenda 460 delivers the results to the execution engine 470 according to the determined priority. Execution engine 470 executes the received results according to priority.

As described above, an optimal embodiment has been disclosed in the drawings and specification. Although specific terms have been employed herein, they are used for purposes of illustration only and are not intended to limit the scope of the invention as defined in the claims or the claims. Therefore, those skilled in the art will appreciate that various modifications and equivalent embodiments are possible without departing from the scope of the present invention. Accordingly, the true scope of the present invention should be determined by the technical idea of the appended claims.

As described above, the inference system according to the present invention can provide time inference through a time index and a network, and at the same time can quickly infer using a network to perform reasoning suitable for a ubiquitous environment, and can be used for various applications. This has the advantage of improving the performance of the overall system.

Claims (14)

A user interface for inputting information necessary for inference; A parser for analyzing and inputting the input information; A working memory for storing facts of the information; A rule base for storing rules of the information; Transmitting the facts and the rules of the information to the working memory and the rule base, respectively, and whether the rules are satisfied using the information and facts stored in the working memory and the rules stored in the rule base. Includes an inference engine If the rules are satisfied, the inference engine outputs the results arising from the satisfied rules as a conflict set, An agenda for receiving the conflict set, determining a priority for the received conflict set based on the degree or order of detail of the rules, and outputting the results according to the determined priority, The facts include time facts, and the inference engine further uses the time facts to infer that the rules are satisfied. The method of claim 1, wherein the information is, An inference system further comprising variables and functions. The inference engine of claim 1, A time network that infers the time relationship of the facts using the time facts; And An inference network that infers whether the rules are satisfied using the facts stored in the working memory, the rules stored in the rule base, the input information, and the inferred time relationship. The method of claim 3, wherein the time facts are: An inference system comprising a time point and a time relationship. delete delete The method of claim 1, And an execution engine for receiving the output results according to the priority and executing the received results. Receiving information necessary for inference from a user through a user interface; Storing facts and rules of the information in a working memory and a rule base, respectively; Infer that the rules are satisfied using the information and the stored facts and rules; If the rules are satisfied, the inferring outputs the results arising from the satisfied rules as a conflict set, Receiving the conflict set to determine a priority for the received conflict set based on a degree or order of detail of the rules; And Outputting the results according to the determined priority, And the inferring step further infers whether the rules are satisfied by further using the time facts included in the facts. The method of claim 8, wherein the information, The method of inference further comprising variables and functions. The method of claim 8, wherein the inferring step comprises: Infer the time relationship of the facts using the time facts; And Inferring whether the rules are satisfied using the facts stored in the working memory, the rules stored in the rule base, the inputted information, and the inferred time relationship. The method of claim 10, wherein the time facts are: An inference method comprising a time point and a time relationship. delete delete 9. The method of claim 8, And receiving the output results according to the priority and executing the received results.

Images