Epistemology

Asks How does it know what it claims?

How a structure knows what it asserts, and on what authority. It turns on separating what licensed a design decision from what admits a fact: a published standard can justify a shape and can never establish that a particular thing happened. Models that blur this cite a standard as though it were evidence.

In this model A cited source licenses a commitment; a durable source reference admits a record. Research and governance are read as peers, after the Dublin Core distinction between what a thing was derived from and what it conforms to.

Represented by

The engineering standards that state this foundation directly, among the works the commitments stand on.

• PROV-O: The PROV OntologyW3C
• DCMI Metadata TermsDublin Core Metadata Initiative
• The FAIR Guiding Principles for scientific data management and stewardshipWilkinson et al., Scientific Data 3, 160018, 2016

Commitments it asks for — 23

• enforcedStore one canonical relationship assertion
• enforcedMake outcome quality, calculation method and attribution inspectable
• enforcedKeep concrete creative separate from its classifications
• enforcedDelivery custody is a named chain, not one vendor field
• enforcedA metric exists because a question needs it
• enforcedCreative form is constrained by where it is delivered
• enforcedProvenance and conformance are read apart
• enforcedA commitment says whether the build proves it
• enforcedA relationship says what kind of claim it makes
• enforcedA declared path must be walkable
• enforcedA move that cannot be counted is a picture
• enforcedA question the graph answers is declared, and walked
• enforcedThe proof runs without a hand
• enforcedThe design is measured, not asserted
• enforcedThe prose says what the registry says
• enforcedA view is one concept, over one primitive
• enforcedOne engine, and a second runtime of it is a port under proof
• enforcedAn answer the graph gives has an address
• enforcedA road declares its grain
• enforcedCause is read by a declared design
• enforcedEvery road answers a competency question
• enforcedA deliverable is a method the industry already writes
• enforcedA question in a reader’s words is answered with an address

What the build enforces — 25

• registry integritycanonical graph integrity
  Endpoints resolve, relationship triples are unique, and compositions remain acyclic where the model requires it.
• registry integritycalculation and projection integrity
  Formula inputs, metric composition, cardinality, and plan projections satisfy their declared contracts.
• registry integrityadmission and shape
  Every kind has a valid shape and evidence class, and every row keeps the admission its kind allows: a record names its source, an exemplar names none, and a world record states the public reference it stands on.
• registry integritystable identifiers
  Kind prefixes are unique, every row keeps the identity convention of its kind, and an identifier once retired is never reused: a kind writes each retirement down with its date and its reason, and every number below its highest is a row or a retirement.
• registry integritytyped relationships
  Every relationship has declared endpoint kinds and a governed cardinality.
• foundation integritycitation coverage
  Every kind, relationship and deliverable is licensed by a cited rule, every source is cited by at least one rule, and every foundation names, among the cited works, the standard that represents it.
• foundation integritygovernance classification
  Every rule declares whether a build check proves it; only an enforced rule names a check, every check is claimed by one, and no commitment or foundation states a count the model does not currently have.
• Every gate is claimed, and every claim resolvesGate coverage
  Every gate a commitment names is a check, a ring or an eval the law catalogs; and every gate the law catalogs is claimed by an enforced commitment, or says itself why nothing here can claim it.
• registry integrityrelational claim
  Every relationship declares what kind of claim it makes, a hedging verb claims no more than it says, a typing is always constitutive because it says what a thing is, one verb carries one claim, and no claim class sits unused.
• registry integrityspine integrity
  Every row of a kind the model leans on states the relationships that kind exists to carry, so a relationship declared across the registry and asserted nowhere is a failure rather than a thin line on a map.
• registry integrityjourney integrity
  Every journey begins at one of its own positions and carries at least one legal move, its positions sit on a contiguous run of rungs, and every position either has a move out or realises a condition another journey leaves from, so no journey is a picture and no position is a dead end.
• registry integrityrow participation
  Every row of a registry kind is touched by at least one relationship besides its own grounding, and every vocabulary is read by at least one filled relationship, so a record or construct nothing relates to, and a set of terms nothing uses, are failures rather than quiet rows.
• registry integritykernel integrity
  Every kind and relationship the kernel names is one the registries declare: a spine's verbs are verbs its kind states or is reached by, the metric derivation names specifications that exist, the contract-status escape names kinds that exist, and the grounding reaches kinds that exist, and the machine's kinds and verbs and the instrumenting kind are kinds and verbs the registries declare.
