UNIT-III

Knowledge Engineering
Knowledge engineering can be defined as the branch of engineering that analyzes knowledge
about some subject and transforms it to a computable form for some purpose.

PRINCIPLES OF KNOWLEDGE REPRESENTATION

There arefive basic principles about knowledge representation:
1. A knowledge representation is a surrogate. Physical objects, events, and relationships,
which cannot be stored directly in a computer, are represented by symbols that serve
as surrogates for the external things.
2. A knowledge representation is a set of ontological commitments. Ontology is thestudy
of existence. For a database or knowledge base, ontology determines thecategories of
things that exist or may exist in an application domain.
3. A knowledge representation is a fragmentary theory of intelligent reasoning. To
support reasoning about the things in a domain, a knowledge representationmust also
describe their behavior and interactions.
4. A knowledge representation is a medium for efficient computation. Besides
representingknowledge, an AI system must encode knowledge in a form that canbe
processed efficiently on the available computing equipment.
5. A knowledge representation is a medium of human expression. A good
knowledgerepresentation language should facilitate communication between the
knowledgeengineers who understand AI and the domain expertswho understand
theapplication. Although the knowledge engineers may write the definitions andrules,
the domain experts should be able to read them and verify whether theyrepresent a
realistic theory of the domain.
SURROGATE
A computational model is a surrogate for some real or hypotheticalsystem - in this case, the
traffic light. Each of the significant entities, such as the current time or the color of the light,
is assigned a variable that serves as an internal surrogate for the external entity. Then the
values of those variables can be transformed, either procedurally or declaratively, to simulate
the behavior of the system.
ONTOLOGICAL COMMITMENTS
By Quine's criterion, the ontological commitmentsare determined by the types of variables in
the knowledge representation.For the traffic light example, the variables stand for the
significant entities, such as the light itself, the current time, the current color, the last time
when the colorchanged, the duration the light is red or green, and the switch for automatic
control. Those commitments may be represented by variables in predicate calculus, by
concepts in a graph, or by slots in data structures called frames, schemas, or templates.
Following is a template for trafficLight, written in a rule-based language called CLIPS:
(deftemplatetrafficLight
(slot name (type SYMBOL))
(slotcurrentColor (allowed-values red green))
(slotredTime (type FLOAT) )
(slotgreenTime (type FLOAT) )
(slotwhenChanged (type FLOAT) )
(slotautoSwitch (allowed-values on off)) )
This template has six slots.
After the template has been defined, it can be instantiated by anassert statement, which
inserts values in the slots. The autoSwitch slot would have the initial value on, but it could be
turned off for manual control.
(assert (trafficLight
(nameBlinky)
(currentColorgreen)
(redTime60)
(greenTime60)
(whenChanged0)
(autoSwitchon) ) )
MEDIUM FOR EFFICIENT COMPUTATION
Both the procedural and the declarative approaches can be transformed to a computable form.
The following program simulates the traffic light by a loop that alternately sets the color to
red or green:
loop while autoSwitch;
setcurrentColor to red;
waitredTime;
setcurrentColor to green;
waitgreenTime;
end loop;
As a knowledge representation, however, it lacks one essential feature: there is no way to get
information out of it. The traffic light doesn't explain why it changes color, it doesn't keep a
record of its color changes, and it doesn't answer questions about the average time it was red
or green or was being operated under manual control.
The declarative way to simulate the traffic light is to translate the Englishdescription to
formulas in logic and to prove theorems about its states.
Following are two axioms that represent the conditions for the light to turn green or red:
(∀x:TrafficLight) (∀t:Time) (∀r:Duration)
((turnsRed(x,t) /\redTime(x,r) /\autoSwitch(on))
⸧turnsGreen(x,t+r)).
(∀x:TrafficLight)(∀t:Time)(∀g:Duration)
((turnsGreen(x,t) /\greenTime(x,g) /\autoSwitch(on))
⸧turnsRed(x,t+g)).
The first axiom says that for any traffic light x,time t, and duration r, if x turnsred at time t,
the red time of x is r, and the autoswitch is turned on, then x turns green at time t +r. The
second axiom is the same, but with green and red interchanged.
MEDIUM FOR HUMAN EXPRESSION
Conceptual graphs and other diagrams have been used successfully asa communication
medium between knowledge engineers and domain experts.
The conceptual graph could be translated tostylized English:
If a traffic light x turns red at time t,
has a red time of a duration r,
and has autoswitch in the state on,
thenx turns green at a time, which is the sum of t and r.
SIMUI.ATION AND THEOREM PROVING
Logic has greater flexibility; it can be used to design a simulator, but it can also be used to
prove theorems:
•Blinky turns green at every even-numbered minute.
•Blinkyturns red at every odd-numbered minute.
• Blinky turns green 30 times per hour.
• Blinky will spend 50 percent of its time red.
• A traffic light with red time rand green time gwill be red for r/ (r + g) of the time.
• A traffic light with red time r and green time g will turn green an average of
3600/(r + g) times per hour.
Theorem proving can derive general principles with absolute certainty. Simulation
andtheorem proving can supplement one another: patterns that are suggested by simulation
can be verified by theorem proving.

