Liberty and immunity: strong permission and effect-locking (+ weak permission as a query)

For LLMs8 sections

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)

Show syntax reference

The liberty form — the holder, the opponent, the action, and the window (there is no goal):

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:

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; windows as intervals and their computation — on the deadline-calendar page; 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.

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:

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

Reading absence of a prohibition as permission: by default — UNDETERMINED, not permission (see pitfalls.md).
Mixing up the parties: bearer on a liberty/immunity instead of holder — the party vocabulary distinguishes the obliged from the entitled (see pitfalls.md).
Expecting a goal on a liberty: performance/breach are duty categories; a liberty has only a window (see pitfalls.md).
Immunity as a prohibition on the organ: the effect is locked, not the action — an invalid exercise may factually happen (see pitfalls.md).
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.

Documentation for Arxo. Writings — blog.arxo.io.

Anonymous visit counts on stats.arxo.io, no cookies.