KR100558331B1 - Rule language processing system and method for describing web interlocking knowledge - Google Patents

Abstract

The present invention relates to a rule language and a processing system effective for creating a rulebase for intelligently providing various services by referring to, interpreting, and inferring two kinds of knowledge (ontologies and rulebases) distributed on the Web. The rule language according to the present invention has a URI as a basic data type. URI can be used to refer to the knowledge elements described in the web ontology and rulebase, and the rule language execution environment according to the present invention performs the various knowledge acquisition operations on the referenced URIs. Allows smooth inference of the written rulebase. In addition, all components (Rule, Fact, Predicate, and Constant) of the rulebase written in the rule language according to the present invention are given a URI as a separator. The URI given to each element is used as a reference when referring to the rule language rulebase according to the present invention at a remote location, through which the knowledge element contained in the remote knowledge base can be easily referred to. Therefore, the rule language according to the present invention enables efficient expression of knowledge on the basis of extended rule expression power, and supports the expression of predicates in the form of secondary logic so that the rules of complex forms can be easily expressed.

Semantic Web, Rulebase, Ontology, Rule Language, Interworking, Expert System

Description

Rule language and processing method for describing web interlocking knowledge and its method {Rule Language and Processing the same for semantic web}             

1A is a block diagram illustrating a distributed web knowledge environment to which the present invention is applied;

1B illustrates a hierarchical structure of the semantic web to which the present invention is applied;

2 is a basic structural diagram of a rule language processing system according to the present invention;

3 is a diagram illustrating distributed knowledge reference, acquisition and processing concept using a rulebase and a rule language processing system written in a rule language according to the present invention;

4 is a diagram illustrating an external web knowledge reference concept through a remote inference engine interworking of a rule language processing system according to the present invention;

5 is a diagram illustrating a remote binding performing procedure of a rule language processing system according to the present invention;

6 is a diagram illustrating a remote binding execution concept through communication with a remote inference engine according to the present invention.

* Description of the symbols for the main parts of the drawings *

102: ontology 104: ontology rule base

106: rulebase 200: rule language processing system

210: internal working memory 220: remote binder

230: inference engine 240: ontology converter

250: Java object interlocker

The present invention relates to an expert system based on the field of knowledge representation and reasoning in the field of artificial intelligence. More specifically, it refers to and interprets two types of knowledge (ontologies and rulebases) distributed on the web. By reasoning, the present invention relates to a rule language and its processing system that are effective in creating a rulebase for intelligently providing various services.

In general, knowledge systems, such as expert systems, are computer systems that emulate the inference tasks used by experts. Such knowledge systems typically use an inference engine to translate the knowledge of an encoded expert stored in a knowledge base. If the area of the knowledge base or the scope of the problem is sufficiently narrow and a sufficiently large amount of knowledge is properly coded in the knowledge base, the expert system can achieve performance comparable to or exceeding that of the expert.

In this way, the expert system applies the expert's knowledge to solve difficult problems and uses symbols to represent the concept of thinking as a problem solving act by repetitive methods. An expert system has a knowledge base that stores expertise that is specific to a particular area of the problem area, where the knowledge is stored in the form of facts or rules.

A key part of the expert system is the reasoning agency, which is responsible for identifying and implementing the appropriate rules for the current situation. Such expert system consists of knowledge base, working memory, control part, and inference engine, and can be classified into inference engine and knowledge base. Inference refers to the process of estimating and extracting new facts from known facts and rules, and the knowledge base consists of facts that represent data and rules that use those facts as the data for decision making.

This field of expert systems has been developed and put into practical use, and now many business rule engine products are being developed for business applications. These existing products, like traditional expert systems, perform inference functions on closed rulebases. In most cases, a simple and small rule set is applied to the execution of one reasoning session, and it is a strong alternative to the logical operation of the enterprise application rather than the processing of knowledge.

For example, "Product / Rule Management System and Method, and a recording medium recording the source of the program", filed by Samsung SDS Co., Ltd. and registered on Aug. 09, 2002, registered with No. 0347961, may be applied to financial institutions such as insurance, banks, cards, etc. To register the implemented business logic and product-related rules in the database, not the program source level, and to disclose a product / rule management system and method for interpreting the rule engine to infer the related business can be processed have.

This prior art does not write product and rule information in application logic using a programming language to provide the retrieved information in response to a user's request for an online or batch connection to a product / rule management server through a network communication network. Constructing rules and product information into a database, retrieving the product and rule information from the database when requesting information retrieval, inferring the information required by the user, providing the inferred information to the user, and modifying the product and rule information Or, if you want to register a new, only the information stored in the above-described database without modifying the application can be changed or newly registered can easily and accurately update the product and rule information.

The "Blackboard-based Mixed Reasoning Expert System" filed by Samsung Heavy Industries Co., Ltd. and registered on 02.03.02 dated 2000.03.02 proactively responds to small and simple systems with simple knowledge expression and knowledge base. In addition, a blackboard-based expert system with independent reasoning engines is disclosed. The expert system of the present invention includes a monitoring module for determining symptoms by monitoring data obtained from an object, an event handler for generating symptoms determined by the monitoring module as an event, a knowledge base for storing knowledge in the form of facts and rules, The reasoning engine is operated only by the change of the blackboard without controlling each other between the knowledge source of the inference engine that estimates and extracts new facts from the facts and rules, and the working memory that stores the information generated in the troubleshooting process. It is configured to be.

