Relation pm#relation_from_collection (pm#collection,*)
  exclusion:  pm#relation_from_situation  pm#spatial_relation_from_entity_with_spatial_feature  pm#relation_from_description_content/medium/container  pm#relation_from_attribute_or_quality_or_measure
  supertype:  pm#relation_from/to_thing_of_common_kind  pm#what_relation
  subtype:  pm#member (pm#collection,*)
     subtype:  pm#domain_object (pm#domain,?)
        subtype:  pm#core_domain_object__central_object_of_domain (pm#domain,?)
     subtype:  pm#reverse_of_KIF_member (kif#set,?)  this type only exists to make the connection to kif#member (which should have been named kif#member_of to respect the common reading conventions of parameters)
     subtype:  pm#item (sumo#list,?)
        subtype:  rdf#item (rdf#list,?)  for item(L,I) read: I is an item in L; either first(L,I) or item(R,I) where rest(L,R)
     subtype:  rdf#li (pm#collection,*)
     subtype:  kif#first (sumo#list -> ?)
        subtype:  rdf#first (rdf#list -> ?)
     subtype:  kif#last (sumo#list -> ?)
     subtype:  kif#butlast (sumo#list -> ?)
     subtype:  kif#nth (sumo#list,sumo#positive_integer -> ?)
  subtype:  kif#nthrest (sumo#list,sumo#nonnegative_integer -> sumo#list)
  subtype:  pm#relation_from_collection_to_number (pm#collection -> sumo#number)
     subtype:  pm#size__number_of_elements (pm#collection -> sumo#nonnegative_integer)
        subtype:  kif#length (sumo#list -> sumo#nonnegative_integer)
     subtype:  pm#minimal_size__minimalsize (pm#collection -> sumo#nonnegative_integer)
     subtype:  pm#maximal_size__maximalsize (pm#collection -> sumo#nonnegative_integer)
     subtype:  pm#percentage (pm#collection -> sumo#number)
     subtype:  pm#average (pm#number_container -> sumo#number)  to specify an average on the values
  subtype:  sumo#list_order_fn (sumo#list,sumo#positive_integer -> ?)  returns the item that is in the given position (2nd argument) in the list, e.g., (sumo#list_order_fn (sumo#list_fn Monday Tuesday Wednesday) 2) would return the value tuesday
  subtype:  sumo#list_length_fn (sumo#list -> sumo#nonnegative_integer)  returns the number of items in the list, e.g., (sumo#list_length_fn (sumo#list_fn Monday Tuesday Wednesday)) would return the value 3
  subtype:  pm#relation_from_an_ontology (pm#ontology,*)
     subtype:  pm#relation_to_another_ontology (pm#ontology,pm#ontology)
        subtype:  owl#backward_compatible_with (pm#ontology,pm#ontology)
        subtype:  owl#incompatible_with (pm#ontology,pm#ontology)
        subtype:  owl#prior_version__priorversion (pm#ontology,pm#ontology)
  subtype:  pm#relation_between_collections (pm#collection,pm#collection+)
     subtype:  pm#sub_collection__subcollection (pm#collection,pm#collection)  a partial order relation
        subtype:  pm#ending_collection (pm#collection,pm#collection)
           subtype:  pm#final_segment__finalsegment (pm#collection,pm#collection)  the second collection is a final segment of the 1st
        subtype:  kif#sublist__final_segment_of__finalsegmentof (sumo#list,sumo#list)  USE pm#final_segment INSTEAD OF THIS RELATION TYPE; "sublist" is a misleading name; "final_segment_of" is better
     subtype:  pm#sub_collection_of (pm#collection,pm#collection)  DO NOT use this type; it only exists because the SUMO does not respect common reading conventions of parameters
        subtype:  sumo#sub_collection__subcollection__sub_collection_of (sumo#collection,sumo#collection)  the 1st collection is a proper part of the 2nd
        subtype:  sumo#sub_list__sublist__sub_list_of (sumo#list,sumo#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:  sumo#initial_list__initiallist (sumo#list,sumo#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:  pm#final_segment_of__finalsegmentof (pm#collection,pm#collection)  USE pm#final_segment INSTEAD
           subtype:  kif#sublist__final_segment_of__finalsegmentof (sumo#list,sumo#list)  USE pm#final_segment INSTEAD OF THIS RELATION TYPE; "sublist" is a misleading name; "final_segment_of" is better
     subtype:  pm#overlapping_collection__overlappingcollection (pm#collection,pm#collection)
     subtype:  pm#not_overlapping_collection__notoverlappingcollection (pm#collection,pm#collection)
        subtype:  pm#collection_complement (pm#collection,pm#collection)
     subtype:  kif#rest (sumo#list -> sumo#list)
        subtype:  rdf#rest (rdf#list -> rdf#list)
     subtype:  kif#append (sumo#list,sumo#list -> sumo#list)
     subtype:  sumo#list_concatenate_fn (sumo#list,sumo#list -> sumo#list)  returns the concatenation of two lists
     subtype:  kif#revappend (sumo#list,sumo#list -> sumo#list)
     subtype:  kif#reverse (sumo#list -> sumo#list)
     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:  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:  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:  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:  pm#relation_to_another_set_or_class (pm#set_or_class,pm#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:  pm#disjoint (pm#set_or_class,pm#set_or_class)  like sumo#disjoint but from a a pm#set_or_class to another
           subtype:  sumo#disjoint (sumo#set_or_class,sumo#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:  pm#exclusive_class__exclusiveclas (rdfs#class,rdfs#class)  the 2 classes have no common subtype/instance; in WebKB, use the link '!'
        subtype:  pm#subclass_of_or_equal (pm#set_or_class,pm#set_or_class)
           subtype:  sumo#subclass__subclass_of (sumo#set_or_class,sumo#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:  sumo#immediate_subclass__immediate_subclass_of (sumo#set_or_class,sumo#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:  rdfs#sub_class_of__subclassof__super_class__superclas (rdfs#class,rdfs#class)  in WebKB, use the link '<'
        subtype:  sumo#power_set_fn__powersetfn (sumo#set_or_class -> sumo#set_or_class)  maps the argument to the set_or_class of all its subclasses
        subtype:  pm#relation_to_another_class (rdfs#class,rdfs#class+)
     subtype:  pm#relation_to_another_ontology (pm#ontology,pm#ontology)
  subtype:  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
     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#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:  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:  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

142 categories printed