Markdown for LLMs
Liberty and immunity: strong permission and effect-locking (+ weak permission as a query)
The source Markdown for this article. Copy it into your assistant or download it as a text file.
# Liberty and immunity: strong permission and effect-locking (+ weak permission as a query)
**In one sentence:** `liberty` is strong (explicit) permission with a holder,
an opponent, an action, and a window, taking part in a priority conflict with
a prohibition; `immunity` protects the holder against someone else's legal effect,
locking materialization without prohibiting the physical action; while weak
permission is not a norm at all but a `weakly_permitted` query result
relative to an explicitly chosen universe, snapshot, interpretation, and closure
policy. The author takes liberty when "may" must defeat a prohibition;
immunity — when "may not be subjected to"; the weak query — when asking
"is it prohibited?" with no permitting norm.
## 1. When to take it and when not to
| Instead | Selection rule |
|---|---|
| `liberty` vs weak permission | Liberty is a norm that creates a position and takes part in conflicts. A weak query computes "no prohibition" with no position. "May, and this must beat a prohibition" — liberty; "is it not prohibited?" — a query. Absence of a prohibition by default gives `UNDETERMINED`, not permission |
| `liberty` vs the other party's `prohibition` | Only liberty and forbearance over the same action conflict, for one subject with overlapping windows. Priority wins (`DEFEATED`); without it — `UNRESOLVED_NORMATIVE_CONFLICT`, both positions stand |
| `immunity` vs a prohibition on the organ | Immunity blocks the legal transformation (the effect never materializes) but does not necessarily prohibit the organ's physical action: an invalid exercise may factually happen with separate consequences. "May not arrest" — a prohibition; "an arrest produces no effect" — immunity |
| `immunity` vs `power` with `valid_when` | The pair is considered together: a power's effect materializes with established `exercise`, `valid_when`, window, and no applicable immunity. An undefeated pair is conservative effect materialization: the effect gets no support |
| `holder/against` vs `bearer/beneficiary` | Liberties and immunities have a `holder` and an `against` (against whom); duties and prohibitions have a `bearer` and a `beneficiary`. The party vocabulary distinguishes "who may / is protected" from "who shall / refrains" |
## Grammar: liberty and immunity (EBNF verbatim from the language grammar)
The `liberty` form — the holder, the opponent, the action, and the window (there is no goal):
```ebnf
liberty_conclusion = "liberty", [ identifier ], "{",
{ liberty_item },
"}" ;
liberty_item = "holder", expression, ";"
| "against", expression, ";"
| "action", expression, ";"
| "window", interval_expression, ";"
| source_anchor_item
| metadata_item ;
```
The `immunity` form — the holder, the opponent, the blocked effect, and the window:
```ebnf
immunity_conclusion = "immunity", [ identifier ], "{",
{ immunity_item },
"}" ;
immunity_item = "holder", expression, ";"
| "against", expression, ";"
| "protected_effect", legal_effect, ";"
| "window", interval_expression, ";"
| source_anchor_item
| metadata_item ;
```
Position statuses and lifecycle live on the [lifecycle page](/constructs/lifecycle-statuses/); windows as intervals and their computation — on the [deadline-calendar page](/constructs/deadline-calendar/); window syntax is not duplicated here.
## 2. Minimal example
Package `examples/may-withdraw/`: a customer may withdraw an order in the first ten
days of March 2026.
```law
rule WithdrawalRule strict {
for s: Supplier;
for c: Customer;
when contract_signed(s, c);
then liberty MayWithdraw {
holder c;
against s;
action withdraws(c, s);
window [@2026-03-01, @2026-03-10];
};
}
```
Case facts 01: `contract_signed(alpha, omega)`. Query:
`evaluate positions()` at `legal_time @2026-03-05`.
The engine's actual answer:
```text
law test research.liberty.may_withdraw: мир research.liberty.may_withdraw
ok [research.liberty.may_withdraw#authored] tests/01-inside-window-active.lawtest / urn:query:research-liberty-01
ok [research.liberty.may_withdraw#authored] tests/02-after-window-expired.lawtest / urn:query:research-liberty-02
итого: 2 проверено, 2 прошли, 0 не прошли, 0 не исполнены; код 0
```
`law engine check` — `check OK`, no warnings. Case 01 gives
`position(MayWithdraw, ACTIVE)` — inside the window the liberty holds.
Sensitivity is over time, not facts: the same case at
`legal_time @2026-03-15` gives `position(MayWithdraw, EXPIRED)` (file
`tests/02-after-window-expired.lawtest`). A liberty's window is a field of the norm itself:
before it starts — `CREATED`, inside — `ACTIVE`, after it ends — `EXPIRED`. A liberty is not
"breached" by use and not "performed" — it has no goal, only a window.
Second package `examples/no-penalty-force-majeure/` — a supplier's immunity from
a penalty under force majeure (`protected_effect penalty_imposed(c, s)`, window the whole
2026). A case with force majeure — `position(…, ACTIVE)`; without it — no position
(`expect not position(…, ACTIVE)`). Run — 2/2, `check OK`.
## 3. Example across domains
- **Law (constitution):** package `tr.constitution` — Constitution of Türkiye,
`then immunity InalienableFundamentalRights` under art. 12 (see
`corpus-forms.md`): "inalienable, unwaivable" read as immunity, not liberty — not
the holder's behaviour but the absence in any act of the force to
transfer the right. An exemplary liberty/immunity separation.
- **Law (constitution):** package `jp.constitution` — Constitution of Japan —
a minister's immunity from prosecution with the premier's
consent as an exception (`unless`) and priority over the prosecution
power: the immunity—power—priority bundle in one node.
- **Law (registry):** package `je.charities` — Jersey charities register —
`then liberty RequestEntryInRestrictedSection`: liberty to request
entry in a restricted register section — "may request" as strong permission.
- **Teaching cases:** `examples/may-withdraw/` (liberty with a window),
`examples/no-penalty-force-majeure/` (immunity shield).
## 4. How the engine answers
Table — actual runs of this directory's examples (query
`evaluate positions()`):
| Facts over the ground | Moment | Observation | Why |
|---|---|---|---|
| contract | inside the liberty window | `position(MayWithdraw, ACTIVE)` | the liberty window holds |
| contract | after the liberty window | `position(MayWithdraw, EXPIRED)` | the window is closed; a liberty has no goal — only a window |
| contract + force majeure | inside the window | `position(NoPenaltyUnderForceMajeure, ACTIVE)` | immunity created |
| contract | inside the window | `not position(NoPenaltyUnderForceMajeure, ACTIVE)` | the shield's ground is not established — no position |
| contract | before the liberty window | `position(MayWithdraw, CREATED)` | the window has not started yet |
- Three liberty-window states (`CREATED` before / `ACTIVE` inside / `EXPIRED`
after): two covered by runs.
- Power in two steps: the rule creates an `ACTIVE` position; the effect comes
only with `exercise` + `valid_when` + window + no immunity. Exercise
without `valid_when` is issue `POWER_INVALID_EXERCISE`, no effect; a judge in
`valid_when` is `REQUIRES_JUDGMENT`, not invalidity.
An undefeated power/immunity pair has its effect locked, `NEITHER` with
`UNRESOLVED_NORMATIVE_CONFLICT`: if the effect is locked anyway,
the judge is not asked.
- Weak permission was not queried in the examples: the
`weakly_permitted` query requires an explicit universe, snapshot, interpretation, and
closure policy.
## Correlates and discretion: views, not norms
Correlative constructs are query views and surfaces, not second instances:
`claim_right(holder, against, content)` is a view of a duty with cross-wired parties;
`liability` is a view of a power; `disability` is a view of an immunity.
The core creates no duplicates: views refer to one canonical position.
The reverse direction (`duty` → `claim_right`) is likewise view-only.
Discretion is not a fifth modality: it is rendered as a power with
several admissible exercises/effects, liberty of choice,
legality constraints/goals on the choice, and where needed evaluative
predicates (`reasonable`, `proportionate`). Whoever looks for a "right to choose"
looks first at the power + liberty + constraint bundle, not at a separate
form.
## 5. Common mistakes
1. Reading absence of a prohibition as permission: by default — `UNDETERMINED`,
not permission (see `pitfalls.md`).
2. Mixing up the parties: `bearer` on a liberty/immunity instead of `holder` — the party
vocabulary distinguishes the obliged from the entitled (see `pitfalls.md`).
3. Expecting a goal on a liberty: performance/breach are duty categories;
a liberty has only a window (see `pitfalls.md`).
4. Immunity as a prohibition on the organ: the effect is locked, not the action —
an invalid exercise may factually happen
(see `pitfalls.md`).
5. Liberty against a prohibition with no priority: `UNRESOLVED_NORMATIVE_CONFLICT`,
both positions stand (see `pitfalls.md`).
## 6. References
- The language specification defines liberty, weak permission, power,
immunity, correlative views, conflict, and statuses; this page states how to use them.
- Tutorials: `/tutorials/writing-tests/` (test observations).
- Details: `corpus-forms.md`, `pitfalls.md`, `boundaries.md`.