# The meaning core After this chapter you will be able to state, in one sentence and without hedging, what this whole estate claims, and to say precisely what would have to be true for the claim to be wrong. Ten concepts. They are the smallest set from which everything else in this book can be derived, and one of them is the thesis the title carries. The move they make together is short enough to fit in a line: **stop asking what a thing declares itself to be, and start computing what it reaches.** Every other region of this atlas is a consequence of taking that seriously. The grammar exists because computing over edges requires the edges to say something. Anchors exist because two parties computing separately need something to compute toward. Confidence exists because a computation over a sparse graph should say so rather than guess. The fractal region exists because the same computation has to work at every size or the claim is a decoration. ## The region, drawn ``` MEANING THROUGH CONNECTIVITY ──▶ departs-from ── declared meaning ◀── grounds ── a node alone means nothing ◀── demonstrates ── the same value, differently connected ◀── requires ── properties carry data, never meaning ──▶ enables ── compatibility is computed, not declared ◀── bounds ── not a graph database pitch DECLARED MEANING ◀── contradicts ── discovered meaning ◀── names ── the Semantic Web's mistake ◀── refuses ── properties carry data, never meaning COMPATIBILITY IS COMPUTED, NOT DECLARED ◀── demonstrates ── the five Reviews ``` ## Where the argument starts, and why it starts there It starts with a negative. A node connected to nothing is meaningless, and the source says *literally*, not rhetorically. That is a strange place to begin a book, and it is the right one, because it is the only part of the argument that is not a preference. If a lone node did carry meaning, everything after it would be optional. The positive claim follows immediately and it is small: what a thing is emerges from the edges you can trace from it. Two variables in a Python program, both holding the number 8080, make the point without any philosophy. One reaches a plain integer and stops. The other reaches a type carrying a range constraint, which belongs to a library, at a pinned version, which has its own tests and licence and maintainer. The value is identical. The meaning is not, and the difference is entirely in what each one reaches. From there the region divides in two. On one side, **declared meaning**: a schema says what things are, in advance, and instances conform or fail. On the other, **discovered meaning**: you traverse, and what you find is the answer. The estate is not neutral between them, and its objection is narrower than it first sounds. It is not against schemas. It is against the direction of authority: a node that describes itself has smuggled the schema back in, which is the sentence the Semantic Web entry is built on. The last two entries in the region are the guard rails. **Properties carry data, never meaning** is the rule that stops the whole thing collapsing back into schema-first thinking by the back door, because a property that answers *what kind of thing is this* is a schema wearing a smaller hat. And **not a graph database pitch** is the disclaimer that keeps the claim falsifiable: this is about a grammar at a boundary, not about a store, and nothing here depends on where the bytes live. ## The entries ### meaning through connectivity {#meaning-through-connectivity} `concept` · **What a thing is emerges from the edges traceable from it, not from anything stored inside it.** > In a graph-first model, what something "is" emerges from the edges you can trace from it. > > — *Thinking in Graphs: Meaning Through Connectivity*, § Nodes Have No Obligation to Explain Themselves *Also called:* the thesis · the title after the colon *Near, but not:* semantic search, which infers meaning from similarity rather than deriving it from structure *The corpus also says it like this:* “meaning comes from edges” **Out.** This departs from [declared meaning](#declared-meaning). This enables [compatibility is computed, not declared](#compatibility-computed). This determines [the confidence ladder](#confidence-ladder). **In.** [A node alone means nothing](#node-alone-means-nothing) grounds this. [The same value, differently connected](#the-difference-is-connectivity) demonstrates this. [Properties carry data, never meaning](#properties-carry-data-not-meaning) requires this. [Not a graph database pitch](#not-a-graph-database-pitch) bounds this. [Join at the node layer](#junction-rule) implements this. [The network of sibling sites](#the-network) carries this. *Where it shows up:* The whole estate: it is the site's lead sentence and the book's subtitle. ``` a node alone means nothing · the same value, differently connected properties carry data, never meaning demonstrates, grounds, requires │ ▼ ╭──────────────────────────────────╮ │ MEANING THROUGH CONNECTIVITY │ ╰──────────────────────────────────╯ │ departs-from, determines, enables ▼ declared meaning · compatibility is computed, not declared the confidence ladder ``` ### a node alone means nothing {#node-alone-means-nothing} `claim` · **A node connected to nothing is meaningless, literally rather than rhetorically: there is nothing there to be right or wrong about. Anything can be a node, and being one obliges it to explain nothing.** > A node connected to nothing is meaningless — literally. > > — *Thinking in Graphs: Meaning Through Connectivity*, § Nodes Have No Obligation to Explain Themselves > **Everything is a node.** Nodes carry local properties but have no obligation to declare > what they are or how they should be used. > > — *Thinking in Graphs: Meaning Through Connectivity*, § Summary: Core Principles — everything is a node *Also called:* a node is just a node *Near, but not:* an empty node, which has a type and a place, and is therefore not the same thing **Out.** This grounds [meaning through connectivity](#meaning-through-connectivity). This grounds [a named absence beats a hidden one](#named-absence). This grounds [rich nodes are good](#rich-nodes-are-good). *Where it shows up:* The first idea of the first edition's altitude 1. ``` ╭────────────────────────────────╮ │ A NODE ALONE MEANS NOTHING │ ╰────────────────────────────────╯ │ grounds ▼ meaning through connectivity · a named absence beats a hidden one rich nodes are good ``` ### the same value, differently connected {#the-difference-is-connectivity} `example` · **Two variables both holding 8080 mean radically different things, because one reaches a type, a library and a pinned version and the other reaches nothing.** > **The difference is not in the value.** Both scenarios have `8080`. The difference is in the > **connectivity**. > > — *Thinking in Graphs: Meaning Through Connectivity*, § The Safe_UInt__Port Example *Also called:* the port example · the Safe_UInt__Port example **Out.** This demonstrates [meaning through connectivity](#meaning-through-connectivity). **In.** [The capability scale](#capability-scale) demonstrates this. *Where it shows up:* The on-ramp of the first edition's altitude 1; the sentence the capability scale reuses in a security register. ``` the capability scale demonstrates │ ▼ ╭───────────────────────────────────────────╮ │ THE SAME VALUE, DIFFERENTLY CONNECTED │ ╰───────────────────────────────────────────╯ │ demonstrates ▼ meaning through connectivity ``` ### declared meaning {#declared-meaning} `concept` · **Meaning asserted in advance by a schema, which instances either conform to or fail.** > The schema is the authority, and instances conform or fail validation. > > — *Thinking in Graphs: Meaning Through Connectivity*, § Meaning Is Not Declared — It Is Discovered *Also called:* schema-first *Near, but not:* having a schema at all: the objection is to the direction of authority, not to structure **In.** [Meaning through connectivity](#meaning-through-connectivity) departs from this. [Discovered meaning](#discovered-meaning) contradicts this. [The Semantic Web's mistake](#semantic-web-mistake) names this. [The anchor node](#anchor-node) refuses this. [Enrichment, not enforcement](#enrichment-not-enforcement) contradicts this. [Properties carry data, never meaning](#properties-carry-data-not-meaning) refuses this. *Where it shows up:* The position the whole estate takes a stand against. ``` meaning through connectivity · discovered meaning · the Semantic Web's mistake contradicts, departs-from, names │ ▼ ╭──────────────────────╮ │ DECLARED MEANING │ ╰──────────────────────╯ ``` ### discovered meaning {#discovered-meaning} `concept` · **Meaning determined at query time by traversing a node's edges, rather than read off its label.** > By traversing those edges, we can determine what this node relates to, what constraints > apply, and how confidently we can characterise it. > > — *Thinking in Graphs: Meaning Through Connectivity*, § Meaning Is Not Declared — It Is Discovered **Out.** This contradicts [declared meaning](#declared-meaning). This requires [every edge is a verb](#edge-is-a-verb). **In.** [Classification is a query, not a judgment](#node-type-formula) implements this. [The WCLM, a deterministic transformer](#wclm) implements this. *Where it shows up:* The WCLM's converge engine answers exactly this way: a meaning with the path that produced it. ``` classification is a query, not a judgment the WCLM, a deterministic transformer implements │ ▼ ╭────────────────────────╮ │ DISCOVERED MEANING │ ╰────────────────────────╯ │ contradicts, requires ▼ declared meaning · every edge is a verb ``` ### properties carry data, never meaning {#properties-carry-data-not-meaning} `position` · **A property may hold a timestamp; it may not hold the answer to what kind of thing this is, because that answer is a query over edges.** > in our graph we do not use properties, because properties do not have meaning, they are just > words; we capture meaning through connectivity. > > — *Digital Twins of Anything, and the Discipline of Reality*, § The Twin Is the Endpoint of the Graph *Also called:* properties are just words *Near, but not:* property graphs, which are a storage model rather than the objection **Out.** This requires [meaning through connectivity](#meaning-through-connectivity). This refuses [declared meaning](#declared-meaning). This requires [classification is a query, not a judgment](#node-type-formula). *Where it shows up:* Held even against the estate's own live typed property graph: 12 node types, 71 nodes, 141 edges. ``` ╭──────────────────────────────────────────╮ │ PROPERTIES CARRY DATA, NEVER MEANING │ ╰──────────────────────────────────────────╯ │ refuses, requires ▼ meaning through connectivity · declared meaning classification is a query, not a judgment ``` ### compatibility is computed, not declared {#compatibility-computed} `concept` · **Whether two things work together is a degree of subgraph overlap, asymmetric and purpose-relative, not a boolean somebody asserts.** > They are compatible to the degree that their subgraphs overlap when traced toward common > reference points. > > — *Thinking in Graphs: Meaning Through Connectivity*, § Compatibility Is a Graph Computation *Also called:* a spectrum, not a boolean *Near, but not:* conformance testing, which asks whether one thing matches a fixed target **Out.** This requires [the anchor node](#anchor-node). **In.** [Meaning through connectivity](#meaning-through-connectivity) enables this. [The five Reviews](#five-reviews) demonstrates this. [The anchor node](#anchor-node) enables this. [The cross-graph edge](#cross-graph-edge) enables this. *Where it shows up:* The five Reviews; the compatibility-testing design across five artefact layers. ``` meaning through connectivity · the five Reviews · the anchor node demonstrates, enables │ ▼ ╭─────────────────────────────────────────────╮ │ COMPATIBILITY IS COMPUTED, NOT DECLARED │ ╰─────────────────────────────────────────────╯ │ requires ▼ the anchor node ``` ### the five Reviews {#five-reviews} `example` · **Five organisations each call something a Review; no definition can be agreed, and the overlap is computable anyway, because the common ground is discovered in the graph rather than imposed on it.** > Consider five different teams, each with a process they call "Review": > > — *Thinking in Graphs: Meaning Through Connectivity*, § The Review Example > The common ground was *discovered* in the graph, not *imposed* on it. > > — *Thinking in Graphs: Meaning Through Connectivity*, § Finding Common Ground Through Graph Analysis — common ground is discovered, not imposed **Out.** This demonstrates [compatibility is computed, not declared](#compatibility-computed). This demonstrates [merging erases the disagreement](#dont-merge-vocabularies). This demonstrates [we know X, we think Y, we cannot confirm Z](#honest-uncertainty). *Where it shows up:* The best on-ramp in the material, and the one to try on a sceptical colleague. ``` ╭──────────────────────╮ │ THE FIVE REVIEWS │ ╰──────────────────────╯ │ demonstrates ▼ compatibility is computed, not declared · merging erases the disagreement we know X, we think Y, we cannot confirm Z ``` ### the Semantic Web's mistake {#semantic-web-mistake} `position` · **The right problem was identified two decades early; the error was attaching meaning to nodes instead of deriving it from edges.** > They ended up attaching meaning *to nodes* rather than deriving meaning *from edges*. > > — *Thinking in Graphs: Meaning Through Connectivity*, § The Semantic Web's Insight (and Mistake) *Also called:* schema-first thinking dressed in graph syntax **Out.** This names [declared meaning](#declared-meaning). This grounds [the anchor node](#anchor-node). *Where it shows up:* The disagreement is with a practice, not with RDF as a serialisation: the live regulation graph exports RDF/Turtle. ``` ╭────────────────────────────────╮ │ THE SEMANTIC WEB'S MISTAKE │ ╰────────────────────────────────╯ │ grounds, names ▼ declared meaning · the anchor node ``` ### not a graph database pitch {#not-a-graph-database-pitch} `position` · **This is the third use of graphs, semantics, not the first two: network analysis and fast joins. The store is an implementation detail.** > This book is about use 3, which is why the disclaimer is stated up front: **not a graph > database pitch.** > > — *Why graphs at all*, § Three different things people mean by graph **Out.** This bounds [meaning through connectivity](#meaning-through-connectivity). This carries [what ships, what is argued](#what-ships-what-is-argued). **In.** [The file system is the source of truth](#file-system-is-the-source-of-truth) refuses this. *Where it shows up:* Carried verbatim into every summary the estate publishes, including llms.txt. ``` the file system is the source of truth refuses │ ▼ ╭────────────────────────────────╮ │ NOT A GRAPH DATABASE PITCH │ ╰────────────────────────────────╯ │ bounds, carries ▼ meaning through connectivity · what ships, what is argued ``` ## Where the estate demonstrates this The five Reviews is the on-ramp: five organisations, five processes, one word, and a precise answer to *did somebody other than the author look at this* without anyone agreeing on anything. It is the first thing to try on a sceptical colleague and it is carried in full in the first edition's altitude 1. The port example is the same claim in six lines of real shipped Python, and it is the one that lands with engineers, because they have written both of those lines and never thought of them as different graphs. And the sharpest version is not in the argument at all. It is in the estate's capability scale, where five published vaults declare what they may reach, and two apps with identical code turn out to be different things because their permission blocks differ. The sentence works unchanged in both registers: the difference is not in the value, it is in the connectivity.