Knowledge

Knowledge is the body of facts and principles. Knowledge can be language, concepts, procedures, rules, ideas, abstractions, places, customs, and so on. In philosophy, the study of knowledge is called epistemology. The philosopher Plato famously defined knowledge as "justified true belief." However, no single agreed definition of knowledge exists, though there are numerous theories to explain it.

Knowledge is a familiarity with someone or something, which can include facts, information, descriptions, or skills acquired through experience or education. It can refer to the theoretical or practical understanding of a subject. It can be implicit (as with practical skill or expertise)

Or

explicit (as with the theoretical understanding of a subject); it can be more or less formal or systematic.

Data

The data might concern numerical quantities of process elements that could include bottle weight, data about the soft drink colour.

Only when these sets of data are put in the right order or in a more specific and more organized framework will they have a meaning.

Information

In this example information could be an excel data sheet that describes several production elements of a specific drink lot.

For example, the title of the sheet could be: Weight of bottles for Coke, Lot No 12445, produced on 29/11/2013.

It is obvious that this sheet with organized information has a specific purpose (to control) and it is associated to a particular production element or object (Coke) and production event (bottles filled for lot No 12445 on 29/11/2013).

When the particular knowledge associated with the above data and information is discussed it could be easily realized that: 

1. Someone, who is expert in quality statistical control, must interpret the data sheet

2. In addition, this person, in order to make his decision, needs a framework for evaluating this information. The final decision of the quality manager could be to send the bottles back for refilling or to rank the lot as quality A or quality B and then decide to which markets the lot should be pushed to.

3. Only this expert was able to decide how the drinks lot in question varied from the past lots and from the quality standards and why this lot should be pushed to market A (more strict customers) or to market B (not so strict customers).

Wisdom

In this example the corresponding wisdom could be described as the ability of the quality expert or quality department to improve the whole quality control process by reviewing the quality standards again as well as by reviewing the required control process taking into consideration previous knowledge and experience.

In any of the above-mentioned cases the company will improve the quality control process.

Transfer of knowledge

Symbolic representations can be used to indicate meaning and can be thought of as a dynamic process. 

Other forms of communication include observation and imitation, verbal exchange, and audio and video recordings. Philosophers of language construct and analyze theories of knowledge transfer or communication. While many would agree that one of the most universal and significant tools for the transfer of knowledge is writing and reading, argument over the usefulness of the written word exists

Procedural knowledge

Procedural knowledge is compiled or processed form of information. Procedural knowledge is related to the performance of some task. For example, sequence of steps to solve a problem is procedural knowledge. In some legal systems, such procedural knowledge has been considered the intellectual property of a company, and can be transferred when that company is purchased.

One advantage of procedural knowledge is that it can involve more senses, such as hands-on experience, practice at solving problems, understanding of the limitations of a specific solution, etc.

Declarative knowledge

Declarative knowledge is passive knowledge in the form of statements of facts about the world.

the type of knowledge that is, by its very nature, expressed in declarative sentences or indicative propositions.  For example, mark statement of a student is declarative knowledge.

Heuristic knowledge

Heuristics knowledge are rules of thumb or tricks. Heuristic knowledge is used to make judgments and also to simplify solution of problems.

It is acquired through experience. An expert uses his knowledge that he has gathered due to his experience and learning. experience-based techniques for problem solving, learning, and discovery that give a solution which is not guaranteed to be optimal.

Where the exhaustive search is impractical, heuristic methods are used to speed up the process of finding a satisfactory solution via mental shortcuts to ease the cognitive load of making a decision.

Examples of this method include using a rule of thumb, an educated guess, an intuitive judgment, stereotyping, or common sense.

Organizing the Knowledge

• Representing the knowledge

– Frames

– Semantic Networks

– Rules

– Propositional and Predicate Logic

Frames

Frames were proposed by Marvin Minsky in his 1974 article "A Framework for Representing Knowledge." A frame is an artificial intelligence data structure used to divide knowledge into substructures by representing "stereotyped situations." Frames are the primary data structure used in artificial intelligence Frame languages.

Frames are also an extensive part of knowledge representation and reasoning schemes. Frames were originally derived from semantic networks and are therefore part of structure based knowledge representations. According to Russell and Norvig's "Artificial Intelligence, A Modern Approach," structural representations assemble "...facts about particular object and even types and arrange the types into a large taxonomic hierarchy analogous to a biological taxonomy."

Frame structure[edit]

The frame contains information on how to use the frame, what to expect next, and what to do when these expectations are not met. Some information in the frame is generally unchanged

while other information, stored in "terminals,"[clarification needed] usually change. Different frames may share the same terminals.

Each piece of information about a particular frame is held in a slot. The information can contain:

Facts or Data

Values (called facets)

Procedures (also called procedural attachments)

IF-NEEDED : deferred evaluation

IF-ADDED : updates linked information

Default Values

For Data

For Procedures

Other Frames or Subframes

Features and Advantages

A frame's terminals are already filled with default values, which is based on how the human mind works. For example, when a person is told "a boy kicks a ball," most people will visualize a particular ball (such as a familiar soccer ball) rather than imagining some abstract ball with no attributes.

One particular strength of frame based knowledge representations is that, unlike semantic networks, they allow for exceptions in particular instances. This gives frames an amount of flexibility that allow representations of real world phenomena to be reflected more accurately.

Like semantic networks, frames can be queried using spreading activation. Following the rules of inheritance, any value given to a slot that is inherited by subframes will be updated (IF-ADDED) to the corresponding slots in the subframes and any new instances of a particular frame will feature that new value as the default.

Because frames are structurally based, it is possible to generate a semantic network given a set of frames even though it lacks explicit arcs. Furthermore, the structure of frames allow for easy analogical reasoning, a much prized feature in any intelligent agent. The procedural attachments provided by frames also allow a degree of flexibility that makes for a more realistic representation and gives a natural affordance for programming applications.

Example

Worth noticing here is the easy analogical reasoning (comparison) that can be done between a boy and a monkey just by having similarly named slots.

Also notice that Alex, an instance of a boy, inherits default values like "Sex" from the more general parent object Boy, but the boy may also have different instance values in the form of exceptions such as the number of legs.

Semantic network

A semantic network, or frame network, is a network which represents semantic relations between

concepts. This is often used as a form of knowledge representation. It is a directed or undirected

graph consisting of vertices, which represent concepts, and edges.

Basics of semantic networks

A semantic network is used when one has knowledge that is best understood as a set of concepts

that are related to one another.

Most semantic networks are cognitively based. They also consist of arcs and nodes which can be

organized into a taxonomic hierarchy. Semantic networks contributed ideas of spreading

activation, inheritance, and nodes as proto-objects.

Limitations

Semantic networks are intractable for large domains, and they do not represent performance or

meta-knowledge very well.[citation needed]

Some properties are not easily expressed using a semantic network, e.g., negation, disjunction,

and general non-taxonomic knowledge. Expressing these relationships requires workarounds,

such as having complementary predicates and using specialized procedures to check for them,

but this can be regarded as less elegant.

Six most common kinds of semantic networks:

1: Definitional networks:

Emphasize the subtype or is-a relation between a concept type and a newly defined subtype.

The resulting network, also called a generalization or subsumption hierarchy, supports the rule

of inheritance for copying properties defined for a supertype to all of its subtypes.

Since definitions are true by definition, the information in these networks is often assumed to be

necessarily true.

2: Assertional networks:

Are designed to assert propositions. Unlike definitional networks, the information in an

assertional network is assumed to be contingently true, unless it is explicitly marked with a

modal operator.

Some assertional netwoks have been proposed as models of the conceptual structures underlying

natural language semantics.

3: Implicational networks:

Use implication as the primary relation for connecting nodes. They may be used to represent

patterns of beliefs, causality, or inferences.

Implicational networks emphasize implication, they are capable of expressing all the Boolean

connectives by allowing a conjunction of inputs to a propositional node and a disjunction of

outputs.

4: Executable networks:

Include some mechanism, such as marker passing or attached procedures, which can perform

inferences, pass messages, or search for patterns and associations.

Executable semantic networks contain mechanisms that can cause some change to the network

itself.

The simplest networks with attached procedures are dataflow graphs, which contain passive

nodes that hold data and active nodes that take data from input nodes and send results to output

nodes.

5: Learning networks:

Build or extend their representations by acquiring knowledge from examples. The new

knowledge may change the old network by adding and deleting nodes and arcs or by modifying

numerical values, called weights, associated with the nodes and arcs.

The purpose of learning, both from a natural and an AI standpoint, is to create modifications that

enable the system to respond more effectively within its environment.

6: Hybrid networks:

Combine two or more of the previous techniques, either in a single network or in separate, but

closely interacting networks.

Systems are usually called hybrids if their component languages have different syntax. . . The

most widely used hybrid of multiple network notations is the Unified Modeling

