Frame Knowledge Representation

Consider the example first discussed in Semantics Nets (Section 6.2.1):

Person

                                isa:                        Mammal

                                Cardinality:                          

Adult-Male

                               isa:                          Person

                                Cardinality:                          

Rugby-Player

                                isa:                         Adult-Male

                                Cardinality:                          

                                Height:

                                              Weight:

                                Position:

                                Team:

                                              Team-Colours:

Back

                                isa:                        Rugby-Player

                                Cardinality:                          

                                Tries:

Mike-Hall

                                instance:                               Back

                                Height:                  6-0

                                Position:                               Centre

                                Team:                    Cardiff-RFC

                                Team-Colours:                      Black/Blue

Rugby-Team

                                isa:                         Team

                                Cardinality:                          

                                Team-size:                            15

                                Coach:

Figure: A simple frame system

Here the frames Person, Adult-Male, Rugby-Player and Rugby-Team are all classes and the frames Robert-Howley and Cardiff-RFC are instances.

Note

• The isa relation is in fact the subset relation.
• The instance relation is in fact element of.
• The isa attribute possesses a transitivity property. This implies: Robert-Howley is a Back and a Back is a Rugby-Player who in turn is an Adult-Male and also a Person.
• Both isa and instance have inverses which are called subclasses or all instances.
• There are attributes that are associated with the class or set such as cardinality and on the other hand there are attributes that are possessed by each member of the class or set.

DISTINCTION BETWEN SETS AND INSTANCES

It is important that this distinction is clearly understood.

Cardiff-RFC can be thought of as a set of players or as an instance of a Rugby-Team.

If Cardiff-RFC were a class then

• its instances would be players
• it could not be a subclass of Rugby-Team otherwise its elements would be members of Rugby-Team which we do not want.

Instead we make it a subclass of Rugby-Player and this allows the players to inherit the correct properties enabling us to let the Cardiff-RFC to inherit information about teams.

This means that Cardiff-RFC is an instance of Rugby-Team.

BUT There is a problem here:

• A class is a set and its elements have properties.
• We wish to use inheritance to bestow values on its members.
• But there are properties that the set or class itself has such as the manager of a team.

This is why we need to view Cardiff-RFC as a subset of one class players and an instance of teams. We seem to have a CATCH 22. Solution: MetaClasses

A metaclass is a special class whose elements are themselves classes.

Now consider our rugby teams as:

Figure: A Metaclass frame system

The basic metaclass is Class, and this allows us to

• define classes which are instances of other classes, and (thus)
• inherit properties from this class.

Inheritance of default values occurs when one element or class is an instance of a class.

Slots as Objects

How can we to represent the following properties in frames?

• Attributes such as weight, age be attached and make sense.
• Constraints on values such as age being less than a hundred
• Default values
• Rules for inheritance of values such as children inheriting parent's names
• Rules for computing values
• Many values for a slot.

A slot is a relation that maps from its domain of classes to its range of values.

A relation is a set of ordered pairs so one relation is a subset of another.

Since slot is a set the set of all slots can be represent by a metaclass called Slot, say.

Consider the following:

SLOT

                                isa:                         Class

                                instance:                              Class

                                domain:

                                range:

                                range-constraint:

                                definition:

                                default:

                                to-compute:

                                single-valued:

Coach

                                instance:                               SLOT

                                domain:                                Rugby-Team

                                range:                    Person

                               range-constraint:                                 (experience x.manager)

                                default:

                                single-valued:                       TRUE

Colour

                                instance:                               SLOT

                                domain:                                Physical-Object

                                range:                    Colour-Set

                                single-valued:                       FALSE

Team-Colours

                                instance:                               SLOT

                                isa:                         Colour

                                domain:                                team-player

                                range:                    Colour-Set

                                range-constraint:                                not Pink

                                single-valued:                       FALSE

Position

                                instance:                               SLOT

                                domain:                                Rugby-Player

                                range:                    { Back, Forward, Reserve }

                                to-compute:                           x.position

                               single-valued:                       TRUE

NOTE the following:

• Instances of SLOT are slots
• Associated with SLOT are attributes that each instance will inherit.
• Each slot has a domain and range.
• Range is split into two parts one the class of the elements and the other is a constraint which is a logical expression if absent it is taken to be true.
• If there is a value for default then it must be passed on unless an instance has its own value.
• The to-compute attribute involves a procedure to compute its value. E.g. in Position where we use the dot notation to assign values to the slot of a frame.
• Transfers through lists other slots from which values can be derived from inheritance.