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

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

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

// 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

// 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

// 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

// 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

// 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:

// 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:

// 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

// 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:

// 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:

// 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:

// 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:

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

// 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

// 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

// 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

// 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

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

Weighted Relationships

// 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)

// 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:

// 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

// 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)

// 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)

// 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.

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).

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:

// "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:

// 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

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

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

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

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

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

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

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

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:

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:

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:

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:

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:

// 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:

// 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:

// 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:

// 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)

// 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)

// 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

// 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 NounTypes) and their relationships (127 VerbTypes) — 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
• Subtypes & Facets
• The Find System
• API Reference