Misplaced Pages

#563436

21-449: There is a whole family of KL-ONE-like systems. One of the innovations that KL-ONE initiated was the use of a deductive classifier , an automated reasoning engine that can validate a frame ontology and deduce new information about the ontology based on the initial information provided by a domain expert. Frames in KL-ONE are called concepts . These form hierarchies using subsume-relations; in

42-647: A rule-based system is a computer system in which domain-specific knowledge is represented in the form of rules and general-purpose reasoning is used to solve problems in the domain. Two different kinds of rule-based systems emerged within the field of artificial intelligence in the 1970s: The differences and relationships between these two kinds of rule-based system has been a major source of misunderstanding and confusion. Both kinds of rule-based systems use either forward or backward chaining , in contrast with imperative programs , which execute commands listed sequentially. However, logic programming systems have

63-738: A frame language was the KL-ONE classifier. A later system built on common lisp was LOOM from the Information Sciences Institute. LOOM provided true object-oriented capabilities leveraging the Common Lisp Object System, along with a frame language. In the Semantic Web the Protege tool from Stanford provides classifiers (also known as reasoners) as part of the default environment. Rule-based systems In computer science ,

84-574: A logical interpretation, whereas production systems do not. A classic example of a production rule-based system is the domain-specific expert system that uses rules to make deductions or choices. For example, an expert system might help a doctor choose the correct diagnosis based on a cluster of symptoms, or select tactical moves to play a game. Rule-based systems can be used to perform lexical analysis to compile or interpret computer programs, or in natural language processing . Rule-based programming attempts to derive execution instructions from

105-447: A new kind of inference engine known as a classifier. A classifier could analyze a class hierarchy (also known as an ontology ) and determine if it was valid. If the hierarchy was invalid the classifier would highlight the inconsistent declarations. For a language to utilize a classifier it required a formal foundation. The first language to successfully demonstrate a classifier was the KL-ONE family of languages. The LOOM language from ISI

126-545: A part in the enabling technology of the Semantic Web . Modern classifiers leverage the Web Ontology Language . The models they analyze and generate are called ontologies . A classic problem in knowledge representation for artificial intelligence is the trade off between the expressive power and the computational efficiency of the knowledge representation system. The most powerful form of knowledge representation

147-498: A series of applications of various state-changing operators, which often gets quite involved (depending on the choices made in deciding which ECA rules fire, when, and so forth), and they can hardly be regarded as declarative". The logic programming family of computer systems includes the programming language Prolog , the database language Datalog and the knowledge representation and problem-solving language Answer Set Programming (ASP). In all of these languages, rules are written in

168-407: A starting set of data and rules. This is a more indirect method than that employed by an imperative programming language , which lists execution steps sequentially. A typical rule-based system has four basic components: Whereas the matching phase of the inference engine has a logical interpretation, the conflict resolution and action phases do not. Instead, "their semantics is usually described as

189-509: A subset of first-order logic with acceptable computation speeds. One of the first and most successful compromises was to develop languages based predominately on modus ponens , i.e. IF-THEN rules. Rule-based systems were the predominant knowledge representation mechanism for virtually all early expert systems . Rule-based systems provided acceptable computational efficiency while still providing powerful knowledge representation. Also, rules were highly intuitive to knowledge workers. Indeed, one of

210-429: Is first-order logic. However, it is not possible to implement knowledge representation that provides the complete expressive power of first-order logic. Such a representation will include the capability to represent concepts such as the set of all integers which are impossible to iterate through. Implementing an assertion quantified for an infinite set by definition results in an undecidable non-terminating program. However,

231-470: Is the generic RoleSet that captures the fact that the role may be filled with more than one filler. Deductive classifier A deductive classifier is a type of artificial intelligence inference engine . It takes as input a set of declarations in a frame language about a domain such as medical research or molecular biology. For example, the names of classes, sub-classes , properties, and restrictions on allowable values. The classifier determines if

