Relation pm#relation_from_class (class,*)
  supertype:  relation_from_type  type of relations from a concept/relation type, i.e. in RDFS terminology, from a class or a property
  subtype:  relation_from_class_to_collection (class,collection)
     subtype:  union_of__unionof (class,list)  for unionOf(X,L) read: X is the union of the classes in the list L; i.e. if something is in any of the classes in L, it is in X, and vice versa
        subtype:  disjoint_union_of (class,list)  for disjointUnionOf(X,L) read: X is the disjoint union of the classes in the list L: (a) for any c1 and c2 in L, disjointWith(c1,c2), and (b) i.e. if something is in any of the classes in L, it is in X, and vice versa
     subtype:  intersection_of (class,list)  for intersectionOf(X,Y) read: X is the intersection of the classes in the list Y; i.e. if something is in all the classes in Y, then it's in X, and vice versa
     subtype:  one_of__oneof (class,list)  for oneOf(C,L) read everything in C is one of the things in L
     subtype:  distinct_members (all_different,list)
     subtype:  relation_to_another_class (class,class+)
        subtype:  sub_class_of__subclassof__super_class__superclas (class,class)  in WebKB, use the link '<'
        subtype:  equivalent_class (class,class)  in WebKB, use the link '='
        subtype:  exclusive_class__exclusiveclas (class,class)  the 2 classes have no common subtype/instance; in WebKB, use the link '!'
           subtype:  complement_class (class -> class)  if something is not in one of the classes, then it is in the other, and vice versa; in WebKB, use the link '/'
        subtype:  restricted_by (class,restriction)
        subtype:  disjoint_decomposition (class,class+)  a disjoint_decomposition of a class C is a set of mutually disjoint subclasses of C
           subtype:  partition (class,class+)  a partition of a class C is a set of mutually disjoint classes (a subclass partition) covering C; each instance of C is instance of exactly one of the subclasses in the partition
        subtype:  exhaustive_decomposition (class,class+)  an exhaustive_decomposition of a class C is a set of subclasses of C such that every instance of C is an instance of one of the subclasses in the set; note:  this does not necessarily mean that the elements of the set are disjoint (see sumo#partition - a partition is a disjoint exhaustive decomposition)
           subtype:  partition (class,class+)  a partition of a class C is a set of mutually disjoint classes (a subclass partition) covering C; each instance of C is instance of exactly one of the subclasses in the partition
  subtype:  abstraction_fn__abstractionfn (class -> Attribute)  a unary_function that maps a class into an attribute that specifies the condition(s) for membership in the class
  subtype:  relation_from_sumo_process_class (sumo_process_class,*)
     subtype:  causes_subclass (sumo_process_class,sumo_process_class)  the 1st argument brings about the 2nd, e.g., (causes_subclass killing death)
     subtype:  capability (sumo_process_class,case_relation_type,object)  the object  has the ability to play the role (case relation) in the given kinds of processes
     subtype:  has_skill__hasskill (sumo_process_class,agentive_physical_object)  similar to the capability predicate with the additional restriction that the ability be practised or demonstrated to some measurable degree
  subtype:  relation_from_attribute_type (attribute_class,*)
     subtype:  contrary_attribute (attribute_class,attribute_class+)  set of attributes such that something can not simultaneously have more than one of these attributes, e.g., in KIF, (sumo#contrary_aAttribute sumo#pliable sumo#rigid) means that nothing can be both pliable and rigid
     subtype:  exhaustive_attribute (attribute_class,attribute_class+)  this predicate relates a class to several types of attributes, and it means that the elements of this set exhaust the instances of the class; for example, in KIF, (sumo#exhaustiveAttribute sumo#physicalState sumo#solid sumo#fluid sumo#liquid sumo#gas) means that there are only three instances of the class sumo#physicalState, viz. sumo#solid, sumo#fluid, sumo#liquid, and sumo#gas
  subtype:  relation_from_restriction (restriction,*)
     subtype:  on_property (restriction,binary_relation_type)  for onProperty(?restrClass,?rel), read: ?restrClass is a restricted with respect to property ?rel
     subtype:  all_values_from (restriction,class)  for onProperty(?restrClass,?rel) and toClass(?restrClass,C), read: i instance of ?restrClass if and only if for all j, ?rel(i,j) implies type(j,C)
     subtype:  has_value__hasvalue (restriction,?)  for onProperty(?restrClass,?rel) and hasValue(?restrClass,V), read: i instance of ?restrClass if and only if ?rel(i,V), i.e. if and only if any ?rel from ?i has for destination an instance of C; toValue is an obsolete name
     subtype:  some_values_from (restriction,class)  for onProperty(?restrClass,?rel) and some_values_from(?restrClass,C), read: i instance of ?restrClass if and only if for some j, ?rel(i,j) and type(j,C), i.e. if and only if i has at least one ?rel which has for destination an instance of C
     subtype:  has_class_q__hasclassq (restriction,class)  property for specifying class restriction with cardinalityQ constraints
     subtype:  cardinality (restriction -> nonnegative_integer)  for onProperty(?restrClass,?rel) and cardinality(?restrClass,n), read: i instance of ?restrClass if and only if there are exactly n distinct j with ?rel(i,j)
     subtype:  cardinality_q__cardinalityq (restriction -> nonnegative_integer)  for onProperty(?restrClass,?rel), cardinalityQ(?restrClass,n) and hasClassQ(?restrClass,C), read: i instance of ?restrClass if and only if there are exactly n distinct j with ?rel(i,j) and type(j,C)
     subtype:  min_cardinality__mincardinality (restriction -> nonnegative_integer)  for onProperty(?restrClass,?rel) and minCardinality(?restrClass,n), read: i instance of ?restrClass if and only if there are at least n distinct j with ?rel(i,j)
     subtype:  min_cardinality_q__mincardinalityq (restriction -> nonnegative_integer)  for onProperty(?restrClass,?rel), minCardinalityQ(?restrClass,n) and hasClassQ(?restrClass,C), read: i instance of ?restrClass if and only if there are at least n distinct j with ?rel(i,j)
     subtype:  max_cardinality__maxcardinality (restriction -> nonnegative_integer)  for onProperty(?restrClass,?rel) and maxCardinality(?restrClass,n), read: i instance of ?restrClass if and only if there are at most n distinct j with ?rel(i,j)
     subtype:  max_cardinality_q__maxcardinalityq (restriction,nonnegative_integer)  for onProperty(?restrClass,?rel), maxCardinalityQ(?restrClass,n) and hasClassQ(?restrClass,C), read: i instance of ?restrClass if and only if there are at most n distinct j with ?rel(i,j) and type(j,C)
  subtype:  wnObject (class,?)
  subtype:  wnNounType (class,?)