1. Semantic Networks
The idea behind a semantic network is that knowledge is often best understood as a set of concepts that are related to one another.
The meaning of a concept is defined by its relationship to other concepts.
A semantic network consists of a set of nodes that are connected by labeled arcs. The nodes represent concepts and the arcs represent relations between concepts.

2. Common Semantic Relations
There is no standard set of relations for semantic networks, but the following relations are very common:
INSTANCE: X is an INSTANCE of Y if X is a specific example of the general concept Y.
Example: Elvis is an INSTANCE of Human
ISA: X ISA Y if X is a subset of the more general concept Y.
Example: sparrow ISA bird
HASPART: X HASPART Y if the concept Y is a part of the concept X. (Or this can be any other property)
Example: sparrow HASPART tail

4. Inheritance
Inheritance is a key concept in semantic networks and can be represented naturally by following ISA links.
In general, if concept X has property P, then all concepts that are a subset of X should also have property P.
But exceptions are pervasive in the real world!
In practice, inherited properties are usually treated as default values. If a node has a direct link that contradicts an inherited property, then the default is overridden.

5. Multiple Inheritance
Multiple inheritance allows an object to inherit properties from multiple concepts.
Multiple inheritance can sometimes allow an object to inherit conflicting properties.
Conflicts are potentially unavoidable, so conflict resolution strategies are needed.

6. ANIMAL
dog
dog
My-Friends

7. Representing Events “Jack kidnapped Billy on August 5”
Kidnapping Event
Kidnap1
perpetrator: Jack
victim: Billy
date: August 5

8. Representing predicates
score(Mavs, Bulls, )
Game
Instance: Game17
hometeam: Mavs
Visiting team: Bulls
Score:

9. Representing Relations
Karl John
height height
Height1 greater-than height2

10. Frames
A frame represents an entity as a set of slots (attributes) and associated values.
Each slot may have constraints that describe legal values that the slot can take.
A frame can represent a specific entity, or a general concept.
Frames are implicitly associated with one another because the value of a slot can be another frame.

11. Mammal NBA_BASKETBALL_PLAYER
isa: ANIMAL isa: ADULTMALE
*haspart: HAIR cardinality: 400
*breathes: AIR *height: > 6'
*salary: > $200,000
HUMAN MICHAELJORDAN
isa: MAMMAL instance: NBABASKETBALLPLAYER
cardinality: 6 million height: 6'9''
*haspart: LEGS(2)
ADULTMALE JOHNSTOCKTON
isa: HUMAN instance: NBABASKETBALLPLAYER
cardinality: 2 million height: 6'1''
*gender: male
An asterisk (*) means that the slot can be inherited.

12. Demons
One of the main advantages of frames is the ability to include demons to compute slot values. A demon is a function that computes the value of a slot on demand.
HUMAN
isa: (MAMMAL)
mortal: (yes :inheritable yes)
cardinality: (6 million :inheritable no)
age: (:inheritable yes :demon compute_age)
MARY int Compute_Age (frame)
instance: HUMAN return(today- (query birthday slot));
gender: FEMALE
birthday: 11/04/60

13. Features of Frame Representations
Frames can support values more naturally than semantic nets (e.g. the value 25)
Frames can be easily implemented using object-oriented programming techniques.
Demons allow for arbitrary functions to be embedded in a representation.
But a price is paid in terms of efficiency, generality, and modularity!
Inheritance can be easily controlled.

14. Comparative Issues in Knowledge Representation
The semantics behind a knowledge representation model depends on the way that it is used (implemented). Notation is irrelevant!
Whether a statement is written in logic or as a semantic network is not important -- what matters is whether the knowledge is used in the same manner.
Most knowledge representation models can be made to be functionally equivalent. It is a useful exercise to try converting knowledge in one form to another form.
From a practical perspective, the most important consideration usually is whether the KR model allows the knowledge to be encoded and manipulated in a natural fashion.

