brainy/docs/architecture/noun-verb-taxonomy.md

---
title: Noun & Verb Types
slug: concepts/noun-types
public: true
category: concepts
template: concept
order: 2
description: 42 NounTypes and 127 VerbTypes cover ~95% of all domains. The universal vocabulary for structuring anything from people and documents to events and relationships.
next:
  - concepts/triple-intelligence
  - api/reference
---

# The Universal Knowledge Protocol: Noun-Verb Taxonomy

> **Brainy is the Universal Knowledge Protocol™ powered by Triple Intelligence™**
>
> Brainy unifies vector, graph, and document search behind one API. That unification — Triple Intelligence — rests on a shared, standardized vocabulary for knowledge: a fixed set of entity types (nouns) and relationship types (verbs) that every tool, integration, and model can speak.

Every example on this page is written against the real Brainy 8.0 API. The setup is always the same:

```typescript
import { Brainy, NounType, VerbType } from '@soulcraft/brainy'

const brain = new Brainy()
await brain.init()
```

- `brain.add({ data, type, subtype?, metadata? })` creates a noun and returns its `string` id.
- `brain.relate({ from, to, type, metadata? })` creates a verb (relationship) between two nouns.
- `brain.find({ query?, type?, where?, connected? })` runs Triple Intelligence search.
- `brain.related({ from })` / `brain.neighbors(id)` read a noun's relationships.

## Universal & Infinite Expressiveness

Brainy's **Noun-Verb Taxonomy** achieves broad coverage of human knowledge through composable expressiveness:

- **42 Noun Types × 127 Verb Types = 5,334 Base Combinations**
- **Unlimited Metadata Fields = Domain Specificity**
- **Multi-hop Graph Traversals = Relationship Complexity**
- **Result: Model data across virtually any industry**

Every piece of information can be represented as entities (nouns) connected by relationships (verbs) carrying properties (metadata). The standardized type system from `@soulcraft/brainy` (`NounType`, `VerbType`) gives those nouns and verbs a stable, shared name.

## The Power of Standardization: Universal Interoperability

### Why Standardized Types = Seamless Integration

Because every entity is classified with a `NounType` and every relationship with a `VerbType`, the same data is legible to any code that imports the same enums.

#### 1. Tool Interoperability

```typescript
// Any tool that understands Brainy's NounType/VerbType can read the same graph.
// One module writes; another reads — no schema translation in between.
const authors = await brain.find({ type: NounType.Person })

for (const author of authors) {
  const authored = await brain.related({
    from: author.id,
    type: VerbType.Creates
  })
  console.log(`${author.data} → ${authored.length} document(s)`)
}
```

#### 2. Data Portability

```typescript
// Snapshot one brain and open it as another — the noun/verb vocabulary
// travels with the data, so the types line up exactly.
const pin = brain1.now()
try {
  await pin.persist('/snapshots/brain-1')
} finally {
  await pin.release()
}

const brain2 = await Brainy.load('/snapshots/brain-1') // same NounType/VerbType vocabulary
```

#### 3. Model & Agent Compatibility

```typescript
// Different models and agents reason over the SAME typed structure.
// Whatever produced the entity, every consumer reads the same NounType.
const conceptId = await brain.add({
  data: 'Quantum Computer',
  type: NounType.Thing,
  subtype: 'computing-hardware'
})

// Any downstream consumer can now retrieve and reason about this entity.
const concept = await brain.get(conceptId)
console.log(concept?.type) // 'thing'
```

#### 4. Extensibility Without Forking the Schema

```typescript
// Subtypes extend a standard NounType for a specific domain — no schema
// migration, no new noun type. The base type stays universally understood.
await brain.add({ data: 'Patient #12345', type: NounType.Person, subtype: 'patient' })
await brain.add({ data: 'Invoice #4471', type: NounType.Document, subtype: 'invoice' })
await brain.add({ data: 'Follower edge', type: NounType.Relationship, subtype: 'social-graph' })

// Domains that share the base types interoperate even with custom subtypes.
const patients = await brain.find({ type: NounType.Person, subtype: 'patient' })
```

#### 5. Cross-Platform Integration

```typescript
// Map external systems onto the standard taxonomy. A CRM's Contact/Account/
// Opportunity become Person/Organization/Event — the same vocabulary everywhere.
const externalRecords = [
  { kind: 'Contact', name: 'Dana Lee', type: NounType.Person },
  { kind: 'Account', name: 'Acme Corp', type: NounType.Organization },
  { kind: 'Opportunity', name: 'Q3 Renewal', type: NounType.Event }
]

for (const record of externalRecords) {
  await brain.add({
    data: record.name,
    type: record.type,
    metadata: { source: 'crm', externalKind: record.kind }
  })
}
```

### The Network Effect: Brainy as the Universal Knowledge Protocol

Like **HTTP** became the protocol for the web and **TCP/IP** for the internet, Brainy's noun-verb taxonomy aims to be a **Universal Knowledge Protocol**:

- **Learn Once**: Developers learn 42 nouns + 127 verbs, not thousands of bespoke schemas
- **Build Anywhere**: Tools built for one domain work in others
- **Share Everything**: Knowledge graphs are universally shareable
- **Compose Freely**: Subtypes and metadata extend types without schema migrations

This isn't just a database — it's a **shared model for how knowledge is represented**.

## Overview

Brainy's **Noun-Verb Taxonomy** models data as entities (nouns) and relationships (verbs), creating a semantic knowledge graph that mirrors how humans naturally think about information.

## Why Noun-Verb?

Traditional databases force you to think in tables, documents, or nodes. Brainy lets you think naturally:

- **Nouns**: Things that exist (people, documents, products, concepts)
- **Verbs**: How things relate (creates, owns, references, related-to)

This simple mental model scales from basic storage to complex knowledge graphs while remaining intuitive.

## Core Concepts

### Nouns (Entities)

Nouns represent any entity in your system. `add()` takes a single object and returns the new entity's id:

```typescript
// Add any entity as a noun
const personId = await brain.add({
  data: 'John Smith, Senior Engineer',
  type: NounType.Person,
  subtype: 'employee',
  metadata: { department: 'engineering', skills: ['TypeScript', 'React', 'Node.js'] }
})

const documentId = await brain.add({
  data: 'Q3 2024 Financial Report',
  type: NounType.Document,
  subtype: 'report',
  metadata: { category: 'financial', confidential: true, created: '2024-10-01' }
})

const conceptId = await brain.add({
  data: 'Machine Learning',
  type: NounType.Concept,
  metadata: { domain: 'technology', complexity: 'advanced' }
})
```

