Markdown for LLMs
Readings: interpretation, group, selection and pin
The source Markdown for this article. Copy it into your assistant or download it as a text file.
# Readings: interpretation, group, selection and pin
**In one sentence:** `interpretation` packs a disputed chunk of theory —
rules, priorities, definitions — into a named reading of a document;
`interpretation_group` declares the fork (`exactly_one` / `any_of` /
`compose_explicitly`), and the case context (`interpretation Name;`) selects
which reading applies. The author takes them when one text reads
several ways: a narrow and a broad reading of an article, literal versus court.
A reading packs a disputed chunk of theory — rules, priorities, definitions —
into a named variant of a document; a group declares the fork, and the case
context selects which variant applies. This catalogue records the practice first.
## 1. When to take it and when not to
| Instead | Selection rule |
|---|---|
| Two separate packages vs two readings | A dispute over reading one document is two `interpretation`s in one package with a group; different documents are different packages. A reading lives next to its pinned primary source (`of Fragment`) |
| `include R` vs a nested `rule` | A ready rule takes part in a reading — `include R` (brings the whole canonical expansion: `R/alt/N`, `R/unless/N`, `R/norm/*`, `R/head/N`). A rule written for the reading's sake — a nested `rule` (the reading's namespace) |
| `status disputed` vs a group | A status selects nothing: a "disputed" reading with no group always applies. A fork with a choice is only an `interpretation_group`; a status is metadata for the jurisdiction profile |
| `exactly_one` vs `any_of` | One right answer, choice mandatory — `exactly_one` (without a choice the dependent queries get `INTERPRETATION_REQUIRED`). Both readings admissible at once — `any_of` (the corpus pairs below are built this way) |
| A reading vs `priority` | Different readings of one norm are readings. A clash of two operative norms is priority. A reading does not rank; priority does not construe |
| A reading vs the judgment channel | An evaluative feature ("excessive", "material") is a judge or a court fact; a dispute over a norm's meaning is a reading. Do not confuse: the judge decides a fact, the reading decides the theory |
## 2. Minimal example
Package `examples/two-readings/`: a filing fee reads two ways —
literal (standard) and court (reduced). Full code —
`examples/two-readings/package.law`.
```law
interpretation Literal {
status reviewed;
rule QLiteral strict {
for c: Case;
when filed(c);
then standard_rate(c);
}
}
interpretation Court {
status reviewed;
rule QCourt strict {
for c: Case;
when filed(c);
then reduced_rate(c);
}
}
interpretation_group MeaningOfRate {
alternatives Literal, Court;
selection exactly_one;
}
```
Case facts: `filed(alpha)`. Selection: the context line
`interpretation Literal;`. Query:
`evaluate truth(standard_rate(alpha))`.
The engine's actual answer:
```text
law test research.constructs.interp_readings: мир research.constructs.interp_readings
ok [research.constructs.interp_readings#authored] tests/01-literal-selected.lawtest / urn:query:research-interp-01
ok [research.constructs.interp_readings#authored] tests/02-court-selected.lawtest / urn:query:research-interp-02
итого: 2 проверено, 2 прошли, 0 не прошли, 0 не исполнены; код 0
```
`law engine check` — `check OK`, no warnings. Sensitivity:
replacing `interpretation Literal;` with `interpretation Court;` for the same
query changes the answer from `TRUE_ONLY` to `NEITHER` (rule `QLiteral`
blocked, another reading selected); deleting the selection line gives
`INTERPRETATION_REQUIRED` — held by the second package
`examples/unresolved-group/tests/01-dependent-blocked.lawtest` on the same
form. Every fact and every context line load-bearing.
Nearest wrong outcome: expecting that without a choice "the first"
reading wins — no: with `exactly_one` and no choice a dependent query
answers nothing at all; the language has no "first/last" order.
## 3. Example across domains
- **Law:** narrow and broad readings of the Turkish Constitution's art. 13 proviso —
package `tr.constitution` — Constitution of Türkiye
(`NarrowGroundReading` / `BroadGroundReading`, both `status disputed`,
group `RestrictionGroundReading`, policy `any_of`; the broad one includes
rule `GroundStatedAnywhereInConstitution`). The "relevant
article = the right's own article vs any article" fork is the canonical subject
of readings (see `corpus-forms.md`).
- **Law:** Iran's Guardian Council supervision —
package `ir.constitution` — Constitution of Iran
(`ApprobatorySupervision` / `InformationalSupervisionReading`, both
`disputed`, `any_of` group): approbatory vs informational supervision.
- **History/custom:** the Yasa's tolerance —
package `mng.corpus.yasa` — the Mongol Yasa
(`TolerationAsCommandReading` / `TolerationAsPracticeReading`,
`any_of` group): command vs practice; three more groups of the same fork form nearby
(`ServiceScopeReadings`, `HorseTheftReadings`).
- **Law:** DPRK Constitution collectivism —
package `kp.constitution` — Constitution of the DPRK
(declarative ground vs exercise condition,
`exactly_one` group): the same form with a mandatory selection policy.
- **Teaching case:** `examples/unresolved-group/` — the same fork plus
a base `BaseRegister` rule outside the readings: a dependent query without
a choice is `INTERPRETATION_REQUIRED`, an independent one is `TRUE_ONLY` +
`COMPUTED`.
## 4. How the engine answers
Table — actual runs of this directory's examples:
| Context | Question | Answer | Why |
|---|---|---|---|
| `interpretation Literal` | `standard_rate` | `TRUE_ONLY` + `COMPUTED` | the selected reading activates its nodes |
| `interpretation Court` | `reduced_rate` | `TRUE_ONLY` + `COMPUTED` | the same for the second alternative |
| `interpretation Court` | `standard_rate` | `NEITHER` | `QLiteral` blocked: another reading selected |
| no choice (`exactly_one`) | `standard_rate` | `INTERPRETATION_REQUIRED` | the group unresolved, the query depends on it |
| no choice (`exactly_one`) | `case_open` (base theory) | `TRUE_ONLY` + `COMPUTED` | the query is independent of the group; demanding a choice answers the wrong question |
- `INTERPRETATION_REQUIRED` is a RESULT status, not a document one:
only dependent queries get it. Dependence is
the closure over rule bodies from the blocked alternatives' heads (the same
edge extractor as stratification): direct
production, transit through intermediate rules,
head-reading by alternatives,
`collect`-dependence, positional dependence.
- The `INTERPRETATION_REQUIRED` issue stays in the document even with
an independent answer — it is a fact about the input.
- `status` (`proposed` … `binding` … `rejected`) alone
selects nothing: the selection policy is set by the jurisdiction profile, not
the reading.
- Cross-rule checks (cycle, late producer,
priorities, defeater goal) run membership-aware:
a cycle across two alternatives of one `exactly_one` group
is statically unreported — it cannot realize.
## 5. Common mistakes
1. `include R` brought a rule without its generated nodes — previously;
today the whole canonical expansion comes in (see `pitfalls.md`).
2. A qualified `include pkg::R` is rejected: an import carries
the interface, not nodes; another's rule takes part through the owner's `pub
interpretation` and `extends`/`alternatives`
(see `pitfalls.md`).
3. A nested rule with an unbound head lived to runtime — previously;
today nested members are checked with the same
`LDC-E4101` code under the lowering name (see `pitfalls.md`).
4. `status disputed` with no group — the reading always applies: status does not
select (see `pitfalls.md`).
5. Expecting an answer "under the first" with no choice — with `exactly_one` a dependent
query gives `INTERPRETATION_REQUIRED`, not the first alternative's answer
(see `pitfalls.md`).
6. An independent query extinguished with the document — previously;
today it gets `COMPUTED` and its `truthStatus` (see `pitfalls.md`).
7. `exclude` without `extends` removes the wrong thing: `exclude R` removes the same
expansion that `include R` brings (see `pitfalls.md`).
## 6. References
- The language specification defines readings, the `include` expansion, nesting,
status, groups, evaluating alternatives, `extends`, conflicting editions,
and the context axis; this page states how to use them.
- Details: `corpus-forms.md`, `pitfalls.md`, `boundaries.md`.