Relation pm#relation_from_type (pm#type,*)  type of relations from a concept/relation type, i.e. in RDFS terminology, from a class or a property
  supertype:  pm#relation_from_collection
  subtype:  pm#specializing_type (pm#type,?)
     subtype:  pm#instance (pm#type,?)  the ':' link in the FT notation
     subtype:  pm#subtype__subtype_or_equal (pm#type,pm#type)  subtype links should actually be strict subtype links or not much checking can be done
        subtype:  pm#strict_subtype (pm#type,pm#type)  the '>' link in the FT notation
           subtype:  dl#properly_subsumes_leaf__PSBL (pm#type,pm#type)  the 2nd type is a leaf type properly subsumed by the 1st type
        subtype:  dl#subsumes_leaf__SBL (pm#type,pm#type)  the 2nd type is a leaf type subsumed by the 1st type
           subtype:  dl#properly_subsumes_leaf__PSBL (pm#type,pm#type)  the 2nd type is a leaf type properly subsumed by the 1st type
  subtype:  pm#supertype (pm#type,pm#type)  in the FT notation, the '<' link is only used to connect to a "strict" supertype
     subtype:  rdfs#sub_class_of__subclassof__super_class__superclas (rdfs#class,rdfs#class)  in WebKB, use the link '<'
     subtype:  sumo#subrelation (pm#relation_type,pm#relation_type)  if the common reading conventions of parameters had been respected, this type would have been named subclass_of; every tuple of the 1st argument (r1) is also a tuple of the 2nd argument (r2), i.e. if r1 holds for some arguments arg_1, arg_2, ... arg_n, then the r2 holds for the same arguments; a consequence of this is that a relation and its subrelations must have the same valence
        subtype:  rdfs#sub_property_of (pm#binary_relation_type,pm#binary_relation_type)  in WebKB, use the link '<'
  subtype:  pm#same_type_as (pm#type,pm#type)
     subtype:  owl#equivalent_class (rdfs#class,rdfs#class)  in WebKB, use the link '='
     subtype:  owl#equivalent_property (pm#binary_relation_type,pm#binary_relation_type)  in WebKB, use the link '='
  subtype:  pm#exclusive_type__exclusivetype (pm#type,pm#type)  in WebKB, use the '!' link
     subtype:  pm#exclusive_class__exclusiveclas (rdfs#class,rdfs#class)  the 2 classes have no common subtype/instance; in WebKB, use the link '!'
        subtype:  pm#complement_class (rdfs#class -> rdfs#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:  pm#closed_exclusion (pm#type -> pm#type)  the '/' link in the FT notation:  the two linked types either are respectively identical to pm#thing and pm#nothing (they are "complement types") or they subtype a same type and form a complete subtype partition
        subtype:  pm#complement_type (pm#type -> pm#type)  a supertype of owl#complement_of which can only connect RDFS/OWL classes
           subtype:  pm#complement_class (rdfs#class -> rdfs#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:  pm#relation_from_relation_type (pm#relation_type,*)
     subtype:  pm#relation_from_binary_relation_type (pm#binary_relation_type,*)
        subtype:  pm#relation_to_another_binary_relation_type (pm#binary_relation_type,pm#binary_relation_type)
           subtype:  owl#equivalent_property (pm#binary_relation_type,pm#binary_relation_type)  in WebKB, use the link '='
           subtype:  rdfs#sub_property_of (pm#binary_relation_type,pm#binary_relation_type)  in WebKB, use the link '<'
           subtype:  pm#inverse__reverse (pm#binary_relation_type -> pm#binary_relation_type)  for inverseOf(R,S) read: R is the inverse of S; i.e. if R(x,y) then S(y,x) and vice versa; in WebKB, use the link '-'
        subtype:  rdfs#domain (pm#binary_relation_type,rdfs#class)
        subtype:  rdfs#range (pm#binary_relation_type,rdfs#class)
     subtype:  sumo#domain (pm#relation_type,sumo#positive_integer,sumo#set_or_class)  the formula (sumo#domain ?REL ?INT ?CLASS) means that the ?INT'th element of each tuple in the relation ?REL must be an instance of ?CLASS
     subtype:  sumo#domain_subclass (pm#relation_type,sumo#positive_integer,sumo#set_or_class)  the formula (sumo#domainSubclass ?REL ?INT ?CLASS) means that the ?INT'th element of each tuple in the relation ?REL must be a subclass of ?CLASS
     subtype:  sumo#range (pm#function_type,sumo#set_or_class)  gives the range of a function, i.e. all of the values assigned by the function are instances of sumo#class
     subtype:  sumo#range_subclass (pm#function_type,sumo#set_or_class)  all of the values assigned by the function in the 1st argument are subclasses of the 2nd argment
     subtype:  sumo#valence (pm#relation_type,sumo#positive_integer)  specifies the number of arguments that a relation can take; if a relation does not have a fixed number of arguments, it does not have a valence and it is an instance of variable_arity_relation, e.g., sumo#holds is a variable_arity_relation
     subtype:  sumo#disjoint_relation (pm#relation_type+)  (sumo#disjointRelation @ROW) means that any two relations in @ROW have no tuples in common; as a consequence, the intersection of all of the relations in @ROW is the null set
     subtype:  sumo#holds__hold (pm#relation_type,*)  (holds P N1 ... NK) is true when the tuple of objects denoted by N1,..., NK is an element of the relation P
     subtype:  sumo#assignment_fn (pm#function_type,*)  if F is a function with a value for the objects denoted by N1,..., NK, then (sumo#assignmentFn F N1 ... NK) is the value of applying F to the objects denoted by N1,..., NK; otherwise, the value is undefined
     subtype:  sumo#distributes__distribute (pm#binary_function_type,pm#binary_function_type)  a binary_function ?F1 is distributive over another binary_function ?F2 just in case (?F1 ?INST1 (?F2 ?INST2 ?INST3)) is equal to (?F2 (?F1 ?INST1 ?INST2) (?F1 ?INST1 ?INST3)), for all ?INST1, ?INST2, and ?INST3
  subtype:  pm#relation_from_class (rdfs#class,*)
     subtype:  pm#relation_from_class_to_collection (rdfs#class,pm#collection)
        subtype:  owl#union_of__unionof (rdfs#class,rdf#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:  daml#disjoint_union_of (rdfs#class,rdf#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:  owl#intersection_of (rdfs#class,rdf#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:  owl#one_of__oneof (rdfs#class,rdf#list)  for oneOf(C,L) read everything in C is one of the things in L
        subtype:  owl#distinct_members (owl#all_different,rdf#list)
        subtype:  pm#relation_to_another_class (rdfs#class,rdfs#class+)
           subtype:  rdfs#sub_class_of__subclassof__super_class__superclas (rdfs#class,rdfs#class)  in WebKB, use the link '<'
           subtype:  owl#equivalent_class (rdfs#class,rdfs#class)  in WebKB, use the link '='
           subtype:  pm#exclusive_class__exclusiveclas (rdfs#class,rdfs#class)  the 2 classes have no common subtype/instance; in WebKB, use the link '!'
           subtype:  daml#restricted_by (rdfs#class,owl#restriction)
           subtype:  sumo#disjoint_decomposition (sumo#class,sumo#class+)  a disjoint_decomposition of a class C is a set of mutually disjoint subclasses of C
              subtype:  sumo#partition (sumo#class,sumo#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:  sumo#exhaustive_decomposition (sumo#class,sumo#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:  sumo#partition (sumo#class,sumo#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:  sumo#abstraction_fn__abstractionfn (sumo#class -> sumo#Attribute)  a unary_function that maps a class into an attribute that specifies the condition(s) for membership in the class
     subtype:  pm#relation_from_sumo_process_class (pm#sumo_process_class,*)
        subtype:  sumo#causes_subclass (pm#sumo_process_class,pm#sumo_process_class)  the 1st argument brings about the 2nd, e.g., (causes_subclass killing death)
        subtype:  sumo#capability (pm#sumo_process_class,pm#case_relation_type,sumo#object)  the object  has the ability to play the role (case relation) in the given kinds of processes
        subtype:  sumo#has_skill__hasskill (pm#sumo_process_class,dl#agentive_physical_object)  similar to the capability predicate with the additional restriction that the ability be practised or demonstrated to some measurable degree
     subtype:  pm#relation_from_attribute_type (pm#attribute_class,*)
        subtype:  sumo#contrary_attribute (pm#attribute_class,pm#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:  sumo#exhaustive_attribute (pm#attribute_class,pm#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:  pm#relation_from_restriction (owl#restriction,*)
        subtype:  owl#on_property (owl#restriction,pm#binary_relation_type)  for onProperty(?restrClass,?rel), read: ?restrClass is a restricted with respect to property ?rel
        subtype:  owl#all_values_from (owl#restriction,rdfs#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:  owl#has_value__hasvalue (owl#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:  owl#some_values_from (owl#restriction,rdfs#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:  daml#has_class_q__hasclassq (owl#restriction,rdfs#class)  property for specifying class restriction with cardinalityQ constraints
        subtype:  owl#cardinality (owl#restriction -> sumo#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:  daml#cardinality_q__cardinalityq (owl#restriction -> sumo#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:  owl#min_cardinality__mincardinality (owl#restriction -> sumo#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:  daml#min_cardinality_q__mincardinalityq (owl#restriction -> sumo#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:  owl#max_cardinality__maxcardinality (owl#restriction -> sumo#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:  daml#max_cardinality_q__maxcardinalityq (owl#restriction,sumo#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:  pm#wnObject (rdfs#class,?)
     subtype:  pm#wnNounType (rdfs#class,?)
  subtype:  pm#relation_from_type_to_collection (pm#type,pm#collection)
     subtype:  pm#partition (pm#type,pm#collection)
     subtype:  pm#instances__instance (pm#type -> pm#collection)
     subtype:  pm#subtypes (pm#type -> pm#collection)
     subtype:  pm#relation_from_class_to_collection (rdfs#class,pm#collection)
  subtype:  sumo#material__material_type_of (pm#substance_class,sumo#corpuscular_object)  all other mereological relations are defined in terms of this one; it means that the 2nd argument is structurally made up in part of the 1st argument; this relation encompasses the concepts of 'composed of', 'made of', and 'formed of'; for example, plastic is a material of my computer monitor; since part is a reflexive_relation, every object is a part of itself