#### Noun Properties

Every noun automatically gets:
- **Unique ID**: System-generated UUID, or supply your own via `id`
- **Vector Embedding**: `data` is embedded for semantic similarity
- **Metadata**: Flexible, queryable JSON properties
- **Timestamps**: `createdAt` / `updatedAt` tracking
- **Indexing**: Automatic field indexing for `where` filters

### Verbs (Relationships)

Verbs define how nouns relate to each other. `relate()` also takes a single object:

```typescript
// Create relationships between entities
await brain.relate({
  from: personId,
  to: documentId,
  type: VerbType.Creates,
  metadata: { role: 'primary_author', contribution: '80%' }
})

await brain.relate({
  from: documentId,
  to: conceptId,
  type: VerbType.Describes,
  metadata: { sections: ['methodology', 'results'], depth: 'detailed' }
})

await brain.relate({
  from: personId,
  to: conceptId,
  type: VerbType.RelatedTo,
  subtype: 'expertise',
  metadata: { yearsExperience: 5, certification: 'Advanced ML Certification' }
})
```

#### Verb Properties

Every verb includes:
- **Source** (`from`): The noun initiating the relationship
- **Target** (`to`): The noun receiving the relationship
- **Type**: The `VerbType` classification
- **Subtype**: Optional per-product sub-classification (fast-path indexed)
- **Metadata**: Relationship-specific queryable data
- **Weight**: Optional relationship strength (0–1)

## Benefits

### 1. Natural Mental Model

```typescript
// Think naturally about your data
const taskId = await brain.add({ data: 'Implement payment system', type: NounType.Task })
const userId = await brain.add({ data: 'Alice Johnson', type: NounType.Person })
const projectId = await brain.add({ data: 'E-commerce Platform', type: NounType.Project })

// Express relationships clearly
await brain.relate({ from: userId, to: taskId, type: VerbType.ParticipatesIn, subtype: 'assignee' })
await brain.relate({ from: taskId, to: projectId, type: VerbType.PartOf })
await brain.relate({ from: userId, to: projectId, type: VerbType.ParticipatesIn, subtype: 'manager' })
```

### 2. Semantic Understanding

The noun-verb model preserves meaning. `find()` accepts a natural-language string or a structured query:

```typescript
// Natural language — embedded and matched semantically
const results = await brain.find({ query: 'tasks for the payment system' })

// Structured — type + graph traversal in one call
const aliceTasks = await brain.find({
  type: NounType.Task,
  connected: { from: userId, via: VerbType.ParticipatesIn }
})
```

### 3. Flexible Schema

No rigid schema requirements — add any type, extend with a `subtype`:

```typescript
// Add any noun type without schema changes
const sensorId = await brain.add({
  data: 'New IoT Sensor',
  type: NounType.Thing,
  subtype: 'iot-device',
  metadata: { protocol: 'MQTT', location: 'Building A' }
})

const buildingId = await brain.add({ data: 'Building A', type: NounType.Location })

// Relationships carry their own structured metadata
await brain.relate({
  from: sensorId,
  to: buildingId,
  type: VerbType.Measures,
  metadata: { metrics: ['temperature', 'humidity'], interval: '5 minutes' }
})
```

### 4. Graph Traversal

Navigate relationships naturally with `connected`:

```typescript
// Find documents reachable from a team via two relationship hops
const teamDocs = await brain.find({
  type: NounType.Document,
  connected: {
    from: teamId,
    via: [VerbType.MemberOf, VerbType.Creates],
    depth: 2
  }
})

// Find products two hops out from a user
const recommendations = await brain.find({
  type: NounType.Product,
  connected: {
    from: userId,
    via: VerbType.Owns,
    depth: 2
  }
})
```

### 5. Temporal Relationships

Track how relationships change over time by storing dates in edge metadata:

```typescript
await brain.relate({
  from: employeeId,
  to: companyId,
  type: VerbType.MemberOf,
  subtype: 'past-employment',
  metadata: { from: '2020-01-01', to: '2023-12-31', position: 'Senior Developer' }
})

await brain.relate({
  from: employeeId,
  to: newCompanyId,
  type: VerbType.MemberOf,
  subtype: 'current-employment',
  metadata: { from: '2024-01-01', position: 'Tech Lead' }
})

// Query with natural language
const employment = await brain.find({ query: 'where did this person work in 2022' })
```

## Real-World Use Cases

### Knowledge Management

```typescript
// Documents and their relationships
const paperId = await brain.add({
  data: 'Neural Networks Paper',
  type: NounType.Document,
  subtype: 'research-paper',
  metadata: { year: 2024 }
})

const authorId = await brain.add({
  data: 'Dr. Sarah Chen',
  type: NounType.Person,
  subtype: 'researcher'
})

const topicId = await brain.add({ data: 'Deep Learning', type: NounType.Concept })
const otherPaperId = await brain.add({ data: 'Backpropagation Survey', type: NounType.Document })

// Rich relationship network
await brain.relate({ from: authorId, to: paperId, type: VerbType.Creates })
await brain.relate({ from: paperId, to: topicId, type: VerbType.Describes })
await brain.relate({ from: paperId, to: otherPaperId, type: VerbType.References })
await brain.relate({ from: authorId, to: topicId, type: VerbType.RelatedTo, subtype: 'research-focus' })

// Query the knowledge graph
const related = await brain.find({ query: 'papers about deep learning by Sarah Chen' })
```

### Social Networks

```typescript
// Users and connections
const user1 = await brain.add({ data: 'Alice', type: NounType.Person })
const user2 = await brain.add({ data: 'Bob', type: NounType.Person })
const post = await brain.add({ data: 'Great article on AI!', type: NounType.Message, subtype: 'post' })

// Social interactions
await brain.relate({ from: user1, to: user2, type: VerbType.Follows })
await brain.relate({ from: user2, to: user1, type: VerbType.Follows }) // mutual
await brain.relate({ from: user1, to: post, type: VerbType.Creates })
await brain.relate({ from: user2, to: post, type: VerbType.Likes })
await brain.relate({ from: user2, to: post, type: VerbType.Communicates, subtype: 'share' })

// Find social patterns
const influencers = await brain.find({ query: 'people who post about AI with many followers' })
```

### E-commerce