Language (UML), which was by designed by three authors . . . who merged their competing

notations.

Rules based Organizing of the Knowledge

In computer science, rule-based systems are used as a way to store and manipulate knowledge to

interpret information in a useful way. They are often used in artificial intelligence applications

and research.

In computer science, a rule-based system is a set of "if-then" statements that uses a set of

assertions, to which rules on how to act upon those assertions are created.

In software development, rule-based systems can be used to create software that will provide an

answer to a problem in place of a human expert. 

The human mental process is internal, and it is too complex to be represented as an

algorithm. However, most experts are capable of expressing their knowledge in the form

of rules for problem solving.

Rules as a knowledge representation technique

The term rule in AI, which is the most commonly used type of knowledge representation, can be

defined as an IF-THEN structure that relates given information or facts in the IF part to some

action in the THEN part.

A rule provides some description of how to solve a problem. Rules are relatively easy to create

and understand.

Any rule consists of two parts:

the IF part, called the antecedent (premise or condition)

and the THEN part called the consequent (conclusion or action).

The antecedent of a rule incorporates two parts: an object (linguistic object) and its value. The

object and its value are linked by an operator.

IF the ‘traffic light’ is greenTHEN the action is goIF the ‘traffic light’ is redTHEN the action is stop

The operator identifies the object and assigns the value. Operators such as is, are, is not, are not

are used to assign a symbolic value to a linguistic object.

Systems can also use mathematical operators to define an object as numerical and assign it to

the numerical value.

IF ‘age of the customer’ < 18

AND ‘cash withdrawal’ > 1000

THEN ‘signature of the parent’ is required

There's If Then, and Then There's If Then

It is very tempting to store if-then logical relationships in procedural code, especially since

procedural code has if-then statements.

In fact, not only is it tempting, it can work reasonably well up to a point.

However there is a big difference between a logical relationship and a procedural if-then. A

procedural if-then is really a branching statement, controlling the flow of execution of a

procedure. If the condition is true, control goes one way, and if not control goes a different way.

It's a fork in the road.

It's the road bit that causes the trouble. A logical relationship can be coded as a procedural if-

then, but must be placed somewhere along the road of execution of the procedure it is in.

Furthermore, if there are more logical relationships, they too must be placed at some point in the

procedural path—and, by necessity, the placement of one affects the behaviour of another. It

makes a difference which rule gets placed first, and if there are branches from previous rules, and

which branch a following rule is placed on.

This is not a problem if the rules map easily to a decision tree, but in that case the knowledge is

really procedural.

It's also not a problem if there are a small number of rules, but as the number of rules increases it

becomes very difficult to maintain them as forks in a procedural flow.

Databases for Rules

• It is possible, in some cases, to shoehorn logical relationships into a database. If the

relationships can be represented in a tabular form, then a database table can be used to

encode the rule.

• So for example, if the amount of discount a customer got was dependent on the amount

of previous sales at a few different levels, this could be represented as a table and stored

in a database.

• However, as with the using procedures, the database approach is limited in that it only

works for very clean sorts of logical relationships.

A Mixed Approach

procedural and database approaches. Logical relationships that can be expressed in tables are

stored in a database, and the remaining relationships are coded as procedural if-then statements.

This can simplify the coding task, but it makes maintenance harder because the logical

knowledge is now spread across two different vehicles.

Despite these difficulties, there is a strong appeal to using data, procedure or both to encode

logical knowledge, and that is that they are familiar techniques, and there are numerous

individuals skilled in their use. The problems with encoding logical relationships were first

explored back in the 1970s by researchers at Stanford University. They were trying to build a

system that advised physicians on courses of antibiotics for treating bacterial infections of the

blood and meningitis. They found that the medical knowledge consists mainly of logical

relationships that can be expressed as if-then rule.

They attempted many times to encode the knowledge using conventional tools, and failed

because of the problems described previously. If the problem with coding logical knowledge is

that the nature of a computer is not well-suited to expressing logical relationships, then clearly

the answer is to create a machine that is. Building specialized hardware is not very practical, but

it turns out a computer is a good tool for creating virtual computers.

This is what the researchers at Stanford did. They effectively created a virtual machine that was

programmed using logical rules. This type of virtual machine is often called a rule engine.

• Why is a computer good at building a rule engine, but not the rules themselves? It is

because behaviour of a rule engine can be expressed in a procedural algorithm, along the

lines of:

• Search for a rule that matches the pattern of data

• Execute that rule

• Go to top

• Forward chaining and backward chaining

Heuristic programming/ rule-based programming

The Stanford researchers who were working on the first rule-based systems had originally called

their work 'heuristic programming,' which is, of course, a fancy way of saying rule-based

programming.

Because a large amount of human thought seems to involve the dynamic applying of pattern-

matching rules stored in our brains, the idea surfaced that this was somehow 'artificial

intelligence'.

However the real reason for the growth of the term was pure and simple marketing—it was

easier to get Department of Defence funding for advanced research on Artificial Intelligence (AI)

than it was for heuristic programming. The term 'expert system' was also invented at about this

time for the same reasons.

The media too, was very excited about the idea of Artificial Intelligence and expert systems, and

the software industry went through a cycle of tremendous hype about AI, followed by

disillusionment as the technology simply couldn't live up to the hype.

Those companies that survived and continue to market and sell the technology have found the

term AI to be a detriment, so they looked for a different term. Now it is most often called rule-

based programming

Rule Knowledge Representation Language

Knowledge representation is the syntax of a particular tool. Each tool allows the entering of

logical knowledge in a certain format, which might be simple if-then statements referencing

simple entities, or complex if-then statements that reference complex objects and properties.

They can be in and English like syntax or more closely resemble formal logic. The classic design

tradeoffs of ease-of-use versus expressive power apply.

A tool might provide other means for expressing logical knowledge as well, such as hierarchical

structures,, and might include capabilities for expressing uncertainty.

Uncertainty is useful for some types of applications, like diagnosis where there isn't a clear right

answer, but just gets in the way for something like pricing where there is only one right answer.

Expert system

In artificial intelligence, an expert system is a computer system that emulates the decision-making ability of a human expert.[1] Expert systems are designed to solve complex problems by reasoning about knowledge, represented primarily as IF-THEN rules rather than through conventional procedural code.[2] The first expert systems were created in the 1970s and then proliferated in the 1980s.[3] Expert systems were among the first truly successful forms of AI software.

An expert system is divided into two sub-systems: the inference engine and the knowledge base. The knowledge base represents facts about the world and rules. The inference engine applies the rules to the known facts to deduce new facts. Inference engines can also include explanation and debugging capabilities.

Transferring Expertise

• Objective of an expert system

– To transfer expertise from an expert to a computer system and

– Then on to other humans (nonexperts)

• Activities

– Knowledge acquisition

– Knowledge representation

– Knowledge inferencing

– Knowledge transfer to the user

Knowledge is stored in a knowledge base

The main players in the development team

There are five members of the expert system development team: the domain expert, the knowledge engineer, the programmer, the project manager and the end-user.

The success of their expert system entirely depends on how well the members work together

Expert System

End-user

Knowledge Engineer ProgrammerDomain Expert

Project Manager

Expert SystemDevelopment Team

The domain expert

The domain expert is a knowledgeable and skilled person capable of solving problems in a specific area or domain.

This person has the greatest expertise in a given domain. This expertise is to be captured in the expert system.

Therefore, the expert must be able to communicate his or her knowledge, be willing to participate in the expert system development and commit a substantial amount of time to the project.

The domain expert is the most important player in the expert system development team.

The knowledge engineer

The knowledge engineer is someone who is capable of designing, building and testing an expert system.

He or she interviews the domain expert to find out how a particular problem is solved.

The knowledge engineer establishes what reasoning methods the expert uses to handle facts and rules and decides how to represent them in the expert system.

The knowledge engineer then chooses some development software or an expert system shell, or looks at programming languages for encoding the knowledge.

And finally, the knowledge engineer is responsible for testing, revising and integrating the expert system into the workplace.

The programmer

The programmer is the person responsible for the actual programming, describing the domain knowledge in terms that a computer can understand.

The programmer needs to have skills in symbolic programming in such AI languages as CLISP, Prolog and OPS5 and also some experience in the application of different types of expert system shells.

In addition, the programmer should know conventional programming languages like C, C++, C# and Basic.

The project manager

The project manager is the leader of the expert system development team, responsible for keeping the project on track.

He or she makes sure that all deliverables and milestones are met, interacts with the expert, knowledge engineer, programmer and end-user.

The end-user

The end-user, often called just the user, is a person who uses the expert system when it is developed.

The user must not only be confident in the expert system performance but also feel comfortable using it.

Therefore, the design of the user interface of the expert system is also vital for the project’s success; the end-user’s contribution here can be crucial.

Structure of a rule-based expert system