However, these conventional technologies do not have a function of processing a web ontology or a rulebase on the web, which is a standardized web knowledge expression tool, and there is a problem that a cumbersome conversion process must be performed to process such knowledge.

On the other hand, with the advent of the Semantic Web, a technology that enables the intelligent and accurate information service through the web by describing knowledge in a standardized and standardized form and opening it on the web has been in the spotlight. As a technology for representing knowledge in a web-friendly form, standard language and processing technologies of the industry related to web ontology are emerging, and standardized rule expression methods are also discussed.

In line with this trend, inference engines have been developed to perform processing such as inference by referring to a knowledge base published and published using semantic web technology, and some have been disclosed. These engines have the advantage of being web-friendly because they can refer to web ontology and perform inferences, but they cannot interoperate with external object systems like the existing commercial business engine products, and have relatively poor problems in expression power. For example, you can't use 'OR' in conditional expressions, you can't use infinitives in conclusions, and most of these engines are based on the W3C's Resource Description Framework (RDF). It can not be described above. Therefore, such a limitation in expressive power has a problem that a user cannot express knowledge effectively.

The present invention provides a rule language processing system and method that can efficiently refer to and process web knowledge while retaining the rich knowledge expression power and external object interworking functions of commercial business rule engines to solve the above problems. There is this.

The system of the present invention for achieving the above object is a semantic web system for reading and processing the ontology and rulebase existing on the web, the internal working memory for reading and storing the rulebase written in a predetermined rule language ; An ontology converter which reads ontology necessary for inferencing work from the web, converts it into an internal data structure, and adds it to the internal working memory; A remote binder for real-time reference of dynamic web knowledge through communication with an external inference engine residing on the web; An inference engine that processes data stored in the internal working memory and performs inference by referring to external knowledge through the remote binder; And a Java object interlocker for finding a Java class of a specific class type or calling a method of the Java object when the inference engine finds a reference URI for a Java class type or a method while executing the inference operation. It is done.

In order to achieve the above object, the method of the present invention is a semantic web for reading and processing ontologies and rulebases distributed on the web, including (1) a syntax for referencing an external web knowledge base, and (2) Predicate expression syntax in secondary logical form, remote knowledge base reference syntax, (3) a syntax for giving URIs to rulebases, facts, rules, classes, objects, and attributes, and (4) weak and strong negativity. Authoring a rulebase using a rule language that simultaneously supports a syntax that can be used; Loading the rulebase into an internal working memory by a rule language processor; A third step of obtaining a remote web ontology and rulebase as described in the rulebase and adding it to the internal working memory; A fourth step of performing a method call for a state reference or a state change of a Java object when a URI indicating a Java object interworking appears; And a fifth step of attempting binding by referring to knowledge of an external web knowledge base when a remote binding is requested.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

[Structure of Rule Language Processing System of the Present Invention]

FIG. 1A is a diagram illustrating a typical semantic web environment utilizing a rule language and a rule language processing system according to the present invention, and FIG. 1B is a diagram showing a hierarchical structure of the semantic web.

In general, the semantic web gives well-defined meanings to information on the web so that not only people but computers can easily interpret the meanings of documents, thereby automating tasks such as searching, interpreting, and integrating information using computers. It is to. Such a semantic web is represented in URI, Unicode, XML, Namespaces, RDF DB, RDF Schema, Ontology, Rule, Proof, and Trust. It has a hierarchical structure. The most basic layer consists of Universal Resource Identifiers (URIs) and UNICODEs that explicitly refer to resources, on top of which there are Extensible Markup Language (XML) and namespaces that allow you to define arbitrary concepts modularly. Next, a resource description framework (RDF) for describing a resource is located. XML can display parts of web pages with user-defined tags. RDF gives meaning and expresses three elements (resource, attribute, value) corresponding to verb and object. Ontologies are expressed as concepts to express knowledge of a particular domain, relationships between concepts, attributes and properties of concepts, constraints and objects imparted to properties and properties. Rules and logic enable inference based on ontology, while Proof and Trust are about the reliability and security of semantic web information.

Referring to FIG. 1A, a web to which the present invention may be applied includes a first site having an ontology 102 and an ontology rule base 104, an ontology 102 and an ontology rule base 104. The second site (Site 2) having, the third site (Site 3) having the rulebase 106, the fourth site (Site 4) having the rulebase 106, and the fifth site having the ontology 102 ( Site 5) exists.

As shown in FIG. 1, web knowledge is largely divided into two types, one is ontology (102) and the other is rulebase (106). Since the ontology 102 and the rulebase 106 have different parts of knowledge expression characteristics and expression power, the user should use both the ontology 102 and the rulebase 106 for the full knowledge representation. The first site (Site 1) and the second site (Site 2) shows a situation in which two types of knowledge bases, that is, the ontology 102 and the ontology rule base 104 coexist in one site.

For example, if you build a site that services knowledge that represents family relationships, knowledge that expresses family organizational structure uses an ontology 102 but cannot be represented by an ontology 102-for example, uncle And nephew relations-knowledge that can only be expressed as a rule-"If the father is the same but the mother has two different brothers, they are half brothers." -Is represented through the ontology rule base 104.