```typescript
// Products and purchases
const product = await brain.add({
  data: 'Wireless Headphones',
  type: NounType.Product,
  metadata: { price: 99.99, category: 'electronics' }
})

const customer = await brain.add({
  data: 'Customer #12345',
  type: NounType.Person,
  subtype: 'customer',
  metadata: { tier: 'premium' }
})

// Purchase and review relationships
await brain.relate({
  from: customer,
  to: product,
  type: VerbType.Owns,
  subtype: 'purchase',
  metadata: { date: '2024-01-15', quantity: 1, price: 99.99 }
})

await brain.relate({
  from: customer,
  to: product,
  type: VerbType.Evaluates,
  subtype: 'review',
  metadata: { rating: 5, text: 'Excellent sound quality!' }
})

// Recommendation queries
const recs = await brain.find({ query: 'products bought by customers who bought headphones' })
```

### Project Management

```typescript
// Projects, tasks, and teams
const project = await brain.add({ data: 'Website Redesign', type: NounType.Project })
const task = await brain.add({ data: 'Update homepage', type: NounType.Task })
const otherTask = await brain.add({ data: 'Design system audit', type: NounType.Task })
const developer = await brain.add({ data: 'Jane Developer', type: NounType.Person, subtype: 'employee' })
const designer = await brain.add({ data: 'John Designer', type: NounType.Person, subtype: 'employee' })

// Work relationships
await brain.relate({ from: task, to: project, type: VerbType.PartOf })
await brain.relate({ from: developer, to: task, type: VerbType.ParticipatesIn, subtype: 'assignee' })
await brain.relate({ from: designer, to: developer, type: VerbType.WorksWith })
await brain.relate({ from: task, to: otherTask, type: VerbType.DependsOn })

// Project queries
const blockers = await brain.find({ query: 'tasks blocked by incomplete work' })
const workload = await brain.find({ query: 'people assigned to multiple active projects' })
```

## Advanced Patterns

### Bidirectional Relationships

```typescript
// Symmetric relationships create the inverse edge automatically
await brain.relate({ from: user1, to: user2, type: VerbType.FriendOf, bidirectional: true })
```

### Weighted Relationships

```typescript
// Add strength/weight to relationships (top-level weight, 0–1)
await brain.relate({
  from: doc1,
  to: doc2,
  type: VerbType.SimilarityDegree,
  weight: 0.95,
  metadata: { algorithm: 'cosine' }
})

// Weights come back on the Relation, so you can filter on them
const edges = await brain.related({ from: doc1, type: VerbType.SimilarityDegree })
const stronglyRelated = edges.filter((edge) => (edge.weight ?? 0) >= 0.8)
```

### Relationship Chains (Multi-hop)

```typescript
// Follow a chain of relationship types out to a fixed depth.
// `via` accepts an array of VerbTypes; `depth` bounds the traversal.
const results = await brain.find({
  type: NounType.Thing,
  connected: {
    from: userId,
    via: [VerbType.Owns, VerbType.Creates, VerbType.Uses],
    depth: 3
  }
})
// Finds: things used by products made by companies owned by the user
```

### Meta-Relationships

Relationships can themselves be reasoned about. The `Relationship` NounType reifies an edge as a first-class entity, and the meta-level verbs (`Endorses`, `Supports`, `Contradicts`, `Supersedes`) express second-order claims between entities:

```typescript
// A second person endorses a claim, and a third supports it with evidence.
const claim = await brain.add({ data: 'X improves retention', type: NounType.Proposition })
await brain.relate({ from: user2, to: claim, type: VerbType.Endorses })
await brain.relate({
  from: user3,
  to: claim,
  type: VerbType.Supports,
  metadata: { reason: 'Matches the A/B test', trustScore: 0.9 }
})
```

## Query Patterns

### Finding Nouns

```typescript
// By type
const people = await brain.find({ type: NounType.Person })

// By type + metadata filters (bare operators — no `$` prefixes)
const documents = await brain.find({
  type: NounType.Document,
  where: {
    confidential: false,
    created: { gte: '2024-01-01' }
  }
})

// By semantic similarity — use `query`, optionally narrowed by type
const similar = await brain.find({
  query: 'machine learning research',
  type: NounType.Document
})
```

> **`where` operators** are bare (never dollar-prefixed): `eq`/`equals`/`is`, `ne`/`notEquals`, `in`/`oneOf`, `gt`/`greaterThan`, `gte`/`greaterThanOrEqual`, `lt`/`lessThan`, `lte`/`lessThanOrEqual`, `between`, `contains`, `exists`, `missing`, plus the logical combinators `allOf`/`anyOf`/`not`.

### Finding Verbs (Relationships)

```typescript
// All relationships originating from a noun
const outgoing = await brain.related({ from: nounId })

// Every edge touching a noun, in either direction
const incident = await brain.related({ node: nounId })

// Filter by relationship type
const authorships = await brain.related({ from: authorId, type: VerbType.Creates })

// Filter returned relationships by their metadata (Relation carries `.metadata`)
const purchases = await brain.related({ from: customerId, type: VerbType.Owns, subtype: 'purchase' })
const recentPurchases = purchases.filter((edge) => edge.metadata?.date >= '2024-01-01')

// Just the count of relationships in the graph
const totalEdges = await brain.getVerbCount()
```

### Combined Queries (Query → Expand)

```typescript
// Start from a semantic query, then expand along the graph.
// Vector + graph in a single find() call.
const results = await brain.find({
  query: 'AI research',
  connected: {
    via: VerbType.Creates,
    depth: 2
  }
})
```

## The Complete Noun Taxonomy (42 Types)

`NounType` is the stable, exported vocabulary for classifying entities. Every value is a plain string, so you can write `NounType.Person` or the literal `'person'`. Pick the closest standard type and refine with `subtype` and `metadata`.

```typescript
const physicistId = await brain.add({
  data: 'Albert Einstein',
  type: NounType.Person,
  metadata: { role: 'physicist', born: '1879-03-14' }
})
```

### Core Entity Types (7)

| NounType | Value | Use for |
|----------|-------|---------|
| `Person` | `'person'` | Individual human entities |
| `Organization` | `'organization'` | Companies, institutions, collectives |
| `Location` | `'location'` | Geographic and named spatial entities |
| `Thing` | `'thing'` | Discrete physical objects and artifacts |
| `Concept` | `'concept'` | Abstract ideas, principles, intangibles |
| `Event` | `'event'` | Temporal occurrences and happenings |
| `Agent` | `'agent'` | Non-human autonomous actors (AI agents, bots) |