In the early seventies, Newell and Simon from Carnegie-Mellon University proposed a production system model, the foundation of the modern rule- based expert systems.

The production model is based on the idea that humans solve problems by applying their knowledge (expressed as production rules) to a given problem represented by problem-specific information.

The production rules are stored in the long-term memory and the problem-specific information or facts in the short-term memory.

Production system model

Conclusion

REASONING

Long-term Memory

ProductionRule

Short-term Memory

Fact

Production system model

Inference Engine

Knowledge Base

Rule: IF-THEN

Database

Fact

Explanation Facilities

User Interface

User

Basic structure of a rule-based expert system

Knowledge base

The knowledge base contains the domain knowledge useful for problem solving.

In a rule- based expert system, the knowledge is represented as a set of rules. Each rule specifies

a relation, recommendation, directive, strategy or heuristic and has the IF (condition) THEN

(action) structure.

When the condition part of a rule is satisfied, the rule is said to fire and the action part is

executed.

Database

The database includes a set of facts used to match against the IF (condition) parts of rules

stored in the knowledge base.

Inference engine

The inference engine carries out the reasoning whereby the expert system reaches a solution.

It links the rules given in the knowledge base with the facts provided in the database.

Explanation facilities

The explanation facilities enable the user to ask the expert system how a particular conclusion is

reached and why a specific fact is needed.

An expert system must be able to explain its reasoning and justify its advice, analysis or

conclusion.

User interface

The user interface is the means of communication between a user seeking a solution to the

problem and an expert system.

User

ExternalDatabase External Program

Inference Engine

Knowledge Base

Rule: IF-THEN

Database

Fact

Explanation Facilities

User Interface DeveloperInterface

Expert System

Expert

Knowledge Engineer

Complete structure of a rule-based expert system

Expert Systems Shells

The E.S shell simplifies the process of creating a knowledge base.

It is the shell that actually processes the information entered by a user relates it to the concepts

contained in the knowledge base and provides an assessment or solution for a particular problem.

Thus E.S shell provides a layer between the user interface and the computer O.S to manage the

input and output of the data.

It also manipulates the information provided by the user in conjunction with the knowledge base

to arrive at a particular conclusion.

An expert system is built to perform at a human expert level in a narrow, specialized domain.

Thus, the most important characteristic of an expert system is its high-quality performance. No

matter how fast the system can solve a problem, the user will not be satisfied if the result is

wrong.

On the other hand, the speed of reaching a solution is very important.

Even the most accurate decision or diagnosis may not be useful if it is too late to apply, for

instance, in an emergency, when a patient dies or a nuclear power plant explodes.

Expert systems apply heuristics to guide the reasoning and thus reduce the search area for a

solution.

A unique feature of an expert system is its explanation capability. It enables the expert system to

review its own reasoning and explain its decisions.

Expert systems employ symbolic reasoning when solving a problem. Symbols are used to

represent different types of knowledge such as facts, concepts and rules.

Can expert systems make mistakes?

Even a brilliant expert is only a human and thus can make mistakes.

This suggests that an expert system built to perform at a human expert level also should be

allowed to make mistakes. But we still trust experts, even we recognize that their judgments are

sometimes wrong.

Likewise, at least in most cases, we can rely on solutions provided by expert systems, but

mistakes are possible and we should be aware of this.

In expert systems, knowledge is separated from its processing (the knowledge base and the

inference engine are split up).

A conventional program is a mixture of knowledge and the control structure to process this

knowledge.

This mixing leads to difficulties in understanding and reviewing the program code, as any

change to the code affects both the knowledge and its processing.

When an expert system shell is used, a knowledge engineer or an expert simply enters rules in

the knowledge base. Each new rule adds some new knowledge and makes the expert system

smarter.

Comparison of expert systems with conventional systems and human experts

Human Experts Expert Systems Conventional Programs

Use knowledge in theform of rules of thumb orheuristics to solveproblems in a narrowdomain.

Process knowledgeexpressed in the form ofrules and use symbolicreasoning to solveproblems in a narrowdomain.

Process data and usealgorithms, a series ofwell-defined operations,to solve general numericalproblems.

In a human brain,knowledge exists in acompiled form.

Provide a clearseparation of knowledgefrom its processing.

Do not separateknowledge from thecontrol structure toprocess this knowledge.

Capable of explaining aline of reasoning andproviding the details.

Trace the rules firedduring a problem-solvingsession and explain how aparticular conclusion wasreached and why specificdata was needed.

Do not explain how aparticular result wasobtained and why inputdata was needed.

Human Experts Expert Systems Conventional Programs

Use inexact reasoning andcan deal with incomplete,uncertain and fuzzyinformation.

Permit inexact reasoningand can deal withincomplete, uncertain andfuzzy data.

Work only on problemswhere data is completeand exact.

Can make mistakes wheninformation is incompleteor fuzzy.

Can make mistakes whendata is incomplete orfuzzy.

Provide no solution at all,or a wrong one, when datais incomplete or fuzzy.

Enhance the quality ofproblem solving via yearsof learning and practicaltraining. This process isslow, inefficient andexpensive.

Enhance the quality ofproblem solving byadding new rules oradjusting old ones in theknowledge base. Whennew knowledge isacquired, changes areeasy to accomplish.

Enhance the quality ofproblem solving bychanging the programcode, which affects boththe knowledge and itsprocessing, makingchanges difficult.

Types of inference engines

• As Expert Systems evolved many new techniques were incorporated into various types of

inference engines. Some of the most important of these were:

– Truth Maintenance.

– Hypothetical Reasoning.

– Fuzzy Logic.

– Ontology Classification.

Truth Maintenance

Truth maintenance systems record the dependencies in a knowledge-base so that when facts are

altered dependent knowledge can be altered accordingly.

For example, if the system learns that Jon is no longer known to be a man it will revoke the

assertion that Jon is mortal.

Hypothetical Reasoning

In hypothetical reasoning, the knowledge base can be divided up into many possible views, aka

worlds.

This allows the inference engine to explore multiple possibilities in parallel.

In this simple example, the system may want to explore the consequences of both assertions,

what will be true if Jon is a Man and what will be true if he is not?

Fuzzy Logic

One of the first extensions of simply using rules to represent knowledge was also to associate a

probability with each rule.

So, not to assert that Jon is mortal but to assert Jon may be mortal with some probability value.

Simple probabilities were extended in some systems with sophisticated mechanisms for

uncertain reasoning and combination of probabilities.

Ontology Classification

With the addition of object classes to the knowledge base a new type of reasoning was possible.

Rather than reason simply about the values of the objects the system could also reason about the

structure of the objects as well.

In this simple example Man can represent an object class and R1 can be defined as a rule that

defines the class of all men.

These types of special purpose inference engines are known as classifiers. Although they were

not highly used in expert systems classifiers are very powerful for unstructured volatile domains

and are a key technology for the Internet and the emerging

Forward chaining and backward chaining

In a rule-based expert system, the domain knowledge is represented by a set of IF-THEN

production rules and data is represented by a set of facts about the current situation.

The inference engine compares each rule stored in the knowledge base with facts contained in

the database. When the IF (condition) part of the rule matches a fact, the rule is fired and its

THEN (action) part is executed. The matching of the rule IF parts to the facts produces inference

chains. The inference chain indicates how an expert system applies the rules to reach a

conclusion.

Knowledge Base

Database

Fact: A is x

Match Fire

Fact: B is y

Rule: IF A is x THEN B is y

Rule1: IF Y is trueAND D is trueTHEN Z is true

Rule2: IF X is trueAND B is trueAND E is trueTHEN Y is true

Rule3: IF A is trueTHEN X is true

A X

B

E

Y

DZ

Forward chaining

Forward chaining is one of the two main methods of reasoning when using inference rules.

Forward chaining is a popular implementation strategy for expert systems, business and

production rule systems. . Forward chaining starts with the available data and uses inference

rules to extract more data until a goal is reached.

An inference engine using forward chaining searches the inference rules until it finds one where

the If clause is known to be true. When such a rule is found, the engine can conclude, the Then

clause, resulting in the addition of new information to its data. Inference engines

will iterate through this process until a goal is reached.

• For example, suppose that the goal is to conclude the color of a pet named Fritz, given

that he croaks and eats flies, and that the rule base contains the following four rules:

• If X croaks and eats flies - Then X is a frog

• If X chirps and sings - Then X is a canary

• If X is a frog - Then X is green

• If X is a canary - Then X is yellow

Backward chaining

Backward chaining (or backward reasoning) is an inference method that can be described as

working backward from the goal(s).

It is used in automated theorem provers, proof assistants and other artificial

intelligence applications.

In game theory, its application to (simpler) subgames in order to find a solution to the game is

called backward induction Backward chaining starts with a list of goals (or a hypothesis) and

works backwards from the consequent to the antecedent to see if there is data available that will

