Inputs: the Prime Kernel (TPK)

The Principia Machina: map
Reading the diagrams Structure key Process key Definition of terms Roles
Reading by audience Start here: the walk through The operator's guide Tutorial: create a UUID Workspace Container (UWC) Public Recorder inputs Sponsors: your first agent
The specification Contents: parts, tables, diagrams TPS 0.5.0 (declared 2026-10-03, revision 8; machine-optimized text) Decisions (the foundations record, one line each)

Public Recorder inputs: a help set for the people who put things into The Principia Machina - authors of a new UWC, operators, and the declaring authority. It explains; the specification governs. Start at the index; for a guided walk from a blank file to a declared UWC, follow the tutorial. Agents read the agent-facing page instead.

The three zones and their digests. The Prime Kernel is the first zone. (diagram page.)

Purpose

What you write in the first zone of the Full Kernel, kind by kind and field by field.

Explains: TPS 0.1.0, revision 4 (declared final 2026-09-22); the zone schemas the declaring authority selected on 2026-09-22 (records D92.1, D98.1, D99.1, D100.1, and for units D103.1, D104.1, D105.1; schema 0.3.0), whose text enters TPS at revision 5, and the kernel tests and isomorphism checks selected the same day (D106.1, D107.1, D108.1; tpm_kernel_tests 0.2.0), whose text follows at the next TPS revision; TPC-PY as built 2026-09-22 (tpc_zone 0.3.0, tpc_units 0.1.0, tpc_tests 0.1.0; no TPC-PY version is declared yet) with check_draft 0.3.0; Generic Specification Guide 0.1.0, sections 3.1 and 3.6. Where this page and the specification differ, the specification governs.

What the Prime Kernel is

The Prime Kernel (TPK) is the axiomatic base of a UWC: its laws, assumptions, hard boundaries and constraints, the constants they use, and the degrees of freedom (DOF) they leave free. It is immutable once declared. Any change, even a typo, is a new UWC by copy-forward, so check it before you submit (TPS 2.1 and 2.2).

The six kinds

A TPK is one JSON object whose keys are kinds. A kind you do not need may be left out; that means it is empty.

Kind	What it holds	Fields you must give	Fields you may add
`DOF`	a degree of freedom the kernel leaves free	NAME, DIMENSION	none
`CONSTANT`	a named quantity	NAME, DIMENSION	VALUE, UNIT, UNCERTAINTY
`LAW`	a statement taken as given	NAME, STATEMENT, REFS	none
`ASSUMPTION`	one proposition taken as given for this UWC	NAME, PROPOSITION, REFS	none
`CONSTRAINT`	a restriction that removes or fixes one DOF	NAME, TARGET, ACTION, STATEMENT	VALUE, UNIT
`BOUNDARY`	where the kernel is not asserted to hold	NAME, PREDICATE, REFS	none

Write the kinds in any order in your file. The digest reads them in a fixed order, so the order you choose changes nothing.

The fields

NAME: Letters, digits and the underscore, not starting with a digit, ASCII only: k_s, A_lin, omega. A name must be unique across the whole TPK, not only within its kind. Greek letters are spelled out, because a Greek letter and a Latin look-alike would read as one name and resolve as two.
DIMENSION: The physical dimension, written in base dimensions with their exponents: L1 T-1 for a speed, M1 L1 T-2 for a force, 1 for a pure number. Always write the exponent, even when it is 1. The bases and the accepted forms are on Text and numbers.
REFS: The list of DOF and CONSTANT names the statement uses. Each must be a DOF or a CONSTANT of the same TPK; a law cannot cite a law, and no entry may cite itself. The checker cannot read your prose, so REFS is how it knows what a statement is about. That REFS names everything the prose uses is inspected by the declaring authority before declaring.
STATEMENT, PROPOSITION, PREDICATE: Prose, in any notation you like, subject to the text rules on Text and numbers. Keep each ASSUMPTION to one proposition: "the restoring force is linear in x" is one; "the force is linear and the mass is constant" is two, and should be two entries. The checker refuses an assumption visibly joined into two claims (T2, below).
VALUE, UNIT, UNCERTAINTY (on a CONSTANT): VALUE is a decimal written as a string, in quotes: "0.05". A VALUE needs a UNIT and a UNIT needs a VALUE. UNCERTAINTY needs a VALUE, is not negative, and is in the same UNIT. The UNIT is written in the unit form on Text and numbers and must have the constant's DIMENSION: a length may be in m, cm or au, never in s.
TARGET, ACTION, VALUE, UNIT (on a CONSTRAINT): TARGET is the one DOF the constraint acts on. ACTION is REMOVE or FIX. FIX needs a VALUE and a UNIT with the TARGET's dimension (1 for a dimensionless DOF, rad or deg for an angle); REMOVE takes neither. A restriction such as "tabletop only" or "no rotation" is written here, as a CONSTRAINT, never as a weakened manifold entry (TPS 2.3).

What is refused

The status fields STATE, SCRUTINY, RIDER, NOTE, CHECKS_OWED and RECORDS. They change over the UWC's life, so they belong in register records.
Any other field the kind does not list.

