Relation pm#relation_between_collections (collection,collection+)
  supertype:  relation_from_collection  relation_to_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)