Relation pm#relation_to_collection (*,collection)
  exclusion:  relation_to_situation  spatial_relation_to_entity_with_spatial_feature  relation_to_time  relation_to_attribute_or_quality_or_measure
  supertype:  relation_from/to_thing_of_common_kind  what_relation
  subtype:  member_of (*,collection)  this type SHOULD NOT BE USED IN WEBKB (its inverse may be used); this type is only provided for knowledge sharing purposes
     subtype:  member (?,set)  this type SHOULD NOT BE USED IN WEBKB: if the common reading conventions of parameters had been respected, the parameters would be swapped or the type would be named member_of
  subtype:  list_of (* -> collection)
  subtype:  set_of__setof (* -> collection)
  subtype:  parts__part (?,collection)  such a type (using a collection as destination) should NOT be used: pm#part or a subtype of it should be used instead
  subtype:  item (?,list)  USE pm#item INSTEAD OF THIS RELATION TYPE: if the common reading conventions of parameters had been respected, the parameters would be swapped or the type would be named item_of
  subtype:  in_list (?,list)  true if the 1st argument is in the list; analog of element and instance for lists
  subtype:  list_fn (* -> list)  a function that takes any number of arguments and returns the list containing those arguments in exactly the same order
  subtype:  function_returning_a_collection_from_2_elements (?,? -> collection)
     subtype:  cons (?,list -> list)
     subtype:  adjoin (?,list -> list)
     subtype:  remove (?,list -> list)
  subtype:  relation_between_collections (collection,collection+)
     subtype:  sub_collection__subcollection (collection,collection)  a partial order relation
        subtype:  ending_collection (collection,collection)
           subtype:  final_segment__finalsegment (collection,collection)  the second collection is a final segment of the 1st
        subtype:  sublist__final_segment_of__finalsegmentof (list,list)  USE pm#final_segment INSTEAD OF THIS RELATION TYPE; "sublist" is a misleading name; "final_segment_of" is better
     subtype:  sub_collection_of (collection,collection)  DO NOT use this type; it only exists because the SUMO does not respect common reading conventions of parameters
        subtype:  sub_collection__subcollection__sub_collection_of (collection,collection)  the 1st collection is a proper part of the 2nd
        subtype:  sub_list__sublist__sub_list_of (list,list)  the 1st argument is a sublist of the 2nd, i.e. every element of the 1st is an element of the 2nd and the elements that are common to both lists have the same order in both lists
           subtype:  initial_list__initiallist (list,list)  the 1st argument (?L1) is a sublist of the 2nd (?L2), and (sumo#list_order_fn ?L1 ?NUMBER) returns the same value as (sumo#list_order_fn ?L2 ?N) for all of the values of ?N over which (sumo#list_order_fn ?L1 ?N) is defined
        subtype:  final_segment_of__finalsegmentof (collection,collection)  USE pm#final_segment INSTEAD
           subtype:  sublist__final_segment_of__finalsegmentof (list,list)  USE pm#final_segment INSTEAD OF THIS RELATION TYPE; "sublist" is a misleading name; "final_segment_of" is better
     subtype:  overlapping_collection__overlappingcollection (collection,collection)
     subtype:  not_overlapping_collection__notoverlappingcollection (collection,collection)
        subtype:  collection_complement (collection,collection)
     subtype:  rest (list -> list)
        subtype:  rest (list -> list)
     subtype:  append (list,list -> list)
     subtype:  list_concatenate_fn (list,list -> list)  returns the concatenation of two lists
     subtype:  revappend (list,list -> list)
     subtype:  reverse (list -> list)
     subtype:  relation_from_type_to_collection (type,collection)
        subtype:  partition (type,collection)
        subtype:  instances__instance (type -> collection)
        subtype:  subtypes (type -> collection)
        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:  relation_to_another_set_or_class (set_or_class,set_or_class+)  this category is needed to group SUMO relations between classes which cannot be subtype of pm#relation_from_type because their signatures curiously also involve sets
        subtype:  disjoint (set_or_class,set_or_class)  like sumo#disjoint but from a a pm#set_or_class to another
           subtype:  disjoint (set_or_class,set_or_class)  classes are exclusive/disjoint only if they share no instance (and hence no subtype), i.e. just in case the result of applying sumo#intersection_fn to them is empty
           subtype:  exclusive_class__exclusiveclas (class,class)  the 2 classes have no common subtype/instance; in WebKB, use the link '!'
        subtype:  subclass_of_or_equal (set_or_class,set_or_class)
           subtype:  subclass__subclass_of (set_or_class,set_or_class)  if the common reading conventions of parameters had been respected, this type would have been named subclass_of; every instance of the 1st argument is also an instance of the 2nd argument; a class may have multiple superclasses and subclasses
              subtype:  immediate_subclass__immediate_subclass_of (set_or_class,set_or_class)  the 1st argument is a subclass of the 2nd argument and there is no other subclass of the 2nd argument such that the 1st is also a subclass of the 2nd; in WebKB, use the link '<'
           subtype:  sub_class_of__subclassof__super_class__superclas (class,class)  in WebKB, use the link '<'
        subtype:  power_set_fn__powersetfn (set_or_class -> set_or_class)  maps the argument to the set_or_class of all its subclasses
        subtype:  relation_to_another_class (class,class+)
     subtype:  relation_to_another_ontology (ontology,ontology)
        subtype:  backward_compatible_with (ontology,ontology)
        subtype:  incompatible_with (ontology,ontology)
        subtype:  prior_version__priorversion (ontology,ontology)
  subtype:  relation_to_set_or_class (*,set_or_class)
     subtype:  closed_on (function_type,set_or_class)  a binary_function is closed on a set_or_class if it is defined for all instances of the set_or_class and its value is always an instance of the set_or_class
     subtype:  reflexive_on__reflexiveon (binary_relation_type,set_or_class)  a binary_relation is reflexive on a set_or_class only if every instance of the set_or_class bears the relation to itself
     subtype:  irreflexive_on__irreflexiveon (binary_relation_type,set_or_class)  a binary_relation is irreflexive on a set_or_class only if no instance of the set_or_class bears the relation to itself
     subtype:  partial_ordering_on (binary_relation_type,set_or_class)  a binary_relation is a partial ordering on a set_or_class only if the relation is reflexive_on the set_or_class, and it is both an antisymmetric_relation, and a transitive_relation
     subtype:  total_ordering_on (binary_relation_type,set_or_class)  a binary_relation ?REL is a total ordering on a set_or_class only if it is a partial ordering for which either (?REL ?INST1 ?INST2) or (?REL ?INST2 ?INST1) for every ?INST1 and ?INST2 in the set_or_class
     subtype:  trichotomizing_on (binary_relation_type,set_or_class)
     subtype:  equivalence_relation_on (binary_relation_type,set_or_class)  a binary_relation is an equivalence_relation_on a set_or_class only if the relation is reflexive_on the set_or_class and it is both a transitive_relation and a symmetric_relation
     subtype:  relation_to_class (*,class)
        subtype:  kind__type___class___instance_of__instanceof (?,class)  the '^' link in the FT notation
        subtype:  extension_fn__extensionfn (Attribute -> class)  a unary_function that maps an attribute into the class whose condition for membership is the attribute
     subtype:  relation_to_another_set_or_class (set_or_class,set_or_class+)  this category is needed to group SUMO relations between classes which cannot be subtype of pm#relation_from_type because their signatures curiously also involve sets
  subtype:  relation_to_type (*,type)
     subtype:  relation_to_class (*,class)
  subtype:  relation_to_string (*,string)
     subtype:  extrinsic_relation__extrinsicrelation (?,Literal)  support for relations ranging on concrete data types
        subtype:  name (entity,Literal)  a relation between an instance of a concept and the name (instance of a concrete data type) of that concept; the name has to be a lexically meaningful name
        subtype:  identifier (entity -> Literal)  a relation between an individual of a concept and the identifier of that concept; the identifier is a concrete data type, usually non_meaningful from the lexical viewpoint; useful to map many database relationships