support any of these consequents. An inference engine using backward chaining would search

the inference rules until it finds one which has a consequent (Then clause) that matches a desired

goal. If the antecedent (If clause) of that rule is not known to be true, then it is added to the list

of goals (in order for one's goal to be confirmed one must also provide data that confirms this

new rule).

• For example, suppose that the goal is to conclude whether Tweety or Fritz is a frog, given

information about each of them, and that the rule base contains the following four rules:

1. If X croaks and eats flies – Then X is a frog

2. If X chirps and sings – Then X is a canary

3. If X is a frog – Then X is green

4. If X is a canary – Then X is yellow

Methods used for conflict resolution

Fire the rule with the highest priority. In simple applications, the priority can be established

by placing the rules in an appropriate order in the knowledge base. Usually this strategy

works well for expert systems with around 100 rules.

Fire the most specific rule. This method is also known as the longest matching strategy. It is

based on the assumption that a specific rule processes more information than a general one.

Fire the rule that uses the data most recently entered in the database. This method relies on

time tags attached to each fact in the database. In the conflict set, the expert system first fires

the rule whose antecedent uses the data most recently added to the database.

What Is CLIPS?

CLIPS is an expert system tool originally developed by the Software Technology Branch

(STB), NASA/Lyndon B. Johnson Space Center. Since its first release in 1986, CLIPS has

undergone continual refinement and improvement. It is now used by thousands of people around

the world.

CLIPS is designed to facilitate the development of software to model human knowledge or

expertise.

There are three ways to represent knowledge in CLIPS:

• Rules, which are primarily intended for heuristic knowledge based on experience.

• Deffunctions and generic functions, which are primarily intended for procedural knowledge.

•Object-oriented programming, also primarily intended for procedural knowledge.

The five generally accepted features of object-oriented programming are supported: classes,

message-handlers, abstraction, encapsulation, inheritance, polymorphism. Rules may pattern

match on objects and facts.

You can develop software using only rules, only objects, or a mixture of objects and rules.

CLIPS has also been designed for integration with other languages such as C and Java. In fact,

CLIPS is an acronym for C Language Integrated Production System. Rules and objects form an

integrated system too since rules can pattern-match on facts and objects. In addition to being

used as a stand-alone tool, CLIPS can be called from a procedural language, perform its function,

and then return control back to the calling program. Likewise, procedural code can be defined as

external functions and called from CLIPS. When the external code completes execution, control

returns to CLIPS. If you are already familiar with object-oriented programming in other

languages such as C++, Smalltalk, Objective C, or Java, you know the advantages of objects in

developing software. If you are not familiar with object-oriented programming, you will find that

CLIPS is an excellent tool for learning this new concept in software development.

Introduction

CLIPS is a type of computer language designed for writing applications called expert systems.

An expert system is a program which is specifically intended to model human expertise or

knowledge. In contrast, common programs such as payroll programs, word processors,

spreadsheets, computer games, and so forth, are not intended to embody human expertise or

knowledge. (One definition of an expert is someone more than 50 miles from home and carrying

a briefcase.)

CLIPS is called an expert system tool because it is a complete environment for developing

expert systems which includes features such as an integrated editor and a debugging tool. The

word shell is reserved for that portion of CLIPS which performs inferences or reasoning. The

CLIPS shell provides the basic elements of an expert system:

1. fact-list, and instance-list: Global memory for data

2. knowledge-base: Contains all the rules, the rule-base

3. inference engine: Controls overall execution of rules

A program written in CLIPS may consist of rules, facts, and objects. The inference engine

decides which rules should be executed and when. A rule-based expert system written in CLIPS

is a data-driven program where the facts, and objects if desired, are the data that stimulate

execution via the inference engine.

This is one example of how CLIPS differs from procedural languages such as Java,

Ada, BASIC, FORTRAN, and C. In procedural languages, execution can proceed

without data. That is, the statements are sufficient in those languages to cause

execution. For example, a statement such as PRINT 2 + 2 could be immediately

executed in BASIC. This is a complete statement that does not require any additional

data to cause its execution. However, in CLIPS, data are required to cause the

execution of rules.

Originally, CLIPS had capabilities to represent only rules and facts. However, the

enhancements of Version 6.0 allow rules to match objects as well as facts. Also, objects

may be used without rules by sending messages and so the inference engine is no

longer necessary if you use only objects. In chapters 1 through 7, we'll discuss the facts

and rules of CLIPS. The object features of CLIPS are covered in chapters 8 through 12.

The Beginning and the End

To begin CLIPS, just enter the appropriate run command for your system. You should

see the CLIPS prompt appear as follows:

CLIPS>

At this point, you can start entering commands directly into CLIPS. The mode in which

you are entering direct commands is called the top-level. If you have a Graphical User

Interface (GUI) version of CLIPS, you can also select some commands using the

mouse or arrow keys rather than typing them in. Please refer to the CLIPS Interfaces

Guide for a discussion of the commands supported by the various CLIPS GUIs. For

simplicity and uniformity in this book, we'll assume the commands are typed in.

The normal mode of leaving CLIPS is with the exit command. Just type

(exit)

in response to the CLIPS prompt and then press the carriage return key.

Making a List

As with other programming languages, CLIPS recognizes certain keywords. For

example, if you want to put data in the fact-list, you can use the assert command.

As an example of assert, enter the following right after the CLIPS prompt as shown:

CLIPS> (assert (duck))

Here the assert command takes (duck) as its argument. Be sure to always press the

carriage return key to send the line to CLIPS.

You will see the response

<Fact-1>

which indicates CLIPS has stored the duck fact in the fact-list and given it the identifier

1. The angle-brackets are used as a delimiter in CLIPS to surround the name of an

item. CLIPS will automatically name facts using a sequentially increasing number and

list the highest fact-index when one or more facts is asserted.

Notice that the (assert) command and its (duck) argument are surrounded by

parentheses. Like many other expert system languages, CLIPS has a LISP-like syntax

which uses parentheses as delimiters. Although CLIPS is not written in LISP, the style

of LISP has influenced the development of CLIPS.

And Checking It Twice

Suppose you want to see what's in the fact-list. If your version of CLIPS supports a GUI,

you may just select the appropriate command from the menu. Alternatively, you can

enter commands from the keyboard. In the following, we'll describe the keyboard

commands since the window selections are self-explanatory.

The keyboard command to see facts is with the facts command. Enter (facts) in

response to the CLIPS prompt and CLIPS will respond with a list of facts in the fact-list.

Be sure to put parentheses around the command or CLIPS will not accept it. The result

of the (facts) command in this example should be

CLIPS> (facts)

f-0 (initial-fact)

f-1 (duck)

For a total of 2 facts.

CLIPS>

The terms f-0 and f-1 are the fact identifier assigned to each fact by CLIPS. Every

fact inserted into the fact-list is assigned a unique fact identifier starting with the letter "f"

and followed by an integer called the fact-index. On starting up CLIPS, and after certain

commands such as clear and reset (to be discussed in more detail later), the factindex

will be set to zero, and then incremented by one as each new fact is asserted.

The (reset) and (clear) commands will also insert a fact (initial-fact) as f-0. In prior

versions of CLIPS this fact was used implicitly by CLIPS to initially activate some types

of rules and could also be used explicitly by user programs to activate rules as well, but

is now only provided for backwards compatibility.

What happens if you try to put a second duck into the fact-list? Let's try it and see.

Assert a new (duck), then issue a (facts) command as follows

CLIPS> (assert (duck))

FALSE

CLIPS> (facts)

f-0 (initial-fact)

f-1 (duck)

For a total of 2 facts.

CLIPS>

The FALSE message is returned by CLIPS to indicate that it was not possible to

perform this command. You'll see just the original "f-1 (duck)". This shows that CLIPS

will not accept a duplicate entry of a fact. However, there is an override command,

set-fact-duplication, which will allow duplicate fact entry.

Of course you can put in other, different facts. For example, assert a (quack) fact and

then issue a (facts) command. You'll see

CLIPS> (assert (quack))

<Fact-2>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (duck)

f-2 (quack)

For a total of 3 facts.

f-0 (initial-fact)

f-1 (duck)

For a total of 2 facts.

CLIPS>

The terms f-0 and f-1 are the fact identifier assigned to each fact by CLIPS. Every

fact inserted into the fact-list is assigned a unique fact identifier starting with the letter "f"

and followed by an integer called the fact-index. On starting up CLIPS, and after certain

commands such as clear and reset (to be discussed in more detail later), the factindex

will be set to zero, and then incremented by one as each new fact is asserted.

The (reset) and (clear) commands will also insert a fact (initial-fact) as f-0. In prior

versions of CLIPS this fact was used implicitly by CLIPS to initially activate some types

of rules and could also be used explicitly by user programs to activate rules as well, but

is now only provided for backwards compatibility.