• registry integritymove propagation
  Every legal move between journey positions is triggered by an event that an instrument observes, and that instrument counts a reading a KPI carries, directly or through the formula that computes it, so a journey that names its moves can also count them and is a model rather than a funnel with arrows; and a move triggered by a window closing belongs to a journey that names the window it counts inactivity over.
• Every pattern is a shape the model can hold, and every kind is in onePattern integrity
  Every pattern's roles name kinds that exist and are named once; every edge is a declared relationship whose ends are its roles' kinds; the shape is connected and crosses no grounding, and a typing only where nothing leads on; a root, where declared, is the first role. A pattern with a root binds from some row, and every kind fills a role in some pattern.
• eval:lawsthe laws bite
  Every law refuses the breakage that is its own to refuse, every law has one, and every refusal the laws, the ledger law and the schema validator can make is reached by at least one: a sentence no breakage reaches is a sentence nobody has proved a gate can still say.
• eval:recordthe record is the build
  The committed graph, dates ledger, schemas, standards, editor mapping and the site's types are the build of the committed ground, byte for byte, and nothing a build writes is left uncommitted.
• eval:hostthe host is the build
  What the host serves is the build of a commit the rings passed: the tree clean, the run for that commit green, the build embedding that commit's graph; and once deployed, the origin answering as the build: the ground digest it serves the build's, a page and its files there, every former address answering with the status the law gives it, a bare name sent to its page, an address the graph does not have answering with the site's own page, the collector counting a signal the graph holds and refusing every other method, and the headers the host owes on every response.
• eval:enginethe engine agrees with itself
  The binder that runs while the graph is built and the binder that runs in a reader's browser find the same bindings: every pattern bound against the whole model to the same instances and the same rows in every role, the published example among them, and every view bound again from every row it answers from, row for row, and the port of the pattern law beside the browser's engine refuses every way a declared pattern can be broken exactly as the law does, and every question bound again from every row of its root kind finds an answer exactly where the build published one and nothing where it did not.
• ring:7the design ring
  The built stylesheet keeps the design system: every colour role clears the contrast the design declares on the surface it is read on, every colour token is measured by a pair or declared decorative with a reason, every band's colour clears its floor as chip text on the surfaces it sits on, no retired colour returns, and no type is set below the floor.
• ring:5the prose ring
  Every authored file says what the registry says: every named relationship exists, every count is the live count, and no word the model has retired survives anywhere, the site's own copy included.
• Every view binds declared patterns from one kindViews compose
  Every view names declared patterns, all asked from one kind, drawn in a way the law's pattern vocabulary declares, belonging to a declared deliverable, a table as one of its tabs and a job as work that produces it; and some row of that kind answers at least one of them. What a view touches is derived from its patterns, never listed beside them.
• ring:6the site ring
  The built site is the whole graph and nothing else: every page indexed, addressed by a label, self-contained and free of any private name; every structured-data identifier a subject the standards export wrote; every page unfurling to its own card, and every sitemap entry naming that card as its image; every journey with its SCXML twin; the sitemaps held to the graph; a graph under a megabyte. And the host held to the ground: the Worker serving the build as its assets and running first for every request; the allowlist and the redirect list it carries cut from the graph, every address the graph once answered to in the list with the status the law gives it and none of them a page; every endpoint served by the files it names; and the beacon sending to the collector's endpoint and nowhere else; every projection the law declares in the build, served by the files that say they serve it, and named in llms.txt; and the Worker reading the host's caching rules and owed headers from the law, writing none of its own; every answer a question carries a page where the walk is non-empty and nowhere else, its structured data naming exactly the rows the walk reached.
• registry integritygrain integrity
  Every relationship declares the grain it is asserted at, and a record road, a fact only an instance carries, is bounded below by zero, is required by no spine, and is walked by no question. The registry asserts a vocabulary road and holds it to its bound; a record road is the registry's declaration of a join a record must be able to make, and treating it as either an unfinished road or a fact about the kinds is the drift this refuses.
• registry integrityroads are walked
  Every relationship the registry declares, other than the grounding every kind makes, is walked by at least one pattern of its grain: a vocabulary road by a question or a shape, a record road by a record shape. A road no pattern walks answers no competency question, and a grammar that grows ahead of what is asked of it is the drift this refuses.