📑 Table of Contents▼

In knowledge representation, ontology components and ontology engineering, including for object-oriented programming and design, is-a (also written as is_a or is a) is a subsumptive[a] 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.[1]

For example, a cat 'is a[n]' animal, but not vice versa. All cats are animals, but not all animals are cats. Behaviour that is relevant to all animals is defined on an animal class, whereas behaviour that is relevant only for cats is defined in a cat class. By defining the cat class as 'extending' the animal class, all cats 'inherit' the behaviour defined for animals, without the need to explicitly code that behaviour for cats.

edit

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.

To summarize the relations, there are:

  • hyperonym–hyponym (supertype/superclass–subtype/subclass) 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);
  • holonym–meronym (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[2] relation:
      • a meronym (member) has a member-of relationship with its holonym (container);
  • concept–object (type–token) relations between types (classes) and objects (instances), where
    • a token (object) has an instance-of relationship with its type (class).

See also

edit

Notes

edit

Citations

edit
  1. ^ "Subtypes and Subclasses" (PDF). MIT OCW. Retrieved 2 October 2012.
  2. ^ See also Containment (computer programming).

References

edit

📚 Artikel Terkait di Wikipedia

Subsumption

programming Subtyping in programming language theory Subsumption architecture in robotics A subsumption relation in category theory, semantic networks and linguistics

Subsumption (Marxism)

In Marxist theory, subsumption is the process by which social relations, particularly the labour process, are progressively brought under the control

Class (knowledge representation)

that is a member of the latter class is a member of the former. The subsumption relation is used to create a hierarchy of classes, typically with a maximally

Theta-subsumption

Theta-subsumption (θ-subsumption, or just subsumption) is a decidable relation between two first-order clauses that guarantees that one clause logically

Subsumption architecture

Subsumption architecture is a reactive robotic architecture heavily associated with behavior-based robotics which was very popular in the 1980s and 90s

Ontology components

and hypernymy, coordinate relation, and others. The set of used relation types (classes of relations) and their subsumption hierarchy describe the expression

Subtyping

Integer> PayloadList<String, Exception> In type theory the concept of subsumption is used to define or evaluate whether a type S is a subtype of type T

Inductive logic programming

the space of possible clauses forms a complete lattice under the subsumption relation, where one clause C 1 {\textstyle C_{1}} subsumes another clause