Inheritance

Version

v1 · 2026-08-24 · History

Prime #

919

Origin domain

Computer Science & Software Engineering

Subdomain

type systems taxonomy → Computer Science & Software Engineering

Core Idea

Inheritance is the structural pattern of a derived entity receiving structure, behaviour, or claims from a parent entity by virtue of a lineage relation, while being permitted — often required — to add, modify, or override some portion of what it received. The three load-bearing commitments are these. Lineage: a directed, asymmetric relation between a parent and a derivative — child class and superclass, descendant and ancestor, heir and decedent, subspecies and species, statute and constitutional predecessor. Default carrying-over: by default the properties of the parent apply to the derivative without re-derivation — a child class gets its parent's methods, a beneficiary gets the testator's estate, an organism gets its parents' alleles, a junior court gets binding precedent.^[1] Selective override and extension: the derivative can specialize, override, or augment parts of what was inherited while remaining recognizably "of the parent" along the un-overridden parts, and this override is what makes inheritance generative rather than mere copying.

A fourth, frequently-present feature is substitutability: a derived entity can stand where the parent was expected — Liskov substitution in software, a subspecies counting as the species in a census, a junior court speaking with the authority of its lineage.^[1] The substrate-independent move the prime supplies is transmit-with-modification along a lineage relation: the default is "continue what came before," the override is "specialize where the context requires," and the state of the system at any moment is the cumulative result of inheritance plus override across the lineage. The pattern is structurally distinct from mere copying (the parent persists), composition (sub-parts independently chosen), and pure assignment (no lineage relation). The term carries family-and-property-law connotation, but the lineage-default-override skeleton beneath it is substrate-neutral.

How would you explain it like I'm…

Passed Down From Parents

A puppy gets a lot from its mom and dad dog — its floppy ears, its bark, its color — just by being their baby. But it isn't an exact copy; it can have its own special spots they didn't have. So it keeps most of what its parents passed down and changes a little to be its own self.

Get It, Then Tweak It

Inheritance is when a new thing gets structure, behavior, or stuff from a parent thing because of a family-like link, but is allowed to add to or change parts of what it got. There are three pieces. First, a lineage — a parent-to-child link that points one direction (a kid and its parents, an heir and the person who left them money). Second, default carrying-over — by default the child gets the parent's stuff without redoing it from scratch. Third, selective override — the child can change or add to some parts while still clearly being 'of the parent' in the parts it didn't change. That last piece is what makes inheritance creative instead of plain copying.

Transmit With Modification

