# 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`.