rhachet-roles-ehmpathy 1.13.0 → 1.13.1

package/dist/logic/roles/bhrain/.briefs/cognition/cog021.structs.treestruct.md

@@ -1,85 +0,0 @@
-# 📚 .brief: TreeStruct
-
-## 🎯 purpose
-to define **TreeStruct** as a general-purpose structural pattern
-and clarify its common usage forms (**RootStruct**, **LeafStruct**) and
-how multiple TreeStructs can safely intersect.
-
----
-
-## 🌲 TreeStruct — general definition
-
-> A **TreeStruct** is a structural form composed of **nodes** and **directed, acyclic links**,
-> where each node has **at most one parent** per dimension or axis.
-
-- meaning-neutral — not tied to any specific interpretation
-- supports both:
-  - **depth-first** and **breadth-first** traversal
-  - **single-axis** and **multi-axis** expansion (when extended)
-- usable for:
-  - hierarchies
-  - workflows
-  - classification systems
-  - nesting, containment, or flow modeling
-
----
-
-## 🌱 LeafStruct — axis-limited subset of TreeStruct
-
-> A **LeafStruct** is a TreeStruct used for **top-down**, **axis-constrained** flows,
-> modeled on **branches funneling into leaves**.
-
-- used when structure narrows from a few high-level origins
-- favors **convergence**, **containment**, or **controlled descent**
-
----
-
-## 🫚 RootStruct — multi-directional subset of TreeStruct
-
-> A **RootStruct** is a TreeStruct used in **bottom-up**, **lateral**, or exploratory growth patterns,
-> modeled on **roots spreading underground**.
-
-- used when structure grows across **many dimensions**
-- often favors **divergence** and **deep local branching**
-- **branches can intersect** and share common nodes, forming a **web-like network** of overlapping subpaths
-
----
-
-## 🌉 intersecting TreeStructs
-
-> Multiple TreeStructs can **safely intersect**, as long as they each preserve
-> their own **local acyclic structure**.
-
-valid forms of intersection:
-
-1. **shared nodes**
-   - two TreeStructs reference the **same node**
-   - useful for **cross-cutting concerns** or shared entities
-
-2. **embedded subtrees**
-   - one TreeStruct is **nested within** a node of another
-   - allows compound or hierarchical system design
-
-3. **cross-links between trees**
-   - TreeStructs remain independent but reference each other via external links
-   - enables navigation between trees without forming a general graph
-
-> These patterns create a **forest with bridges**: each tree remains intact,
-> but the system supports **inter-tree coordination**.
-
----
-
-## 🧩 summary
-
-| struct         | metaphor           | shape pattern           | dimensionality     | common use cases                          |
-|----------------|--------------------|--------------------------|--------------------|-------------------------------------------|
-| **TreeStruct**   | neutral tree         | any branching structure   | general-purpose     | workflows, hierarchies, branching systems |
-| **LeafStruct**   | branches → leaves    | top-down narrowing        | narrow (few axes)  | classification, taxonomies, decisions     |
-| **RootStruct**   | roots underground    | bottom-up or lateral      | broad (many axes)  | exploration, divergence, distributed plans|
-
----
-
-> ✔️ **TreeStruct** is a flexible structural pattern.
-> It supports both **divergent** and **convergent** design through RootStruct and LeafStruct,
-> and can safely **intersect with other TreeStructs** through shared nodes, nesting, or cross-links —
-> as long as **local acyclicity is preserved**.

package/dist/logic/roles/bhrain/.briefs/cognition/cog021.structs.vector.md

