Descriptions

  Descriptions are the most important notion in Description Logic-based Knowledge Representation Systems. In NEOCLASSIC, a description is built up using expressions that contain other descriptions (including concepts) as well as roles and individuals. Descriptions cannot use concepts, roles, or individuals from different knowledge bases. A grammar describing all the ways of building descriptions in the character interface is given in Appendix A.

Descriptions are applied to individuals (in the manner that one-place predicates are applied to constants in predicate logic). An individual is said to be an instance of, or satisfy, a description if the information known about the individual implies the description. In the CLASSIC family, descriptions can be in either the CLASSIC realm or the HOST realm, depending on which type of individuals they describe.

For example, one could describe ``people between the ages of 30 and 40 with at most 5 friends and all of whose friends are doctors'' as

• []

  
  (and Person
  		(all age (and (minimum 30) (maximum 40)))
  		(atMost 5 friend)
  		(all friend Doctor))
  

If jill is known to be a Person with age 35, with at most 2 friends, and with friends bill and jack; and both bill and jack are known to be Doctors; then jill would satisfy the above description.

Building CLASSIC Descriptions

  The CLASSIC and operator forms the conjunction of some number of CLASSIC descriptions. Its syntax is

• [](and ClassicDescription+)

For example, a VegetarianPerson might be someone who is both a Vegetarian and a Person:

• [](and Vegetarian Person)

  A CLASSIC oneOf description enumerates a set of classic individuals, which are the only possible instances of the description. The syntax is

• [](oneOf ClassicIndividual+)

For example, (oneOf White Red Rose), defines a set of three CLASSIC individuals.

  The four operators all, atLeast, atMost, and fills form special types of descriptions known as role restrictions, that restrict the fillers of a role. Depending on the kind of role restriction, either the type of the fillers can be restricted (all restrictions), the number of fillers can be restricted (atLeast and atMost restrictions), or some of the actual fillers can be specified (fills restrictions).

  A value restriction, or all restriction, has the syntax

• [](all Role Description)

An all restriction specifies that all the fillers of a particular role must be individuals described by a particular description. For an individual I to satisfy the value restriction (all r C1), either all the fillers of r on I must be known and all of them must satisfy C1; or there must be a derivable all restriction on I, (all r C2), such that C1 subsumes (is more general than) C2.

For example, the instances of

• [](all food Plant)

must have all their fillers for food be instances of plant, such as, for example, LeafLettuce.

It is possible for the description in an all restriction to be incoherent (i.e., a description that can have no instances because it contains conflicting information). This means that the role can have no fillers, which is fine as long as there is not a (positive) atLeast restriction on the role. For example, suppose that Male and Female are two disjoint primitive concepts in the same disjoint grouping. Now suppose the concept IllegalChildren were defined as

• [](all child (and Male Female))

Since no individual can be described by both Male and Female, this would be equivalent to the concept of someone with no children:

• [](atMost 0 child)

  An atLeast restriction specifies the minimum number of fillers allowed for a given role on a concept or individual. Its syntax is

• [](atLeast PositiveInteger Role)

For example, a Parent might be defined to have at least 1 child:

• [](atLeast 1 child)

For an individual I to satisfy the atLeast restriction (atLeast n1 r), either at least n1 fillers for r on I must be known, or there must be a derivable atLeast restriction on I, (atLeast n2 r), such that n2 is greater than or equal to n1.

An atMost restriction specifies the maximum number of fillers allowed for a given role on a concept or individual. The syntax is

• [](atMost NonNegativeInteger Role)

For example, an Orphan might be defined to have no parents:

• [](atMost 0 parent)

For an individual I to satisfy the atMost restriction (atMost n1 r) there must be a derivable atMost restriction on I, (atMost n2 r), such that n2 is less than or equal to n1.

  The fills operator specifies that a particular role is filled by the specified individuals. The syntax is

• [](fills Role Individual+)

where an individual is either the name of a CLASSIC individual, e.g., (fills brother Fred Sam) says that the brother role is filled with the individuals Fred and Sam), or a string or an int or a float, e.g., (fills address "123 Main Street") says that the address role is filled with the given string). A fills description requires that an individual satisfying it must have the given role filled with the given value(s) (and possibly other values also).

For example, MaleFriendOfSue might be

• []

  
  (and Person (fills friend Sue)
  		 (fills gender Male))
  

where the filler of the friend role is the CLASSIC individual Sue, and the filler of the gender role is the CLASSIC individual Male. The concept PersonNamedSam could be

• [](and Person (fills first-name "Sam"))

where the filler of the first-name role is the string "Sam".

  It is possible to extend the description-forming capabilities of NEOCLASSIC by writing C++ code that determines whether a CLASSIC individual is an instance of a CLASSIC description. The syntax is

• [](testC ClassicTestGenerate Parameter*)

ClassicTestGenerate is a NEOCLASSIC name for a C++ object that embodies the procedural test. It must have a member function called run, that takes a CLASSIC individual and two sets of individuals (that are modified to indicate dependencies--see Section B.3) and returns one of three values:

testFalse: the individual is inconsistent with this description;

testMaybe: the individual is currently consistent with this description, but if information is added to the individual, the individual may become either inconsistent with the description or definitely described by the description; or

testTrue: the individual definitely satisfies this description.

The run function also has access to the parameters of the test.

For details on how to write these C++ objects, see Section B.1.

Building HOST Descriptions

  The HOST and operator forms the conjunction of some number of HOST descriptions. Its syntax is

• [](and HostDescription+)

For example, a PRIME-NUMBER might be an integer that is prime

• [](and INTEGER (testH prime))

  A HOST oneOf description enumerates a set of host individuals, which are the only possible instances of the description. The syntax is

• [](oneOf Individual+)

For example, (oneOf 3 5), defines a set of two HOST individuals.

  A minimum description specifies that an individual must be a number with a given lower bound. The syntax is

• [](minimum Number)

For example, the description (minimum 5) specifies that the value must be greater than or equal to 5.

A maximum description specifies that an individual must be a number with a given upper bound. The syntax is

• [](maximum Number)

For example, the description (maximum 5) specifies that the value must be less than or equal to 5.

Intervals are often used for all restrictions. For example,

• []

  
  (all age (and Integer (minimum 18)
  		 (maximum 65)))
  

restricts someone's age to be an integer between 18 and 65.

  There is a method for extending HOST descriptions in the same way as CLASSIC descriptions can be extended. Its syntax is:

• [](testH HostTestGenerate Parameter*)

HostTestGenerate is a NEOCLASSIC name for a C++ object that embodies the procedural test. The run function is similar to the run function for classic tests, but does not have the extra dependency arguments.

For details on how to write these C++ objects, see Section B.1.

Building Other Descriptions

It is possible to create incoherent descriptions--descriptions that can never have any individuals that belong to them. Usually this happens as a result of specifying conflicting information, such as

• [](and (atLeast 3 r) (atMost 2 r))

However, there is a direct way of stating an incoherent description, and this description is neither a CLASSIC nor a HOST description.   The empty oneOf description specifies an empty set. The syntax is

• [](oneOf)

It is sometimes necessary to provide a universal description--a description that allows any individual, CLASSIC or HOST, as an instance. Such a description is formed using the universal and operator. Its syntax is

• [](and)