The frame ontology defines the terms that capture conventions used in object-centered knowledge representation systems. Since these terms are built upon the semantics of KIF, one can think of KIF plus the frame-ontology as a specialized representation language. The frame ontology is the conceptual basis for the Ontolingua translators.One purpose of this ontology is to enable people using different representation systems to share ontologies that are organized along object-centered, term-subsumption lines. Translators of ontologies written in KIF using the frame ontology, such as those provided by Ontolingua, allow one to work from a common source format and yet continue to use existing representation systems.

The definitions in this ontology are based on common usage in the computer science and mathematics literatures. However, there is no claim that these definitions capture the semantics of existing, implemented systems in full detail. Nuances of the meaning of terms that depend on the algorithms for inheritance, for instance, are not addressed in this ontology. See the acknowledgements at the end of the file.

This ontology is specified using the definitional forms provided by Ontolingua. All of the embedded sentences are in KIF 3.0, and the whole thing can be translated into pure KIF top level forms without loss of information.

The basic ontological commitments of this ontology are

- Relations are sets of tuples -- named by predicates

- Functions are a special case of relations

- Classes are unary relations -- no special syntax for types

- Extensional semantics for classes -- defined as sets, not descriptions

- No special treatment of slots, just binary relations and unary functions

- KL-ONE style specs are relations on relations (second-order relations, not metalinguistic or modal)

**Last modified:***Monday, 20 December 1993***Source code: frame-ontology.lisp****List of other known theories**

Kif-RelationsKif-SetsKif-ListsKif-Numbers

Vt-DomainVt-ExampleConfiguration-DesignVt-DesignSimple-BikesVt-Domain...Physical-QuantitiesUnary-Scalar-FunctionsCmlThermodynamicsDmeThermodynamicsStandard-UnitsSimple-BikesCml...Vt-Design...Unary-Scalar-Functions...Scalar-QuantitiesVt-Design...Vector-QuantitiesAbstract-AlgebraPhysical-Quantities...Jat-GenericJob-Assignment-TaskGeneric-BibliographySlot-Constraint-SugarGeneric-Bibliography

Class-PartitionRelationFunctionUnary-FunctionOne-To-One-RelationSingle-ValuedMany-To-One-RelationClassN-Ary-RelationUnary-RelationBinary-RelationUnary-Function...Single-ValuedAsymmetric-RelationAntisymmetric-RelationPartial-Order-RelationTotal-Order-RelationAntireflexive-RelationIrreflexive-RelationReflexive-RelationEquivalence-RelationPartial-Order-Relation...Symmetric-RelationEquivalence-RelationTransitive-RelationEquivalence-RelationPartial-Order-Relation...Weak-Transitive-RelationMany-To-One-RelationOne-To-Many-RelationMany-To-Many-RelationThing

**Alias****Composition-Of****Direct-Instance-Of****Direct-Subclass-Of****Documentation****Domain****Domain-Of****Exhaustive-Subclass-Partition****Has-Value****Inherited-Slot-Value****Instance-Of****Maximum-Slot-Cardinality****Maximum-Value-Cardinality****Minimum-Slot-Cardinality****Minimum-Value-Cardinality****Nth-Domain****Onto****Range****Range-Of****Same-Slot-Values****Same-Values****Single-Valued-Slot****Slot-Value-Type****Subclass-Of****Subclass-Partition****Subrelation-Of****Superclass-Of****Total-On****Value-Type**

**All-Inherited-Slot-Values****All-Instances****All-Values****Arity****Compose****Composition****Exact-Domain****Exact-Range****Inverse****One-Of****Projection****Relation-Universe****Slot-Cardinality****Value-Cardinality**

**The following constants were used from included theories:**

**=***defined as a***relation***in theory***Kif-Sets****=<***defined as a***relation***in theory***Kif-Numbers****>=***defined as a***relation***in theory***Kif-Numbers****Bounded***defined as a***class***in theory***Kif-Sets****Butlast***defined as a***function***in theory***Kif-Lists****Cardinality***defined as a***function***in theory***Kif-Sets****Defined***defined as a***class***in theory***Kif-Relations****Double***defined as a***class***in theory***Kif-Lists****Empty***defined as a***class***in theory***Kif-Sets****First***defined as a***function***in theory***Kif-Lists****Holds***defined as a***relation***in theory***Kif-Relations****Individual***defined as a***class***in theory***Kif-Sets****Integer***defined as a***class***in theory***Kif-Numbers****Item***defined as a***relation***in theory***Kif-Lists****Last***defined as a***function***in theory***Kif-Lists****Length***defined as a***function***in theory***Kif-Lists****List***defined as a***class***in theory***Kif-Lists****Member***defined as a***relation***in theory***Kif-Sets****Nonnegative-Integer***defined as a***class***in theory***Kif-Numbers****Nth***defined as a***function***in theory***Kif-Lists****Null***defined as a***class***in theory***Kif-Lists****Positive-Integer***defined as a***class***in theory***Kif-Numbers****Second***defined as a***function***in theory***Kif-Lists****Set***defined as a***class***in theory***Kif-Sets****Single***defined as a***class***in theory***Kif-Lists****String***defined as a***class***in theory***Kif-Lists****Undefined***defined as a***class***in theory***Kif-Relations**

**All constants that were mentioned were defined.**

A relation is a set of tuples that represents a relationship among objects in the universe of discourse. Each tuple is a finite, ordered sequence (i.e., list) of objects. A relation is also an object itself, namely, the set of tuples. Tuples are also entities in the universe of discourse, and can be represented as individual objects, but they are not equal to their symbol-level representation as lists.By convention, relations are defined intensionally by specifying constraints that must hold among objects in each tuple. That is, a relation is defined by a predicate which holds for sequences of arguments that are in the relation.

Relations are denoted by relation constants in KIF. A fact that a particular tuple is a member of a relation is denoted by (

<relation-name>arg_1 arg_2 .. arg_n), where the arg_i are the objects in the tuple. In the case of binary relations, the fact can be read as `arg_1 is<relation-name>arg_2' or `a<relation-name>of arg_1 is arg_2.' The relation constant is a term as well, which denotes the set of tuples.