Representing Structure in Frames

Besides representing knowledge, a language must be able to analyze knowledge inlow-level
primitives and organize it in high-level structures. In natural language, the basic unit is the
word, and the basic structure is the sentence. But higher-level structures like paragraphs,
sections, chapters, and volumes are needed to classify and organize the knowledge. In
symbolic logic, the basic units are predicates, which are connected by operators like/\, ˅,
and ⸧ to create formulas. In conceptual graphs, the basic units are concepts and relations,
which are linked to one another in graphs. Besides linking, .a knowledge representation
language must have methods of grouping or nesting that can organize knowledge and
package it in larger structures.
FRAMES
A frame is a data structure for representing a stereotyped situation, like being in a certain
kind of living room or going to a child's birthday party.
A frame can be considered as a network of nodes and relations. The "top levels" of a frame
are fixed, and represent things that are always true about the supposed situation. The lower
levels have many terminals- "slots" that must be filled by specific instances of data.
Following is a frame that defines the type TrafficLight:
(defineTypeTrafficLight
(supertype Object)
(currentColor (type Color) (oneOf (red green)))
(redTime (type Duration))
(greenTime (type Duration))
(whenChanged (type PointInTime) )
(autoSwitch (type State) (oneOf (on off))))
The CLIPS assertion for Blinky corresponds to an instance definition:
(defineInstanceBlinky
(typeTrafficLight)
(currentColor green)
(redTime (60 second))
(greenTime (60 second))
(whenChanged (0 : 00 hour))
(autoSwitch on))

Besides creating types and instances, frame definitions specify supertypes toform a hierarchy
with inheritance.
The following frame declares the type Truck with supertype Vehicle and with slots for
unloaded weight, maximum gross weight, cargo capacity, and number of wheels:
(defineTypeTruck
(supertype Vehicle)
(unloadedWt(type WtMeasure) )
(maxGrossWt (type WtMeasure))
(cargoCapacity(type VolMeasure))
(numberOfWheels (type Integer)))
A type TrailerTruck could be defined as a subtype of Truck:
(defineTypeTrailerTruck
(supertypeTruck)
(has Part(type Trailer))
(numberOfWheels 18))
Trailer Truck would inherit the information for Truck by a process of merging the slotsfor the
Truck frame with the slots for the TrailerTruck frame.
(defineTypeTrailerTruck
(supertype Truck)
(unloadedWt(type WtMeasure))
(maxGrossWt(type WtMeasure))
(cargoCapacity(type VolMeasure))
(has Part(type Trailer))
(nurnberOfWheels 18))
MAPPING FRAMES TO LOGIC
The information in a frame can be translated to any notation for first-orderlogic.
[TrafficLight: Blinky]-
(currentColor) → [Color: green]
(redTime) → [Duration: <60, second>]
(greenTime) → [Duration: <60, second>]
(whenChanged) →[PointInTime: <0:00, hour>]
(autoSwitch) → [State: on]
In predicate calculus
(Ǝx:TrafficLight)(x= Blinky/\
currentColor(x,green) /\
redTime(x, <60,second>) /\
greenTime(x,<60,second>) /\
whenChanged(x, <0:00,hour>) /\
autoswitch(x,on)).
In conceptual graphs and predicate calculus, that merger is based on a rule of inference called
unification.
Following are the Truck and TrailerTruck frames translated to CG type definitions:
typeTruck ( *x) is
[Vehicle: ?x] -
(UnloadedWt) → [WtMeasure]
(MaxGrossWt) → [WtMeasure]
(CargoCapacity) → [VolMeasure]
(NumberOfWheels) → [Integer].
A trailer truck is then defined as a type of truck:
typeTrailerTruck'( *x) is
[Truck: ?x] -
(HasPart) → [Trailer]
(NumberOfWheels) → [Integer: 18].
In predicate calculus, the CG type definitions map to monadic lambda expressions that are
equivalent line by line to the CG and frame definitions:

Truck=
(λx: Vehicle) (
(Ǝy1:WtMeasure)unloadedWt(x,y1) /\
(Ǝy2:WtMeasure)maxGrossWt(x,y2) /\
(Ǝy3:VolMeasure)cargoCapacity(x,y3) /\
(Ǝy4:Integer)numberOfWheels(x,y4)
TrailerTruck =
(λx: Truck) (
(Ǝy1:Trailer)hasPart(x,y1) /\
(Ǝy2:Integer)(numberOfWheels(x,y2) /\ y2=18)).

FRAMES AND SYLLOGISMS

A frame is a package of propositions about sometype or some instance of a type. Logically, a
frame that defines n slots for a type tis a conjunction of n universal affirmative (type A)
propositions that are true for every instance of the type t.
Every truck
• is a vehicle.
• has an unloaded weight, whose value is a weight measure.
• has a maximum gross weight, whose value is a weight measure.
• has a cargo capacity, whose value is a volume measure.
• has a number of wheels, whose value is an integer.
A frame that defines n slots for an instance x is a conjunction of n particular affirmative (type
I) propositions that are true of x. The instance frame for X39071 D asserts two type I
propositions:

X39071D
• is a truck.
• has a cargo capacity of 25 cubic meters.
• has 6 wheels.
The two principal rules of inference in frame systems are based on the syllogisms
Barbara and Darii. Barbara supports inheritance from supertypes to subtypes:
A: Every truck has a cargo capacity.
A: Every trailer truck is a truck.
A: Therefore, every trailer truck has a cargo capacity.
The syllogism Darii supports inheritance from type frames to instance frames:
A: Every truck has a cargo capacity.
I: X39071D is a truck.
I: Therefore, X3907ID has a cargo capacity.
KL-ONE
Minskyoriginally described a frame as "a network of nodes and relations." Ronald
Brachman(1979) designed a network notation for his Knowledge Language One (KL-ONE),
which is the ancestor of many frame systems.

Figure 3.2shows the information in the Truck and TrailerTruck frames represented in a
KLONE network. The network has nine ovals for concept nodes and nine arrows, which
represent different kinds of links. The double-linearrows represent subtype-supertype links
from TrailerTruck to Truck and fromTruck to Vehicle. The arrows with a circle in the middle
represent roles, which correspond to the slots other than supertype in the previous frames.
The Truck node has four roleslabeledUnloadedWt, MaxGrossWt, CargoCapacity, and
NumberOfWheels. The TrailerTruck node has two roles, one labeledHasPart and one that
restricts the NumberOfWheels role of Truck to the value 18.

Rules and Data

During the 1970s rule-based expert systems were designed while Ted Codd at IBM
developed the theory of relational databases. Expert systems use repeated executions of rules
on relatively small amounts of data, while database systems execute short chains of rules on
large amounts of data.
The convergence of the two kinds of systems results from their common logical foundations:
they both store data in the existential-conjunctive (EC) subset of logic, and they use the same
rules of inference to answer questions, perform updates, and check constraints.
The two primary rules are called modus ponens (mode of putting) and modus tollens(mode of
taking away):
• Modus ponens. From the formulas p and (p⸧q), infer the consequent q.
• Modus tollens. From the formulas ~q and (p⸧q), infer the denial of the antecedent ~p.

Repeated execution of modus ponens is called forward chainingand repeated modus tollens is
called backward chaining. As an example, consider the following chain of implications:
p⸧q. q⸧r. r⸧s.
Forward chaining proceeds in the direction of the implications: given an assertion
p, the first rule leads to the new assertion q;then q plus the second rule produces
r; finally r plus the third rule produces s.
Backward chaining goes in the reverse direction: given a negation ~s, the last rule produces
~r; then ~r plus the middle rule produces ~q;and ~q plus the first rule produces ~p.
In applications, forward chaining is commonly used to make insertions and modifications to a
database or working memory, and backward chaining is used to answer questions.

MICROPLANNER, PROLOG, AND SQL

Microplanner, a language derived fromPlanner, pioneered techniques that have been used in
both expert systems and relational databases.
Figure 3.3 shows a database for representing blocks and pyramids. On the right side of Figure
3.3 are two database relations, named Objects and Supports. The Objects relation identifies
each object in the stack, its shape, and its color. The supports relation shows which objects
are supporters and supportees.
Microplanner can be used as both a database query language and a problem solving language
for updating and transforming the database.
Consider thethree goal statements in Microplanner:
(goal (objects ?xl block?))
(goal (objects ?x2 pyramid?))
(goal(supports ?xl ?x2))
The first goal searches the objects relation for an object xl of shape block, thesecond searches
for an object x2 of shape pyramid, and the third searches the supports relation to determine
whether xl supports x2.
To answer a query, Microplanner, Prolog, and SQL use a technique called backtracking.
1. Search the objects relation to find some block xl;
if there are no more blocks, then stop and report failure.
2. Search the objects relation to find some pyramid x2;
if no more pyramids, backtrack to step 1 to find another block xl.
3. Check whether xl supports x2;
if so, stop and return xl as the answer;
if not, backtrack to step 2 to find another pyramid x2.
For the database shown in Figure 3.3, they would find the block D at step 1 andthe pyramid A
at step 2. Since D does not support A, they would backtrack to step
2 to try pyramid B, then C, and finally E. Since D supports E, they would stop with Das the
answer for the variable xl.

LOGICAL FOUNDATIONS
Thetwo database relations in Figure 3.3, for example, can be mapped to that form withonly
the Ǝ quantifier and the /\operator.
Every row of the objects relation maps to a proposition of the following form:
(Ǝx:Object)(id(x,A) /\ shape(x,pyramid) /\ color(x,red)).
There exists an x of type object whose id is A and whose shape is pyramid and whose color is
red.
Every row of the supports relation maps to aproposition of the form,
(Ǝx:Support)(supportee(x,A) /\supporter(x,D)).
This formula says There exists an x of type support whose supportee is A and whose
supporter is D.

FORWARD CHAINING
Rules have two parts: a pattern that is matched to something in the database or working
memory, and an action to be performed ifthe pattern match succeeds:
pattern => action.
This kind of rule is called a production rule.
An important use of forward-chaining rules is to check and correct possible violations of
integrityconstraintson database relations.
(defrulecheckForBoxSupporter
(supports ?x ?y)
(objects ?x box ?)
=>
(assert (contains ?x ?y)))
The pattern part of this rule is invoked for every assertionthat some x supports some y. Then
if x is an object of shape box, the action part asserts that x contains y. To make the contains
relation transitive, the following rule checks whether the supporter xis contained in some z. If
so, it also asserts that z contains y.
(defrulemakeContainsTransitive
(supports ?x ?y)
(contains ?z ?x)
=>
(assert (contains ?z ?y)))
Together, these two rules maintain the consistency of the contains, supports, and objects
relations with respect to the constraint that boxes contain anything they support, either
directly or indirectly.

Object-Oriented Systems
The object-oriented programming systems (OOPS) combine a declarative style for specifying
objects with a procedural style for defining the actions by and upon those objects. An 0-0
language has three components: a programming language, a frame system, and a structure
that encapsulates the procedures with the frames.

0-0 DECLARATIONS
The frame examples can be translated to Java, one of the most popular object-oriented
languages.
Following is a Java declaration for a class that corresponds to the Truck frame:

public class Truck extends Vehicle {

//Define an instance variable for each slot in the frame.
privateWtMeasureunloadedWt, maxGrossWt;
privateVolMeasurecargoCapacity;
private Wheel[] wheels;
//The methods return the current values of the private variables.
publicWtMeasureunloadedWt() {return unloadedWt;};
publicWtMeasuremaxGrossWt() {return maxGrossWt;};
publicVolMeasurecargoCapacity() {return cargoCapacity;};
publicintnumberOfWheels() {return wheels.length;};
}

The top line declares Truck as an extension or subtype of Vehicle. The Truck class inherits
declarations from the Vehicle class in the same way frames inherit from supertypes.
The Trailer Truck class extends Truck with another variable for the trailer and a method
called a constructor, which initializes some of the variables:

public class TrailerTruck extends Truck {

//Inherits from Truck and adds the following:
private protected Trailer trailer;
//Constructor to initialize each new TrailerTruck.
publicTrailerTruck() {
trailer = new Trailer;
wheels= new Wheel[18];
for (inti=0; i<l8; i++)
wheels[i] = new Wheel;
}
}

The constructor creates a new object of type Trailer, which it assigns to the variable named
trailer. To initialize the variable wheels, it creates an array to hold 18 wheels and creates a
new instance ofWheel for each element of the array.

MAPPING FRAMES AND RULES TO OBJECTS

Frames and 0-0 systems differ in the way they allow procedures to access the slotsor instance
variables:
• To a host language like LISP or C, frames look like a network of globally accessible
records. The programs can read the slots, modify them, and follow chains of pointers from
one frame to another.
• In an 0-0 system, the objects can be encapsulated. Only programs or methods in the
declaration of the object class or one of its subclasses can access private variables directly.

Generating procedural code from logic specifications is more difficult, but many special
cases can be automated:
• Backward chaining. Deterministic Horn-clause rules, which require no backtracking, can be
translated to if-then statements and recursive subroutine calls. This technique, called
recursive descent, is widely used to translate grammar rules to executable code.
• Forward chaining. To support an SQL-style of triggers, the Java library defines two classes,
called Observer and Observable. Each object of type Observable maintains a list of pointers
to objects of type Observer, which may be affected by changes in the observable data.
Whenever a change occurs, the observable sends an update message to each ofits observers.

LOGIC-BASED 0-0 SYSTEMS

In conceptualgraphs, contexts are represented by concept boxes that contain nested graphs
that describe the referent of the concept. In predicate calculus, the nesting can be represented
by the description predicate dscr(x,p), which relates an object x to a proposition p that
describes x. To illustrate the encapsulation, Figure 3.4 shows a graph for a birthday party that
occurred at the point in time (PTim) of 26 May 1996.

Figure 3.4 may be translated to the following formula in predicate calculus:

(Ǝx:BirthdayParty)(date(26Mayl996) /\ptim(x,26May1996)).
This formula says that there exists a birthday party x, 26 May 1996 is a date, and the point in
time of xwas 26 May 1996.
Inside the large box in Figure 3.5, the first graph says that 40 guests are givingpresents to a
person named Marvin, and the second one says that 50 candles are on a cake. The relations
Agnt, Ptnt, and Rcpt are linguistic case relations that indicate the agent (guests who are
giving), the patient (presents that are being given), and the recipient (the birthday boy,
Marvin). The notation{*} indicates a set of things,and the qualifiers "@40" and "@50"
indicate the count of elements in the sets. The nested graphs in Figure 3.5 describe the
birthday party. In predicate calculus, the corresponding formula uses the description predicate
dscr(b,p), which relates the birthday party b to a nested proposition that describes it:
(Ǝb:BirthdayParty)(date(26May1996) /\ptim(b,26May1996) /\
dscr(b,
(Ǝx:Set) (Ǝz1:Give) (Ǝz2:Set) (Ǝy:Set) (Ǝz3:Cake) (Ǝp:Process)

count(x,40) /\ (∀m1∈x)(guest(m1) /\ agnt(z1,m1)) /\

(person(Marvin) /\rcpt(z1,Marvin) /\

count(y,50) /\ (∀m2∈y)(candle(m2) /\ on(m2,z3)) /\

(∀m3∈z2)(present(m3) /\ thme(z1,m3)) ))).
This formula says that there is a birthday party b on the date 26 May 1996; b is described by
the proposition that there exist a set x, an instance of giving z1, a set
Z2, a set y, a cake z3, and a process p; the person Marvin is the recipient of the giving z1; the
set x has 40 members, and for all m1in x, ml is a guest and m1is an agent of z1; the set y has 50
members, and for all m2in y, m2is a candle and m2is on the cake z3;and for all m3in the set z2,
m3is a present and m3is a theme of the giving z1. The logical effect of the context box or the
description predicate is to quote the nested proposition, which may hold under different
conditions from the containing context.

TRANSLATIONS TO NATURAL LANGUAGE

Although conceptual graphs are quite readable, they are a formal language that would
normally be used by programmers, systems analysts, and other professionals. End users
would usually prefer natural languages. But even programmers use natural language for
comments, documentation, and help facilities. Since conceptual graphs were originally
designed as a semantic representation for natural language, they can help form a bridge
between computer languages and the natural languages that everyone reads, writes, and
speaks.

A stylized English description could be generated by translating each context of Figure 3.6 to
a sentence or paragraph:
There is a birthday party b on 26 May 1996.
In b, 40 guests x are giving presents to the person Marvin. 50 candles y are on a
cake.
There is a process p.
In the process p, there is a state s1 with a duration of 15 seconds. The state s1 isfollowed by an
event e at the time 20:23:15 GMT. The event e is followed by a state s2 with a duration of 5
seconds.
In the state s1the candles y are burning. The guests x are singing the song "Happy Birthday."
In the event e, the person Marvin blowsout the candles y.
In the state s2, the candles y are generating smoke.

Natural Language Semantics

Natural languages are the ultimate knowledge representation languages. Aristotle began his
study of knowledge representation with an analysis of the semantic categories and
relationships expressedin natural language.

LANGUAGE ANALYSIS
To illustrate the difference between what is easy andwhat is difficult, it is helpful to consider
an example from an implemented system.
The following sentence from an Italian newspaper was successfully processed by a system
called DANTE, which was implemented by Velardi et al. (1988).

L'associazionedegliindustrialiaapprovato un nuovo piano di investimentinel

mezzogiorno.
(The association of the industrialists approved a new project of investments in the south.)

DANTE took input sentences from news services and analyzed their word forms
(morphology), their grammar (syntax), and their meaning (semantics). Figure 3.8 shows the
stages of processing a sentence and translating it to conceptual graphs.
Each of the three stages in sentence processing depends on a repository of linguistic
knowledge: dictionaries of word forms for the morphology, grammar rules for the syntax, and
conceptual patterns for the semantics. Following is a brief summary of what happens in each
stage:
1. Morphology. The first stage looks up all the words in a dictionary, determines their root
forms plus inflections, expands contractions, and finds the parts of speech.
2. Syntax. The second stage uses grammar rules to compute a parse tree, which represents the
syntax as a combination of phrases and subphrases.
3. Semantics. Finally, a semantic interpreter scans the parse tree and translates it to a
conceptual graph that represents the meaning.

The graph at the bottom of Figure 3.8 contains two concepts linked by a conceptual relation.
The concept [Association: #] represents the phrase the association; the concept [Industrialist:
{*}#] represents the industrialists, and the relation (Part) represents "to have as part."
Altogether, the conceptual graph means "the association has as parts the industrialists."

For the entire sentence, DANTE generated the conceptual graph shown in Figure
3.9.

The seven circles in Figure 3.9 represent conceptual relations. Following is a brief description
of each of them:
• Agent (Agnt) links a concept of an action to a concept of an animate being (person or
animal) that performs it: approve has the association as agent.
• Theme (Thme) links a concept of an event or state to a concept of the principal entity that is
involved: approve has project as theme.
• Past (Past) marks the past tense: approve occurred in the past.
• Part (Part) links a concept of an entity to some other concept that represents a
part of the entity: the association has the industrialists as parts.
• Attribute (Attr) links one concept to another one that represents some attribute
of the first: a project has the attribute new.
• Goal (Goal) links a concept to another one that represents its goal: a project has
the investments as goal.
• In (In) links a concept whose referent is contained in the referent of the concept
it is linked to: the investments are in the south of Italy.
QUESTION ANSWERING
After building up a knowledge base of conceptual graphs, DANTE could answer questions or
select documents that contain relevant information. Figure 3.10 shows the processing steps in
question answering.

The input question Checosasiapprova? (What thing is approved?) is analysed by the same
processes used for the original text. The result is a query graph that represents the meaning of
the question. It is a conceptual graph that contains one or more concepts with a question mark
in the referent field, as in [Thing:?]. The question mark, which is derived from the question
word che(what), serves as a trigger that initiates a search through the knowledge base. As an
answer, the search engine finds a conceptual graph that specializes the concept [Thing:?] to
the concept [Project] for the purpose of [Investment: {*}]. Finally, the generation stage
translates the answer graph to the sentence Si approvaunprogetto di investimenti(A project of
investments is approved).

Levels of Representation
A computer program must represent information about things in theworld, but the
computerized information passes through many levels of representation.

Figure 3 .11 showsan image that represents a person named Harry, the letters "Harry" used
torepresent the sound of his name, and four ways of encoding the letters. The symbol
0x486172727900 is the C language representation of the hexadecimal representationof the
ASCII encoding of the character string; and X'C8819999A8' is thePL/I representation of the
corresponding EBCDIC encoding. On the right side ofFigure 3.11 are two strings of ls and 0s
that represent the bits stored on disk

KNOWLEDGE LEVELS
The epistemological level is solely devoted to knowledge about objects andprocesses in the
application domain, while the heuristic level introduces datastructures for representing the
objects and programs for simulating the processes.
1. ImplementationalThe level of data structures such as atoms, pointers, lists,and other
programming notions.
2. Logical Symbolic logic with its propositions, predicates, variables, quantifiers,and Boolean
operators.
3. Epistemological A level for defining concept types with subtypes, inheritance, and
structuring relations.
4. Conceptual The level of semantic relations, linguistic roles, objects, and actions.
5. Linguistic. The level of arbitrary concepts, words, and expressions of naturallanguages.

COMPETENCE LEVELS
A robot is an AI system that receives signals from theenvironment and acts on the
environment in a way that helps it to achieve somepreestablished goals. Rodney Brooks
(1986) distinguished eight levels of competence, each withincreasingly more sophisticated
goals and means for achieving them:
I. Avoiding. Avoid contact with other objects, either moving or stationary.
2. Wandering. Wander around-aimlessly without hitting things.
3. Exploring. Look for places in the world that seem reachable and head for them.
4. Mapping. Build a map of the environment and record the routes from oneplace to another.
5. Noticing. Recognize changes in the environment that require updates to themental maps.
6. Reasoning. Identify objects, reason about them, and perform actions on them.
7. Planning. Formulate and execute plans that involve changing the environmentin some
desirable way.
8. Anticipating. Reason about the behavior of other objects, anticipate theiractions, and
modify plans accordingly.

DESIGN LEVELS
For his Information System Architecture USA), John Zachman(1987) distinguished five
separate levels. Zachman organized his five levels in a matrix with six columns to show
thirtydifferent perspectives on the knowledge representation of Oz CarRegistration Authority
(OCRA).
1. Scope. The first row corresponds to an executive summary, which describes ingross terms
the purpose of the system, its scope, its cost, and what it would do.
2. Enterprise model. The entities at the enterprise level are the people, resources,products,
and tasks of the business.
3. System model. Describes the information system as designed bya systems analyst who
must determine the data elements and functions that. Represent business entities and
processes.
4. Technology model. Deals with the technology used to implementthe information elements.
It is the representation usedby the programmers who must map the system analyst's view to
the programminglanguages.
5. Components. Represents the detailed specifications that are givento programmers who
code individual modules
At the bottom of each column is a single word that summarizes thecollective contribution of
the things in that column to the working system:
1. Entity-Relationship. The answer to the question What? is a list of the entity types at each
level. The representation of all the entities and their relationshipsto other entities constitutes
the total data of the working system.
2. Function/Argument. The answer to How? is a list of functions performed by thesystem.
Each function takes one or more entity types as arguments. The totality of all the individual
functions and arguments constitutes the overall systemfunction.
3. Location/Link. The answer to Where? is a list of the significant locations, whichmay be
physical rooms, buildings, and cities or logical sites inside a computersystem. Each location
has one or more links that connect it to other locations.The connection of all the locations and
links constitutes the network.
4. Agent/Work. The answer to Who? is a list of the agents that play some role inthe system.
The agents include humans, such as employees and customers, andcomputerized agents that
operate automatically. Each agent has associatedactivities, tasks, or work that he/she/it
performs. The totality of all the agents.and their work constitutes the organization.
5. Time/Cycle. The answer to When? is a list of times when significant events takeplace. Each
point in time occurs on some cycle, which may be periodic, suchas a billing cycle, or
irregular, such as demand-driven events initiated by variousagents. The totality of times and
cycles determines the schedule.
6. End Means. The answer to Why? is a list of the ends or purposes for eachentity, function,
location, agent, or time. Each end has an associated means bywhich it may be accomplished.
The totality of all ends and means constirutesthe strategy.

MEANING TRIANGLE
The ISA levels illustrate some of the relationships betweensymbols, objects, and meaning.
Figure 3.13 organizes those relationships ina meaning triangle.

The threevertices of the meaning triangle are (sign) for the symbol, (sense) forthe concept,
and (reference) for the object.

METALEVELS
The concept would be represented by a metalevel symbolwhose interpretant would be a
metalevel concept.