@@ -1,112 +0,0 @@
-# 🧭 .brief: `physics.vector`
-
-## .what
-A **physics vector** is a mathematical object used to represent **quantities that have both magnitude and direction** in physical space.
-It also functions as a **data structure** — encoding directionally relevant information for computation, simulation, and modeling.
-
----
-
-## 🧩 structure
-
-A vector is defined by:
-
-- **magnitude** → the scalar size of the quantity
-- **direction** → the orientation in space
-- **components** → projections along basis axes (e.g. `x`, `y`, `z`)
-  - written as `v = ⟨vx, vy, vz⟩` or `v = vx î + vy ĵ + vz k̂`
-
----
-
-## 🧠 examples of vector quantities
-
-| quantity         | description                                 |
-|------------------|---------------------------------------------|
-| **velocity**     | speed + direction of motion                 |
-| **acceleration** | rate of change of velocity (directional)    |
-| **force**        | push or pull with a direction               |
-| **momentum**     | mass × velocity                             |
-| **electric field** | directional force on a unit charge        |
-
----
-
-## 🔧 operations on vectors
-
-| operation             | meaning                                             |
-|------------------------|-----------------------------------------------------|
-| **addition**          | combine vectors tip-to-tail                         |
-| **subtraction**       | find relative vector between two                   |
-| **scalar multiplication** | scales magnitude, keeps direction            |
-| **dot product**       | projects one vector onto another (returns scalar)   |
-| **cross product**     | finds perpendicular vector (returns vector)         |
-
----
-
-## 📐 geometric interpretation
-
-Vectors live in a **Euclidean space** (ℝ², ℝ³) and can be visualized as **arrows**:
-
-- **length** of arrow = magnitude
-- **angle** = direction relative to axes
-- operations map to geometric rules (e.g. triangle or parallelogram rule)
-
----
-
-## 🧮 as a data structure
-
-In computational systems, a vector is a **structured container of values**, optimized for directional computation:
-
-| property           | value                                      |
-|--------------------|--------------------------------------------|
-| **type**           | `Vector` or `Array<number>`                |
-| **arity**          | dimensionality (e.g. 2D, 3D, nD)            |
-| **shape**          | fixed-length tuple of scalars              |
-| **indexing**       | ordered (e.g. `[0] = x`, `[1] = y`)        |
-| **mutability**     | may be mutable (runtime), or immutable     |
-
-Vectors are frequently implemented as:
-
-\`\`\`ts
-type Vector3 = [number, number, number]
-\`\`\`
-
-or with named accessors:
-
-\`\`\`ts
-interface Vector3 {
-  x: number
-  y: number
-  z: number
-}
-\`\`\`
-
-This enables:
-
-- direct algebraic operations (`add`, `dot`, `normalize`, etc.)
-- efficient storage (especially in graphics, physics engines)
-- compatibility with matrix operations and coordinate transforms
-
----
-
-## ⚠️ important distinctions
-
-- Vectors ≠ scalars — direction matters
-- Coordinate representation is **basis-relative**
-- The vector itself is **basis-invariant**
-
----
-
-## 🧬 advanced notes
-
-- In relativity: vectors generalize to **4-vectors** (e.g. spacetime)
-- In field theory: **vector fields** assign a vector to each point in space
-- In curved space: vectors live in **tangent spaces** and obey **manifold** rules
-- In graphics and physics engines: vectors are core data primitives — enabling transforms, simulations, and animations
-
----
-
-## 🧰 summary: dual perspective
-
-| perspective     | usage                                  |
-|------------------|------------------------------------------|
-| **physical**     | represents real-world directional quantity |
-| **computational**| structured data enabling math operations  |

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.definition.md

@@ -1,115 +0,0 @@
-# 📘 .brief: concept
-
-## .what
-A **concept** is a mental abstraction that represents a category, pattern, or principle.
-
-- it defines a class of things that share common structure or meaning
-- it serves as a mental placeholder that can apply across situations
-- it enables grouping, comparison, recognition, and symbolic reasoning
-- it is not tied to any single instance but generalizes across many
-
-## .why
-Concepts are foundational to how we think, learn, and communicate.
-
-- they allow us to generalize from specific experiences
-- they reduce cognitive load by compressing recurring patterns
-- they enable symbolic thought and language (e.g. words refer to concepts)
-- they support transfer of learning and abstract reasoning
-- without concepts, perception and memory would remain fragmented and unstructured
-
-## .origin
-All concepts arise through some form of **abstraction** — extracting structure from experience.
-
-- abstraction involves identifying similarities across multiple examples or events
-- concepts may emerge from direct sensory interaction (e.g. learning "hot" from touching a stove)
-- or from social learning (e.g. learning "wedding" by seeing it enacted or described)
-- or from formal instruction (e.g. learning "photosynthesis" in school)
-- in all cases, concept formation requires generalizing beyond the specific to the shared
-
-
-## .traits
-- abstract and generalized
-- not tied to a specific instance
-- formed through experience, reflection, or instruction
-- may be intuitive (e.g. “tree”) or technical (e.g. “prime number”)
-- can vary in granularity or scope (e.g. “animal” vs. “dog”)
-
-## .examples
-
-- **circle** — abstracted from seeing repeated round shapes like wheels, coins, and the sun (perceptual experience)
-- **dog** — formed by generalizing across encounters with different dog breeds and behaviors (direct interaction)
-- **wedding** — abstracted from witnessing or hearing about ceremonies that formalize unions (cultural exposure)
-- **freedom** — distilled from contrasting experiences of constraint vs autonomy (social experience)
-- **justice** — shaped by stories and events involving fairness, consequences, and moral resolution (moral narratives)
-- **prime number** — learned by observing which numbers are divisible only by 1 and themselves (formal instruction)
-- **game** — generalized from diverse activities with rules, goals, and competition (play and observation)
-- **vehicle** — abstracted from tools that enable movement across space (functional abstraction)
-- **tool** — learned by recognizing shared purpose across objects used to modify the environment (goal-oriented use)
-- **emotion** — abstracted by noticing recurring internal states like fear or joy across different contexts (introspective pattern)
-- **government** — formed by generalizing across systems of authority and law in history, media, and education (institutional exposure)
-
-## .relationships
-- a **concept** can be instantiated by specific **examples**
-- concepts serve as nodes in **semantic treestructs**
-  - connected by abstraction paths
-  - higher nodes represent broader, more general concepts
-  - while lower nodes represent more specific subtypes or instances
-
-## .metaphor
-A **concept** is like a mold — many unique shapes can be cast from it, but they all carry its defining structure.
-
-## .struct
-In a **semantic TreeStruct**, each concept is a **node** positioned along dimensions of meaning (e.g. category, function, emotion).
-- "dog" → child of "mammal" → child of "animal"
-- "knife" → child of "cutting tool" → child of "tool"
-
-Concepts can thus be:
-- **abstracted** inward to general types
-- **specialized** outward to specific subtypes
-- **clustered** by similarity
-- **cross-linked** via shared features across branches
-
-## .usecases
-
-### 🧠 cognitive compression & efficiency
-Concepts reduce mental overhead by filtering detail and enabling compact representation.
-
-- **eliminate irrelevant detail** — discard noise and focus on structural features
-- **reduce memory load** — bundle multiple features into a single abstract handle
-- **compose higher constructs** — build layered models from compact mental units
-- **reuse mental structure** — once formed, concepts can be applied across contexts
-- **schema-based learning** — fit new observations into known conceptual frames
-
-### 🔍 perception & attention
-Concepts guide what we notice and how we interpret sensory input.
-
-- **pattern detection** — expose regularities across diverse instances
-- **selective attention** — filter sensory streams for concept-relevant features
-- **domain focusing** — foreground what's signal-bearing in a specific context
-- **comparison and contrast** — highlight similarities and differences between concepts
-
-### 📡 reasoning & inference
-Concepts power generalization, prediction, and higher-order logic.
-
-- **prediction** — infer missing or future information based on conceptual type
-- **analogical mapping** — transfer structure between domains via shared conceptual form
-- **deduction & induction** — structure logical operations through known categories
-- **abstraction chaining** — compose concepts into hierarchical or recursive reasoning models
-
-### 🗣 communication & collaboration
-Concepts enable symbolic representation and shared understanding across minds.
-
-- **symbolic reference** — words, icons, and gestures can point to shared concepts
-- **cultural transmission** — pass conceptual structures across generations or tribes
-- **semantic alignment** — synchronize meaning for collaboration and coordination
-- **efficient memory indexing** — act as anchors that connect memories across time and modality
-
-### 🛠 planning & action
-Concepts shape behavior by structuring intentions, goals, and procedures.
-
-- **goal decomposition** — break down abstract objectives into actionable steps
-- **problem modeling** — frame challenges in terms of known concept structures
-- **tool selection** — choose actions or instruments based on conceptual fit
-- **cognitive scaffolding** — support stepwise planning and skill acquisition with layered abstractions
-
-Concepts function as the **semantic operating system** of cognition — compressing, structuring, and aligning mental operations across perception, memory, communication, and action.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct._.md

@@ -1,112 +0,0 @@
-# 🌲 .brief: concept.treestruct
-
-## .what
-The **concept.treestruct** is a semantic structure where concepts are arranged as interconnected nodes within a **radial RootStruct**, centered on the abstract core: `"concept"`.
-
-Rather than a single hierarchy, the TreeStruct is a **recursive mesh** of intersecting conceptual trees.
-It enables navigation through **abstraction**, **specialization**, **clustering**, and **frame-shifting**, supporting both **structured reasoning** and **creative exploration**.
-
----
-
-## .why
-This structure enables rich, flexible reasoning:
-
-- models concept space as a **geometry of meaning**
-- supports **semantic traversal** along depth, breadth, and perspective
-- reflects how humans think: by **anchoring**, **zooming**, **shifting**, and **linking**
-- integrates both **objective structure** and **subjective experience**
-
----
-
-## .directions
-Traversal within the TreeStruct occurs in distinct directions:
-
-- **radial** → abstraction or specialization
-  - inward = more abstract (e.g. `"banana"` → `"fruit"` → `"plant organ"`)
-  - outward = more specific (e.g. `"fruit"` → `"banana"` → `"ripe banana"`)
-
-- **lateral** → peer clustering
-  - shift across neighboring nodes at the same depth
-  - e.g. `"banana"` ↔ `"mango"` ↔ `"apple"`
-
-- **angular** → frame-shifting
-  - shift semantic axis or domain (e.g. taxonomy → function → metaphor)
-  - often includes radial movement as well
-  - e.g. `"knife"` ↔ `"word"` (metaphor: both cut)
-
-> Lateral ≈ angular when angular displacement is small.
-> Angular motion becomes distinct when reframing occurs across axes or domains.
-
----
-
-## .geometry
-The TreeStruct forms an **infinite radial space**, anchored at `"concept"`. Its topology supports:
-
-- `focal.depth` → radial distance from the core (abstraction level)
-- `focal.breadth` → number of peer or radial options in view
-- `focal.acuity` → level of resolution within the current concept
-
-Traversal is:
-- **continuous** (drifting among neighbors)
-- **recursive** (zooming into sub-structures)
-- **semantic** (paths shaped by meaning, not just structure)
-
-> Thought is not linear — it spirals through this field of meaning.
-
----
-
-## .metaphor
-Think of the concept.treestruct as a **semantic gravity field**:
-
-- zoom **inward** to distill essence
-- zoom **outward** to expand contextual roles
-- pan **laterally** to compare siblings
-- bend **angularly** to reframe or analogize
-
-> High-gravity concepts shape your local space of thought.
-> You orbit them — or escape them — with effort.
-
----
-
-## .example
-
-Starting at the concept **“banana”**:
-
-- **radial-in**: `"banana"` → `"fruit"` → `"plant organ"` → `"organic structure"`
-- **radial-out**: `"banana"` → `"ripe banana"` → `"peeled banana"`
-- **lateral**: `"banana"` ↔ `"mango"` ↔ `"pineapple"`
-- **angular**:
-  - `"banana"` ↔ `"banana phone"` (visual pun)
-  - `"banana"` ↔ `"joke"` (slapstick tool)
-  - `"banana"` ↔ `"color yellow"` (perceptual role)
-
----
-
-## .struct
-The TreeStruct is:
-
-- **recursive** — any node can be a root of a new TreeStruct
-- **intersective** — nodes may appear in multiple trees simultaneously
-- **perspectival** — motion can be described from:
-  - the **universal perspective** (objective coordinates)
-  - the **relative perspective** (anchored focal view)
-  - the **fractal perspective** (nested, overlapping trees)
-
-> Meaning is not contained in a single path — it emerges from intersections.
-
----
-
-## .notes
-This model integrates with:
-
-- **cortal.focus mechanics**
-  - `focal.depth`, `focal.breadth`, and `focal.acuity`
-- **concept.gravity**
-  - high-gravity nodes anchor navigation and recall
-- **concept.traversal**
-  - radial, lateral, and angular motion as the grammar of thought
-- **concept.lens** *(implied)*
-  - perspectives and domain lenses guide how the structure is explored
-
-> The TreeStruct is not just a model of concepts —
-> it’s a model of how thought moves through them.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.coords.1.spherical.md

@@ -1,80 +0,0 @@
-# 🌳 .brief: `concept.treestruct.spherical`
-
-## .why
-use this brief if you want to...
-
-- **understand how abstraction works** in a concept `TreeStruct`, in terms of generality and specificity
-
-- **navigate or manipulate concepts radially** — moving inward toward abstractions or outward toward instances
-
-- **distinguish between different kinds of abstraction**, such as categorical vs functional vs modal
-
-- **identify the semantic axis** a concept belongs to (e.g., “fruit” is a categorical abstraction)
-
-- **structure your knowledge hierarchically** by tracing how concepts generalize along meaningful dimensions
-
-- **design tools or prompts** that rely on structured abstraction (e.g., AI reasoning, taxonomy design, teaching models)
-
-
-## .what
-The `concept.treestruct` models conceptual space using a **spherical coordinate system**, where each concept has both:
-
-- a **radial position** *(aka "abstractive position")*: how abstract or concrete it is
-- an **angular position** *(aka "descriptive position")*: how it varies descriptively from its peers
-
-This structure allows concepts to be organized by both **hierarchical abstraction** and **semantic variation**, enabling multidirectional traversal.
-
----
-
-## 🧭 dimensions
-
-| spherical axis     | treestruct role                | alias                    | description                                           |
-|--------------------|--------------------------------|--------------------------|-------------------------------------------------------|
-| **radius** `r`     | abstractive hierarchy          | **abstractive position** | inward = more abstract/core<br>outward = more concrete/detail |
-| **inclination** `θ`| categorical differentiation    | **descriptive position** | vertical angular shifts between categories or frames  |
-| **azimuth** `φ`    | sibling/instance differentiation | **descriptive position** | horizontal angular shifts between analogs or variants |
-
-> The angular dimensions (`θ`, `φ`) are both descriptive: they define where the concept sits relative to peers at the same level of abstraction.
-
----
-
-## 🪜 radial motion: abstraction
-
-Radial motion moves through layers of **conceptual generality**:
-
-- **inward**: toward more universal, abstract ideas
-- **outward**: toward more specific, detailed instances
-
-This defines the **core structure** of the tree — from root abstractions to concrete applications.
-
----
-
-## 🔀 angular motion: variation
-
-Angular motion explores **alternative expressions** at the same abstractive level:
-
-- **vertical tilt** (`θ`) shifts across **types or categories**
-- **horizontal rotation** (`φ`) shifts across **peer instances or analogies**
-
-These motions describe **semantic diversity**, not hierarchy.
-
----
-
-## 🌐 structural implications
-
-- The treestruct forms **layers of abstraction** (radial) populated by **rings of descriptive diversity** (angular)
-- Concepts can be:
-  - **grouped** by angular proximity (descriptive similarity)
-  - **traced** by radial lineage (abstractive derivation)
-
----
-
-## 🌀 navigation
-
-- to **generalize** → move **inward** (more abstract)
-- to **specialize** → move **outward** (more concrete)
-- to **reframe**, **contrast**, or **analogize** → rotate **angularly**
-
-This enables precise, multidimensional navigation of meaning.
-
----

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.coords.2.abstractive.md

@@ -1,59 +0,0 @@
-# 🧭 .brief: `cog101.concept.treestruct.coords.abstractive`
-
-## .why
-Use this brief if you want to:
-
-- **understand how abstraction works** in a concept `TreeStruct`, especially in terms of generality and specificity
-- **navigate or manipulate concepts radially** — moving inward toward abstractions or outward toward instances
-- **distinguish between different kinds of abstraction**, such as categorical vs functional vs modal
-- **identify the semantic axis** a concept belongs to (e.g., “fruit” is a categorical abstraction)
-- **structure your knowledge hierarchically** by tracing how concepts generalize along meaningful dimensions
-- **design tools or prompts** that rely on structured abstraction (e.g., AI reasoning, taxonomy design, teaching models)
-
----
-
-## .what
-The **abstractive coordinate** of a concept describes its **radial position** in a `TreeStruct` of meaning — how **general or specific** it is.
-
-This radial motion is called **abstraction**, and moves either:
-- **inward** toward **more general, inclusive** ideas
-- or **outward** toward **more specific, detailed** instances
-
-Every abstraction path follows a **semantic axis** — a distinct dimension of meaning.
-
----
-
-## 🧱 structure
-
-Each concept has a position along one or more **abstractive semantic axes**.
-Each axis defines a **consistent rule** of generalization.
-
-Examples of such axes:
-
-| axis name        | abstraction path                           | generalizes by...          |
-|------------------|--------------------------------------------|----------------------------|
-| **categorical**  | `"banana"` → `"fruit"` → `"plant"`         | kind or type               |
-| **functional**   | `"spoon"` → `"utensil"` → `"tool"`         | purpose or behavior        |
-| **modal**        | `"can walk"` → `"mobility"` → `"agency"`   | ability or constraint      |
-| **causal**       | `"match"` → `"ignition"` → `"fire source"` | influence or mechanism     |
-| **emotional**    | `"fear"` → `"negative affect"` → `"alert"` | affective tone             |
-| **ontological**  | `"emotion"` → `"neural event"` → `"process"` | being or substance        |
-| **logical**      | `"even number"` → `"divisible by 2"` → `"numeric property"` | provable structure |
-
----
-
-## 🔁 radial traversal
-
-Abstractive motion is **radial** in the `concept.treestruct`, not lateral.
-Each axis defines a **line of abstraction** from specific to general — i.e., from **leaf** to **trunk**.
-
-- **inward** motion = `<generalize>`: higher-level, more inclusive
-- **outward** motion = `<instantiate>`: more detailed or constrained
-
----
-
-## 📌 key point example
-> "Category" is not just a label — it's a **semantic abstraction** along the **categorical axis**.
-
-All categories are abstractive.
-But not all abstractions are categorical.

package/dist/logic/roles/bhrain/.briefs/cognition/cog101.concept.treestruct.coords.3.descriptive.md

@@ -1,64 +0,0 @@
-# 🧭 .brief: `cog101.concept.treestruct.coordinates.descriptive`
-
-## .why
-Use this brief if you want to:
-
-- **understand how concepts vary across peers**, not just across levels of abstraction
-- **navigate laterally** within a concept space — across similar-level alternatives
-- **distinguish a concept from its siblings** by highlighting descriptive differences
-- **identify the descriptive axes** a concept can vary along (e.g., flavor, size, style, plausibility)
-- **model variation, contrast, or diversity** within a semantic category
-- **support analogy-making, reframing, or contrastive analysis** between similar ideas
-
----
-
-## .what
-The **descriptive coordinate** of a concept defines its **angular position** in the `TreeStruct`.
-It captures **how a concept differs from its peers** — not by abstraction, but by **descriptive variation**.
-
-This is an **angular motion**, moving **around the same level** of abstraction.
-
-Where radial abstraction answers “what is this an instance of?”,
-descriptive variation asks “**what kind of this** is it?”
-
----
-
-## 🧱 structure
-
-Each concept can vary along one or more **descriptive semantic axes**,
-which define the dimensions by which peer concepts differ.
-
-Examples of descriptive axes:
-
-| axis name         | example variations                                | describes...                      |
-|-------------------|---------------------------------------------------|-----------------------------------|
-| **qualitative**   | red / blue / green                                | color                             |
-| **quantitative**  | small / medium / large                            | size                              |
-| **stylistic**     | formal / casual / ironic                          | tone or mode of expression        |
-| **temporal**      | recent / ongoing / historical                     | time-related state                |
-| **systemic**      | part / module / whole                             | structural composition            |
-| **behavioral**    | aggressive / passive / cooperative                | attitude or action pattern        |
-| **plausibility**  | absurd / unlikely / likely / obvious              | perceived believability or realism|
-
----
-
-## 🔄 angular traversal
-
-Descriptive motion is **lateral** or **angular** — it moves among **peers at the same abstraction level**.
-Think of concepts orbiting the same distance from the core, but **differing in character**.
-
-This enables operations like:
-
-- `<reframe>` — view the same concept from another descriptive lens
-- `<contrast>` — emphasize a difference along one axis
-- `<analogize>` — map lateral structure to a different context
-
----
-
-## 📌 key point
-> Descriptive motion defines **how** something *is that thing*, not *what* thing it is.
-
-A “banana” and a “mango” are **peers** under the **categorical abstraction** "fruit" —
-but they differ descriptively by flavor, texture, shape, and usage.
-
-Descriptive axes **reveal the variation space** within a category.