**Subclass-Of:**Set

**Axioms:**

(<=> (Relation ?Relation) (And (Set ?Relation) (Forall (?Tuple) (=> (Member ?Tuple ?Relation) (List ?Tuple)) )))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp****Also defined in:**Kif-relations

A function is a mapping from a domain to a range that associates a domain element with exactly one range element. The elements of the domain are tuples, as in relations. The range is a class -- a set of singleton tuples -- and element of the range is an instance of the class. Functions are also first-class objects in the same sense that relations are objects: namely, functions can be viewed as sets of tuples.

**Subclass-Of:**Relation

**Axioms:**

(<=> (Function ?Relation) (And (Relation ?Relation) (Forall (?Tuple1 ?Tuple2) (=> (Member ?Tuple1 ?Relation) (Member ?Tuple2 ?Relation) (= (Butlast ?Tuple1) (Butlast ?Tuple2)) (= (Last ?Tuple1) (Last ?Tuple2)) ))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp****Also defined in:**Kif-relations

A class can be thought of as a collection of individuals. Formally, a class is a unary relation, a set of tuples (lists) of length one. Each tuple contains an object which is said to be an instance of the class. An individual, or object, is any identifiable entity in the universe of discourse (anything that can be denoted by a object constant in KIF), including classes themselves.The notion of CLASS is introduced in addition to the relation vocabulary because of the importance of classes and types in knowledge representation practice. The notion of class and relation are merged to unify relational and object-centered representational conventions. Classes serve the role of `sorts' and `types'.

There is no first-order distinction between classes and unary relations. One is free to define a second-order predicate that makes the distinction. For example, (predicate C) could mean that the unary relation C should be thought of more as a property than as a collection of individuals over which one might quantify some statement. Logically, all such predicates would still be instances of the metaclass CLASS.

The fact that an object i is an instance of class C is denoted by the sentence (C i). One may also use the equivalent form (INSTANCE-OF i C). This is not equivalent to (MEMBER i C).

An instance of a class is not a set-theoretic member of the class; rather, the tuple containing the instance is a element of the set of tuples which is a relation.The definition of a class is a predicate over a single free variable, such that the predicate holds for instances of the class. In other words, classes are defined

intentionally. Two separately-defined classes may have the same extension (in this case they are = to each other). It is possible to define a class by enumerating its instances, using KIF's set operations. For example, (define-class primary-color (?color)

(member ?color (set red green blue)))

**Subclass-Of:**Relation

**Arity:**1

*Slots Of Instances:*

**Axioms:**

(<=> (Class ?Class) (And (Relation ?Class) (= (Arity ?Class) 1)))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

THING is the class of everything in the universe of discourse that can be in a class. This includes all the relations and objects defined in the KIF specification, plus all other objects defined in user ontologies. Every THING is either a set or an individual.

**Alias:**Bounded**Exhaustive-Subclass-Partition:**{Individual, Set}

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp****Also defined in:**Dme

An object is an instance-of a class if it is a member of the set denoted by that class. One would normally state the fact that individual i is an instance of class C with with the relational form (C i), but it is equivalent to say (INSTANCE-OF i C). Instance-of is useful for defining the second-order relations and classes that are about class/instance networks.An individual may be an instance of many classes, some of which may be subclasses of others. Thus, there is no assumption in the meaning of instance-of about specificity or uniqueness. See DIRECT-INSTANCE-OF.

**Arity:**2**Range:**Class

**Axioms:**

(<=> (Instance-Of ?Individual ?Class) (And (Class ?Class) (Holds ?Class ?Individual)) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

The instances of some classes may be specified extensionally. That is, one can list all of the instances of the class by definition. For this case we say (= (all-instances C) (setof V_1 V_2 ... V_n)), where C is a class and the V_i are its instances.ALL-INSTANCES imposes a monotonic constraint. Any subclass of C cannot have any instances outside of the ALL-INSTANCES of C. Note that this is not indexical or modal: whether something is in all-instances is a property of the modeled world and does not depend on the facts currently stored in some knowledge base.

**Arity:**2**Domain:**Class**Range:**Set

**Axioms:**

(<=> (All-Instances ?Class ?Set-Of-Instances) (And (Class ?Class) (Set ?Set-Of-Instances) (Forall (?Instance) (<=> (Member ?Instance ?Set-Of-Instances) (Instance-Of ?Instance ?Class) ))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

ONE-OF is a function for defining classes by enumerating their instances. It takes a variable number of terms as arguments, and denotes the class whose instances are exactly those terms.For example, (one-of yes no) denotes the class containing the objects called yes or no. (instance-of yes (One-of yes no)) is true, and (instance-of maybe (one-of yes no) is false. A common use for one-of is in defining type restrictions. For example, the relation value-type takes a class as an argument. To specify a finite set of possible values for a slot, one can use (value-type ?instance ?slot (one-of a b c)).

**Axioms:**

(Undefined (Arity One-Of)) (<=> (One-Of @Members ?Class) (Forall (?Instance) (<=> (Instance-Of ?Instance ?Class) (Member ?Instance (Setof @Members)) )))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Class C is a subclass of parent class P if and only if every instance of C is also an instance of P. A class may have multiple superclasses and subclasses. Subclass-of is transitive: if (subclass-of C1 C2) and (subclass-of C2 C3) then (subclass-of C1 C3).Object-centered systems sometimes distinguish between a subclass-of relationship that is asserted and one that is inferred. For example, (subclass-of C1 C3) might be inferred from asserting (subclass-of C1 C2)

and (subclass-of C2 C3). The functional interfaces to such systems might call the asserted form something like `parents' and the inferred form `ancestors'. However, both are logically identical to subclass-of; distinctions based on inference procedures and the current state of the knowledge base are not captured in this ontology.

**Instance-Of:**Relation, Transitive-relation**Arity:**2**Domain:**Class**Range:**Class

**Axioms:**

(<=> (Subclass-Of ?Child-Class ?Parent-Class) (And (Class ?Parent-Class) (Class ?Child-Class) (Forall (?Instance) (=> (Instance-Of ?Instance ?Child-Class) (Instance-Of ?Instance ?Parent-Class) ))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Superclass-of is the inverse of the subclass-of relation. It is useful to create an explicit inverse because there are efficient ways to assert and query superclass and subclass relationships separately.In Cyc, superclass-of is called #%allSpecs because it is a slot from a collection to all of its specializations (subclasses).

**Arity:**2**Inverse:**Subclass-of

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A relation R is a subrelation-of relation R' if, viewed as sets, R is a subset of R'. In other words, every tuple of R is also a tuple of R'. In some more words, if R holds for some arguments arg_1, arg_2, ... arg_n, then R' holds for the same arguments. Thus, a relation and its subrelation must have the same arity, which could be undefined.In CycL, subrelation-of is called #%genlSlots.

**Arity:**2**Domain:**Relation**Range:**Relation

**Axioms:**

(<=> (Subrelation-Of ?Child-Relation ?Parent-Relation) (And (Relation ?Child-Relation) (Relation ?Parent-Relation) (Forall (?Tuple) (=> (Member ?Tuple ?Child-Relation) (Member ?Tuple ?Parent-Relation) ))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

An individual i is an DIRECT-INSTANCE-OF class C if i is an instance-of C and there is no other subclass of C defined in the current ontology of which i is also an instance-of. Such a class C is a `minimal' or `most-specific' parent class for the individual i. The direct class is not necessarily unique; an individual can have several most-specific classes. Note that this relation is indexical -- its truth depends the contents of the current knowledge base rather than the world.The distinction between INSTANCE-OF and DIRECT-INSTANCE-OF is

notthe same as the relationship between asserting instance-of directly and having the system infer it. The meanings of both instance-of and direct-instance-of, and every other object-level relation in a knowledge base mean, are independent of whether they are asserted explicitly or inferred.Cyc makes the distinction between #%instanceOf and #%allInstanceOf. #%allInstanceOf means the same thing as INSTANCE-OF in our ontology. However, #%instanceOf is subtlely different from direct-instance-of. When someone asserts (#%instanceOf i C) to Cyc, it means the same thing as (#%allInstanceOf i C), but Cyc creates a pointer between an instance unit and a collection unit. Later, someone may define a subclass C_sub of C and assert (#%instanceOf i C_sub), and this is consistent with the earlier #%instanceOf assertion.

Direct-instance-of is useful for maintaining a class hierarchy in a modular, canonical form. It is defined here because some systems maintain direct-instance-of and some applications depend on this.

**Arity:**2**Subrelation-Of:**Instance-of

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

DIRECT-SUBCLASS-OF is the same thing as SUBCLASS-OF with an additional constraint: there is no other class `between' child and parent class in the subclass hierarchy of the current knowledge base. In other words, if (direct-subclass-of C P) then there is no other defined class P' in

the current knowledge base that is a superclass of C and also a subclass of P.Note that this relation is indexical -- its truth depends the contents of the current knowledge base rather than the world. There certaintly might be a set of tuples in the world that is a superset of C and a subset of P, but it can't have been defined as a class in the current knowledge base if (direct-subclass-of C P) is true for that knowledge base.

The direct-subclass-of of a class is not necessarily unique.

In systems with term classifiers, direct-subclass-of relations are usually inferred, rather than asserted.

**Arity:**2**Subrelation-Of:**Subclass-of

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Arity is the number of arguments that a relation can take. If a relation can take an arbitrary number of arguments, its arity is undefined. For example, a function such as `+' is of undefined arity; its last formal argument is specified with a sequence variable. The arity of a function is one more than the number of arguments it can take, in keeping with the unified treatment of functions and relations. The arity of the empty relation (i.e., with no tuples) is undefined.

**Arity:**2**Domain:**Relation**Range:**Integer

**Axioms:**

(<=> (Arity ?Relation ?N) (And (Relation ?Relation) (Not (Empty ?Relation)) (Integer ?N) (Forall (?Tuple) (=> (Member ?Tuple ?Relation) (Length ?Tuple ?N)) )))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

The EXACT-DOMAIN of a relation is a relation whose tuples (all of them) are mapped by the relation to instances of the range. A binary relation R is defined as a set of tuples of form<x,y>. If we say (= (exact-domain R) D) then all of the x's must be in the class D, and for each instance x of class D, the relation maps x to some y. The exact-domain of a relation of arity other than 2 is the relation that represents a cross product. For example, the notation F:A x B -> C, means that function F maps pairs<a,b> onto c's where a is an instance of A, b is an instance of B, and c is an instance of C. The exact-domain of F is the set of pairs<a,b> that occur in some triple<a,b,c> in F.Some treatments of functions define a function as a

mappingfrom a domain to a range. This ontology treats functions as relations, and relations as sets of tuples. Thus, functions and relations arenotdefined relative to domains and ranges; the exact-domain is a function of the set of tuples. It follows that all functions are `total' with respect to their exact-domains and `onto' with respect to their exact-ranges.The exact-domain of a variable-arity relation is another variable-arity relation; the lengths of the tuples in the exact-domain of R is one less than the corresponding tuples in the relation R. The exact-domain of a unary relation, or a relation that contains a tuple of length one, is undefined.

**Arity:**2**Domain:**Relation**Range:**Relation

**Axioms:**

(<=> (Exact-Domain ?Relation ?Domain-Relation) (And (Relation ?Relation) (Relation ?Domain-Relation) (Forall (?Tuple) (=> (Member ?Tuple ?Relation) (Not (Empty (Butlast ?Tuple))) )) (Forall (?Tuple @Args) (<=> (Holds ?Domain-Relation @Args) (And (Member ?Tuple ?Relation) (= (Listof @Args) (Butlast ?Tuple)) )))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A relation maps elements of a domain onto element of a range. For each tuple in the relation, the last item is in the range, and the tuple formed by the preceeding items is in the domain. The EXACT-RANGE is the class whose instances are exactly those that appear in the last item of some tuple in the relation.The EXACT-RANGE of a relation is always a class, while the exact-domain may be a relation of any arity, including variable arity (e.g., the + function can take 0 or more arguments, but its exact-range is some subset of the class NUMBER).

In KIF, functions are a special case of relations. This definition is based on relational terminology, but applies to functions as well. In discussions of functions, one often sees the notation f:X -> Y. Usually, X and Y are sets of elements x and y. In this ontology, the unary function f is also a binary relation, where X is the exact-domain of f and Y is the exact-range of f. This generalizes to cross products. For the function g:A x B x C -> D, the domain is the ternary relation of tuples (a, b, c) and the range is the unary relation of tuples (d). The exact-range of just those d's that are actually the value of g on some (a, b, c).

The EXACT-RANGE of a function is unique, and every function f maps (exact-domain f)

onto(exact-range f). Sometimes the EXACT-RANGE of f is called the ``image of (exact-domain f) under d.''The relation RANGE is a

constrainton the possible values of a function. It is a superclass of the EXACT-RANGE, and is not unique.

**Arity:**2**Domain:**Relation**Range:**Class

**Axioms:**

(<=> (Exact-Range ?Relation ?Range-Class) (And (Relation ?Relation) (Class ?Range-Class) (Forall (?Range-Instance) (<=> (Instance-Of ?Range-Instance ?Range-Class) (Exists (?Tuple) (And (Member ?Tuple ?Relation) (Last ?Tuple ?Range-Instance) ))))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A relation R is TOTAL-ON a domain class C if there are tuples in the relation (x,y) for every instance x of C. If the domain is a relation D, it represents a Cartesian product, and the relation is total on D if for every tuple (x1, x2, ... xn) in D there is a tuple (x1, x2, ... xn, y) in R.

**Arity:**2

**Axioms:**

(<=> (Total-On ?Relation ?Domain-Relation) (Subrelation-Of (Exact-Domain ?Relation) ?Domain-Relation) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A relation R is ONTO range class C iff for every element y in C there is a tuple in R (x1, x2, ... y).

**Arity:**2

**Axioms:**

(<=> (Onto ?Relation ?Range-Class) (Subclass-Of (Exact-Range ?Relation) ?Range-Class) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

An N-ary relation is a relation with some FIXED arity.

**Subclass-Of:**Relation

**Axioms:**

(<=> (N-Ary-Relation ?Relation) (And (Relation ?Relation) (Not (Undefined (Arity ?Relation)))) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A unary relation is a relation of arity 1. Unary relations are the same thing as classes. In this ontology there is no logical distinction between a monadic predicate (unary relation) and a type (class).

**Subclass-Of:**Relation

**Arity:**1

*Slots Of Instances:*

**Axioms:**

(<=> (Unary-Relation ?Relation) (And (Relation ?Relation) (= (Arity ?Relation) 1)) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp****Also defined in:**Kif-relations

A binary relation maps instances of a class to instances of another class. Its arity is 2. Binary relations are often shown as slots in frame systems.

**Subclass-Of:**Relation

**Arity:**2

*Slots Of Instances:*

**Axioms:**

(<=> (Binary-Relation ?Relation) (And (Relation ?Relation) (= (Arity ?Relation) 2)) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp****Also defined in:**Kif-relations

A unary function is a functional mapping from instances of a class to instances of another class. It is a relation of arity 2. Binary relations are often shown as slots in frame systems.

**Subclass-Of:**Binary-relation, Function

**Axioms:**

(<=> (Unary-Function ?F) (And (Binary-Relation ?F) (Function ?F)))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp****Also defined in:**Kif-relations

Single-valued relations are binary relations that are functional. The predicate SINGLE-VALUED is useful for asserting that a slot will have at most one value without using a function-defining form. It is restricted to binary relations because it is defined only for slots. Note that specifying a relation as single valued says that it is function forallsubclasses of its domain.

**Subclass-Of:**Binary-relation, Function

**Axioms:**

(<=> (Single-Valued ?Relation) (And (Binary-Relation ?Relation) (Function ?Relation)) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

One binary relation is the inverse of another if they are equivalent when their arguments are swapped.

**Arity:**2**Domain:**Binary-relation**Range:**Binary-relation

**Axioms:**

(<=> (Inverse ?Binary-Relation ?Inverse-Relation) (And (Binary-Relation ?Binary-Relation) (Binary-Relation ?Inverse-Relation) (<=> (Holds ?Binary-Relation ?X ?Y) (Holds ?Inverse-Relation ?Y ?X) )))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp****Also defined in:**Kif-relations

The projection of an N-ary relation on column i is the class whose instances are the ith items of each tuple in the relation.

**Arity:**3

**Axioms:**

(Nth-Domain Projection 3 Class) (Nth-Domain Projection 2 Positive-Integer) (Nth-Domain Projection 1 N-Ary-Relation) (<=> (Projection ?Relation ?Column ?Projection-Relation) (And (N-Ary-Relation ?Relation) (Positive-Integer ?Column) (=< ?Column (Arity ?Relation)) (Class ?Projection-Relation) (Forall (?Projection-Instance) (<=> (Instance-Of ?Instance ?Projection-Relation) (Exists (?Tuple) (And (Member ?Tuple ?Relation) (Nth ?Tuple ?Column ?Instance) ))))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

The composition of binary relations R_1 and R_2 is a relation R_3 such that R_1(x,y) and R_2(y,z) implies R_3(x,z).

**Arity:**3

**Axioms:**

(Nth-Domain Composition 3 Binary-Relation) (Nth-Domain Composition 2 Binary-Relation) (Nth-Domain Composition 1 Binary-Relation) (= (Composition ?R1 ?R2) (Setofall (Listof ?X ?Z) (Exists (?Y) (And (Holds ?R1 ?X ?Y) (Holds ?R2 ?Y ?Z))) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp****Also defined in:**Kif-relations

A binary relation R is a COMPOSITION-OF a sequence of binary relations R_1, R_2, ... R_N iff there exists a relation R' that is a COMPOSITION-OF the sequence R_1 ... R_{N-1}, and R is the (COMPOSITION R_1 R').Relations are composed right to left. For example, if (composition-of R (listof a b c d)) then R = (composition d (composition c (composition b a))).

When the relations are unary functions, the sequence corresponds to nested parentheses in functional notation. For example, if F is composition-of functions a, b, and c, (COMPOSITION-OF F (listof a b c)) means (f ?x) is equal to (a (b (c ?x))).

**Arity:**2**Domain:**Binary-relation**Range:**List

**Axioms:**

(<=> (Composition-Of ?Binary-Relation ?List-Of-Relations) (And (Binary-Relation ?Binary-Relation) (List ?List-Of-Relations) (Not (Null ?List-Of-Relations)) (=> (Item ?R ?List-Of-Relations) (Binary-Relation ?R)) (Or (And (Single ?List-Of-Relations) (= ?Binary-Relation (First ?List-Of-Relations)) ) (And (Double ?List-Of-Relations) (= ?Binary-Relation (Composition (Second ?List-Of-Relations) (First ?List-Of-Relations) ))) (Exists (?Left-Sub-Relation) (And (= ?Binary-Relation (Composition (Last ?List-Of-Relations) ?Left-Sub-Relation)) (Composition-Of ?Left-Sub-Relation (Butlast ?List-Of-Relations)))))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

arbitrary-arity version of COMPOSITION. The left-to-right argument order composes relations outside-in. e.g., (COMPOSE f g h) means (composition h (composition g f)). If the relations are unary functions, then the composition order corresponds to nested function terms. For example, if f,g,h are functions, then (value (COMPOSE f g h) ?arg) is equivalent to (f (g (h ?arg))).

**Range:**Binary-relation

**Axioms:**

(Undefined (Arity Compose)) (<=> (Compose @Binary-Relations ?Composed-Relation) (Composition-Of ?Composed-Relation (Listof @Binary-Relations)) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Alias is a way to specify that two relations have the same extension. It is logically equivalent to the = relation, except that it is restricted to relations.

**Arity:**2**Domain:**Relation**Range:**Relation**Subrelation-Of:**=

**Axioms:**

(<=> (Alias ?Relation-1 ?Relation-2) (And (Relation ?Relation-1) (Relation ?Relation-2) (= ?Relation-1 ?Relation-2) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

DOMAIN is short for ``domain restriction''. A domain restriction of a binary relation is a constraint on the exact-domain of the relation. A domain restriction is superclass of the exact-domain; that is, all instances of the exact-domain of the relation are also instances of the DOMAIN restriction. Thus, the DOMAIN of a relation is not unique.In an ontology, specifying a domain restriction of a binary relation is a way to specify partial information about the objects to which the relation applies. For example, one can state that favorite-beer is a relation from beer drinkers to beers as (domain favorite-beer person). This says that all people who have

a favorite-beer are instances of person, even though there may be some instances of person who do not have a favorite beer.Representation systems can use these specifications to classify terms and check integrity constraints.

**Arity:**2**Domain:**Binary-relation**Range:**Class

**Axioms:**

(<=> (Domain ?Relation ?Restriction) (And (Binary-Relation ?Relation) (Class ?Restriction) (Subclass-Of (Exact-Domain ?Relation) ?Restriction) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

DOMAIN-OF is the inverse of the DOMAIN relation; i.e., (domain-of D R) means that D is a domain restriction of R. A DOMAIN-OF a binary relation is a class to which the binary relation can be meaningfully applied; i.e., it is possible, but not assured, that there are instances d of D for which R(d,v) holds. Of course, every instance i for which R(i,v) does hold is an instance of D.One interpretation of the assertion (DOMAIN-OF my-class my-relation) is `the slot my-relation may apply to some of the instances of my-class.' A less precise but common paraphrase is `my-class

hasthe slot my-relation'. User interfaces to frame and object systems often have some symbol-level heuristic for showing slots that `have' or `make sense for' the class. Keep in mind that DOMAIN-OF is a constraint on the logically consistent use of the relation, not a relevance assertion. There are many classes that are DOMAINs-OF a given relation; namely, all superclasses of the exact-domain. (THING, for example, is a DOMAIN-OF all relations.) Therefore, it is quite possible that most of the instances of a domain-of a relation do not `make sense' for that relation.Whereever one uses (domain-of D R) it is equivalent to adding D to the list of domain restrictions on the definition of R. In other words if R was defined as (define-relation R (?x ?y) :def (and (A ?x) (B ?y))) then the statement (DOMAIN-OF D R) has the same meaning as changing the definition to (define-relation R (?x ?y) :def (and (A ?x) (D ?x) (B ?y))). For modularity reasons DOMAIN-OF is preferred only when R is not given its own definition in an ontology.

**Arity:**2**Inverse:**Domain

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

RANGE is short for ``range restriction.'' Specifying a RANGE restriction of a relation is a way to constrain the class of objects which participate as the last argument to the relation. For any tuple<d1d2 ...dn r> in the relation, if class T is a RANGE restriction of the relation, r must be an instance of T.RANGE restrictions are very helpful in maintaining ontologies. One can think of a range restriction as a type constraint on the value of a function or range of a relation. Representation systems can use these specifications to classify terms and check integrity constraints.

If the restriction on the range of the relation is not captured by a named class, one can use specify the constraint with a predicate that defines the class implicitly, coerced into a class. For example, (kappa (?x) (and (prime ?x) (

<?x 100)))

denotes the class of prime numbers under 100.It is consistent to specify more than one RANGE restriction for a relation, as long as they all include the EXACT-RANGE of the relation.

Note that range restriction is true regardless of what the restricted relation is applied to. For class-specific range constraints, use slot-value-type.

**Arity:**2**Domain:**Relation**Range:**Class

**Axioms:**

(<=> (Range ?Relation ?Type) (And (Relation ?Relation) (Class ?Type) (Subclass-Of (Exact-Range ?Relation) ?Type) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

The inverse of RANGE. A class C is a range-of a relation R if C is a superclass-of the exact range of R.

**Arity:**2**Inverse:**Range

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Domain restrictions generalized to n-ary relations. The sentence (nth-domain rel 3 type-class) says that the 3rd element of each tuple in the relation REL is an instance of type-class.

**Arity:**3

**Axioms:**

(Nth-Domain Nth-Domain 3 Class) (Nth-Domain Nth-Domain 2 Positive-Integer) (Nth-Domain Nth-Domain 1 N-Ary-Relation) (<=> (Nth-Domain ?Relation ?N ?Type) (And (N-Ary-Relation ?Relation) (Positive-Integer ?N) (Class ?Type) (Forall (?Tuple) (=> (Member ?Tuple ?Relation) (And (>= (Length ?Tuple) ?N) (Instance-Of (Nth ?Tuple ?N) ?Type) )))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A relation-universe of a relation of any arity is a class from which is drawn every item in every tuple of the relation. Like EXACT-DOMAIN, it is exactly those items and no other. Thus, to state that the universe of a relation is covered by some class, one can state that the relation-universe is a subclass of the covering class.

**Arity:**2**Domain:**Relation**Range:**Class

**Axioms:**

(<=> (Relation-Universe ?Relation ?Type-Class) (And (Relation ?Relation) (Class ?Type-Class) (Forall (?X) (<=> (Exists (?Tuple) (And (Member ?Tuple ?Relation) (Item ?X ?Tuple) )) (Instance-Of ?X ?Type-Class) ))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

HAS-VALUE is a way to state that an instance has a value on some slot. Its third argument is a single value; one may use HAS-VALUE repeatedly for each value of a multiple-valued relation.For example, (HAS-VALUE i R v_1), (HAS-VALUE i R v_2) means that slot R applied to domain instance i maps to values v_1 and v_2. In other words, R(i,v_1) and R(i,v_2) hold.

There is no closed-world assumption implied; there may be other values for the specified slot on a given domain instance.

**Arity:**3

**Axioms:**

(Nth-Domain Has-Value 2 Binary-Relation) (<=> (Has-Value ?Instance ?Binary-Relation ?Value) (And (Binary-Relation ?Binary-Relation) (Holds ?Binary-Relation ?Instance ?Value) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

ALL-VALUES is a way to state all of the the values of a slot on an instance. Its third argument is a set. If all-values are given for a slot on an instance, there cannot be any other values for that slot on that instance. For example, (= (ALL-VALUES i R) (setof v_1 v_2 v_3)) means that R(i,v_1), R(i,v_2), and R(i,v_3) hold, and there is no other unique v_i for which R(i,v_i) holds.

**Arity:**3

**Axioms:**

(Nth-Domain All-Values 2 Binary-Relation) (<=> (All-Values ?Instance ?Binary-Relation ?Set-Of-Values) (And (Binary-Relation ?Binary-Relation) (Forall (?Value) (<=> (Member ?Value ?Set-Of-Values) (Holds ?Binary-Relation ?Instance ?Value) ))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

The VALUE-TYPE of a binary relation R with respect to a given instance d is a constraint on the values of R when R is applied to d. The constraint is specified as a class T such that when R(d,t) holds, t is an instance of T.

**Arity:**3

**Axioms:**

(Nth-Domain Value-Type 3 Class) (Nth-Domain Value-Type 2 Binary-Relation) (<=> (Value-Type ?Instance ?Binary-Relation ?Type) (And (Binary-Relation ?Binary-Relation) (Class ?Type) (Forall (?Value) (=> (Holds ?Binary-Relation ?Instance ?Value) (Instance-Of ?Value ?Type) ))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Two binary relations R1 and R2 have the SAME-VALUES on instance i if whenever R1(i,v) holds for some value v, then R2(i,v) holds for the same domain instance i and value v.

**Arity:**3

**Axioms:**

(Nth-Domain Same-Values 3 Binary-Relation) (Nth-Domain Same-Values 2 Binary-Relation) (<=> (Same-Values ?Instance ?Slot1 ?Slot2) (And (Binary-Relation ?Slot1) (Binary-Relation ?Slot2) (<=> (Holds ?Slot1 ?Instance ?Value) (Holds ?Slot2 ?Instance ?Value) )))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

The VALUE-CARDINALITY of a binary-relation with respect to a given domain instance is the number of range-elements to which the relation maps the domain-element. For a function (single-valued relation), the VALUE-CARDINALITY is 1 on all domain instances for which the function is defined. It is 0 for those instances outside the exact domain of the function.VALUE-CARDINALITY may be used within the definition of a class to specify a slot cardinality if its first argument is the class's instance variable.

**Arity:**3

**Axioms:**

(Nth-Domain Value-Cardinality 3 Nonnegative-Integer) (Nth-Domain Value-Cardinality 2 Binary-Relation) (= (Value-Cardinality ?Instance ?Binary-Relation) (Cardinality (Setofall ?Y (Holds ?Binary-Relation ?Instance ?Y))) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Minimum value cardinality is a constraint on the number of values to which a binary relation can map a domain instance. It implies the existence of at least N values for a given relation on an instance.

**Arity:**3

**Axioms:**

(Nth-Domain Minimum-Value-Cardinality 3 Nonnegative-Integer) (Nth-Domain Minimum-Value-Cardinality 2 Binary-Relation) (<=> (Minimum-Value-Cardinality ?Instance ?Binary-Relation ?N) (And (Binary-Relation ?Binary-Relation) (Nonnegative-Integer ?N) (>= (Value-Cardinality ?Instance ?Binary-Relation) ?N) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Maximum value cardinality is a constraint on the number of values to which a binary relation can map a domain instance. It restrict the relation to AT MOST N values for a given a domain instance. A cardinality of 0 means that the relation does not hold for that instance.

**Arity:**3

**Axioms:**

(Nth-Domain Maximum-Value-Cardinality 3 Nonnegative-Integer) (Nth-Domain Maximum-Value-Cardinality 2 Binary-Relation) (<=> (Maximum-Value-Cardinality ?Instance ?Binary-Relation ?N) (And (Binary-Relation ?Binary-Relation) (Nonnegative-Integer ?N) (=< (Value-Cardinality ?Instance ?Binary-Relation) ?N) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

The SLOT-VALUE-TYPE of a relation R with respect to a domain class C is a constraint on the values of R when R is applied to instances of C. The constraint is specified as a class T such that for any instance c of C, when R(c,t), t is an instance of T.

**Arity:**3

**Axioms:**

(Nth-Domain Slot-Value-Type 3 Class) (Nth-Domain Slot-Value-Type 2 Binary-Relation) (Nth-Domain Slot-Value-Type 1 Class) (<=> (Slot-Value-Type ?Class ?Binary-Relation ?Type) (And (Class ?Class) (Binary-Relation ?Binary-Relation) (Class ?Type) (Forall (?Instance) (=> (Instance-Of ?Instance ?Class) (=> (Holds ?Binary-Relation ?Instance ?Slot-Value) (Instance-Of ?Slot-Value ?Type) )))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

If a SLOT-CARDINALITY of relation R with respect to a domain class C is N, then for all instances c of class C, R maps c to exactly N individuals in the range. For single-valued relations, the slot-cardinality is 1. Specifying a SLOT-CARDINALITY is a constraint between classes and binary-relations which does not always hold; there need not be any fixed value-cardinality for R on all instances of C.

**Arity:**3

**Axioms:**

(Nth-Domain Slot-Cardinality 3 Nonnegative-Integer) (Nth-Domain Slot-Cardinality 2 Binary-Relation) (Nth-Domain Slot-Cardinality 1 Class) (<=> (Slot-Cardinality ?Domain-Class ?Binary-Relation ?N) (=> (Instance-Of ?Instance ?Domain-Class) (Value-Cardinality ?Instance ?Binary-Relation ?N) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

MINIMUM-VALUE-CARDINALITY specifies a lower bound on the number of range elements to which a given relation can map instance of a given domain class. In other words, it is the minimum number of slot values for a slot local to a class.

**Arity:**3

**Axioms:**

(Nth-Domain Minimum-Slot-Cardinality 3 Nonnegative-Integer) (Nth-Domain Minimum-Slot-Cardinality 2 Binary-Relation) (Nth-Domain Minimum-Slot-Cardinality 1 Class) (<=> (Minimum-Slot-Cardinality ?Domain-Class ?Relation ?N) (=> (Instance-Of ?Instance ?Domain-Class) (>= (Value-Cardinality ?Instance ?Relation) ?N) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

MAXIMUM-VALUE-CARDINALITY specifies an upper bound on the number of range elements associated with any instance of a given domain class.It is inspired by the CLASSIC and Loom `at-most' operator.

**Arity:**3

**Axioms:**

(Nth-Domain Maximum-Slot-Cardinality 3 Nonnegative-Integer) (Nth-Domain Maximum-Slot-Cardinality 2 Binary-Relation) (Nth-Domain Maximum-Slot-Cardinality 1 Class) (<=> (Maximum-Slot-Cardinality ?Domain-Class ?Relation ?N) (=> (Instance-Of ?Instance ?Domain-Class) (=< (Value-Cardinality ?Instance ?Relation) ?N) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

SINGLE-VALUED-SLOT is a constraint on the second argument of a binary relation that is conditional on the first argument to the relation being an instance of a given class. It is like single-valued, except it is local to the values of the relation on instances of the given subset of the domain.

**Arity:**2

**Axioms:**

(<=> (Single-Valued-Slot ?Class ?Binary-Relation) (= (Slot-Cardinality ?Class ?Binary-Relation) 1) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

AN inherited-slot-value of binary relation R on class C is value V for which R(i,v) holds on each instance i of C. There is no closed-world assumption; there may exist other values v_i for which R(i,v_i) holds. Inherited values are monotonic, not default.

**Arity:**3

**Axioms:**

(Nth-Domain Inherited-Slot-Value 2 Binary-Relation) (Nth-Domain Inherited-Slot-Value 1 Class) (<=> (Inherited-Slot-Value ?Class ?Binary-Relation ?Value) (And (Class ?Class) (Binary-Relation ?Binary-Relation) (Forall (?Instance ?Value) (=> (Instance-Of ?Instance ?Class) (Holds ?Binary-Relation ?Instance ?Value) ))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

The all-inherited-slot-values of binary relation R on class C is the set V of values for which R(c,s) holds on each instance i of C and member v of V. Unlike inherited-slot-values, there may not exist any other value v_i for which R(i,v_i) holds. Inherited values are monotonic, not default.

**Arity:**3

**Axioms:**

(Nth-Domain All-Inherited-Slot-Values 2 Binary-Relation) (Nth-Domain All-Inherited-Slot-Values 1 Class) (<=> (All-Inherited-Slot-Values ?Class ?Binary-Relation ?Set-Of-Values) (And (Class ?Class) (Binary-Relation ?Binary-Relation) (Forall (?Instance ?Value) (=> (Instance-Of ?Instance ?Class) (<=> (Member ?Value ?Set-Of-Values) (Holds ?Binary-Relation ?Instance ?Value) )))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Let class C be in the domain of two binary relations R_1 and R_2. The relation (same-values C R_1 R_2) means that the values of the two relations are the same when applied to instances of the class.

**Arity:**3

**Axioms:**

(Nth-Domain Same-Slot-Values 3 Binary-Relation) (Nth-Domain Same-Slot-Values 2 Binary-Relation) (Nth-Domain Same-Slot-Values 1 Class) (<=> (Same-Slot-Values ?Class ?Slot1 ?Slot2) (And (Class ?Class) (Binary-Relation ?Slot1) (Binary-Relation ?Slot2) (Forall (?Instance ?Value) (=> (Instance-Of ?Instance ?Class) (<=> (Holds ?Slot1 ?Instance ?Value) (Holds ?Slot2 ?Instance ?Value) )))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A set of mutually disjoint classes. Disjointness of classes is a special case of disjointness of sets.

**Subclass-Of:**Set

**Axioms:**

(<=> (Class-Partition ?Set-Of-Classes) (And (Set ?Set-Of-Classes) (Forall (?C) (=> (Member ?C ?Set-Of-Classes) (Class ?C))) (Forall (?C1 ?C2) (=> (And (Member ?C1 ?Set-Of-Classes) (Member ?C2 ?Set-Of-Classes) (Not (= ?C1 ?C2)) ) (Forall (?I) (=> (Instance-Of ?I ?C1) (Not (Instance-Of ?I ?C2)) ))))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A subclass-partition of a class C is a set of subclasses of C that are mutually disjoint.

**Arity:**2**Domain:**Class**Range:**Class-partition

**Axioms:**

(<=> (Subclass-Partition ?C ?Class-Partition) (And (Class ?C) (Class-Partition ?Class-Partition) (Forall (?Subclass) (=> (Member ?Subclass ?Class-Partition) (Subclass-Of ?Subclass ?C) ))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A subrelation-partition of a class C is a set of mutually-disjoint classes (a subclass partition) which covers C. Every instance of C is is an instance of exactly one of the subclasses in the partition.

**Arity:**2**Subrelation-Of:**Subclass-partition

**Axioms:**

(<=> (Exhaustive-Subclass-Partition ?C ?Class-Partition) (And (Subclass-Partition ?C ?Class-Partition) (Forall (?Instance) (=> (Instance-Of ?Instance ?C) (Exists (?Subclass) (And (Member ?Subclass ?Class-Partition) (Member ?Instance ?Subclass) ))))))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Relation R is asymmetric if it is not symmetric.

**Subclass-Of:**Binary-relation

**Axioms:**

(<=> (Asymmetric-Relation ?R) (And (Binary-Relation ?R) (Not (Symmetric-Relation ?R))) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Relation R is antisymmetric if for distinct x and y, R(x,y) implies not R(y,x). In other words, for all x,y, R(x,y) and R(y,x) => x=y.

**Subclass-Of:**Binary-relation

**Axioms:**

(<=> (Antisymmetric-Relation ?R) (And (Binary-Relation ?R) (=> (And (Holds ?R ?X ?Y) (Holds ?R ?Y ?X)) (= ?X ?Y)) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Relation R is antireflexive if R(a,a) never holds.

**Subclass-Of:**Binary-relation

**Axioms:**

(<=> (Antireflexive-Relation ?R) (And (Binary-Relation ?R) (Not (Holds ?R ?X ?X))) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Relation R is irreflexive if it is not reflexive.

**Subclass-Of:**Binary-relation

**Axioms:**

(<=> (Irreflexive-Relation ?R) (And (Binary-Relation ?R) (Not (Reflexive-Relation ?R))) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Relation R is reflexive if R(x,x) for all x in the domain of R.

**Subclass-Of:**Binary-relation

**Axioms:**

(<=> (Reflexive-Relation ?R) (And (Binary-Relation ?R) (=> (Instance-Of ?X (Exact-Domain ?R)) (Holds ?R ?X ?X)) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Relation R is symmetric if R(x,y) implies R(y,x).

**Subclass-Of:**Binary-relation

**Axioms:**

(<=> (Symmetric-Relation ?R) (And (Binary-Relation ?R) (=> (Holds ?R ?X ?Y) (Holds ?R ?Y ?X)) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Relation R is transitive if R(x,y) and R(y,z) implies R(x,z).

**Subclass-Of:**Binary-relation

**Axioms:**

(<=> (Transitive-Relation ?R) (And (Binary-Relation ?R) (=> (And (Holds ?R ?X ?Y) (Holds ?R ?Y ?Z)) (Holds ?R ?X ?Z) )))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Relation R is weak-transitive if R(x,y) and R(y,z) and x /= z implies R(x,z).

**Subclass-Of:**Binary-relation

**Axioms:**

(<=> (Weak-Transitive-Relation ?R) (And (Binary-Relation ?R) (=> (And (Holds ?R ?X ?Y) (Holds ?R ?Y ?Z) (Not (= ?X ?Z))) (Holds ?R ?X ?Z) )))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

**Subclass-Of:**Unary-function

**Inverse:***Slot-Value-Type:*Function

*Slots Of Instances:*

**Axioms:**

(<=> (One-To-One-Relation ?R) (And (Unary-Function ?R) (Value-Type ?R Inverse Function)) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

**Subclass-Of:**Binary-relation, Function

**Axioms:**

(<=> (Many-To-One-Relation ?R) (And (Binary-Relation ?R) (Function ?R)) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

**Subclass-Of:**Binary-relation

**Inverse:***Slot-Value-Type:*Function

*Slots Of Instances:*

**Axioms:**

(<=> (One-To-Many-Relation ?R) (And (Binary-Relation ?R) (Value-Type ?R Inverse Function)) )

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

**Subclass-Of:**Binary-relation

**Axioms:**

(<=> (Many-To-Many-Relation ?R) (And (Binary-Relation ?R) (Not (Function ?R)) (Not (Function (Inverse ?R))) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A relation is an equivalence relation if it is reflexive, symmetric, and transitive.

**Subclass-Of:**Reflexive-relation, Symmetric-relation, Transitive-relation

**Axioms:**

(<=> (Equivalence-Relation ?R) (And (Reflexive-Relation ?R) (Symmetric-Relation ?R) (Transitive-Relation ?R) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A relation is an partial-order if it is reflexive, antisymmetric, and transitive.

**Subclass-Of:**Antisymmetric-relation, Reflexive-relation, Transitive-relation

**Axioms:**

(<=> (Partial-Order-Relation ?R) (And (Reflexive-Relation ?R) (Antisymmetric-Relation ?R) (Transitive-Relation ?R) ))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

A relation R is an total-order if it is partial-order for which either R(x,y) or R(y,x) for every x or y in its domain.

**Subclass-Of:**Partial-order-relation

**Axioms:**

(<=> (Total-Order-Relation ?R) (And (Partial-Order-Relation ?R) (=> (And (Instance-Of ?X (Exact-Domain ?R)) (Instance-Of ?Y (Exact-Domain ?R)) ) (Or (Holds ?R ?X ?Y) (Holds ?R ?Y ?X)) )))

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Documentation is a relation between objects in the domain of discourse and strings of natural language text. The domain of DOCUMENTATION is not constants (names), but the objects themselves. This means that one does not quote the names when associating them with their documentation.

**Arity:**2**Domain:**Individual**Range:**String

**Defined in theory: Frame-ontology****Source code: frame-ontology.lisp**

Formatting and translation code was written by