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