What happens if you try to put a second duck into the fact-list? Let's try it and see.

Assert a new (duck), then issue a (facts) command as follows

CLIPS> (assert (duck))

FALSE

CLIPS> (facts)

f-0 (initial-fact)

f-1 (duck)

For a total of 2 facts.

CLIPS>

The FALSE message is returned by CLIPS to indicate that it was not possible to

perform this command. You'll see just the original "f-1 (duck)". This shows that CLIPS

will not accept a duplicate entry of a fact. However, there is an override command,

set-fact-duplication, which will allow duplicate fact entry.

Of course you can put in other, different facts. For example, assert a (quack) fact and

then issue a (facts) command. You'll see

CLIPS> (assert (quack))

<Fact-2>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (duck)

f-2 (quack)

For a total of 3 facts.

CLIPS>

Notice that the (quack) fact is now in the fact-list.

Facts may be removed or retracted. When a fact is retracted, the other facts do not

have their indices changed, and so there may be "missing" fact-indices. As an analogy,

when a football player leaves a team and is not replaced, the jersey numbers of the

other players are not all adjusted because of the missing number (unless they really

hate the guy's guts and want to forget he ever played for them.)

Clearing Up the Facts

The clear command removes all facts from memory, as shown by the following.

CLIPS> (facts)

f-0 (initial-fact)

f-1 (duck)

f-2 (quack)

For a total of 3 facts.

CLIPS> (clear)

CLIPS>

and all facts in the fact-list will be removed.

The (clear) command essentially restores CLIPS to its original startup state. It clears

the memory of CLIPS, resets the fact-identifier to zero, and asserts the (initial-fact). To

see this, assert (animal-is duck), then check the fact-list. Notice that (animal-is duck)

has a fact-identifier of f-1 because the (clear) command reset the fact identifiers. The

(clear) command actually does more than just remove facts. Besides removing all the

facts, (clear) also removes all the rules, as you'll see in the next chapter.

The following example shows how three facts are asserted, and the (facts) command

is used. The (clear) command is used to get rid of all facts in memory and reset the factindices

to start with f-0.

CLIPS> (clear)

CLIPS> (assert (a) (b) (c))

<Fact-3>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (a)

f-2 (b)

f-3 (c)

For a total of 4 facts.

CLIPS> (facts 0)

f-0 (initial-fact)

f-1 (a)

f-2 (b)

f-3 (c)

For a total of 4 facts.

CLIPS> (facts 1)

f-1 (a)

f-2 (b)

f-3 (c)

For a total of 3 facts.

CLIPS> (facts 2)

f-2 (b)

f-3 (c)

For a total of 2 facts.

CLIPS> (facts 1 2)

f-1 (a)

f-2 (b)

For a total of 2 facts.

CLIPS> (facts 1 3 2)

f-1 (a)

f-2 (b)

For a total of 2 facts.

CLIPS>

Notice only one (assert) is used to assert the three facts, (a), (b), and (c). The highest

fact-index is 3 and this is returned by CLIPS in the informational message <Fact-3>.

The much longer alternative would be to assert one fact per command (This may be

done by people who like to show off their typing speed.)

Sensitive Fields and Slurping

A fact such as (duck) or (quack) is said to consist of a single field. A field is a

placeholder (named or unnamed) that may have a value associated with it. As a simple

analogy, you can think of a field as a picture frame. The frame can hold a picture,

perhaps a picture of your pet duck (For those of you who are curious what a picture of a"quack"

looks like, it could be (1) a photo of an oscilloscope trace of a duck saying

"quack", where the signal input comes from a microphone, or (2) for those of you who

are more scientifically inclined, a Fast Fourier Transform of the "quack" signal, or (3) a

TV-huckster selling a miracle cure for wrinkles, losing weight, etc.). Named placeholders

are only used with deftemplates, described in more detail in chapter 5.

The (duck) fact has a single, unnamed placeholder for the value duck. This is an

example of a single-field fact. A field is a placeholer for a value. As an analogy to

fields, think of dishes (fields) for holding food (values).

The order of unnamed fields is significant. For example, if a fact was defined

(Brian duck)

and interpreted by a rule as the hunter Brian shot a duck, then the fact

(duck Brian)

would mean that the hunter duck shot a Brian. In contrast, the order of named fields is

not significant, as you'll see later with deftemplate.

Actually, it is good software engineering to start the fact with a relation that describes

the fields. A better fact would be

(hunter-game duck Brian)

to imply that the first field is the hunter and the second field is the game.

A few definitions are now necessary. A list is a group of items with no implied order.

Saying that a list is ordered means that the position in the list is significant. A

multifield is a sequence of fields, each of which may have a value. The examples of

(duck Brian) and (Brian duck) are multifield facts. If a field has no value, the special

symbol nil, which means "nothing" may be used for an empty field as a placeholder. For

example,

(duck nil)

would mean that the killer duck bagged no trophies today.

Note that the nil is necessary to indicate a placeholder, even if it has no value. For

example, think of a field as analogous to a mailbox. There's a big difference between an

empty mailbox, and no mailbox at all. Without the nil, the fact becomes a single-field fact

(duck). If a rule depends on two fields, it will not work with only one field, as you'll see

later.

There are a number of different types of fields available: float, integer, symbol,

string, external-address, fact-address, instance-name and instance-address The

type of each field is determined by the type of value stored in the field. In an unnamed

field, the type is determined implicitly by what type you put in the field. In deftemplates,

you can explicitlty declare the type of value that a field can contain. The use of explicit

types enforces the concepts of software engineering, which is a discipline of

programming to produce quality software.

A symbol is one type of field that starts with a printable ASCII character and is

followed optionally by zero or more printable characters. Fields are commonly delimited

or bounded, by one or more spaces or parentheses. For example,

(duck-shot Brian Gary Rey)

has four fields to indicate all the hunters shot by the killer duck. In this fact, the fields are

delimited by spaces, and the opening and closing parentheses.

Facts are not allowed to be embedded within other facts. For example, the following

is an illegal ordered fact.

(duck (shot Brian Gary Rey))

However, this could be a legal deftemplate fact if "shot" is defined as the name of a

field, while "Brian Gary Rey" are the values associated with the named field.

CLIPS is case-sensitive. Also, certain characters have special meaning to CLIPS.

" ( ) & | < ~ ; ? $

The "&", "|", and "~" may not be used as stand-alone symbols or as any part of a

symbol.

Some characters act as delimiters by ending a symbol. The following characters act

as delimiters for symbols.

• any non-printable ASCII character, including spaces, carriage returns, tabs, and

Linefeeds • double quotes, "

• opening and closing parentheses, ()

• ampersand, &

• vertical bar, |

• less than, <. Note that this may be the first character of a symbol

• tilde, ~

• semicolon, ; indicates start of a comment, a carriage return ends it

• ? and $? may not begin a symbol but may be inside it

The semicolon acts as the start of a comment in CLIPS. If you try to assert a

semicolon, CLIPS will think you're entering a comment and wait for you to finish. If you

accidentally enter a semicolon in top-level, just type in a closing parenthesis and

carriage return. CLIPS will respond with an error message and the CLIPS prompt will

reappear (This is one of the few approved occasions in life in which it's necessary to do

something wrong to get something right.)

As you read through this manual, you will learn the special meanings of the

characters above. With the exception of the "&", "|", and "~", you may use the others as

described. However, it may be confusing to someone reading your program and trying

to understand what the program is doing. In general, it's best to avoid using these

characters in symbols unless you have some good reason for using them.

The following are examples of symbols.

duck

duck1

duck_soup

duck-soup

duck1-1_soup-soup

d!?#%^

The second type of field is the string. A string must begin and end with double

quotes. The double quotes are part of the field. Zero or more characters of any kind can

appear between the double quotes. Some examples of strings follow.

"duck"

"duck1"

"duck/soup"

"duck soup"

"duck soup is good!!!"

The third and fourth types of field are numeric fields. A field which represents a

number which can be either an integer or floating-point type field. A floating-point type

is commonly referred to simply as a float.

All numbers in CLIPS are treated as “long long” integers or double-precision floats.

Numbers without a decimal point are treated as integers unless they are outside integer

range. The range is machine dependent on the number of bits, N, used to represent the

integer as follows.

- 2N-1 ... 2N-1-1

For 64-bit “long long” integers, this corresponds to a range of numbers

- 9,223,372,036,854,775,808 ... 9,223,372,036,854,775,807

As some examples of numbers, assert the following data where the last number is in

exponential notation, and uses the "e" or "E" for the power-of-ten.

CLIPS> (clear)

CLIPS> (facts)

f-0 (initial-fact)

For a total of 1 fact.

CLIPS> (assert (number 1))

<Fact-1>

CLIPS> (assert (x 1.5))

<Fact-2>

CLIPS> (assert (y -1))

<Fact-3>

CLIPS> (assert (z 65))

<Fact-4>

CLIPS> (assert (distance 3.5e5))

<Fact-5>

CLIPS> (assert (coordinates 1 2 3))

<Fact-6>

CLIPS> (assert (coordinates 1 3 2))

<Fact-7>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (number 1)

f-2 (x 1.5)

f-3 (y -1)

f-4 (z 65)

f-5 (distance 350000.0)

f-6 (coordinates 1 2 3)

f-7 (coordinates 1 3 2)

For a total of 8 facts.

CLIPS>

As you can see, CLIPS prints the number entered in exponential notation as 350000.0

because it converts from power-of-ten format to floating-point if the number is small

enough.

Notice that each number must start with a symbol such as "number", "x", "y", etc.

Before CLIPS version 6.0, it was possible to enter only a number as a fact. However,

now a symbol is required as the first field. Also, certain reserved words used by CLIPS

cannot be used as the first field, but may be used for other fields. For example, the

reserved word not is used to indicate a negated pattern and may not be used as the first

field of a fact.

A fact consists of one or more fields enclosed in matching left and right parentheses.

For simplicity we'll only discusss facts in the first seven chapters, but most of the

discussion of pattern matching applies to objects as well. Exceptions are certain

functions such as assert and retract which only apply to facts, not objects. The

corresponding ways to handle objects are discussed in chapters 8–12.

A fact may be ordered or unordered. All the examples you've seen so far are

ordered facts because the order of fields makes a difference. For example, notice that

CLIPS considers these as separate facts although the same values "1", "2", and "3" are

used in each.

f-6 (coordinates 1 2 3)

f-7 (coordinates 1 3 2)

Ordered facts must use field position to define data. As an example, the ordered fact

(duck Brian) has two fields and so does (Brian duck). However, these are considered as

two separate facts by CLIPS because the order of field values is different. In contrast,

the fact (duck-Brian) has only one field because of the "-" concatenating the two values.

Deftemplate facts, described in more detail later, are unordered because they use

named fields to define data. This is analogous to the use of structs in C and other languages.

Multiple fields normally are separated by white space consisting of one or more

spaces, tabs, carriage returns, or linefeeds. For example, enter the following examples

as shown and you'll see that each stored fact is the same.

CLIPS> (clear)

CLIPS> (assert (The duck says "Quack"))

<Fact-1>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (The duck says "Quack")

For a total of 2 facts.

CLIPS> (clear)

CLIPS> (assert (The duck says "Quack" ))

<Fact-1>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (The duck says "Quack")

For a total of 2 facts.

CLIPS>

Carriage returns may also be used to improve readability. In the following example, a

carriage return is typed after every field and the asserted fact is the same as before

when the fact was entered on one line.

CLIPS> (clear)

CLIPS> (assert (The

duck

says

"Quack"))

<Fact-1>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (The duck says "Quack")

For a total of 2 facts.

CLIPS>

However, be careful if you insert a carriage return inside of a string, as the following

example shows.

languages.

Multiple fields normally are separated by white space consisting of one or more

spaces, tabs, carriage returns, or linefeeds. For example, enter the following examples

as shown and you'll see that each stored fact is the same.

CLIPS> (clear)

CLIPS> (assert (The duck says "Quack"))

<Fact-1>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (The duck says "Quack")

For a total of 2 facts.

CLIPS> (clear)

CLIPS> (assert (The duck says "Quack" ))

<Fact-1>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (The duck says "Quack")

For a total of 2 facts.

CLIPS>

Carriage returns may also be used to improve readability. In the following example, a

carriage return is typed after every field and the asserted fact is the same as before

when the fact was entered on one line.

CLIPS> (clear)

CLIPS> (assert (The

duck

says

"Quack"))

<Fact-1>

CLIPS> (facts)

f-0 (initial-fact)

f-1 (The duck says "Quack")

For a total of 2 facts.

CLIPS>

However, be careful if you insert a carriage return inside of a string, as the following

example shows.

CLIPS>

As you can see, CLIPS replaced the carriage returns and tabs with single spaces.

While the use of white space in separating the facts is convenient for a person reading a

program, they are converted to single spaces by CLIPS.

Making Good Rules

To accomplish useful work, an expert system must have rules as well as facts. Sinceyou've seen how facts are asserted and retracted, it's time to see how rules work. A ruleis similar to an IF THEN statement in a procedural language like Java, C, or Ada. An IFTHEN rule can be expressed in a mixture of natural language and computer languageas follows:IF certain conditions are trueTHEN execute the following actionsAnother term for the above statement is pseudocode, which literally means falsecode. While pseudocode cannot be directly executed by the computer, it serves as avery useful guide to writing executable code. Pseudocode is also helpful in documentingrules. A translation of rules from natural language to CLIPS is not very difficult if youkeep this IF THEN analogy in mind. As your experience with CLIPS grows, you'll findthat writing rules in CLIPS becomes easy. You can either type rules directly into CLIPSor load rules in from a file of rules created by a text editor.The pseudocode for a rule about duck sounds might beIF the animal is a duck

THEN the sound made is quack— 22 —The following is a fact, and a rule named duck which is the pseudocode aboveexpressed in CLIPS syntax. The name of the rule follows immediately after the keyworddefrule. Although you can enter a rule on a single line, it's customary to put differentparts on separate lines to aid readability and editing.CLIPS> (unwatch facts)CLIPS> (clear)CLIPS> (assert (animal-is duck))<Fact-1>CLIPS> (defrule duck(animal-is duck)=>(assert (sound-is quack)))CLIPS>If you type in the rule correctly as shown, you should see the CLIPS prompt reappear.Otherwise, you'll see an error message. If you get an error message, it is likely that youmisspelled a keyword or left out a parenthesis. Remember, the number of left and rightparentheses always must match in a statement.The same rule is shown following with comments added to match the parts of therule. Also shown is the optional rule-header comment in quotes, "Here comes thequack". There can be only one rule-header comment and it must be placed after the rulename and before the first pattern. Although we're only discussing pattern matchingagainst facts now, more generally a pattern can be matched against a pattern entity. Apattern entity is either a fact or an instance of a user-defined class. Pattern matching onobjects will be discussed later.CLIPS tries to match the pattern of the rule against a pattern entity. Of course, whitespace consisting of spaces, tabs, and carriage returns may be used to separate theelements of a rule to improve readability. Other comments begin with a semicolon andcontinue until the carriage return key is pressed to terminate a line. Comments areignored by CLIPS.— 23 —(defrule duck "Here comes the quack" ; Rule header(animal-is duck) ; Pattern=> ; THEN arrow(assert (sound-is quack))) ; Action• Only one rule name can exist at one time in CLIPS.Entering the same rule name, in this case "duck", will replace any existing rule withthat name. That is, while there can be many rules in CLIPS, there can be only one rulewhich is named "duck". This is analogous to other programming languages in whichonly one procedure name can be used to uniquely identify a procedure.The general syntax of a rule is shown following.(defrule rule_name "optional_comment"(pattern_1) ; Left-Hand Side (LHS)(pattern_2) ; of the rule consisting of elements. ; before the "=>"

.

.(pattern_N)=>(action_1) ; Right-Hand Side (RHS)(action_2) ; of the rule consisting of elements. ; after the "=>".(action_M)) ; the last ")" balances the opening; "(" to the left of "defrule". Be; sure all your parentheses balance; or you will get error messagesThe entire rule must be surrounded by parentheses. Each of the rule patterns andactions must be surrounded by parentheses. An action is actually a function whichtypically has no return value, but performs some useful action, such as an (assert) or(retract). For example, an action might be (assert (duck)). Here the function name is"assert" and its argument is "duck". Notice that we don't want any return value such as anumber. Instead, we want the fact (duck) to be asserted. A function in CLIPS is a pieceof executable code identified by a specific name, which returns a useful value or— 24 —performs a useful side-effect, such as (printout).A rule often has multiple patterns and actions. The number of patterns and actions donot have to be equal, which is why different indices, N and M, were chosen for the rulepatterns and actions.Zero or more patterns may be written after the rule header. Each pattern consists ofone or more fields. In the duck rule, the pattern is (animal-is duck), where the fields are"animal-is" and "duck". CLIPS attempts to match the patterns of rules against facts inthe fact-list. If all the patterns of a rule match facts, the rule is activated and put on theagenda. The agenda is a collection of activations which are those rules which matchpattern entities. Zero or more activations may be on the agenda.The symbol "=>" that follows the patterns in a rule is called an arrow. The arrowrepresents the beginning of the THEN part of an IF-THEN rule (and may be read as"implies").The last part of a rule is the list of zero or more actions that will be executed when therule fires. In our example, the one action is to assert the fact (sound-is quack). The termfires means that CLIPS has selected a certain rule for execution from the agenda.• A program will cease execution when no activations are on the agenda.When multiple activations are on the agenda, CLIPS automatically determines whichactivation is appropriate to fire. CLIPS orders the activations on the agenda in terms ofincreasing priority or salience.The part of the rule before the arrow is called the left-hand side (LHS) and the part ofthe rule after the arrow is called the right-hand side (RHS). If no patterns are specified,CLIPS automatically activates the rule when a (reset) command is entered.Let's Get QuackingCLIPS always executes the actions on the RHS of the highest priority rule on theagenda. This rule is then removed from the agenda and the actions of the new highest