15. Expressiveness of Semantic Nets
Some types of properties are not easily expressed using a semantic network. For example: negation, disjunction, and general non-taxonomic knowledge.
There are specialized ways of dealing with these relationships, for example partitioned semantic networks and procedural attachment. But these approaches are ugly and not commonly used.
Negation can be handled by having complementary predicates (e.g., A and NOT A) and using specialized procedures to check for them. Also very ugly, but easy to do.
If the lack of expressiveness is acceptable, semantic nets have several advantages: inheritance is natural and modular, and semantic nets can be quite efficient.

16. Inheritance
As we stated before, semantic networks and frames are often used because inheritance is represented so naturally.
But rule based systems can also be used to do
inheritance! How?
Semantic networks (and frames) have an implementation advantage for inheritance because special-purpose algorithms can be used to follow the ISA links.

17. Comparative Summary
Rules are appropriate for some types of knowledge, but do not easily map to others.
Semantic nets can easily represent inheritance and exceptions, but are not well-suited for representing negation, disjunction, preferences, conditionals, and cause/effect relationships.
Frames allow arbitrary functions (demons) and typed inheritance. Implementation is a bit more cumbersome.

18. And just when you thought it was safe to go out…. Networks cont
And just when you thought it was safe to go out….Networks cont. (implementation)
We see hierarchical organizations in the real world all the time. They may not be "pure" hierarchies, but they're hierarchical in spirit at least. It might be easier to think of these things as "networks" instead of hierarchies. Take for example the common dictionary. At first glance, it looks like a very linear organization of the words in our language. But what a dictionary really specifies is a very complex and somewhat hierarchical map of the relationships between the words in our language. Here are some sample definitions:

19. dog: any of a large and varied group of domesticated animals related to the fox, wolf, and jackal
chihuahua: any of an ancient Mexican breed of very small dog with large, pointed ears
bird: any of a class of warm-blooded, two-legged, egg-laying vertebrates with feathers and wings
penguin: any of an order of flight-less birds found in the Southern Hemisphere, having webbed feet and paddle-like flippers for swimming and diving
ostrich: a large, swift-running bird of Africa and the Near East; the largest and most powerful of living birds; it has a long neck, long legs, two toes on each foot, and small useless wings
canary: a small yellow songbird of the finch family, native to the Canary Islands

20. Notice that these definitions all relate the thing being defined to some larger class of things, and then goes on to try to distinguish that thing from other similar things. Note also that as the things being described stray further and further from what we might think of as being norms or stereotypes, the definitions get longer and more detailed. For example, compare the canary (a stereotypical bird) to an ostrich (an extremely non-stereotypical bird). When we take the time to look at the dictionary in this way, we uncover what is essentially a bunch of pointers from one word to others.

21. In any case, we can use our high-level data abstraction, the directed graph, to make these relationships a bit more visual. For example, from the bird definitions, we can construct the following abstraction:
  vertebrate ^
| is-a
has-part
| / wings
/ reproduction
| / egg-laying
| / body-temp
| / warm-blooded
bird--< no. of legs
^ ^ ^ \
/ | \ \ covering
is-a / | \ \ feathers
/ | \ \ movement
color / | \ \ flight
yellow canary
size / | is-a \ is-a
small / | \ movement
| ostrich run
movement | \ size
swim penguin \ big

22. How to represent your networks in LISP
Hey, it's simple. Use an association list.
(defun *database* ()
'((canary (is-a bird)
(color yellow)
(size small))
(penguin (is-a bird)
(movement swim))
(bird (is-a vertebrate)
(has-part wings)
(reproduction egg-laying)
) ))
You'd use the "assoc" function with a key of "canary" to extract all the information about the "canary" type.

23. Or…As property lists… (setf (get 'bird 'isa) 'mammal) MAMMAL
CL-USER 3 > (setf (get 'mammal 'has-a) 'feet-2)
FEET-2

24. Then…Getting the properties and values
defun get-object (obj prop)
(cond ((equal (get obj 'has-a) prop) t)
(t (get-object (get obj 'isa) prop))))
(get-object 'bird 'feet-2) T