Inheritance is the structural pattern of a derived entity receiving structure, behavior, or claims from a parent entity by virtue of a *lineage* relation, while being permitted — often required — to add, modify, or override some portion of what it received. Three load-bearing commitments: lineage (a directed, asymmetric parent-to-derivative relation — child class and superclass, heir and decedent, subspecies and species, statute and constitutional predecessor); default carrying-over (by default the parent's properties apply without re-derivation — a child class gets its parent's methods, a beneficiary gets the estate, an organism gets its parents' alleles); and selective override and extension (the derivative can specialize or augment parts while remaining recognizably 'of the parent' along the un-overridden parts — and this override is what makes inheritance generative rather than mere copying). A frequent fourth feature is substitutability: a derived entity can stand where the parent was expected (Liskov substitution, a subspecies counting as the species in a census). The move it supplies is *transmit-with-modification along a lineage*: continue what came before, specialize where context requires — distinct from mere copying (the parent persists), composition (sub-parts independently chosen), and pure assignment (no lineage).

 

Inheritance is the structural pattern of a derived entity receiving structure, behavior, or claims from a parent entity by virtue of a lineage relation, while being permitted — often required — to add, modify, or override some portion of what it received. The three load-bearing commitments are these. Lineage: a directed, asymmetric relation between a parent and a derivative — child class and superclass, descendant and ancestor, heir and decedent, subspecies and species, statute and constitutional predecessor. Default carrying-over: by default the properties of the parent apply to the derivative without re-derivation — a child class gets its parent's methods, a beneficiary gets the testator's estate, an organism gets its parents' alleles, a junior court gets binding precedent. Selective override and extension: the derivative can specialize, override, or augment parts of what was inherited while remaining recognizably 'of the parent' along the un-overridden parts, and this override is what makes inheritance generative rather than mere copying. A fourth, frequently-present feature is substitutability: a derived entity can stand where the parent was expected — Liskov substitution in software, a subspecies counting as the species in a census, a junior court speaking with the authority of its lineage. The substrate-independent move the prime supplies is transmit-with-modification along a lineage relation: the default is 'continue what came before,' the override is 'specialize where the context requires,' and the state of the system at any moment is the cumulative result of inheritance plus override across the lineage. The pattern is structurally distinct from mere copying (the parent persists), composition (sub-parts independently chosen), and pure assignment (no lineage relation). The term carries family-and-property-law connotation, but the lineage-default-override skeleton beneath it is substrate-neutral.

Structural Signature

a parent entity — a derived entity — a directed lineage relation between them — default carrying-over of the parent's structure — selective override and extension by the derivative — the substitutability invariant — the downward-coupling liability

A relation is inheritance when the following hold:

• A parent and a derivative. Two entities, one prior and one derived from it — superclass and subclass, ancestor and descendant, decedent and heir, species and subspecies.
• A directed lineage relation. An asymmetric "derives from" relation linking derivative to parent; it is distinct from copying (the parent persists) and from composition (parts independently chosen).
• Default carrying-over. By default the parent's structure, behaviour, or claims apply to the derivative without re-derivation — methods, alleles, estate, binding precedent transmitted for free.
• Selective override and extension. The derivative may specialise, override, or augment portions of what it received while remaining recognisably "of the parent" along the un-overridden portions; this override is what makes inheritance generative rather than mere copying.
• The substitutability invariant. Frequently the derivative can stand wherever the parent was expected (Liskov substitution, a subspecies counting as the species, a junior court speaking with its lineage's authority), constraining which overrides are admissible.
• The downward-coupling liability. Because children depend on inherited facts, a change to the parent can propagate to — and break — every derivative (the fragile-base-class problem, gene-network constraint, stare-decisis caution).^[2]

These compose into one move: transmit structure along a lineage by default, override where context requires, and read any derived system as parent contribution plus override delta — paying for the compression with standing downward coupling.

What It Is Not

• Not composition. Composition builds an entity from independently chosen sub-parts assembled together; inheritance derives an entity from a parent along a lineage relation, carrying the parent's structure by default. Composition is has-a; inheritance is is-a-kind-of.
• Not hierarchy. A hierarchy is a static ranking of levels by containment or authority; inheritance is a transmission relation that carries structure downward by default with selective override. A lineage forms a hierarchy, but the inheritance is the carrying-over, not the ranking.
• Not specialization. Specialization is the narrowing of a general thing to a specific case; inheritance is the broader lineage-default- override apparatus of which specialization is the override component. Inheritance also carries the un-narrowed defaults.
• Not mere copying. Copying duplicates and severs; inheritance retains a live lineage — the parent persists and changes to it propagate to derivatives (the fragile-base-class liability). Copying has no such downward coupling.
• Not dependency in general. Dependency is any reliance of one thing on another; inheritance is the specific dependency of a derivative on a parent along a lineage, with default carry-over and substitutability, not arbitrary coupling.
• Common misclassification. Reading any shared structure as inheritance. Catch it by testing for a directed lineage relation with default carry-over and selective override; if the sharing is by assembly (has-a) or by duplication (copy), it is composition or copying, not inheritance.

Broad Use

The skeleton recurs across substrates. In object-oriented programming it is class inheritance, method override, the Liskov substitution principle, mixins and traits, and prototype-based inheritance.^[3] In biology it is Mendelian and polygenic inheritance, cytoplasmic and epigenetic inheritance, cultural inheritance, and dual-inheritance theory.^[4] In law it is inheritance of property by will or intestacy, succession to titles, trust-beneficiary chains, and tax-basis carryover. In taxonomy it is Linnaean classification and its cladistic descendants, trait inheritance down a phylogenetic tree, and IS-A relations in formal ontologies. In legal hierarchy it is lower courts bound by higher-court precedent and statutes inheriting interpretive principles from constitutional and common-law backgrounds. In organisations it is corporate-culture inheritance from founder to successors, regimental traditions, and apprenticeship transmission. In religion it is apostolic succession, rabbinic ordination chains, lineage holders in Tibetan Buddhism, and isnād chains in hadith transmission.^[5] In linguistics it is language families and inherited vocabulary, and inherited grammatical features through language change. In real estate it is rights inherited with land — water rights, easements, mineral rights — and covenants binding successive owners. The substrate varies — chromosomes, source code, deeds, precedents, ordination chains — but the transmit-by-default-with-selective-override structure recurs.

Clarity

The prime makes visible which parts of a system are "still the parent" and which parts are "specialized child." Once inheritance is seen as a pattern, every derived system reads as "parent contribution + lineage default + override delta," and this reading exposes hidden defaults: features the child "got for free" and never thought to question, a major source of legacy and constraint. In law the clarity is between binding inheritance (controlling precedent, dispositive will provision) and persuasive inheritance (non-binding but influential prior practice); in biology, between genetic and cultural channels; in software, between interface inheritance (contract only) and implementation inheritance (code reuse). The same distinction-by-mode appears across substrates. The clarifying force is to decompose any inherited system into what was transmitted unchanged, what was overridden, and why — making the inherited defaults inspectable rather than invisible, and the overrides accountable rather than ad hoc.

Manages Complexity

Inheritance replaces redundant restatement with derivation-by-lineage. Instead of describing every child fully, describe the parent and the delta. This is the structural reason taxonomies are compact: a million species are described as "vertebrate, mammal, primate, hominid, Homo, H. sapiens" — six levels of inherited features plus one species-specific delta.^[6] The same compression appears in class libraries, legal commentaries, and trait-heritability summaries. The cost is coupling: changing a parent can break, silently or loudly, every child that depended on the inherited fact — the "fragile base class" problem in software, gene-network constraints in genetics, stare-decisis carefulness in law, the conservative bias of orthodoxy in religion.^[2] The management payoff is that a vast set of derived entities is captured by a small set of parents plus per-child deltas, so the description grows with the differences between entities rather than their full content — but the dividend is paid for with a standing coupling liability that propagates parent changes downward.

Abstract Reasoning

The pattern enables substrate-independent questions. What does the child inherit by default? — every method, allele, estate item, binding precedent. What is overridden, and why? — specialization, error correction, contextual fit, exception. Is the override compatible with substitutability? — can the child stand where the parent stood? What is the depth and width of the lineage? — deep inheritance is brittle, wide inheritance with shallow depth is more evolvable. Are there multiple parents? — the diamond problem in software, dual inheritance in evolution, multiple doctrines feeding one decision.^[7] And how does the regime handle the un-anticipated? — intestacy rules, polymorphic dispatch, common-law gap-filling. These transfer cleanly across software design review, evolutionary trait analysis, estate planning, taxonomic revision, and canonical legal interpretation. The reasoner asks, of any derived entity: what was transmitted, what was overridden, can it substitute for its parent, and how brittle is its lineage?

Knowledge Transfer

The intervention catalog carries portable lessons. Composition over inheritance — the long-standing software advice — is a substrate- independent design lesson: when inheritance coupling becomes brittle, replace lineage-by-default with explicitly assembled parts, the same lesson that surfaces in modular organisational design and in deliberate cultural change.^[3] Override-with-discipline: every override is an exception to a default, and disciplined regimes (audit trails, super-calls, ordering rules) keep the pattern useful while undisciplined ones degenerate into ad-hocery in software, legal reasoning, and organisational norms alike. Single-versus-multiple-inheritance trade-off: the diamond problem, the homologous-versus-analogous-trait problem, and the multiple-doctrine reconciliation problem are the same shape, and discipline-imposed linearization (C3 linearization, cladistic parsimony, lex specialis) all solve it.^[8] And lineage repair: updating child-states when a parent is found defective — a bug, a discredited precedent, a flawed founding doctrine — is recurringly difficult and follows the same shape everywhere. The role mappings are direct: lineage ↔ class hierarchy / descent / succession / precedent chain, default carrying-over ↔ inherited methods / alleles / estate / binding rules, override ↔ method override / mutation / will provision / distinguishing a case, substitutability ↔ Liskov / a subspecies as the species / a junior court's authority. A jurisdiction's tax code inheriting concepts from its predecessors, from common-law doctrine, from Roman law — adding a "qualified business income" deduction as a delta while inheriting the rest — has exactly the structure of a class library where Mammal.feed_young is inherited by Primate and overridden by Human, of a phylogenetic tree where the four-limbed body plan is inherited by tetrapods and overridden in cetaceans and snakes, and of a family business whose founder's practices are inherited and selectively reinterpreted each generation. A biologist who understands phylogenetic inheritance reads an OOP design book and sees the substitutability question; a software architect who understands deep-inheritance brittleness reads an estate-law case and sees the same brittleness in multi-generation trusts. Because the lineage-default-override skeleton is structural while only the term's connotation is family-and-property-bound, the transfer is recognition of one shape across software, biology, law, taxonomy, religion, linguistics, and organisations.

Examples

Formal/abstract

Take a class hierarchy Shape → Polygon → Square in object-oriented programming as the rigorous instance, because it makes substitutability exact. The parent and derivative are superclass and subclass; the directed lineage relation is "Square derives from Polygon derives from Shape," asymmetric and distinct from copying (the parent classes persist). Default carrying-over is concrete: Square inherits Polygon's area() and vertices() and Shape's boundingBox() without re-implementing them — structure transmitted for free. Selective override and extension is what makes it generative: Square overrides area() with the specialised \(side^2\) formula and adds a side field, while remaining recognisably a Polygon along the un-overridden parts.^[3] The substitutability invariant (Liskov) is the rigorous constraint the prime names: a Square may stand wherever a Shape is expected only if its overrides honour the parent's contract — the classic failure is making Square inherit from Rectangle and overriding setWidth to also change height, which breaks code that relied on Rectangle's independent-dimensions contract.^[1] The downward-coupling liability is the fragile-base-class problem: a change to Shape's boundingBox() propagates to every descendant, possibly breaking overrides that assumed the old behaviour. The intervention the prime enables: read the hierarchy as parent-contribution-plus-override-delta, check each override against substitutability, and when coupling turns brittle, apply the portable lesson composition over inheritance — assemble the behaviours explicitly rather than transmitting them by lineage.

Mapped back: The shape hierarchy instantiates every role — lineage, default method transmission, specialising override, Liskov substitutability, fragile-base-class coupling — and shows the compression (describe parent plus delta) bought at the price of standing downward coupling.

Applied/industry

Consider biological inheritance through a phylogenetic tree and legal inheritance of precedent through a court hierarchy as two applied instances. In phylogeny the parent and derivative are an ancestral and a descendant clade; the lineage relation is descent; default carrying-over transmits the ancestral body plan — the four-limbed tetrapod plan is inherited by all tetrapods without re-evolving; and selective override specialises it, as when cetaceans override the hindlimbs to near-absence and snakes override the limb plan entirely while remaining recognisably tetrapod in skeleton and physiology.^[9] The downward-coupling liability appears as gene-network constraint: a deeply inherited developmental pathway cannot be changed without disrupting every descendant that depends on it, which is why some ancient features are evolutionarily frozen. The legal case runs the same shape: a junior court inherits binding precedent from higher courts by default, overrides by distinguishing a case on its facts, and the substitutability analog is that the junior court speaks with its lineage's authority only when its rulings stay within the inherited doctrine. The prime's lineage-repair difficulty is shared and instructive: correcting a discredited founding precedent (overruling) is hard precisely because so many later rulings inherited from it, exactly as correcting a defective base class or a deleterious deeply-inherited allele is hard. The shared intervention: decompose any derived entity into transmitted-unchanged versus overridden, and weigh the coupling cost before changing a parent.

Mapped back: Phylogenetic descent and binding precedent both run the prime end-to-end — lineage, default transmission, selective override, substitutability, and downward coupling — confirming the transmit-with-modification skeleton recurs identically across biology and law, with only the substrate (genomes, rulings) differing.

Structural Tensions

T1 — Compression versus Coupling. Inheritance compresses description — parent plus per-child delta instead of full restatement — but pays with downward coupling: a change to the parent propagates to every derivative. The tension is that the two are the same mechanism viewed from opposite ends. The failure mode is the fragile-base-class problem — editing a parent and silently breaking children that depended on the old inherited behaviour. Diagnostic: before changing any parent, ask how many derivatives inherit the affected fact and whether the coupling cost of propagation exceeds the compression benefit that justified the lineage.

T2 — Default Carrying-Over versus Hidden Inheritance. Children get parent structure for free, which is the efficiency — and the trap, because the inherited defaults become invisible, accepted without ever being questioned. The tension is that "got it for free" and "never examined it" are the same condition. The failure mode is a derivative carrying a stale or wrong inherited fact nobody noticed because it was never re-derived — a legacy constraint, a deprecated default, a frozen developmental pathway. Diagnostic: decompose the derived entity into transmitted-unchanged versus overridden, and audit the transmitted-unchanged portion for defaults that were inherited by inertia rather than choice.

T3 — Override Freedom versus Substitutability. The derivative may override, but substitutability (Liskov, a subspecies counting as the species) constrains which overrides are admissible — the child must still stand where the parent stood. The tension is that override power and substitutability pull against each other. The failure mode is an override that breaks the parent's contract — Square overriding setWidth to also change height, breaking code that relied on Rectangle's independent dimensions — so the child can no longer safely substitute. Diagnostic: check each override against the parent's contract; if the override violates a guarantee callers depend on, substitutability is broken even though the code compiles.

T4 — Single versus Multiple Lineage. One parent gives a clean default chain; multiple parents create the diamond problem — conflicting inherited facts with no canonical resolution (homologous-vs-analogous traits, multiple doctrines feeding one ruling). The tension is scopal: richer inheritance buys more reuse but loses a unique default. The failure mode is an ambiguous or order-dependent resolution silently picking one parent's version, so behaviour depends on linearization order nobody specified. Diagnostic: ask whether a derivative has multiple parents contributing the same fact, and impose an explicit resolution discipline (C3 linearization, lex specialis, cladistic parsimony) rather than relying on default ordering.

T5 — Lineage Depth versus Evolvability. Deep inheritance chains maximize reuse but are brittle — a change high in the chain ripples far — while shallow, wide hierarchies are more evolvable but reuse less. The tension is scalar: depth trades reuse against rigidity. The failure mode is a deep chain where an ancient inherited feature is effectively frozen because too many descendants depend on it (gene-network constraint, multi-generation trust, foundational precedent), so the system cannot evolve where it most needs to. Diagnostic: measure how deep the lineage runs and how many descendants depend on its upper levels; deep-and-wide dependence signals brittleness, and may warrant composition over inheritance.

T6 — Lineage Default versus Parent Repair. Inheritance assumes the parent is correct, so when a parent is found defective — a bug, a discredited precedent, a deleterious allele, a flawed founding doctrine — repair is hard precisely because so much inherited from it. The tension is temporal: the very transmission that made the parent valuable makes correcting it costly. The failure mode is leaving a known-bad parent in place because overruling, refactoring, or correcting it would disrupt every derivative that built on it. Diagnostic: when a parent is discredited, trace what inherited the defective fact before repairing, and weigh the disruption of lineage repair against the cost of leaving the defect propagating downward.

Structural–Framed Character

Inheritance sits on the structural side of the structural–framed spectrum — mixed-structural, aggregate 0.3. The lineage-default-override skeleton is genuinely substrate-neutral, but the word carries strong family-and-property-law connotation, and that residue lifts three diagnostics to the half-mark.

Walk them. Vocabulary travels (0.5): the transmit-by-default-with-override idea is statable plainly and recurs in phylogeny, precedent chains, and language families, but the term "inheritance" — and "parent," "child," "heir" — drags a family/estate flavour along. Institutional origin (0.5): the construct is software-coined for type systems, yet its most salient instances (estate succession, apostolic succession, stare decisis) are institutional, giving it a real but partial institutional cast — balanced by genuinely non-institutional cases like Mendelian inheritance. Import vs. recognize (0.5): calling a phylogenetic tree or a class hierarchy "inheritance" half-imports the lineage-and-override frame and half-recognizes a transmission relation already there. The other two read zero. No evaluative weight (0): inheritance is neither good nor bad — "fragile base class" is a structural liability, not a moral judgment. Not human-practice-bound (0): Mendelian and epigenetic inheritance transmit structure along a lineage in a biological substrate with no human practice whatsoever, and DNA replication preserves identity per daughter chromosome indifferently. Three half-points against two zeros land exactly at the 0.3 aggregate and mixed-structural label — a structural skeleton with a connotation-bearing name.

Substrate Independence

Inheritance is a strongly substrate-independent prime — composite 4 / 5 on the substrate-independence scale. Its domain breadth is maximal: the transmit-by-default-with-selective-override skeleton recurs as class inheritance and the Liskov substitution principle in object-oriented programming, as Mendelian, epigenetic, and cultural inheritance in biology, as property succession and tax-basis carryover in law, as Linnaean and cladistic classification in taxonomy, as binding precedent in legal hierarchy, as corporate-culture and regimental transmission in organizations, as apostolic succession and isnād chains in religion, as language families in linguistics, and as water rights and covenants in real estate — chromosomes, source code, deeds, precedents, and ordination chains all carrying the identical structure. The structural abstraction is high: the same decomposition — parent contribution plus lineage default plus override delta, constrained by substitutability and paid for with downward coupling — applies across every instance, and it is distinct from copying, composition, and bare dependency in the same way everywhere. The transfer evidence is concrete: "composition over inheritance" is a substrate-independent design lesson surfacing in software, modular org design, and deliberate cultural change; the diamond problem, the homologous-versus-analogous-trait problem, and multiple-doctrine reconciliation are the same shape solved by C3 linearization, cladistic parsimony, and lex specialis; and lineage-repair difficulty (overruling a precedent, correcting a deeply-inherited allele, refactoring a base class) recurs identically. Mendelian inheritance transmitting structure along a lineage with no human practice anchors the pattern firmly in a biological substrate. What caps it at 4 is a connotation accent: the word "inheritance" — and "parent," "child," "heir" — drags a family-and-property-law flavour along even though the skeleton beneath is neutral. Maximal spread and strong cross-domain transfer with a connotation-bearing name give a confident 4.

• Composite substrate independence — 4 / 5
• Domain breadth — 5 / 5
• Structural abstraction — 4 / 5
• Transfer evidence — 4 / 5

Relationships to Other Abstractions

Current abstraction Inheritance Prime

Parents (1) — more general patterns this builds on

• Inheritance is a kind of, typical Dependency Prime

  Inheritance is the specific dependency of a derivative on a parent ALONG A LINEAGE, with default carry-over and substitutability — a specialization of bare dependency ('not dependency in general').

Children (18) — more specific cases that build on this

• Classical education movement Domain-specific is a kind of Inheritance

  The proposed strict upward parent is prime:inheritance.

• Copying Mechanism Domain-specific is a kind of Inheritance

  The minimal prospective placement is a strict composition/instantiates edge to live prime:inheritance.

• DATR Domain-specific is a kind of Inheritance

  Inheritance is the proposed immediate parent.

▸ Show 15 more

Hierarchy path (1) — routes to 1 parentless root

• Inheritance → Dependency

Neighborhood in Abstraction Space

Inheritance sits in a sparse region of abstraction space (85^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely rather than landing on a neighbor.

Family — Unclustered & Miscellaneous (424 primes)

Nearest neighbors

• Hierarchy — 0.72
• Aspectual Individual — 0.68
• Supersession — 0.68
• Canonical Form — 0.68
• Substitutability — 0.68

Computed from structural-signature embeddings · 2026-09-10

Not to Be Confused With

The single most important contrast — drilled into a generation of software designers as "favour composition over inheritance" — is with composition. Both are ways of building a complex entity out of simpler material, but they relate the pieces differently. Composition assembles an entity from independently chosen sub-parts: the whole has its parts, the parts are selected and wired together, and a part can be swapped without any claim that the whole is a kind of anything. Inheritance derives an entity from a parent along a lineage: the derivative is a kind of the parent, receives the parent's structure by default, and overrides selectively. The practical consequence is the coupling profile. Composition couples the whole only to the interfaces of its parts and lets you recombine freely; inheritance couples the derivative to the parent's implementation, so a change to the parent can silently break every descendant (the fragile-base- class problem). Confusing the two — reaching for inheritance to get code reuse when no genuine is-a relation holds — buys default carry-over at the price of standing downward coupling that composition would have avoided.

It is also distinct from hierarchy, with which it is often elided because inheritance relations form tree-shaped lineages. A hierarchy is a static structural ranking — levels ordered by containment, authority, or generality. Inheritance is a dynamic transmission: structure flows from parent to child by default, and the child modifies what it received. The hierarchy is the shape the lineage takes; the inheritance is the carrying- over-with-override that happens along it. You can have a hierarchy with no inheritance (an org chart that ranks roles without transmitting any properties) and inheritance whose conceptual lineage you would not call a hierarchy. Reading inheritance as "just a hierarchy" loses the default-and- override machinery that is the entire point.

A third confusion is with specialization, which is in fact a component of inheritance rather than a synonym for it. Specialization is the narrowing of a general thing to a more specific case — the override-and-extend move. Inheritance is the larger pattern that also carries the un-overridden parent structure forward by default and supports substitutability. So every inheritance involves the possibility of specialization, but inheritance additionally commits to default transmission and lineage coupling that specialization alone does not name. Treating the two as identical foregrounds the override and forgets the default carry-over — exactly the half of inheritance that creates both its compression benefit and its coupling liability.

For a practitioner the distinctions are design-critical. Choose composition when you want recombination without coupling to implementation; recognize a hierarchy when you are ranking, not transmitting; and reserve inheritance for genuine is-a lineages where default carry-over is worth the downward coupling it imposes. The inheritance signature — lineage, default carry-over, selective override, substitutability — is what marks it off from each of these, and getting the match wrong is the origin of much fragile design.

Solution Archetypes

Solution archetypes in the catalog that build on this prime — directly (this prime is a source ingredient) or as a related prime.

Built directly on this prime (2)

• Controlled Inheritance Propagation: Let descendants receive shared structure by default from a lineage ancestor while requiring every exception to have a scoped, visible, and testable override.
  ▸ Mechanisms (14)
• Substrate Lineage Risk Audit: Audit the lineage of a borrowed or inherited substrate so hidden origin conditions do not become unowned local risk.
  ▸ Mechanisms (14)

Also a related prime in 2 archetypes

• Founding Population Composition and Drift Management: Define whom or what a new lineage is intended to represent, widen or stratify its founding population, track how early composition is amplified through descent, and refresh the lineage before accidental origin bias becomes irreversible identity.
• Legacy-Form Refashioning: Establish a new medium by borrowing recognizable forms from an older one just long enough to earn legibility, trust, and competence transfer, then deliberately shed inherited constraints and unlock native affordances.

References

[1] Liskov, Barbara H., and Jeannette M. Wing. "A Behavioral Notion of Subtyping." ACM Transactions on Programming Languages and Systems, vol. 16, no. 6 (1994): 1811–1841. Formal statement of the substitutability principle (LSP): a subtype must be usable wherever its supertype is expected. registry ↩a ↩b ↩c

[2] Snyder, Alan. "Encapsulation and Inheritance in Object-Oriented Programming Languages." OOPSLA '86 Proceedings, ACM SIGPLAN Notices, vol. 21, no. 11 (1986): 38–45. Identifies the tension between inheritance and encapsulation underlying the fragile-base-class problem. registry ↩a ↩b

[3] Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Reading, MA: Addison-Wesley, 1994. Source of the 'favor composition over inheritance' design principle and the discussion of inheritance versus delegation. registry ↩a ↩b ↩c

[4] Boyd, Robert, and Peter J. Richerson. Culture and the Evolutionary Process. Chicago: University of Chicago Press, 1985. Foundational treatment of cultural inheritance and dual-inheritance (gene-culture coevolution) theory. registry ↩

[5] Brown, Jonathan A. C. Hadith: Muhammad's Legacy in the Medieval and Modern World. Oxford: Oneworld Publications, 2009. Treats the isnād (chain-of-transmission) system as the verification structure whereby scholarly authority is inherited along an unbroken lineage of narrators back to the source. registry ↩

[6] Encyclopaedia Britannica. "Taxonomy — The Linnaean system." Establishes the nested taxonomic-rank hierarchy (kingdom, phylum, class, order, family, genus, species) in which each level inherits the features of those above it — the inherited-feature compression behind the vertebrate→mammal→primate→Homo→H. sapiens chain. registry ↩

[7] Stroustrup, Bjarne. "Multiple Inheritance for C++." Proceedings of the Spring 1987 EUUG Conference, 1987; revised in USENIX Computing Systems, vol. 2, no. 4 (1989): 367–395. Introduces multiple inheritance in C++ and the diamond/ambiguity problem it creates. registry ↩

[8] Barrett, Kim, Bob Cassels, Paul Haahr, David A. Moon, Keith Playford, and P. Tucker Withington. "A Monotonic Superclass Linearization for Dylan." OOPSLA '96 Proceedings, ACM SIGPLAN Notices, vol. 31, no. 10 (1996): 69–82. Defines the C3 linearization algorithm that resolves multiple-inheritance method-resolution order. registry ↩

[9] Shubin, Neil, Cliff Tabin, and Sean Carroll. "Fossils, genes and the evolution of animal limbs." Nature, vol. 388 (1997): 639–648. Evolutionary-developmental account of the tetrapod limb plan inherited along lineages and overridden (e.g., limb reduction in snakes and cetaceans). registry ↩