SECTION 10

#1732858117564

252-485: The KL-ONE terminology a super class is said to subsume its subclasses . Multiple inheritance is allowed. Actually a concept is said to be well-formed only if it inherits from more than one other concept. All concepts, except the top concept (usually THING), must have at least one super class. In KL-ONE descriptions are separated into two basic classes of concepts: primitive and defined. Primitives are domain concepts that are not fully defined. This means that given all

273-484: The data points that encouraged researchers to develop rule-based knowledge representation was psychological research that humans often represented complex logic via rules. However, after the early success of rule-based systems there arose more pervasive use of frame languages instead of or more often combined with rules. Frames provided a more natural way to represent certain types of concepts, especially concepts in subpart or subclass hierarchies. This led to development of

294-493: The form of clauses : and are read as declarative sentences in logical form: In the simplest case of Horn clauses (or "definite" clauses), which are a subset of first-order logic , all of the A, B 1 , ..., B n are atomic formulae . Although Horn clause logic programs are Turing complete , for many practical applications, it is useful to extend Horn clause programs by allowing negative conditions, implemented by negation as failure . Such extended logic programs have

315-420: The knowledge representation capabilities of a non-monotonic logic . The most obvious difference between the two kinds of systems is that production rules are typically written in the forward direction, if A then B , and logic programming rules are typically written in the backward direction, B if A . In the case of logic programming rules, this difference is superficial and purely syntactic. It does not affect

336-462: The problem is deeper than not being able to implement infinite sets. As Levesque demonstrated, the closer a knowledge representation mechanism comes to first-order logic, the more likely it is to result in expressions that require infinite or unacceptably large resources to compute. As a result of this trade-off, a great deal of early work on knowledge representation for artificial intelligence involved experimenting with various compromises that provide

357-490: The properties of a concept, this is not sufficient to classify it. They may also be viewed as incomplete definitions. Using the same view, defined concepts are complete definitions. Given the properties of a concept, these are necessary and sufficient conditions to classify the concept. The slot-concept is called roles and the values of the roles are role-fillers. There are several different types of roles to be used in different situations. The most common and important role type

378-513: The response is simply to draw a conclusion B from an assumption A , as in modus ponens , the match-resolve-act cycle is restricted to reasoning forwards from A to B . Reasoning backwards in a production system would require the use of an entirely different kind of inference engine. In his Introduction to Cognitive Science, Paul Thagard includes logic and rules as alternative approaches to modelling human thinking. He does not consider logic programs in general, but he considers Prolog to be, not

399-438: The semantics of the rules. Nor does it affect whether the rules are used to reason backwards, Prolog style, to reduce the goal B to the subgoals A , or whether they are used, Datalog style, to derive B from A . In the case of production rules, the forward direction of the syntax reflects the stimulus-response character of most production rules, with the stimulus A coming before the response B . Moreover, even in cases when

420-676: The various declarations are logically consistent and if not will highlight the specific inconsistent declarations and the inconsistencies among them. If the declarations are consistent the classifier can then assert additional information based on the input. For example, it can add information about existing classes, create additional classes, etc. This differs from traditional inference engines that trigger off of IF-THEN conditions in rules. Classifiers are also similar to theorem provers in that they take as input and produce output via first-order logic . Classifiers originated with KL-ONE frame languages. They are increasingly significant now that they form

441-584: Was heavily influenced by KL-ONE. LOOM also was influenced by the rising popularity of object-oriented tools and environments. Loom provided a true object-oriented capability (e.g. message passing) in addition to frame language capabilities. Classifiers play a significant role in the vision for the next generation Internet known as the Semantic Web. The Web Ontology Language provides a formalism that can be validated and reasoned on via classifiers such as Hermit and Fact++. The earliest versions of classifiers were logic theorem provers . The first classifier to work with

SECTION 20

#1732858117564
#563436