salience rule is executed. This process continues until there are no more activations ora command to stop is encountered.You can check what's on the agenda with the agenda command. For example,CLIPS> (agenda)0 duck: f-1For a total of 1 activation.— 25 —CLIPS>The first number "0" is the salience of the "duck" activation, and "f-1" is the factidentifierof the fact, (animal-is duck), which matches the activation. If the salience of arule is not declared explicitly, CLIPS assigns it the default value of zero, where thepossible salience values range from -10,000 to 10,000. In this book, we'll use thedefinition of the term default as meaning the standard way.If there is only one rule on the agenda, that rule will fire. Since the LHS pattern of theduck-sound rule is(animal-is duck)this pattern will be satisfied by the fact (animal-is duck) and so the duck-sound ruleshould fire.Each field of the pattern is said to be a literal constraint. The term literal meanshaving a constant value, as opposed to a variable whose value is expected to change.In this case, the literals are "animal-is" and "duck".To make a program run, just enter the run command. Type (run) and press thecarriage return key. Then do a (facts) to check that the fact was asserted by the rule.CLIPS> (run)CLIPS> (facts)f-0 (initial-fact)f-1 (animal-is duck)f-2 (sound-is quack)For a total of 3 facts.CLIPS>Before going on, let's save the duck rule with the save command so that you don'thave to type it in again (if you haven't already saved it in an editor). Just enter acommand such as(save "duck.clp")to save the rule from CLIPS memory to disk and name the file "duck.clp" where the".clp" is simply a convenient extension to remind us this is a CLIPS source code file.— 26 —Note that saving the code from CLIPS memory like this will only preserve the optionalrule-header comment in quotes and not any semicolon comments.Kick your DuckAn interesting question may occur to you at this time. What if you (run) again? There isa rule and a fact which satisfies the rule, so the rule should fire. However, if you try thisand (run) again, you'll see that the rule won't fire. This may be somewhat frustrating.However, before you do something drastic to ease your frustration — like kicking yourpet duck — you need to know a little more about some basic principles of expertsystems.

A rule is activated if its patterns are matched by a1. a brand new pattern entity that did not exist before or,2. a pattern entity that did exist before but was retracted and reasserted, i.e., a"clone" of the old pattern entity, and thus now a new pattern entity.The rule, and indices of the matching patterns, is the activation. If either the rule orthe pattern entity, or both change, the activation is removed. An activation may also beremoved by a command or an action of another rule that fired before and removed theconditions necessary for activation.The Inference Engine sorts the activations according to their salience. This sortingprocess is called conflict resolution because it eliminates the conflict of deciding whichrule should fired next. CLIPS executes the RHS of the rule with the highest salience onthe agenda, and removes the activation. This execution is called firing the rule inanalogy with the firing of a neuron. A neuron emits a voltage pulse when an appropriatestimulus is applied. After a neuron fires, it undergoes refraction and cannot fire againfor a certain period of time. Without refraction, neurons would just keep firing over andover again on exactly the same stimulus.Without refraction, expert systems always would be caught in trivial loops. That is, assoon as a rule fired, it would keep firing on that same fact over and over again. In thereal world, the stimulus that caused the firing eventually would disappear. For example,a real duck might swim away or get a job in the movies. However, in the computerworld, once data is stored, it stays there until explicitly removed or the power is turnedoff.The following example shows activations and firing of a rule. Notice that the (watch)commands are used to more carefully show every fact and activation. The arrow goingto the right means an entering fact or activation while an arrow to the left would mean anexiting fact or activation.CLIPS> (clear)CLIPS> (defrule duck(animal-is duck)=>(assert (sound-is quack)))CLIPS> (watch facts)CLIPS> (watch activations)CLIPS> (assert (animal-is duck))==> f-1 (animal-is duck)==> Activation 0 duck: f-1 ; Activation salience is 0 by<Fact-1> ; default, then rule name:pattern entity indexCLIPS> (assert (animal-is duck)) ; Notice that duplicate factFALSE ; cannot be enteredCLIPS> (agenda)0 duck: f-1For a total of 1 activation.CLIPS> (run)==> f-2 (sound-is quack)CLIPS> (agenda) ; Nothing on agenda after rule firesCLIPS> (facts)

f-0 (initial-fact) ; Even though fact matches rule,f-1 (animal-is duck) ; refraction will not allow thisf-2 (sound-is quack) ; activation because the rule alreadyFor a total of 3 facts. ; fired on this factCLIPS> (run)CLIPS>You can make the rule fire again if you retract the fact and then assert it as a new fact.Show Me the RulesSometimes you may want to see a rule while you're in CLIPS. There's a commandcalled ppdefrule – the pretty print rule – that prints a rule. To see a rule, specify the rulename as an argument to ppdefrule. For example,CLIPS> (ppdefrule duck)(defrule MAIN::duck— 28 —(animal-is duck)=>(assert (sound-is quack)))CLIPS>CLIPS puts different parts of the rule on different lines for the sake of readability. Thepatterns before the arrow are still considered the LHS and the actions after the arroware still considered the RHS of the rule. The term MAIN refers to the MAIN module thatthis rule is in by default. You can define modules to put rules in analogous to thestatements that may be put in different packages, modules, procedures, or functions ofother programming languages. The use of modules make it easier to write expertsystems having many rules since these may be grouped together with their ownagendas for each module. For more information, see the CLIPS Reference Manual.What if you want to print a rule but can't remember the name of the rule? Noproblem. Just use the rules command in response to a CLIPS prompt and CLIPS willprint out the names of all the rules. For example, enterCLIPS> (rules)duckFor a total of 1 defrule.CLIPS>Write to MeBesides asserting facts in the RHS of rules, you also can print out information using theprintout function. CLIPS also has a carriage return/linefeed keyword called crlf which isvery useful in improving the appearance of output by formatting it on different lines. Fora change, the crlf is not included in parentheses. As an example,CLIPS> (defrule duck(animal-is duck)=>(printout t "quack" crlf)) ; Be sure to type in the "t"==> Activation 0 duck: f-1CLIPS> (run)quackCLIPS>

— 29 —The output is the text within the double quotes. Be sure to type the letter "t" followingthe printout command. This tells CLIPS to send the output to the standard outputdevice of your computer. Generally, the standard output device is your terminal (hencethe letter "t" after printout.) However, this may be redefined so that the standard outputdevice is some other device, such as a modem or disk.

Stop And Go

Until now, you've only seen the simplest type of program consisting of just one rule.

However, expert systems consisting of only one rule are not very useful. Practical expert

systems may consist of hundreds or thousands of rules. Let's now take a look at an

application requiring multiple rules.

Suppose you wanted to write an expert system to determine how a mobile robot

should respond to a traffic light. It is best to write this type of problem using multiple

rules. For example, the rules for the red and green light situations can be written as

follows.

(defrule red-light

(light red)

=>

(printout t "Stop" crlf))

(defrule green-light

(light green)

=>

(printout t "Go" crlf))

After the rules have been entered into CLIPS, assert a fact (light red) and run. You'll

see "Stop" printed. Now assert a (light green) fact and run. You should see "Go" printed.

— 32 —

Take a Walk

If you think about it, other possibilities beside the simple red, green, and yellow cases

exist. Some traffic lights also have a green arrow for protected left turns. Some have a

hand that lights up to indicate whether a person can walk or not. Some have signs that

say walk or don't walk. So depending on whether our robot is walking or driving, it may

have to pay attention to different signs.

The information about walking or driving must be asserted in addition to information

about the status of the light. Rules can be made to cover these conditions, but they

must have more than one pattern. For example, suppose we want a rule to fire if the

robot is walking and if the walk-sign says walk. A rule could be written as follows:

(defrule take-a-walk

(status walking)

(walk-sign walk)

=>

(printout t "Go" crlf))

The above rule has two patterns. Both patterns must be satisfied by facts in the

fact-list for the rule to fire. To see how this works, enter the rule and then assert the

facts (status walking) and (walk-sign walk). When you (run), the program will print out

"Go" since both patterns are satisfied and the rule is fired.

You can have any number of patterns or actions in a rule. The important point to

realize is that the rule is placed on the agenda only if all the patterns are satisfied by

facts. This type of restriction is called a logical AND conditional element (CE) in

reference to the AND relation of Boolean logic. An AND relation is said to be true only if

all its conditions are true.

Because the patterns are of the logical AND type, the rule will not fire if only one of

the patterns is satisfied. All facts must be present before the LHS of a rule is satisfied

and the rule is placed on the agenda.

A Question of Strategy

The word strategy was originally a military term for the planning and operations of

warfare. Today, the term strategy is commonly used in business (because business is

— 33 —

war) to refer to the high-level plans of an organization in achieving its goals, e.g., "Make

a lot of money by selling more greasy hamburgers than anyone else in the world!"

In expert systems, one use of the term strategy is in conflict resolution of activations.

Now you might say, "Well, I'll just design my expert system so that only one rule can

possibly be activated at one time. Then there is no need for conflict resolution." The

good news is that if you succeed, conflict resolution is indeed unnecessary. The bad

news is that this success proves that your application can be well represented by a

sequential program. So you should have coded it in C, Java, or Ada in the first place

and not bothered writing it as an expert system.

CLIPS offers seven different modes of conflict resolution: depth, breadth, LEX, MEA,

complexity, simplicity, and random. It's difficult to say that one is clearly better than

another without considering the specific application. Even then, it may be difficult to

judge which is "best." For more information on the details of these strategies, see the

CLIPS Reference Manual.

The depth strategy is the standard default strategy of CLIPS. The default setting is

automatically set when CLIPS is first started. Afterwards, you can change the default

setting. In the depth strategy, new activations are placed on the agenda after activations

with higher salience, but before activations with equal or lower salience. All this simply

means is that the agenda is ordered from highest to lowest salience.

In this book, all discussions and examples will assume depth strategy.

Now that all these different optional settings are available, be sure that before you run

an expert system developed by someone else, that your settings are the same as theirs.

Otherwise, you may find the operation is inefficient or even incorrect. In fact, it's a good

idea to explicitly encode all the settings in any system that you develop so that it will be

configured properly.

Gimme Deffacts

As you work with CLIPS, you may become tired of typing in the same assertions from

the top-level. If you are going to use the same assertions every time a program is run,

you can first load assertions from a disk using a batch file. An alternative way to enter

facts is by using the define facts keyword, deffacts. For example,

CLIPS> (unwatch facts)

CLIPS> (unwatch activations)

— 34 —

CLIPS> (clear)

CLIPS> (deffacts walk "Some facts about walking"

(status walking) ; fact to be asserted

(walk-sign walk)) ; fact to be asserted

CLIPS> (reset) ; causes facts from defacts to be asserted

CLIPS> (facts)

f-0 (initial-fact)

f-1 (status walking)

f-2 (walk-sign walk)

For a total of 3 facts.

CLIPS>

The required name of this deffacts statement, walk, follows the deffacts keyword.

Following the name is an optional comment in double quotes. Like the optional

comment of a rule, the (deffacts) comment will be retained with the (deffacts) after it's

been loaded by CLIPS. After the name or comment are the facts that will be asserted in

the fact-list. The facts in a deffacts statement are asserted using the CLIPS (reset) command.

The (initial-fact) is put in automatically by a (reset). The fact-identifier of the initial-fact

is always f-0. Even without any deffacts statements, a (reset) always will assert an

(initial-fact). In prior versions of CLIPS this fact was used to activate some types of

rules, but is no longer used for this purpose. It is provided for backwards compatibility

for programs which explicitly match against this fact.

The (reset) has an advantage compared to a (clear) command in that (reset) doesn't

get rid of all the rules. The (reset) leaves your rules intact. Like (clear), it removes all

activated rules from the agenda and also removes all old facts from the fact-list. Giving

a (reset) command is a recommended way to start off program execution, especially if

the program has been run before and the fact-list is cluttered with old facts.

In summary, the (reset) does three things for facts.

(1) It removes existing facts from the fact-list, which may remove activated rules

from the agenda.

(2) It asserts (initial-fact).

(3) It asserts facts from existing (deffacts) statements.

Actually, the (reset) also does corresponding operations on objects. It deletes

instances, creates initial-object, and asserts instances from definstances.

— 35 —

Selective Elimination

The undeffacts command excises a (deffacts) from asserting facts by eliminating the

deffacts from memory. For example,

CLIPS> (undeffacts walk)

CLIPS> (reset)

CLIPS> (facts)

f-0 (initial-fact)

For a total of 1 fact.

CLIPS>

This example demonstrates how the (deffacts) walk has been excised. To restore a

deffacts statement after an (undeffacts) command, you must enter the deffacts

statement again. You can even get rid of initial-fact with (undeffacts). In addition to facts,

CLIPS also allows you to eliminate rules selectively by using the undefrule.

Watch It!

You can watch rules firing and watch activations on the agenda. The watch

statistics prints information about the number of rules fired, run time, rules per second,

mean number of facts, maximum number of facts, mean number of activations, and

maximum number of activations. The statistics information may be useful in tuning up

an expert system to optimize its speed. Another command, called watch compilations,

shows information when rules are being loaded. The watch all command will watch

everything.

Printing of watch information to the screen or to disk with the dribble command will

slow down your program somewhat because CLIPS uses more time to print or to save

to disk. The dribble-on command will store everything entered in the Dialog Window to

a disk file until the dribble-off command is entered. This is convenient in providing a

permanent record of everything that happens. These commands are as follows.

(dribble-on <filename>)

(dribble-off <filename>)

Another useful debugging command is (run) which takes an optional argument of the

— 36 —

number of rule firings. For example, a (run 21) command would tell CLIPS to run the

program and then stop after 21 rule firings. A (run 1) command allows you to step

through a program firing one rule at a time. The (step) command is equivalent to

(run 1).

Just like many other programming languages, CLIPS also gives you the capability of

setting breakpoints. A breakpoint is simply an indicator to CLIPS to stop execution just

prior to executing a specified rule. A breakpoint is set by the set-break command. The

remove-break command will remove a breakpoint that has been set. The show-breaks

will list all the rules which have breakpoints set. The syntax of these rules for the

argument <rulename> is shown following.

(set-break <rulename>)

(remove-break <rulename>)

(show-breaks)

A Good Match

You may encounter a situation in which you are certain a rule should be activated but

isn't. While it is possible that this is due to a bug in CLIPS, it's not very likely because of

the great skill of the people who programmed CLIPS (NOTE: PAID COMMERCIAL

ANNOUNCEMENT FOR THE DEVELOPERS)

In most cases, the problem occurs because of the way that you wrote the rule. As an

aid to debugging, CLIPS has a command called matches that can tell you which

patterns in a rule match facts. Patterns which do not match prevent the rule from

becoming activated. One common reason that a pattern won't match a fact results from

misspelling an element in the pattern or in the assertion of the fact.

The argument of (matches) is the name of the rule to be checked for matches. To see

how (matches) works, first (clear), then enter the following rule.

(defrule take-a-vacation

(work done) ; Conditional element 1

(money plenty) ; Conditional element 2

(reservations made) ; Conditional element 3

=>

(printout t "Let's go!!!" crlf))

— 37 —

The following shows how (matches) is used. Enter the commands as shown. Notice

that (watch facts) is turned on. This is a good idea when you are asserting facts

manually since it gives you an opportunity to check the spelling of facts.

CLIPS> (watch facts)

CLIPS> (assert (work done))

==> f-1 (work done)

<Fact-1>

CLIPS> (matches take-a-vacation)

Matches for Pattern 1

f-1

Matches for Pattern 2

None

Matches for Pattern 3

None

Partial matches for CEs 1 - 2 ; CE is conditional element

None

Partial matches for CEs 1 - 3

None

Activations

None

CLIPS>

The fact with fact-identifier f-1 matches the first pattern or conditional element in the

rule and is reported by (matches). Given that a rule has N patterns, the term partial

matches refers to any set of matches of the first N-1 patterns with facts. That is, the

partial matches begin with the first pattern in a rule and end with any pattern up to but

not including the last (Nth) pattern. As soon as one partial match cannot be made,

CLIPS does not check any further. For example, a rule with four patterns would have

partial matches of the first and second patterns and also of the first, second, and third

patterns. If all N patterns match, the rule will be activated.

Other Features

Some additional commands are useful with deffacts. For example, the command

list-deffacts will list the names of currently loaded deffacts in CLIPS. Another useful

command is ppdeffacts which prints the facts stored in a deffacts.

Other functions allow you to manipulate strings easily.

Function Meaning

assert-string Performs a string assertion by taking a string as argument

and asserted as a nonstring fact.

str-cat Constructs a single-quoted string from individual items by

string concatenation

str-index Returns a string index of first occurrence of a substring

sub-string Returns a substring from a string.

str-compare Performs a string compare

str-length Returns the string length which is the length of a string:

sym-cat Returns a concatenated symbol.

If you want to printout a multifield variable without parentheses, the simplest way is by

using the string implode function, implode$.