As such, the ontology and rulebase are both required to express intact knowledge as a complementary relationship, and therefore, the rule language processing system 200 of the present invention may not only express rules as well as ontologies for proper web knowledge processing. Must be able to handle In addition, there is a need for a method that can use knowledge expressed in ontology in a rulebase or use knowledge defined in a rulebase in an ontology. The rule language and the rule language processing system according to the present invention satisfactorily satisfy these requirements.

2 is a block diagram of a rule language processing system according to the present invention.

Referring to the drawings, the rule language processing system 200 according to the present invention includes an internal working memory 210, a remote binder 220, a forward inference engine 230, an ontology converter 240, a Java object interlocker 250, and the like. It consists of five major components.

The inference engine 230 is a forward inference engine that performs inference by inputting the rule base 106 written in the rule language according to the present invention. The rule language processing system 200 reads the rule base 106 and inputs it into the internal working memory 210, and the inference engine 230 performs the inference work on the internal working memory 210.

The web ontology 102 is a knowledge base that maintains a complementary relationship with the rule base 106 as described above. The rule language processing system 200 of the present invention reads the ontology 102 necessary for the reasoning work from the web, converts the ontology 102 into an internal data structure through the ontology converter 240, and then infers it by adding it to the internal work memory 210. Apply to your work.

The Java object interlocker 250 is a part in charge of the Java object interworking function of the rule language processing system 200 according to the present invention. If the inference engine 230 finds a reference URI for a Java class type or method while executing an inference operation, it must find a Java object 202 of a particular class type or call a method of the Java object 202.

The part performing such a task is the Java object interlocker 250. The remote binder 220 is a part in which the regular language processing system 200 according to the present invention is distributed on the web and performs a function required for inferring dynamically changing knowledge. The remote binder 220 is an element that performs internal rule processing by referring to the external inference engine 204 or an external knowledge base, that is, a web ontology, rule base, remote Java object, web service, and the like. Mainly referring to the dynamic web knowledge through communication with the external inference engine 204.

The rule language of the present invention processed by such a rule language processing system of the present invention is as follows.

[Rule Language According to the Present Invention]