### Biological & Material Types (2)

| NounType | Value | Use for |
|----------|-------|---------|
| `Organism` | `'organism'` | Living biological entities (animals, plants, bacteria) |
| `Substance` | `'substance'` | Physical materials and matter (water, iron, DNA) |

### Property, Temporal & Functional Types (3)

| NounType | Value | Use for |
|----------|-------|---------|
| `Quality` | `'quality'` | Properties and attributes that inhere in entities |
| `TimeInterval` | `'timeInterval'` | Temporal regions, periods, durations |
| `Function` | `'function'` | Purposes, capabilities, functional roles |

### Informational Type (1)

| NounType | Value | Use for |
|----------|-------|---------|
| `Proposition` | `'proposition'` | Statements, claims, assertions, declarative content |

### Digital/Content Types (4)

| NounType | Value | Use for |
|----------|-------|---------|
| `Document` | `'document'` | Text-based files and written content |
| `Media` | `'media'` | Non-text media (audio, video, images) |
| `File` | `'file'` | Generic digital files and data blobs |
| `Message` | `'message'` | Communication content and correspondence |

### Collection Types (2)

| NounType | Value | Use for |
|----------|-------|---------|
| `Collection` | `'collection'` | Groups and sets of items |
| `Dataset` | `'dataset'` | Structured data collections and databases |

### Business/Application Types (4)

| NounType | Value | Use for |
|----------|-------|---------|
| `Product` | `'product'` | Commercial products and offerings |
| `Service` | `'service'` | Service offerings and intangible products |
| `Task` | `'task'` | Actions, todos, work items |
| `Project` | `'project'` | Organized initiatives and programs |

### Descriptive Types (6)

| NounType | Value | Use for |
|----------|-------|---------|
| `Process` | `'process'` | Workflows, procedures, ongoing activities |
| `State` | `'state'` | Conditions, status, situational contexts |
| `Role` | `'role'` | Positions, responsibilities, classifications |
| `Language` | `'language'` | Natural and formal languages |
| `Currency` | `'currency'` | Monetary units and exchange mediums |
| `Measurement` | `'measurement'` | Metrics, quantities, measured values |

### Scientific & Legal Types (4)

| NounType | Value | Use for |
|----------|-------|---------|
| `Hypothesis` | `'hypothesis'` | Scientific theories, research hypotheses |
| `Experiment` | `'experiment'` | Controlled studies, trials, methodologies |
| `Contract` | `'contract'` | Legal agreements, terms, binding documents |
| `Regulation` | `'regulation'` | Laws, rules, compliance requirements |

### Technical Infrastructure Types (2)

| NounType | Value | Use for |
|----------|-------|---------|
| `Interface` | `'interface'` | APIs, protocols, specifications, endpoints |
| `Resource` | `'resource'` | Compute, bandwidth, storage, infrastructure assets |

### Social Structure Types (3)

| NounType | Value | Use for |
|----------|-------|---------|
| `SocialGroup` | `'socialGroup'` | Informal social groups and collectives |
| `Institution` | `'institution'` | Formal social structures and practices |
| `Norm` | `'norm'` | Social norms, conventions, expectations |

### Information Theory Types (2)

| NounType | Value | Use for |
|----------|-------|---------|
| `InformationContent` | `'informationContent'` | Abstract information (stories, ideas, schemas) |
| `InformationBearer` | `'informationBearer'` | Physical or digital carrier of information |

### Meta-Level & Extensible Types (2)

| NounType | Value | Use for |
|----------|-------|---------|
| `Relationship` | `'relationship'` | Relationships reified as first-class entities |
| `Custom` | `'custom'` | Domain-specific entities outside the standard set |

## The Complete Verb Taxonomy (127 Types)

