Class Relation

Subclass-Of@Frame-Ontology: Set
Binary-Relation, Function, Unary-Relation, Class@Frame-Ontology, Facet@Frame-Ontology ...
Disjoint, Mutually-Disjoint, Pairwise-Disjoint, Set-Cover, Set-Partition ...
Instance-Of@Frame-Ontology: Class@Frame-Ontology, Relation, Set
Alias@Frame-Ontology, Exact-Domain@Frame-Ontology, Exact-Range@Frame-Ontology, Range@Frame-Ontology, Relation-Universe@Frame-Ontology ...
Range-Of@Frame-Ontology: Alias@Frame-Ontology, Exact-Domain@Frame-Ontology, Subrelation-Of@Frame-Ontology
Arity@Frame-Ontology: 1
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.


  • See-Also: In Loom, relations are called relations.

    In CycL, relations are called relationships.

    In KEE, relations are not supported explicitly.

    In Epikit, relations are called relations.

    In Algernon, relations are called slots.

  • What about slots?

    Slots can be represented with unary functions, binary relations, or both. In some systems, all slots are unary functions that take a frame object as an argument and return a set of objects as the value of the slot. In other systems, slots are always binary relations that map frames to individual slot fillers. In the frame ontology, slots are represented by binary relations, some of which are also unary functions. A single-valued-slot may be used in the functional position of a KIF term expression. In this case, the constant naming the relation is a KIF function constant. In other cases, the constant may be a relation constant or a function constant.

  • What about variable-arity relations?

    They are allowed, but need to use a sequence variable in the definition.

  • Originally defined in the KIF-RELATIONS ontology



Implication Axioms for Relation:

(=> (Relation ?Relation)
    (Forall (?Tuple) (=> (Member ?Tuple ?Relation) (List ?Tuple))))

Equivalence Axioms for Relation:

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

Implication Axioms mentioning Relation:

(=> (Function ?Relation) (Relation ?Relation))

(=> (Unary-Relation ?Relation) (Relation ?Relation))

(=> (Binary-Relation ?Relation) (Relation ?Relation))

(=> (Class@Frame-Ontology ?Class) (Relation ?Class))

(=> (Facet@Frame-Ontology ?Relation) (Relation ?Relation))

Equivalence Axioms mentioning Relation:

(<=> (Holds ?R @Args) (And (Relation ?R) (Member (Listof @Args) ?R)))

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

(<=> (Unary-Relation ?Relation)
     (And (Relation ?Relation)
          (Not (Empty ?Relation))
          (Forall (?Tuple)
                  (=> (Member ?Tuple ?Relation) (Single ?Tuple)))))

(<=> (Binary-Relation ?Relation)
     (And (Relation ?Relation)
          (Not (Empty ?Relation))
          (Forall (?Tuple)
                  (=> (Member ?Tuple ?Relation) (Double ?Tuple)))))

(<=> (Class@Frame-Ontology ?Class)
     (And (Relation ?Class) (= (Arity@Frame-Ontology ?Class) 1)))