pm#unary_function_type  class of functions requiring a single argument; if R is functional, then if R(x -> y) and P(x -> z) then y=z
  subtype:  unary_constant_function_quantity_type  one_to_one_function_type
  instance:  unary_function  power_set_fn  front_fn  back_fn  abstraction_fn  extension_fn  probability_fn  list_length_fn  property_fn  absolute_value_fn  ceiling_fn  cosine_fn  denominator_fn  floor_fn  imaginary_part_fn  integer_square_root_fn  numerator_fn  rational_number_fn  real_number_fn  reciprocal_fn  round_fn  signum_fn  sine_fn  square_root_fn  tangent_fn  successor_fn  predecessor_fn  complement_fn  generalized_union_fn  generalized_intersection_fn  cardinality_fn  kilo_fn  mega_fn  giga_fn  tera_fn  milli_fn  micro_fn  nano_fn  pico_fn  magnitude_fn  wealth_fn  begin_fn  end_fn  when_fn  past_fn  immediate_past_fn  future_fn  immediate_future_fn  year_fn  hole_host_fn  hole_skin_fn  immediate_family_fn  government_fn  premises_fn
  equal:  unary_function (pm)  functional_property (pm)  unique_property (pm)
  type:  class_of_inheritable_relation_type  each instance RT of this class is a subclass of the 2nd-order_type pm#relation_type and the properties of RT can be inherited downward in the class hierarchy via the "subrelation" predicate
  supertype:  function_type  term-forming relation that maps from a n-tuple of arguments to a range and that associates this n-tuple with at most one range element; note that the range is a set_or_class, and each element of the range is an instance of the set_or_class
     supertype:  single_valued_relation_type  when an assignment of values to every argument position except the last one determines at most one assignment for the last argument position; not all single_valued_relations are total_valued_relations
        supertype:  relation_type  there are three kinds of relation(_types): pm#predicate_type, pm#function_type and sumo#list; both predicates and functions denote sets of ordered n-tuples; the difference between these two classes is that predicates cover formula-forming operators, while functions cover term-forming operators; a list, on the other hand, is a particular ordered n-tuple
           supertype:  1st_order_type__1stordertype__type1  all 1st order types are implicitely or explicitely instance of that 2nd-order type
              supertype:  type  second-order type or more
                 supertype:  non_spatial_collection__nonspatialcollection__true_collection  something gathering separated things (entities/situations) and that is not a spatial object
                    supertype:  non_spatial_object_that_is_not_an_attribute_or_quality_or_measure
                       supertype:  non_spatial_object__nonspatialobject  abstraction or description content/medium/container (a description medium that has some spatial feature is both instance of sumo#object and pm#non_spatial_object
                          supertype:  entity  something that can be "involved" in a situation
                             supertype:  thing__something___T__t___3D_or_4D_thing_or_anything_else  any category (type or individual) is instance of this type; any type is also a subtype of this type
                          supertype:  intangible  The collection of things that are not physical -- are not made of, or encoded in, matter. Every cyc#Collection is a cyc#intangible (even if its instances are tangible), and so are some cyc#individuals.  Caution: do not confuse `tangibility' with `perceivability' -- humans can perceive light even though it's intangible--at least in a sense.
                             supertype:  partially_intangible__partiallyintangible  The collection of things that either are wholly intangible (see cyc#Intangible) or have at least one intangible (i.e. immaterial) part (see cyc#intangibleParts). This includes intangible individuals, such as instances of cyc#Number-General  or cyc#Agreement, as well as non-individuals (all of which are intangible), i.e. instances of cyc#SetOrCollection.  It also includes things that have both tangible and intangible components (see cyc#CompositeTangibleAndIntangibleObject),  such as a printed copy of a newspaper (as its information content is intangible) or a person (as her mental states are intangible).
                                supertype:  thing__something___T__t___3D_or_4D_thing_or_anything_else  any category (type or individual) is instance of this type; any type is also a subtype of this type
                    supertype:  collection  something gathering separated things (entities/situations)
                       supertype:  divisible_entity__divisibleentity  many classifications under this category are application-dependant
                          supertype:  entity  something that can be "involved" in a situation
                          supertype:  divisible_thing__divisiblething
                             supertype:  thing__something___T__t___3D_or_4D_thing_or_anything_else  any category (type or individual) is instance of this type; any type is also a subtype of this type
                 supertype:  abstract__entity_without_spatial_feature  e.g., knowledge, motivation, measure; properties or qualities as distinguished from any particular embodiment of the properties/qualities in a physical medium; instances of sumo#abstract can be said to exist in the same sense as mathematical objects such as sets and relations, but they cannot exist at a particular place or time without some physical encoding or embodiment
                    supertype:  non_spatial_object__nonspatialobject  abstraction or description content/medium/container (a description medium that has some spatial feature is both instance of sumo#object and pm#non_spatial_object
  supertype:  binary_relation_type  all binary relation types are instance of that object
     supertype:  relation_type  there are three kinds of relation(_types): pm#predicate_type, pm#function_type and sumo#list; both predicates and functions denote sets of ordered n-tuples; the difference between these two classes is that predicates cover formula-forming operators, while functions cover term-forming operators; a list, on the other hand, is a particular ordered n-tuple

No statement uses or specializes unary_function_type; click here to add one.


Another search (with same display options)?