Markdown for LLMs

Priority: boundaries

The source Markdown for this article. Copy it into your assistant or download it as a text file.

# Priority: boundaries

What the construct does NOT do in 0.2: limits, closed lists,
neighbouring constructs, and the selection rule.

## Does not do

- **Does not infer speciality.** Number of conditions, date of adoption, and
  act level decide nothing on their own: the ground is given by
  an explicit relation with a `reason`. Without the edge — Contradiction, and that
  is correct.
- **Does not touch strict supports.** Nobody defeats strict support:
  priority over a strict rule is a rejection `LDC-E4105`; a conflict
  of two strict rules is preserved as Contradiction forever.
- **Does not assert for the defeater.** A defeater only blocks:
  it does not support the target’s complement; after defeat — Not established, not refuted.
- **Does not pick “latest/first”.** Rule writing order means nothing: only
  the declared order wins — a strict partial order with transitive
  closure.
- **Does not break rings at runtime.** A ring of conditional priorities gives
  `PRIORITY_CONFLICT` with both sides preserved: no tie-break,
  “victory in a circle” is impossible.
- **Does not collide same polarity.** Two inferences of one relation are not
  opposite under any arguments; an edge between them is warning
  `LDC-E2142`, except the live chain edge of an `unless` chain.

## Reserved and closed

- Exactly one `prefer A over B` edge per declaration: without
  `prefer` or on repeat — `LDC-E0201` (body element order is free,
  but `prefer` uniqueness is a static check).
- `reason` is the named ground; the list of grounds is open per
  profile, but the corpus holds to five (`lex_specialis`,
  `explicit_exception`, `lex_superior`, `lex_posterior`,
  `constitutional_exception`).
- In a conditional priority, `higher` and `lower` are implicit meta-variables
  of type `RuleApplication`; the `$higher` spelling of earlier
  editions is rejected by the lexer. The engine publishes
  `conflicts(higher, lower)` as `urn:law:std#conflicts`.
- A defeater with `defeat not p(x)` is rejected by the parser
  (`LDC-E0201`): a defeater against a negative head is inexpressible.
- A contrary proviso on a norm head (`unless C then not duty …`) is
  undefined and rejected at lowering: a position has no complement.
  A bare proviso is lawful and gives a defeated position.

## Neighbours and selection rule

- `priority` vs `unless`: a collision of standalone norms is an edge; a
  local exception of an article is a clause. See the
  [defeasible-rules page](/constructs/rule-defeasible-unless/).
- `priority` vs a strict negative head: a prohibition without exceptions is
  stronger on its own; no edge needed and forbidden (`LDC-E4105`).
- `priority` vs `priority policy`: a pinpoint edge between rules is an
  ordinary collision; a policy over the meta-domain of applications
  is an act hierarchy.
- `lex_specialis` vs `lex_posterior`: speciality is about norm
  scope, posterior about time; both only as an explicit `reason`, never
  automatic.
- Defeat of a position makes it defeated: the position is
  visible but publishes nothing. See the
  [lifecycle statuses page](/constructs/lifecycle-statuses/).