Frames

Someone tells you what matters to them, in words. To read a simulation against those words you have to turn some of them into measures and limits, and you lose something every time you do. The compiler keeps all three stages: the sentence the person said, the measure it became together with the loss, and the form the machine runs. When turning a sentence into a measure would mean making a decision that belongs to people, the compiler hands that decision back and gives you no reading at all.

Hover overTap an element for what it records.

Every claim is tagged with one of eight illocutionary forces. The term is J. L. Austin's: when you say something you are also doing something, and issuing a mandate does a different thing than telling a story. That tag decides what happens when a claim has no mapping. An assertion or a mandate left without a mapping stops the compiler and goes back to people, because it carries enforcement and the compiler cannot guess how you meant to enforce it. The other six go through with a warning.

A claim can also carry a logic modality, which says how you reason about it. Epistemic is about what is known or believed. Deontic is about what is required or permitted. Alethic is about what is necessary or possible. Force and modality vary on their own, so a mandate can be epistemic and a story can be deontic.

Hover overTap a statement type for what it does and what the compiler does when it has no mapping.

Each mapping ties one or more claims to one thing the machine can run: a limit, an objective or a gate. It has to declare three things about itself. The loss profile names what it dropped: dimensions, simplifications, known failure modes. The validity envelope says how far to trust it, with a confidence value, the gaps in its coverage, and the assumptions that would break it. The provenance says who made it, how, when and why, and whether anyone has reviewed it. If a mapping declares no loss, it is claiming nothing was lost, and you can challenge that like any other claim.

If you dispute a translation you can contest the mapping on its own and leave the claim and the computation alone. The model refuses a mapping that names a method but not its author or its date, so you can always trace a contested translation back to whoever made it.

Hover overTap a part of the mapping for what it declares in this example.

A constraint states a limit: a measure, a comparison and a threshold, plus a deontic operator and a tier. The operator is must, must not, should or may. The tier says what can happen under pressure. A non-negotiable constraint never gets relaxed, a preferred one gets relaxed with a warning, an aspirational one gets relaxed freely. The model refuses the pairs struck through below. An obligation or a prohibition cannot be aspirational, and a permission cannot be non-negotiable.

A limit is a line a result must not cross. A weight is a price at which crossing it becomes acceptable. A right that the applicable authority recognizes is applied as a limit and never turns into a weight. The frame names who asserts the right and which source recognizes it. The platform applies it inside the frame; it does not establish that the right exists.

An objective names a measure, a direction, a value space and a weight above zero. Objectives are where trade-offs happen. A capability gate allows, denies or requires one of the ten reasoning operations under a stated condition.

Hover overTap a cell for why the model accepts or refuses the pair, or a gate action for what it does.

Every limit and objective refers to a value space: minutes, vehicles per hour, a count of people, a category of land use. Each value space declares its measurement scale, and the model defines the four scales by the arithmetic each one supports. Names are the strict case. The compiler refuses to combine a nominal space with anything else, contract or no contract, because names support equality and membership and nothing more.

Any two other value spaces combine only under a commensuration contract, which names both spaces, the exchange rate, who authorized it and the community behind it. Without one, the compiler returns a deliberation result naming the pair, and CHOOSE, the operation that ranks options, drops off the list of what can still run. Minutes do not become money, or a sacred place, unless someone says so on the record.

Hover overTap a scale for the arithmetic it supports, or a cell for what the compiler did with that pair.

Compiling a frame returns either the executable representation or a deliberation result. The model refuses to build a result holding both, or neither, or one whose success flag disagrees with what it holds. A deliberation result tells you what the compiler declined to compute: the claims behind each trigger, who has standing to decide, the questions to put to them, and which operations can still run.

Four triggers produce one. Each tile below came from compiling a small frame when this page was built, and its card quotes the compiler's own question. A malformed frame is refused before either outcome, with an error naming the fault. Warnings travel with both outcomes.

Hover overTap a trigger for the compiler's own question, a warning or an error for its message, or a primitive for whether it can still run.

Apply a frame to a finished result and you get a record of what it could and could not evaluate. Every measure the frame names gets one of six dispositions, so you can tell a concern the result answered from one it had no measure for. If the result offers a measure no part of the frame asked about, that is listed on its own, as available and not examined. Set aside as irrelevant has no path that records it yet, because the frame model gives you no way to declare it.

Each limit is checked against the result and comes back binding, satisfied, violated or skipped, and a skipped limit names its reason. When a non-negotiable must or must-not limit cannot be checked, the record marks compliance as not established and treats the option as non-compliant for the decision. It records a violation only when the evidence shows one.

The record also says who shaped the frame: which groups contributed claims, how many of those claims became computations, which sovereign restrictions apply, and which affected groups contributed nothing, along with the basis for asserting that absence.

Hover overTap a disposition, a status or a skip reason for what it records.

Two frames are compared layer by layer. Claims in one only, in the other only, or held by both in different words. Mappings the same way. Then in the executable form: gates, value spaces, limits and objectives. The comparison records which layers diverge, and it reports two kinds of disagreement about measures: one both frames read but each translates with a different loss, and one that only a single frame reads at all.

Across more than two frames, the comparison sorts claims into those every frame holds, those only one holds, and those some hold. Where frames with independent sources land on the same threshold, it records the agreement and weights it by how independent those sources are.

Hover overTap a band or a concern for what the comparison found.

Every frame says who is asserting it. If it also claims to speak for a community, it records that, and the platform does not check it: the field is there so someone can ask the question later. A frame only speaks for a community when that community wrote the version or authorized it.

You identify a frame by what is in it, not by a name someone gave it. Take a digest of what the author wrote, a digest of what the compiler produced, and a note of which compiler turned one into the other: that is the frame's identity. The digests below belong to the worked example and were computed when this page was built. Signatures and governance fields sit outside that hash, so you can sign a frame without changing which frame it is.

You choose who can see it: keep it private, share it with named communities, or make it public. You also choose whether anyone may fork it. A fork has to say what it is arguing with: which layer, which elements, and why. Retiring a frame leaves it readable. Tombstoning is the heavier move, and the record keeps who in governance ordered it, their reason, and a digest of both.

Publishing a reading means signing it. The platform checks your signature against the keys you registered before it stores anything, and refuses a reading that is unsigned or whose signature does not check out.

Hover overTap a state, a digest or an access setting for what it means.