Is-A Relation

(Redirected from IsA Relation)
Jump to: navigation, search

An Is-A Relation is a domain independent semantic relation that is a strict partial order relation (antisymmetric, irreflexive, transitive) between a subclass concept and a superclass concept.



  • (Wikipedia, 2020) ⇒ Retrieved:2020-12-1.
    • In knowledge representation, object-oriented programming and design (see object-oriented program architecture), is-a (is_a or is a) is a subsumption [1] relationship between abstractions (e.g. types, classes), wherein one class A is a subclass of another class B (and so B is a superclass of A). In other words, type A is a subtype of type B when A's specification implies B's specification. That is, any object (or class) that satisfies A's specification also satisfies B's specification, because B's specification is weaker. The is-a relationship is to be contrasted with the has-a (has_a or has a) relationship between types (classes); confusing the relations has-a and is-a is a common error when designing a model (e.g., a computer program) of the real-world relationship between an object and its subordinate. The is-a relationship may also be contrasted with the instance-of relationship between objects (instances) and types (classes): see "type-token distinction" and "type-token relations." [2] To summarize the relations, there are: * hyperonymhyponym (supertype–subtype) relations between types (classes) defining a taxonomic hierarchy, where ** for a subsumption relation: a hyponym (subtype, subclass) has a type-of (is-a) relationship with its hyperonym (supertype, superclass);
      • holonymmeronym (whole/entity/container-part/constituent/member) relations between types (classes) defining a possessive hierarchy, where
        • for an aggregation (i.e. without ownership) relation:
          • a holonym (whole) has a has-a relationship with its meronym (part),
        • for a composition (i.e. with ownership) relation:
          • a meronym (constituent) has a part-of relationship with its holonym (entity),
        • for a containment [3] relation:
      • concept-object (type-token) relations between types (classes) and objects (instances), where
        • a token (object) has an instance-of relationship with its type (class).


  • (Wikipedia, 2009) ⇒
    • In object-oriented programming, inheritance is a way to form new classes (instances of which are called objects) using classes that have already been defined. The inheritance concept was invented in 1967 for Simula. [1]
    • The new classes, known as derived classes, take over (or inherit) attributes and behavior of the pre-existing classes, which are referred to as base classes (or ancestor classes). It is intended to help reuse existing code with little or no modification.
    • Inheritance provides the support for representation by categorization in computer languages. Categorization is a powerful mechanism number of information processing, crucial to human learning by means of generalization (what is known about specific entities is applied to a wider group given a belongs relation can be established) and cognitive economy (less information needs to be stored about each specific entity, only its particularities).
    • Inheritance is also sometimes called generalization, because the is-a relationships represent a hierarchy between classes of objects. For instance, a "fruit" is a generalization of "apple", "orange", "mango" and many others. One can consider fruit to be an abstraction of apple, orange, etc. Conversely, since apples are fruit (i.e., an apple is-a fruit), apples may naturally inherit all the properties common to all fruit, such as being a fleshy container for the seed of a plant.
    • The subsumption relation can be understood as a relation of implication which relates more specific to more general concepts in conceptual taxonomies. In formal terms, subsumption defines a lattice, a kind of partial ordering, which may be represented as a directed acyclic graph. The hierarchical graphs defined by subsumption need not be trees, but can be more general kinds of graph in which child nodes are re-entrant, i.e. a child node may have more than one parent node. However, commonly a subsumption lattice has a core tree structure, with superimposition of more than one tree, or of other cross-classifiying structures. The subsumption relation may be seen as a generalisation relation, in that the subsumer expresses a generalisation over the subsumed.