The present invention includes a rule language suitable for web-linked knowledge processing. Table 1 below describes the syntax structure of the rule language presented by the present invention as a virtual BNF (Backus-Naur Form). Hereinafter, the structure and function of the language will be described based on the main generation rule.

 rulebase :: = {reference | uriprefix} basenamespace "rulebase" [name | uri] "{" {fact | rule | classdef | propertydef | individual} "}" reference :: = "refer" uri ";" uriprefix :: = "prefix" identifier "=" uri ";" basenamespace :: = "namespace" "=" uri ";" rule :: = "rule" (name | uri) "is" rulebody ";" rulebody :: = "if" {quantifier} sentence "then" sentence ";" fact :: = "fact" name "is" (gpredicate | "neg" gpredicate) ";" gpredicate :: = objectconst ["(" constant {"," constant}] classdef :: = "class" classid ["inherits" classid {"," classid} ";" propertydef :: = "property" propertyid "for" classid {"," classid} "is" typeid ";" individual :: = "individual" individualid "is" classid ["and" propvalue {"," propvalue}] ";" propvalue :: = propertyid "=" constant quantifier :: = "(" ("forall" | "forsome") variable {"," variable} ")" sentence :: = atom {("and" | "or") atom} atom :: = literal | " ("sentence") "literal :: = predicate |" not "predicate |" neg "predicate | compexpr predicate :: = predsymbol [" ("term {", "term}") "predsymbol :: = objectconst | variable term :: = (variable | constant | functioncall) | term "," term functioncall :: = functionid "(" [term {"," term}] ")" compexpr :: = term ("<" | "<=" | "=" | "> =" | ">") term variable :: = "?" identifier constant :: = objectconst | valueconst objectconst :: = name | qName | uri valueconst :: = integer | float | st ring | boolean propertyid :: = name | qName | uri typeid :: = classid | uri classid :: = name | qName | uri boolean :: = "true" | "false" name :: = identifier qName :: = prefix ":" identifier prefix :: = identifier uri :: =String that conforms to the IETF URI syntax syntax integer :: =A string representing an integer float :: =A string representing a real number  string :: =Quoted string 

[Rulebase]

Using the rule language according to the present invention, a rule base is defined as shown in Table 2 below.

rulebase :: = {reference | uriprefix} basenamespace "rulebase" [name | uri] "{" {fact | rule | classdef | propertydef | individual} "}"

Referring to Table 2 above, the rulebase begins with a list of various URI-related information. The "reference" generation rule is used to describe a URI that points to a knowledge base that needs to be referenced for rulebase processing. Here, the knowledge base is the web ontology 102 or the rule base 106.

The "uriprefix" generation rule is used to indicate an abbreviation for the URI to use in the rulebase.

The "basenamespace" generation rule is used to define the namespace in which the knowledge elements generated by the rulebase-rules, facts, predicates, and so on-exist.

The body of a rulebase begins with the keyword "rulebase". "rulebase" is followed by a rulebase, in which the name of the rulebase to be used is described. The contents of the rulebase are enclosed in braces ("{", "}"). The rulebase consists of facts, rules, classdefs, propertydefs, and individual definitions declared as true. The code in Table 3 below shows the skeleton of the rulebase according to the rulebase creation rule.

refer http://person.com/Persons; prefix family = http://family.com/Family#; prefix human = http://human.com/Human#; namespace = http://mysite.com/Rules#; rulebase MyRuleBase {......}                                             

In this example, MyRuleBase receives a formula of "http://mysite.com/Rules#", which is the namespace URI defined by the namespace, so when referencing this rulebase externally, "http://mysite.com/Rules #MyRuleBase ".

Table 4 below is an example of a rulebase written in the rule language according to the present invention, and is a part of the rulebase for RDF inference.

prefix rdf = http://www.w3.org/1999/02/22-rdf-syntax-ns#; prefix owl = http://www.w3.org/2002/07/owl#; prefix xsd = http://www.w3.org/2001/XMLSchema#; prefix rdfs = http://www.w3.org/2000/01/rdf-schema#; namespace is http://etri.re.kr/2003/10/Bossam#; rulebase OwlRules {fact Fact1 is rdfs: Class (rdf: List); fact Fact2 is rdf: Property (rdf: first); fact Fact3 is rdfs: domain (rdf: first, rdf: List); fact Fact4 is rdfs: range (rdf: first, rdfs: Resource); fact Fact5 is rdf: Property (rdf: rest); fact Fact6 is rdfs: domain (rdf: rest, rdf: List); fact Fact7 is rdfs: range (rdf: rest, rdf: List); fact Fact8 is rdf: List (rdf: nil);                                                  fact subPropertyOfIsTransitive is owl: TransitiveProperty (rdfs: subPropertyOf); fact subClassOfIsTransitive is owl: TransitiveProperty (rdfs: subClassOf); fact differentFromIsSymmetric is owl: SymmetricProperty (owl: differentFrom); fact equivalenceIsSymmetric is owl: SymmetricProperty (owl: equivalentClass); fact OwlDLClass is rdfs: subClassOf (owl: Class, rdfs: Class); fact OwlFullClass is owl: equivalentClass (owl: Class, rdfs: Class);                                                  rule subClassOfRule1 is if rdfs: subClassOf (? subC,? supC) and? subC (? ind) then? supC (? ind); rule equivalentClass1 is if owl: equivalentClass (? c1,? c2) and? c1 (? z) then? c2 (? z);                                                  rule RangeRule1 is if rdfs: range (? p,? r) and? p (? x,? y) then? r (? y); rule DomainRule1 is if rdfs: domain (? p,? d) and? p (? x,? y) then? d (? x);                                                  rule CollectionRule1 is if rdf: rest (? l, rdf: nil) and rdf: first (? l,? i) then member (? i,? l) and length (? l, 1); rule CollectionRule2 is if length (? l1,? len) and rdf: rest (? l,? l1) and [? l! =? l1] then length (? l, add (? len, 1)); rule CollectionRule4 is if member (? i,? l1) and rdf: rest (? l,? l1) and [? l! =? l1] then member (? i,? l); rule Collection1 is if rdf: first (? list,? i) then member (? i,? list); ......}                                             

When the rule language processing system 200 according to the present invention executes an inference operation using the rule base described above, if there is a knowledge base available by accessing the URI written in the "reference" part, the internal working memory 210 is obtained. ) To make reference to the knowledge base possible.

3 illustrates a structure of referencing external web knowledge statically in accordance with the present invention.

The inference engine 301 of the rule language processing system of the first site 310 performs the inference operation on the rule base 106 written in the rule language according to the present invention. In the case where there is a referencing instruction to the external knowledge base through the refer statement in the rulebase 106, the inference engine 301 uses the URIs described in Site 2 (320), Site 3 (330), and Site 4 (340). Access the knowledge base (ontologies or rule bases) provided by each site. The read knowledge base, that is, the web ontology 102 and the rule base 106 is added to the internal working memory 210 of the rule language processing system 200.

[Fact]

In the rule language of the present invention, the fact definition is defined as shown in Table 5 below.

fact :: = "fact" name "is" (gpredicate | "neg" gpredicate) ";" gpredicate :: = objectconst ["(" constant {"," constant}]

In Table 5, a fact consists of a "gpredicate" consisting of a constant predicate symbol and a constant term only. "neg" is a keyword indicating strong negation. When "neg" is given to a fact, it is true that the opposite of the fact is declared. Conventional logic programming languages or commercial business rule products do not provide a way to express strong negativity, but the rule language according to the present invention can express it using the keyword "neg". The code in Table 6 below is an example of a fact definition syntax written according to a fact generation rule.

fact Father Of John is family: has Father (John, Sam); --- (1) fact BrotherOfSam is family: hasBrother (Sam, Nil); --- (2)

In Table 6, the phrase (1) means that the entity John has an entity Sam as a father, and the phrase (2) means that the entity Sam has an entity Nil as a sibling.

[Classdef]

In the rule language of the present invention, classes are defined as shown in Table 7 below.

classdef :: = "class" classid ["inherits" classid {"," classid} ";"                                             

In Table 7, the class is used to express object-oriented knowledge. By defining classes and attributes, you can define the structure of an object, and you can create concrete examples of classes through object definitions. As you can see from the syntax structure, the class definition is a simple structure that describes the ID of the class being defined. In addition, the upper class list can be described using the keyword "inherits".

Table 8 below is an example of defining classes in the rule language of the present invention.

Class Human inherits Animal;                                             

[Propertydef]

In the rule language of the present invention, attributes are defined as shown in Table 9 below.

propertydef :: = "property" propertyid "for" classid {"," classid} "is" typeid ";"                                             

Property definition is the syntax used to define properties of a class. The ID of the property, the list of classes that will have the property defined, and the data type of the property are described. The code in Table 10 below is an example of an attribute definition.

property age for Human is http://www.w3.org/2001/XMLSchema#positiveInteger;- (1) property hasFather for Human is Human; --- (2)                                             

In Table 10, (1) is a syntax for creating an attribute called "age." age can be used as an attribute of Human class, and the value that age attribute can have is defined as positive integer (positiveInteger) defined in W3C's XML schema. The rule language processing system 200 according to the present invention understands the data type defined in the XML schema, and accordingly, can check whether the value is a positive integer value when the age attribute is used in the object declaration or the rule. . In Table 10, (2) is a property of the Human class and defines the property hasFather whose type is the Human class.

[Individual definition]

In the rule language of the present invention, an entity is defined as shown in Table 11 below.

individual :: = "individual" individualid "is" classid ["and" propvalue {"," propvalue}] ";"                                             

In Table 11, the entity is a concrete example of a class. An entity definition is defined by listing the entity's ID, the entity's type, and its property values. The code in Table 12 below is an example of an object definition.

individual John is Human and age = 16, has Father = Sam;                                             

The syntax in Table 12 is a syntax for creating an entity named John. John's type is the Human class. The age property is set to 16 and the hasFather property is set to Sam.

[Rule]

Rules in the rule language of the present invention are defined as shown in Table 13.

rule :: = "rule" (name | uri) "is" rulebody ";" rulebody :: = "if" {quantifier} sentence "then" sentence ";" quantifier :: = "(" ("forall" | "forsome") variable {"," variable} ")" sentence :: = atom {("and" | "or") atom} atom :: = literal | "(" sentence ")"                                             

In Table 13, rules, the core knowledge element of the rulebase, consist of conditional parts and conclusions. In the "Rulebody" generation rule, the sentence following the keyword "if" is a sentence describing a conditional condition, and the sentence following "then" is a sentence describing a conclusion portion.

"quantifier" is a production rule describing a quantifier. "forall" means universal Yangsa, modifies the variables that appear later, and "forsome" means existence Yangsa. "sentence" represents a logical statement. In the rule language according to the present invention, a logical statement is a list of "atoms" connected by "and" or "or".

The atom is the most basic logical element, defined here as a literal or parenthesized sentence.

The code in Table 14 below is an example of rule definition according to the rule definition syntax.

rule FatherRule1 is if hasFather (? x,? y) and hasBrother (? y,? z) then hasUncle (? x,? z);                                             

Where hasFather (? X,? Y), hasBrother (? Y,? Z) and hasUncle (? X,? Z) are "atom", respectively, and hasFather (? X,? Y) and hasBrother (? Y ,? z) becomes "sentence". An identifier preceded by a question mark (?) Denotes a variable.

[Literal]

In the rule language of the present invention, literals are defined as shown in Table 15 below.

literal :: = predicate | "not" predicate | "neg" predicate | compexpr predicate :: = predsymbol ["(" term {"," term} ")"] predsymbol :: = objectconst | variable compexpr :: = term ("<" | "<=" | "=" | "> =" | ">") term term :: = (variable | constant | functioncall) | term "." term                                             

As we saw earlier in the atom creation rules, the basic component of an atom is literal. Literal can be seen as a predicate. However, by adding a modifier to a predicate or by writing a predicate in the form of an expression, several different forms can be taken. Therefore, these predicates are combined and synthesized as literals.

As you can see from the construction rules, literals are ordinary predicates, weak negation predicates with "not", strong negation predicates with "neg", and compexpr in the form of expressions. Are distinguished. Here, a characteristic part of the rule language according to the present invention is that a variable may come in place of a predsymbol of a predicate.

In primary predicate logic, variables cannot come in place of predicate symbols. The rule language according to the present invention, unlike the rule language of other commercial business engine products, provides a syntax for describing predicates in the form of secondary logic, thereby enabling a wider knowledge representation. The regular language processing system 200 according to the present invention has an inference function capable of processing predicates of secondary logic.

"term" represents a term of a predicate or function. The rule language according to the present invention, like commercial business rule engine products, provides an object-oriented attribute value reference function. That is, the same syntax as John.age. This statement performs a reference to the age property of the John object.

The "compexpr" generation rule enables the description of predicates in the form of comparison operations.

The code in Table 16 below shows examples of using various literal statements.

hasFather (? x,? y) --- (1)? x <? y --- (2) hasFather (? x,? y) and not Woman (? x) --- (3) if Man (? x) then neg Woman (? x) --- (4) Human (? x) and? p (? x,? y) and follows (? p,? q) --- (5) Human (? x) and? x.age> 20 --- (6)                                             

In Table 16, syntax (1) is the most common predicate, and syntax (2) is a predicate in the form of a comparison operation. Syntax (3) is an example of using a predicate with a weak negation of "not", and syntax (4) is an example of using a predicate using a strong negation of "neg". The syntax (5) is an example of constructing a sentence including a predicate of a secondary logical form. Note that the variable? P, which is used as a predicate symbol, is used as a term for the next predicate "follows".

 This expressiveness is not possible with existing commercial business rule engine products based on primary logic. Syntax (6) is an example of constructing a predicate using an object-oriented attribute value reference syntax. In the second predicate of syntax (6),? X.age refers to the age attribute value of the object bound to? X.

[Functioncall]

In the rule language of the present invention, a function call is defined as in Table 17 below.

functioncall :: = functionid "(" [term {"," term}] ")"                                             

Function calls are used when you need functions that need to be solved through built-in functions, such as mathematical operations. The structure of a function is almost identical to that of a predicate, except that a predicate is used as a component of a logical statement, whereas a function can only be used as a term in a predicate.

Table 18 shows an example of using a function call.

add (? x.age, 20) <= 40 --- (1) areaSize (? l, mult (? x, 2)) --- (2)                                             

In Table 18, the syntax (1) is an example of calling the add () function using the age attribute value of the object bound to? X and 20 as input arguments. Syntax (2) is an example of a mult () function call that multiplies two input arguments.

[Simultaneous Support of Strong and Weak Negatives]

Conventional logic programming languages or commercial business engine products that support only weak negation (Negation As Failure or Weak Negation) have used inference techniques that allow the facts to be true if they are not included in the knowledge base. This is useful in reasoning on a closed knowledge base, but its effectiveness is halved when targeting open web knowledge. In addition, since the web ontology 102, which is the subject of major inference, can express strong negation, in order to perform inference on the web ontology 102, it must be able to handle the strong negation.

Therefore, the rule language that wants to provide a web interworking function supports both strong and weak negation at the same time so that the user can effectively process the knowledge represented by the web ontology 102 and utilize efficient negation knowledge reasoning technique of weak negation. Should be.

The rule language according to the present invention according to the present invention provides phrases that can express both strong and weak negation through the keywords "neg" and "not", respectively, and the rule language processing system 200 according to the present invention It has a reasoning function to properly handle these two denials.

[Unsafe weak negation through strong negation]

In general, the use of weak negation requires constructing sentences in a safe form. In the following example of Table 19, syntax (1) is a safe weak negation, while syntax (2) is an unsafe weak negation.

if Human (? x) and not Woman (? x) then serviceKind (? x, ManPlus); --- (1) // If? X is not a woman, provide? X for men. if not Woman (? x) then serviceKind (? x, ManPlus); --- (2)                                             

In Table 19, the syntax (1) has no problem in processing not Woman (? X) because constants that may come to? X are first determined through the positive predicate Human (? X). However, in a sentence containing a weak negation such as the syntax (2),? X in not Woman (? X) can come in place of all constants except constants defined as Woman, so proper inference cannot be performed. Inference engines do not allow these unsafe statements.

The rule language processing system 200 according to the present invention can use the strong negation to process the weak insecure. See the example in Table 20 below.

// John is Man Man (John); // If? x is Man,? x is the opposite of Woman. if Man (? x) then neg Woman (? x); // If? x is not a woman,? x is given to men. if not Woman (? x) then serviceKind (? x, ManPlus);

If the facts and rules include the above strong negation, the inference engine derives the neg woman (John) for the entity named John. Not Woman (? x) by itself is insecure and weak to negate, but we can infer not Woman (John) based on the fact that neg Woman (John) is derived, and connect John to? x. You can do it. This is an extension of the existing weak negation scheme and is very useful for the processing of negation knowledge.

[Predicate Representation of Secondary Logical Forms]

Currently, commercial business rule engines are based on primary predicate logic, so you cannot use variables as predicate symbols. However, the regular language processing system 200 according to the present invention may use a variable as a predicate symbol. Using variables as predicate symbols allows you to describe inference rules for the predicate itself, thus simplifying the representation of complex rules. Table 21 below is an example of rule utilization using secondary logic.

rule FollowsRule1 is if follows (? x,? y) and? y (? z) then? x (? z); --- (1) fact Follows is follows (cooling, overheat); --- (2) rule Overheat is if Heater (? X) and? X.degree> 80 then overheat (? X); --- (3) fact Heater1 is Heater (h1); --- (4) fact Heater1Degree is degree (h1,90 ); --- (5)                                             

Here, it can be seen that syntax (1) includes predicates of secondary logical form, and the "follows" predicate is a predicate for the predicate. When this type of rule is expressed as primary logic, it is shown in Table 22 below.

rule FollowsRule1 is if follows (? x,? y) and asserted (? y,? z) then asserted (? x,? z); --- (1) fact Follows is follows (cooling, overheat); --- (2) rule Overheat is if Heater (? X) and? X.degree> 80 then asserted (overheat,? X); --- (3) fact Heater1 is Heater (h1); --- (4) fact Heater 1 Degree is degree (h1,90); --- (5)                                             

In Table 22, the syntax (1) is to replace the predicate of the secondary logic form by using a general-purpose predicate "asserted". The first term of the "asserted" predicate represents the actual predicate, and the remaining terms are mapped to the terms of the predicate. This primary logic form has the disadvantage of using asserted as the predicate symbol, which does not reveal the meaning of the predicate. In addition, when the structure of a rule becomes complicated, it becomes a syntax that is difficult to write and difficult to understand. The use of secondary logical syntax forms enables natural and concise rule expressions, and enriches the expression of knowledge about predicates, thus enhancing the user's knowledge representation productivity.

[External Knowledge Base Reference Function]

4 is a schematic diagram illustrating an external web knowledge reference concept through a remote inference engine interworking of the rule language processing system 200 according to the present invention, and FIG. 5 illustrates a procedure of performing remote binding of the rule language processing system according to the present invention. 6 is a diagram illustrating a remote binding execution structure through communication with a remote inference engine according to the present invention.

The rule language processing system 200 according to the present invention includes a function of referring to the contents of an external knowledge base by communicating with the external inference engine 410 in a standardized manner. As shown in FIG. 4, the processing structure includes a rulebase 106, a rule language processing system 200, and remote inference engines 410, and the rule language processing system 200 includes an internal working memory 404. And an internal binder 403 connected to the remote binder and a remote binder 405 connected to the remote inference engines 410. The remote binder 405 then uses the remote engine reference URI map table 420 to refer to the remote inference engine.

Binding, a process of inference, is a task that compares facts and predicates of rules and extracts constants that make the predicate true.

The rule language processing system 200 according to the present invention needs to perform an inference function on knowledge that is distributed and exists in an open web environment and dynamically changes, thus providing an additional binding function unlike the existing rule engine. .

Existing rule engines and inference techniques load all knowledge into the internal working memory 404 and then perform inference operations based on this knowledge. That is, the inference subject knowledge has the precondition that all knowledge must exist in the internal working memory 404.

The rule language processing system 200 according to the present invention may perform a binding operation by referring to external knowledge through the remote binder 405. At this time, the procedure in which the remote binder 405 is called is shown in FIG. 5.

Referring to FIG. 5, in operation 501, an internal binding operation is performed on an internal working memory 404 in the same manner as a conventional inference engine. Step 502 is a step of determining whether to call the remote binder 405 in the inference step. Determination of whether to call the remote binder 405 may be variously performed as in the following several examples.

First, when a result of binding through the inner binder 403 is not found at all, the remote binder 405 is called.

Second, the remote binder 405 is always called regardless of the result of binding through the inner binder 403.

Third, the remote binder 405 is periodically called at a preset time interval.

If the call of the remote binder 405 is determined according to the determination result of steps 502 and 503, step 504 is performed. The manner in which the remote binder 405 references the external web knowledge in operation 504 may be variously performed according to the form of the external web knowledge and the method of providing the knowledge. The inference operation then continues at step 505.

4 illustrates an embodiment of performing a remote binding function through interworking with inference engines 410 existing in a remote location. First, using the rule language according to the present invention, each predicate constituting a rule is referred to as a URI. The remote engine reference URI map 420 is a table that contains information about where the remote inference engine 410 provides knowledge that can be bound to each predicate. The remote binder 405 searches the URI map table 420 using the predicate to be keyed as a key, and then attempts to bind by finding the URI of the remote inference engine.

FIG. 6 illustrates the external inference engine interworking function represented in FIG. 4 again in a network environment.

Referring to FIG. 6, each site on the web includes an inference engine and a knowledge base according to the present invention to perform remote binding through communication between the inference engines. That is, the first site 610 includes a rule base 106 and an inference engine 612, and the second site 620 uses the ontology 102, the ontology rule base 104, and the inference engine 622. Similarly, the third site 630 and the fourth site 640 are also provided with an ontology 102, an ontology rule base 104, and inference engines 632 and 642. The inference engine 612 performs binding with other remote inference engines 622, 632, and 642 through communication.

[Java Object Linkage Function]

The rule language processing system 200 according to the present invention provides a function capable of interworking with an external Java object. The external object interworking function is an essential function to perform a series of judgment processes according to the change of the external environment and then generate an effect on the external environment.

For example, if there is a Java object that can check the electrical state of the house and perform the electrical cut-off and connection function, the rule language for operating the house electricity in the rule language according to the present invention to create a intelligence based on the electrical situation of the house Electrical control work can be performed. The following rule example of Table 23 is an example of a rule to notify the user with an alarm sound when the household's electricity usage is over 200W.

rule Alarm is if java: //home.com/ElectricityGage#currentLoad (? x,? load) and? load> 200 then java: //home.com/MessageAlarm#alarmMessage ("Current Elec Load is" +? load) ;

In the conditional section and the conclusion section of the rule presented in this example, one Java object method is called. The syntax describing the Java method to be called is based on the URI structure set in the rule language processing system 200 according to the present invention. Table 24 shows the information represented by each component of a URI that represents a Java object call.

Component meaning Yes URI scheme Indicates that this is a URI for Java interworking java URI host Java package name home.com URI path Java class name Electricitygage Fragment ID Java class type Class Java method name currentLoad

If "Class" is used as the fragment ID as shown in Table 24 above, it means the Java class type. For example, if you used the predicate java: //home.com/ElectricityGage#Class (? X) in the conditional part of the rule, the meaning of this predicate is that the Java objects of class home.com.ElectricityGage are typed in the variable? X. It means to bind.

[Java object creation function]

The above-described Java class type reference functions are interpreted differently when they exist in the conditional part and when they exist in the conclusion part. When Java: //home.com/ElectricityGage (? X) is described in the conditional state, it means that objects of the home.com.ElectricityGage class type among Java objects existing in the internal working memory 404 are bound to? X. On the other hand, if the same predicate is described in the conclusion, it means creating a new object of type home.com.ElectricityGage and binding it to the variable? X.

Conventional rule engines do not have a function of creating a new object at all, or create an object through a separate object creation function, but the rule language processing system 200 according to the present invention internally generates an object according to the meaning of knowledge. And references are handled separately. This reduces the developer's effort to express knowledge and has the effect of smoothing the results of knowledge representation.

 As described above, the rule language and rule language processing system according to the present invention enables efficient rule-based processing for an extended knowledge expression capability and a knowledge base distributed on the web, thereby enabling distributed web ontology and rule base. It can provide intelligent services through the processing of knowledge, which can greatly improve the productivity of application development and the efficiency of developed applications.

In addition, the present invention can express a wider range of knowledge through a wide range of expressive power, web affinity, and a Java object interworking function, and can easily construct a practical knowledge processing system that naturally interworks with an external system.

In addition, the present invention includes an extension function capable of interworking with the external environment based on the URI, various functions when the external system needs to be operated as a result of the inference or when the external environment information is read and a series of inferences are performed. Can be expanded.

Although the above has been described with reference to a preferred embodiment of the present invention, those skilled in the art will be variously modified and changed within the scope of the present invention without departing from the spirit and scope of the invention described in the claims below. I can understand that you can.

Claims (11)

In the semantic web system for reading and processing the ontology and rulebase distributed on the web, An internal working memory for reading and storing the rule base written in a predetermined rule language; An ontology converter which reads ontology necessary for inferencing work from the web, converts it into an internal data structure, and adds it to the internal working memory; A remote binder for real-time reference of dynamic web knowledge through communication with an external inference engine residing on the web; An inference engine that processes data stored in the internal working memory and performs inference by referring to external knowledge through the remote binder; And A Java object interlocker for finding a Java class of a specific class type or calling a method of a Java object when the inference engine finds a reference URI for a Java class type or a method while executing an inference operation; Rule language processing system comprising a. The method of claim 1, wherein the rule base is Syntax to refer to an external web knowledge base, Predicate expression syntax in secondary logical form, remote knowledge base reference syntax, Syntax for giving URIs to rulebases, facts, rules, classes, objects, and properties, A rule language processing system, characterized by a rule language that simultaneously supports both weak and strong negative syntax. The method of claim 1, wherein the rule base is Rule language processing system comprising a fact, rule, classdef, propertydef, and individual definition declared as true. The method of claim 1, wherein the remote binder Rule language processing system characterized in that it is called periodically when a constant linked to a binding target predicate as a result of binding through an internal binder or at a predetermined time interval. The method of claim 1, wherein the remote binder A remote language inference engine reference URI processing rule language, characterized in that to refer to the remote inference engine. In the semantic web for reading and processing the ontology and rulebase that are distributed on the web, (1) a syntax to reference an external web knowledge base, (2) predicate expression syntax in secondary logical form, remote knowledge base reference syntax, (3) the syntax to assign URIs to rulebases, facts, rules, classes, objects, and properties; (4) Syntax that can express weak negativity and strong negativity A first step of storing a rulebase using a rule language supported simultaneously; Loading the rulebase into an internal working memory by a rule language processor; A third step of obtaining a remote web ontology and rulebase as described in the rulebase and adding it to the internal working memory; A fourth step of performing a method call for a state reference or a state change of a Java object when a URI indicating a Java object interworking appears; And The rule language processing method for describing web interworking knowledge, comprising a fifth step of attempting binding by referring to knowledge of an external web knowledge base when a remote binding is requested. The method of claim 6, wherein the first step, Granting a base namespace URI of the authoring rulebase; Publishing the authored rulebase to the web through a web server or a corresponding server; And When there is a request for transmission of a knowledge element by referring to the knowledge element constituting the rulebase using a URI from the outside, the web-related knowledge including the step of delivering the knowledge element referenced in the rule base to the requester is described. Rules language processing method. The method of claim 6, wherein the fourth step Writing a "java" protocol in the URI to mean accessing a Java object; Writing the Java package name and the Java class name in the path of the URI; Writing "Class" as a fragment ID of a URI to refer to a Java class type; And In order to refer to a method of a Java class, writing a method name of a Java class with a fragment ID following a path of a URI. The method of claim 6, wherein the fourth step Finding objects corresponding to the reference information among the Java objects currently present in the internal working memory using a URI having Java class and method reference information; A type searching step of referring to the type of the class when the class is referenced in the conditional part of the rule; An attribute value reference step of referring to a value through a method call when the method of the class is referenced in the conditional part of the rule; Creating an object with the class type when the class is referenced at the conclusion of the rule; And Changing a state of an object through a method call when a method of a class is referred to at the conclusion of the rule. The method of claim 6, wherein the fifth step Rules describing web-interlocking knowledge, including inference techniques for extracting facts that may lead to weak negation from facts derived by strong negation, if the conditional clause of the rule consists of insecure weak negation constructs. Language processing method. The method of claim 6, wherein the fifth step Determining a need for a remote binding operation; Finding a remote knowledge service provider by referring to an information engine providing a remote engine reference URI map or corresponding information; And Rule language processing method for describing web-linked knowledge comprising the step of requesting / obtaining knowledge for binding by connecting to a remote knowledge service provider.

Images