Both are refused, never silently dropped: text outside the digest would be text the chain does not cover.

The checks

T1 well-formedness runs first, in TPC-PY and, when it is built, in TPX. It checks that every entry has its fields and no others, that names are identifiers and unique, that every REFS and TARGET resolves to the right kind, that dimensions, decimals and units parse, that every unit has the dimension of what it measures, and that no entry cites itself.

If T1 passes, two more kernel tests run as the zone is entered (tpm_kernel_tests 0.2.0):

T2 atomicity, the part a machine can read: no assumption is joined into two claims at its top level. Refused: the words "and", "but" and "whereas" in any case, the phrase "as well as", the symbols & and ∧, a semicolon, a second sentence (a full stop, ! or ? followed by a space and a capital letter), and a list (a new line beginning with -, *, +, • or a number). Text inside closed brackets or closed quotation marks is not top level, so "linear in x (Hooke's range and below)" passes; brackets around the whole proposition are ignored, so "(A and B)" is still two claims. A bracket or quotation mark left open hides nothing (record D106.1).
T5 DOF yield: every DOF is named in the REFS of some law - a DOF no law names is idle - and every constraint's TARGET is named by some law, since a constraint on a DOF no law leaves free does nothing.

At the final pass, after the Measure Set is entered:

T3 consistency, over the constraints: no DOF is both removed and fixed, and none is fixed at two different values. Values are compared after conversion to SI, so "0 m" and "0 cm" agree and "0 m" and "2 cm" do not. Two values in units of different kind - a frequency in Hz against an angular speed in rad s-1 - cannot be compared and come back to you. T3 waits for the final pass because the depth it needs, S_MAX, is in the Measure Set.

What no machine reads yet stays with the declaring authority, who inspects it before declaring; each inspection is recorded as debt (TPS 2.2):

T2, the rest: whether each assumption really states one claim. The machine rule is a filter over English: it refuses "x lies between 0 and 1" (write 0 < x < 1), and it misses a comma splice or a word it does not list, such as "while" or "plus".
T3 over the laws and assumptions, to the depth S_MAX.
T4 dimensional homogeneity of each law. A law's STATEMENT is prose, so its dimensions cannot be read. The constraints' half of T4 is already in T1: a FIX's unit must have its TARGET's dimension.
T6 boundary closure: that each boundary is decided for every value of its DOF. Its other half - a boundary names only DOF and constants - is in T1.

An optional machine-readable form for laws and boundaries has been chosen (record D108.1). It will be built as its own step; for a draft that uses it, T4, T6 and part of T3 will then run by machine. Until then they are inspections.

Non-goals

The checks do not judge whether your laws are right, or consistent beyond the bounded search T3 makes. The kernel certifies completeness only against the DOF it yields: a degree of freedom the kernel failed to include is invisible to every check (TPS 2.2).

Worked example

The spring kernel: three DOF (position x, velocity v, height z), three constants (the mass, the spring stiffness, and the largest displacement for which the linear law is asserted), three laws, one assumption, one constraint that fixes z at 0, and one boundary.

{
  "TPK": {
    "DOF": [
      {"NAME": "x", "DIMENSION": "L1"},
      {"NAME": "v", "DIMENSION": "L1 T-1"},
      {"NAME": "z", "DIMENSION": "L1"}
    ],
    "CONSTANT": [
      {"NAME": "m", "DIMENSION": "M1"},
      {"NAME": "k_s", "DIMENSION": "M1 T-2"},
      {
        "NAME": "x_max",
        "DIMENSION": "L1",
        "VALUE": "0.05",
        "UNIT": "m",
        "UNCERTAINTY": "0.001"
      }
    ],
    "LAW": [
      {
        "NAME": "N2",
        "STATEMENT": "m dv/dt = -k_s x",
        "REFS": ["m", "v", "k_s", "x"]
      },
      {
        "NAME": "KIN",
        "STATEMENT": "dx/dt = v",
        "REFS": ["x", "v"]
      },
      {
        "NAME": "FREE_Z",
        "STATEMENT": "d2z/dt2 = 0",
        "REFS": ["z"]
      }
    ],
    "ASSUMPTION": [
      {
        "NAME": "A_lin",
        "PROPOSITION": "the restoring force is linear in x (Hooke régime)",
        "REFS": ["x"]
      }
    ],
    "CONSTRAINT": [
      {
        "NAME": "C_NOZ",
        "TARGET": "z",
        "ACTION": "FIX",
        "VALUE": "0",
        "UNIT": "m",
        "STATEMENT": "motion confined to z = 0"
      }
    ],
    "BOUNDARY": [
      {
        "NAME": "B_small",
        "PREDICATE": "|x| < x_max",
        "REFS": ["x", "x_max"]
      }
    ]
  }
}

C_NOZ fixes z, which FREE_Z would otherwise leave free, so the kernel yields motion along x only. B_small states where the kernel is asserted. The checker reports TPK PASS, T2 PASS and T5 PASS for this zone; step by step, it is built on tutorial step 2.

Governing sections: TPS 2.1, 2.2 and 2.5.

Previous: The new-container form. Next: The Translation Manifold.