Verb Types

127 standardized relationship types. Combined with 42 Noun Types, this creates 5,334+ base combinations covering 96-97% of human knowledge domains.

Why Verb Types?

Verb Types define the semantic meaning of relationships between entities. They don't just connect things—they express how they're connected.

The 127 verbs cover:

• Mereological — Part-whole relationships
• Spatial — Location and position
• Temporal — Time and sequence
• Causal — Cause and effect
• Social — Human relationships
• Epistemic — Knowledge and belief
• Deontic — Obligation and permission
• And more...

Quick Reference

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

// Use the VerbType enum
await brain.relate({
  from: nextId,
  to: reactId,
  type: VerbType.Extends
})

// Or use string literals
await brain.relate({
  from: ideaId,
  to: resultId,
  type: "eventuallyLeadsTo"
})

Part-Whole (Mereological) — 8 types

How things are composed of other things:

Spatial — 11 types

Location and position relationships:

Temporal — 9 types

Time and sequence relationships:

Causal & Dependency — 14 types

Cause, effect, and dependency relationships:

Social & Organizational — 12 types

Human and organizational relationships:

Creation & Transformation — 10 types

How things are made and changed:

Epistemic (Knowledge & Belief) — 10 types

Knowledge, belief, and perception:

Deontic (Obligation & Permission) — 8 types

Rules, obligations, and permissions:

Classification & Description — 12 types

How things are categorized and described:

Comparison & Similarity — 8 types

Comparing and measuring relationships:

Technical & Code — 9 types

Software and technical relationships:

Property & Quality — 6 types

Properties and measurements:

General Relations — 10 types

General-purpose relationships:

Using Verb Types

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

// Create entities
const alice = await brain.add({
  data: "Alice - Senior Developer",
  type: NounType.Person
})

const team = await brain.add({
  data: "Engineering Team",
  type: NounType.Organization
})

// Create relationships with different verb types
await brain.relate({ from: alice, to: team, type: VerbType.MemberOf })
await brain.relate({ from: alice, to: bobId, type: VerbType.Mentors })
await brain.relate({ from: alice, to: projectId, type: VerbType.WorksWith })

Query by Relationship

// Find all things a person mentors
const mentees = await brain.find({
  connected: { from: aliceId, type: VerbType.Mentors }
})

// Find all dependencies of a project
const deps = await brain.find({
  connected: { from: projectId, type: VerbType.DependsOn }
})

// Traverse multiple relationship types
const network = await brain.find({
  connected: {
    from: userId,
    type: [VerbType.WorksWith, VerbType.FriendOf],
    depth: 2
  }
})

The Universal Protocol

The 127 Verb Types aren't arbitrary—they're based on formal ontology research:

• Mereology — Part-whole relationships (composedOf, partOf)
• Topology — Spatial relationships (above, inside, adjacent)
• Temporal logic — Time relationships (precedes, during)
• Causality — Cause and effect (causes, enables, prevents)
• Epistemology — Knowledge states (knows, believes, doubts)
• Deontic logic — Obligations (mustBe, permittedTo)

Combined with 42 Noun Types, this creates 5,334+ base combinations that achieve Stage 3 CANONICAL coverage: 96-97% of all human knowledge domains can be expressed with these types plus unlimited metadata.

See Also

• Noun Types — 42 entity types
• relate() — Creating relationships
• find() — Querying by relationships
• Triple Intelligence — Unified queries