`VerbType` is the exported vocabulary for classifying relationships. As with nouns, every value is a plain string — write `VerbType.Creates` or `'creates'`. Where no verb is an exact fit, choose the closest base verb and refine it with `subtype` and `metadata` (see [Coverage Completeness](#coverage-completeness-analysis)).

```typescript
await brain.relate({ from: authorId, to: documentId, type: VerbType.Creates })
```

### Foundational Ontological (3)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `InstanceOf` | `'instanceOf'` | Individual to class (Fido instanceOf Dog) |
| `SubclassOf` | `'subclassOf'` | Taxonomic hierarchy (Dog subclassOf Mammal) |
| `ParticipatesIn` | `'participatesIn'` | Entity participation in events/processes |

### Core Relationships (4)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `RelatedTo` | `'relatedTo'` | Generic relationship (fallback) |
| `Contains` | `'contains'` | Containment relationship |
| `PartOf` | `'partOf'` | Part-whole (mereological) relationship |
| `References` | `'references'` | Citation and referential relationship |

### Spatial (2)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `LocatedAt` | `'locatedAt'` | Spatial location relationship |
| `AdjacentTo` | `'adjacentTo'` | Spatial proximity relationship |

### Temporal (3)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Precedes` | `'precedes'` | Temporal sequence (before) |
| `During` | `'during'` | Temporal containment |
| `OccursAt` | `'occursAt'` | Temporal location |

### Causal & Dependency (5)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Causes` | `'causes'` | Direct causal relationship |
| `Enables` | `'enables'` | Enablement without direct causation |
| `Prevents` | `'prevents'` | Prevention relationship |
| `DependsOn` | `'dependsOn'` | Dependency relationship |
| `Requires` | `'requires'` | Necessity relationship |

### Creation & Transformation (5)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Creates` | `'creates'` | Creation relationship |
| `Transforms` | `'transforms'` | Transformation relationship |
| `Becomes` | `'becomes'` | State change relationship |
| `Modifies` | `'modifies'` | Modification relationship |
| `Consumes` | `'consumes'` | Consumption relationship |

### Lifecycle (1)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Destroys` | `'destroys'` | Termination and destruction relationship |

### Ownership & Attribution (2)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Owns` | `'owns'` | Ownership relationship |
| `AttributedTo` | `'attributedTo'` | Attribution relationship |

### Property & Quality (2)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `HasQuality` | `'hasQuality'` | Entity to quality attribution |
| `Realizes` | `'realizes'` | Function realization relationship |

### Effects & Experience (1)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Affects` | `'affects'` | Patient/experiencer relationship |

### Composition (2)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `ComposedOf` | `'composedOf'` | Material composition (distinct from partOf) |
| `Inherits` | `'inherits'` | Inheritance relationship |

### Social & Organizational (8)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `MemberOf` | `'memberOf'` | Membership relationship |
| `WorksWith` | `'worksWith'` | Professional collaboration |
| `FriendOf` | `'friendOf'` | Friendship relationship |
| `Follows` | `'follows'` | Following/subscription relationship |
| `Likes` | `'likes'` | Liking/favoriting relationship |
| `ReportsTo` | `'reportsTo'` | Hierarchical reporting relationship |
| `Mentors` | `'mentors'` | Mentorship relationship |
| `Communicates` | `'communicates'` | Communication relationship |

### Descriptive & Functional (8)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Describes` | `'describes'` | Descriptive relationship |
| `Defines` | `'defines'` | Definition relationship |
| `Categorizes` | `'categorizes'` | Categorization relationship |
| `Measures` | `'measures'` | Measurement relationship |
| `Evaluates` | `'evaluates'` | Evaluation relationship |
| `Uses` | `'uses'` | Utilization relationship |
| `Implements` | `'implements'` | Implementation relationship |
| `Extends` | `'extends'` | Extension relationship |

### Advanced Relationships (5)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `EquivalentTo` | `'equivalentTo'` | Equivalence/identity relationship |
| `Believes` | `'believes'` | Epistemic relationship (cognitive state) |
| `Conflicts` | `'conflicts'` | Conflict relationship |
| `Synchronizes` | `'synchronizes'` | Synchronization relationship |
| `Competes` | `'competes'` | Competition relationship |

### Modal (6)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `CanCause` | `'canCause'` | Potential causation (possibility) |
| `MustCause` | `'mustCause'` | Necessary causation (necessity) |
| `WouldCauseIf` | `'wouldCauseIf'` | Counterfactual causation |
| `CouldBe` | `'couldBe'` | Possible states |
| `MustBe` | `'mustBe'` | Necessary identity |
| `Counterfactual` | `'counterfactual'` | General counterfactual relationship |

### Epistemic States (9)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Knows` | `'knows'` | Knowledge (justified true belief) |
| `Doubts` | `'doubts'` | Uncertainty/skepticism |
| `Desires` | `'desires'` | Want/preference |
| `Intends` | `'intends'` | Intentionality |
| `Fears` | `'fears'` | Fear/anxiety |
| `Loves` | `'loves'` | Strong positive emotional attitude |
| `Hates` | `'hates'` | Strong negative emotional attitude |
| `Hopes` | `'hopes'` | Hopeful expectation |
| `Perceives` | `'perceives'` | Sensory perception |

### Learning & Cognition (1)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Learns` | `'learns'` | Cognitive acquisition and learning |

### Uncertainty & Probability (4)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `ProbablyCauses` | `'probablyCauses'` | Probabilistic causation |
| `UncertainRelation` | `'uncertainRelation'` | Unknown relationship with confidence bounds |
| `CorrelatesWith` | `'correlatesWith'` | Statistical correlation (not causation) |
| `ApproximatelyEquals` | `'approximatelyEquals'` | Fuzzy equivalence |

### Scalar Properties (5)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `GreaterThan` | `'greaterThan'` | Scalar comparison |
| `SimilarityDegree` | `'similarityDegree'` | Graded similarity |
| `MoreXThan` | `'moreXThan'` | Comparative property |
| `HasDegree` | `'hasDegree'` | Scalar property assignment |
| `PartiallyHas` | `'partiallyHas'` | Graded possession |

### Information Theory (2)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Carries` | `'carries'` | Bearer carries content |
| `Encodes` | `'encodes'` | Encoding relationship |

### Deontic (5)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `ObligatedTo` | `'obligatedTo'` | Moral/legal obligation |
| `PermittedTo` | `'permittedTo'` | Permission/authorization |
| `ProhibitedFrom` | `'prohibitedFrom'` | Prohibition/forbidden |
| `ShouldDo` | `'shouldDo'` | Normative expectation |
| `MustNotDo` | `'mustNotDo'` | Strong prohibition |

### Context & Perspective (5)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `TrueInContext` | `'trueInContext'` | Context-dependent truth |
| `PerceivedAs` | `'perceivedAs'` | Subjective perception |
| `InterpretedAs` | `'interpretedAs'` | Interpretation relationship |
| `ValidInFrame` | `'validInFrame'` | Frame-dependent validity |
| `TrueFrom` | `'trueFrom'` | Perspective-dependent truth |

### Advanced Temporal (6)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Overlaps` | `'overlaps'` | Partial temporal overlap |
| `ImmediatelyAfter` | `'immediatelyAfter'` | Direct temporal succession |
| `EventuallyLeadsTo` | `'eventuallyLeadsTo'` | Long-term consequence |
| `SimultaneousWith` | `'simultaneousWith'` | Exact temporal alignment |
| `HasDuration` | `'hasDuration'` | Temporal extent |
| `RecurringWith` | `'recurringWith'` | Cyclic temporal relationship |

### Advanced Spatial (9)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `ContainsSpatially` | `'containsSpatially'` | Spatial containment |
| `OverlapsSpatially` | `'overlapsSpatially'` | Spatial overlap |
| `Surrounds` | `'surrounds'` | Encirclement |
| `ConnectedTo` | `'connectedTo'` | Topological connection |
| `Above` | `'above'` | Vertical (superior position) |
| `Below` | `'below'` | Vertical (inferior position) |
| `Inside` | `'inside'` | Within containment boundaries |
| `Outside` | `'outside'` | Beyond containment boundaries |
| `Facing` | `'facing'` | Directional orientation |

### Social Structures (5)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Represents` | `'represents'` | Representative relationship |
| `Embodies` | `'embodies'` | Exemplification or personification |
| `Opposes` | `'opposes'` | Opposition relationship |
| `AlliesWith` | `'alliesWith'` | Alliance relationship |
| `ConformsTo` | `'conformsTo'` | Norm conformity |

### Measurement (4)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `MeasuredIn` | `'measuredIn'` | Unit relationship |
| `ConvertsTo` | `'convertsTo'` | Unit conversion |
| `HasMagnitude` | `'hasMagnitude'` | Quantitative value |
| `DimensionallyEquals` | `'dimensionallyEquals'` | Dimensional analysis |

### Change & Persistence (4)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `PersistsThrough` | `'persistsThrough'` | Persistence through change |
| `GainsProperty` | `'gainsProperty'` | Property acquisition |
| `LosesProperty` | `'losesProperty'` | Property loss |
| `RemainsSame` | `'remainsSame'` | Identity through time |

### Parthood Variations (4)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `FunctionalPartOf` | `'functionalPartOf'` | Functional component |
| `TopologicalPartOf` | `'topologicalPartOf'` | Spatial part |
| `TemporalPartOf` | `'temporalPartOf'` | Temporal slice |
| `ConceptualPartOf` | `'conceptualPartOf'` | Abstract decomposition |

### Dependency Variations (3)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `RigidlyDependsOn` | `'rigidlyDependsOn'` | Necessary dependency |
| `FunctionallyDependsOn` | `'functionallyDependsOn'` | Operational dependency |
| `HistoricallyDependsOn` | `'historicallyDependsOn'` | Causal history dependency |

### Meta-Level (4)

| VerbType | Value | Meaning |
|----------|-------|---------|
| `Endorses` | `'endorses'` | Second-order validation |
| `Contradicts` | `'contradicts'` | Logical contradiction |
| `Supports` | `'supports'` | Evidential support |
| `Supersedes` | `'supersedes'` | Replacement relationship |

## Coverage Completeness Analysis

### Is Anything Missing?

The taxonomy is intentionally bounded. When no type is an exact fit, three escape hatches keep it complete:

#### 1. Generic Fallbacks

- **`Custom` noun type**: For any entity that doesn't fit a standard type
- **`RelatedTo` verb type**: For any relationship not explicitly named
- **`subtype` + metadata**: Refine a base type with domain-specific semantics

#### 2. Semantic Flexibility Through Subtype & Metadata

Instead of adding ever more verb types, refine a base verb with a `subtype` and structured metadata:

```typescript
// "approves" → Evaluates with a result
await brain.relate({
  from: managerId,
  to: requestId,
  type: VerbType.Evaluates,
  subtype: 'approval',
  metadata: { result: 'approved', timestamp: Date.now() }
})

// "shares" → Communicates with an action
await brain.relate({
  from: userId,
  to: documentId,
  type: VerbType.Communicates,
  subtype: 'share',
  metadata: { permissions: 'read-only' }
})

// "delegates" → ParticipatesIn with a role + delegation metadata
await brain.relate({
  from: employeeId,
  to: taskId,
  type: VerbType.ParticipatesIn,
  subtype: 'delegate',
  metadata: { delegatedBy: managerId, authority: 'full' }
})
```

#### 3. Edge Cases Are Covered

Even exotic scenarios fit the standard types:

```typescript
// Quantum computing
const qubitId = await brain.add({
  data: 'Qubit-1',
  type: NounType.Thing,
  subtype: 'quantum-bit',
  metadata: { superposition: [0.707, 0.707] }
})

// Cryptocurrency transactions
const txId = await brain.add({
  data: 'Bitcoin Transfer',
  type: NounType.Event,
  subtype: 'blockchain-transaction',
  metadata: { hash: '1A2B3C...' }
})

// AI model training
const modelId = await brain.add({
  data: 'Neural Network',
  type: NounType.Process,
  subtype: 'ml-model',
  metadata: { architecture: 'transformer' }
})
```

### The Philosophy: Simplicity Over Specificity

A bounded type system stays learnable:
1. **A fixed vocabulary is easier to learn** than thousands of bespoke schemas
2. **Subtype + metadata provide open-ended extensibility**
3. **Consistent patterns** carry across domains
4. **No taxonomy explosion** as new use cases appear

## Industry-Specific Coverage Analysis

### Why 42 Nouns + 127 Verbs = Broad Coverage

The combination of **42 noun types** and **127 verb types** yields **5,334 base combinations**, and with subtypes, metadata, and multi-hop relationships that expands to cover essentially any domain. Here's how it maps onto common industries.

### Healthcare & Medical

```typescript
const patientId = await brain.add({
  data: 'John Doe',
  type: NounType.Person,
  subtype: 'patient',
  metadata: { mrn: '12345' }
})

const diagnosisId = await brain.add({
  data: 'Type 2 Diabetes',
  type: NounType.State,
  subtype: 'diagnosis',
  metadata: { icd10: 'E11.9' }
})

const medicationId = await brain.add({
  data: 'Metformin',
  type: NounType.Substance,
  subtype: 'medication',
  metadata: { dosage: '500mg' }
})

const doctorId = await brain.add({ data: 'Dr. Reyes', type: NounType.Person, subtype: 'physician' })

// Medical relationships
await brain.relate({ from: patientId, to: diagnosisId, type: VerbType.HasQuality, subtype: 'diagnosis' })
await brain.relate({ from: medicationId, to: diagnosisId, type: VerbType.Affects, subtype: 'treats' })
await brain.relate({ from: doctorId, to: patientId, type: VerbType.RelatedTo, subtype: 'treats' })
```

### Finance & Banking

```typescript
const accountId = await brain.add({
  data: 'Checking Account',
  type: NounType.Thing,
  subtype: 'account',
  metadata: { balance: 10000 }
})

const transactionId = await brain.add({
  data: 'Wire Transfer',
  type: NounType.Event,
  subtype: 'transaction',
  metadata: { amount: 5000 }
})

const regulationId = await brain.add({
  data: 'KYC Requirement',
  type: NounType.Regulation,
  subtype: 'compliance'
})

const customerId = await brain.add({ data: 'Account Holder', type: NounType.Person, subtype: 'customer' })

// Financial relationships
await brain.relate({ from: customerId, to: accountId, type: VerbType.Owns })
await brain.relate({ from: transactionId, to: accountId, type: VerbType.Modifies })
await brain.relate({ from: accountId, to: regulationId, type: VerbType.ConformsTo })
```

### Manufacturing & Supply Chain

```typescript
const factoryId = await brain.add({
  data: 'Plant #3',
  type: NounType.Location,
  subtype: 'facility'
})

const assemblyLineId = await brain.add({
  data: 'Assembly Line A',
  type: NounType.Process,
  subtype: 'production'
})

const componentId = await brain.add({
  data: 'Circuit Board v2',
  type: NounType.Thing,
  subtype: 'component'
})

const productId = await brain.add({ data: 'Controller Unit', type: NounType.Product })
const supplierId = await brain.add({ data: 'Acme Components', type: NounType.Organization, subtype: 'supplier' })

// Manufacturing relationships
await brain.relate({ from: assemblyLineId, to: componentId, type: VerbType.Creates })
await brain.relate({ from: componentId, to: productId, type: VerbType.PartOf })
await brain.relate({ from: supplierId, to: componentId, type: VerbType.RelatedTo, subtype: 'supplies' })
```

### Education & Learning

```typescript
const courseId = await brain.add({
  data: 'Machine Learning 101',
  type: NounType.Collection,
  subtype: 'course'
})

const lessonId = await brain.add({
  data: 'Neural Networks',
  type: NounType.Document,
  subtype: 'lesson'
})

const assessmentId = await brain.add({
  data: 'Final Exam',
  type: NounType.Event,
  subtype: 'assessment'
})

const studentId = await brain.add({ data: 'Student #88', type: NounType.Person, subtype: 'student' })

// Educational relationships
await brain.relate({ from: studentId, to: courseId, type: VerbType.MemberOf, subtype: 'enrolled' })
await brain.relate({ from: courseId, to: lessonId, type: VerbType.Contains })
await brain.relate({ from: studentId, to: assessmentId, type: VerbType.ParticipatesIn, subtype: 'completed' })
```

### Legal & Compliance

```typescript
const contractId = await brain.add({
  data: 'Service Agreement',
  type: NounType.Contract,
  subtype: 'service-agreement'
})

const clauseId = await brain.add({
  data: 'Liability Clause',
  type: NounType.Document,
  subtype: 'clause'
})

const caseId = await brain.add({
  data: 'Case #2024-1234',
  type: NounType.Event,
  subtype: 'legal-case'
})

const partyId = await brain.add({ data: 'Counterparty LLC', type: NounType.Organization })

// Legal relationships
await brain.relate({ from: contractId, to: clauseId, type: VerbType.Contains })
await brain.relate({ from: partyId, to: contractId, type: VerbType.RelatedTo, subtype: 'signatory' })
await brain.relate({ from: caseId, to: contractId, type: VerbType.References })
```

### Retail & E-commerce

```typescript
const productId = await brain.add({
  data: 'Wireless Earbuds',
  type: NounType.Product,
  metadata: { sku: 'WE-128-BLK' }
})

const cartId = await brain.add({
  data: 'Shopping Cart',
  type: NounType.Collection,
  subtype: 'cart'
})

const promotionId = await brain.add({
  data: 'Holiday Sale',
  type: NounType.Event,
  subtype: 'promotion'
})

const customerId = await brain.add({ data: 'Customer #5521', type: NounType.Person, subtype: 'customer' })

// Retail relationships
await brain.relate({ from: customerId, to: productId, type: VerbType.RelatedTo, subtype: 'view' })
await brain.relate({ from: cartId, to: productId, type: VerbType.Contains })
await brain.relate({ from: promotionId, to: productId, type: VerbType.Affects, subtype: 'applies' })
```

### Real Estate

```typescript
const propertyId = await brain.add({
  data: '123 Main St',
  type: NounType.Location,
  subtype: 'property'
})

const listingId = await brain.add({
  data: 'MLS #789',
  type: NounType.Document,
  subtype: 'listing'
})

const inspectionId = await brain.add({
  data: 'Home Inspection',
  type: NounType.Event,
  subtype: 'inspection'
})

const ownerId = await brain.add({ data: 'Property Owner', type: NounType.Person })

// Real estate relationships
await brain.relate({ from: ownerId, to: propertyId, type: VerbType.Owns })
await brain.relate({ from: listingId, to: propertyId, type: VerbType.Describes })
await brain.relate({ from: inspectionId, to: propertyId, type: VerbType.Evaluates })
```

### Government & Public Sector

```typescript
const citizenId = await brain.add({
  data: 'Citizen #123',
  type: NounType.Person,
  subtype: 'citizen'
})

const permitId = await brain.add({
  data: 'Building Permit',
  type: NounType.Document,
  subtype: 'permit'
})

const departmentId = await brain.add({
  data: 'Planning Dept',
  type: NounType.Organization,
  subtype: 'government'
})

const propertyId = await brain.add({ data: '500 Oak Ave', type: NounType.Location, subtype: 'property' })

// Government relationships
await brain.relate({ from: citizenId, to: permitId, type: VerbType.RelatedTo, subtype: 'request' })
await brain.relate({ from: departmentId, to: permitId, type: VerbType.Creates, subtype: 'issues' })
await brain.relate({ from: permitId, to: propertyId, type: VerbType.PermittedTo, subtype: 'authorizes' })
```

### Why This Covers Most Knowledge

#### 1. Structural Completeness

The noun-verb model forms a **graph structure** where:
- Any entity can be represented as a noun
- Any relationship can be represented as a verb
- Complex knowledge emerges from simple combinations

#### 2. Semantic Coverage

Most information falls into one of these categories:
- **Entities** (who, what, where) → Nouns
- **Actions/relations** (how, when, why) → Verbs
- **Attributes** (properties) → Metadata
- **Context** (conditions) → Graph structure

#### 3. Compositional Power

Simple types combine to represent complex knowledge:

```typescript
const researchPaper = await brain.add({ data: 'AI Ethics Study', type: NounType.Document })
const researcher = await brain.add({ data: 'Dr. Smith', type: NounType.Person })
const institution = await brain.add({ data: 'MIT', type: NounType.Organization })
const concept = await brain.add({ data: 'AI Ethics', type: NounType.Concept })

// A rich knowledge graph emerges from a handful of typed edges
await brain.relate({ from: researcher, to: researchPaper, type: VerbType.Creates })
await brain.relate({ from: researcher, to: institution, type: VerbType.MemberOf })
await brain.relate({ from: researchPaper, to: concept, type: VerbType.Describes })
await brain.relate({ from: institution, to: researchPaper, type: VerbType.Creates, subtype: 'publishes' })
```

#### 4. Domain Independence

The same types work across domains:

**Science:**
```typescript
const moleculeId = await brain.add({ data: 'H2O', type: NounType.Substance, metadata: { category: 'molecule' } })
const processId = await brain.add({ data: 'Photosynthesis', type: NounType.Process })
await brain.relate({ from: moleculeId, to: processId, type: VerbType.ParticipatesIn })
```

**Business:**
```typescript
const metricId = await brain.add({ data: 'Q3 Revenue', type: NounType.Measurement, metadata: { value: 10_000_000 } })
const teamId = await brain.add({ data: 'Sales Team', type: NounType.Organization })
await brain.relate({ from: teamId, to: metricId, type: VerbType.RelatedTo, subtype: 'achieves' })
```

**Social:**
```typescript
const personId = await brain.add({ data: 'John', type: NounType.Person })
const groupId = await brain.add({ data: 'Community Group', type: NounType.SocialGroup })
await brain.relate({ from: personId, to: groupId, type: VerbType.MemberOf })
```

#### 5. Temporal Coverage

Time lives in edge metadata, so past, present, and future all fit:

```typescript
// Past
await brain.relate({
  from: personId,
  to: companyId,
  type: VerbType.MemberOf,
  subtype: 'past-employment',
  metadata: { from: '2010', to: '2020' }
})

// Present
await brain.relate({
  from: personId,
  to: projectId,
  type: VerbType.ParticipatesIn,
  subtype: 'manager',
  metadata: { since: '2024-01-01' }
})

// Future
await brain.relate({
  from: eventId,
  to: venueId,
  type: VerbType.LocatedAt,
  metadata: { scheduledFor: '2025-06-15' }
})
```

#### 6. Hierarchical Representation

Every level of abstraction fits:

```typescript
// Micro level
await brain.add({ data: 'Electron', type: NounType.Thing, metadata: { scale: 'quantum' } })

// Macro level
await brain.add({ data: 'Solar System', type: NounType.Location, metadata: { scale: 'astronomical' } })

// Abstract level
await brain.add({ data: 'Justice', type: NounType.Concept, metadata: { domain: 'philosophy' } })
```

### Extensibility

While the core types cover most domains, you extend with `subtype` (and metadata) — never a schema migration:

```typescript
// Extend Person for the medical domain
await brain.add({
  data: 'Patient #12345',
  type: NounType.Person,
  subtype: 'patient',
  metadata: { medicalRecord: 'MR-12345' }
})

// Extend Document for the legal domain
await brain.add({
  data: 'Contract ABC',
  type: NounType.Document,
  subtype: 'contract',
  metadata: { jurisdiction: 'California' }
})

// Extend a verb with a domain-specific subtype + billing metadata
await brain.relate({
  from: lawyerId,
  to: contractId,
  type: VerbType.ParticipatesIn,
  subtype: 'negotiator',
  metadata: { billableHours: 10 }
})
```

### How the Taxonomy Stays Complete

The noun-verb model is designed to represent any knowledge that can be expressed as entities and relations:

1. **Storage**: Any data can be stored as nouns
2. **Relational**: Any relationship can be expressed as verbs
3. **Property**: Open-ended metadata captures all attributes
4. **Graph**: Multi-hop traversals express arbitrary complexity
5. **Temporal**: Date metadata handles all temporal aspects
6. **Semantic**: Vector embeddings capture meaning and similarity

#### The Composition Formula

```
Expressiveness = (42 nouns × 127 verbs) × metadata × graph depth
              = 5,334 base combinations × open-ended refinement
```

That composition lets Brainy represent:
- **Scientific Knowledge**: From quantum physics to molecular biology
- **Business Data**: From transactions to supply chains
- **Social Graphs**: From friendships to organizational hierarchies
- **Historical Records**: From events to archaeological findings
- **Creative Works**: From media metadata to story relationships
- **Technical Systems**: From software architecture to network topology
- **Personal Information**: From memories to preferences

### Real-World Proof: Unmappable Becomes Mappable

Even the most complex scenarios map naturally:

```typescript
// String Theory — high-dimensional physics
const braneId = await brain.add({
  data: 'D3-Brane',
  type: NounType.Concept,
  metadata: { dimensions: 11, vibrationalModes: ['0,1', '1,0', '2,1'] }
})

// Consciousness — the "hard problem" of philosophy
const qualiaId = await brain.add({
  data: 'Red Qualia',
  type: NounType.Concept,
  subtype: 'phenomenal-experience',
  metadata: { ineffable: true }
})

// Causal paradoxes
const futureEvent = await brain.add({
  data: 'Future Effect',
  type: NounType.Event,
  metadata: { temporalPosition: 'future' }
})
const pastCause = await brain.add({
  data: 'Past Cause',
  type: NounType.Event,
  metadata: { temporalPosition: 'past' }
})
await brain.relate({
  from: futureEvent,
  to: pastCause,
  type: VerbType.Causes,
  metadata: { paradoxType: 'bootstrap' }
})
```

If it exists, thinks, happens, or can be imagined — Brainy can model it.

## Migration from Traditional Models

### From Relational (SQL)

```typescript
// Instead of JOIN queries:
// SELECT * FROM users JOIN orders ON users.id = orders.user_id

// Use noun-verb relationships
const userId = await brain.add({ data: 'User', type: NounType.Person, metadata: { email: 'u@example.com' } })
const orderId = await brain.add({ data: 'Order #1', type: NounType.Event, subtype: 'order' })
await brain.relate({ from: userId, to: orderId, type: VerbType.Creates, subtype: 'placed' })

// Query naturally via the graph
const userOrders = await brain.find({
  type: NounType.Event,
  connected: { from: userId, via: VerbType.Creates }
})
```

### From Document (NoSQL)

```typescript
// Instead of embedded documents: { user: { orders: [...] } }

// Use explicit relationships
const userId = await brain.add({ data: 'User', type: NounType.Person })
for (const order of orders) {
  const orderId = await brain.add({ data: order.summary, type: NounType.Event, subtype: 'order' })
  await brain.relate({ from: userId, to: orderId, type: VerbType.Creates, subtype: 'placed' })
}
```

### From Graph Databases

```typescript
// Similar to a graph database, with added benefits:
// 1. Automatic vector embeddings for similarity
// 2. Natural language querying
// 3. Unified with metadata filtering

// Vector + graph in one query
const results = await brain.find({ query: 'users who bought similar products' })
```

## Conclusion

The Noun-Verb Taxonomy gives Brainy a natural, flexible, and powerful way to model any domain. By thinking in terms of entities (42 `NounType`s) and their relationships (127 `VerbType`s) — refined with `subtype` and metadata — you can build everything from simple data stores to complex knowledge graphs while keeping code clear and queries simple.

## See Also

- [Triple Intelligence](/docs/concepts/triple-intelligence)
- [Subtypes & Facets](/docs/guides/subtypes-and-facets)
- [The Find System](/docs/guides/find-system)
- [API Reference](/docs/api/reference)