docs← Back to article

Markdown for LLMs

Ban, liberty, power, and immunity

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

Download this articlePlain text ↗
# Ban, liberty, power, and immunity

Duty is one of four modalities. Law also bans, permits, empowers
changing another's position, and shields from such power. In the corpus
`prohibition` occurs 931 times, `power` 482, `liberty` 422, `immunity`
114 (measured 05.09.2026). Three of the four behave other than intuition
suggests: a ban is not violated by itself, a liberty derives nothing, and
a power fires only in two steps.

The Archive of Veliky Ustin: photography is banned in the rare-collections
room, a researcher may request a visit extension, the director may fine
for damage and revoke accreditation on the ethics committee's finding,
while one who reported damage herself is shielded from the fine.

```law
language "law.core" version "0.2";
package tutorial.archive version "0.7.0";
namespace "urn:law:tutorial:archive";

entity Person;
entity Official;

relation in_researcher_registry(p: Person) kind institutional;
relation visit_registered(p: Person, from: Date, to: Date) kind empirical { key(p); }
relation photographs(p: Person) kind empirical;
relation no_photography(p: Person) kind institutional;
relation requests_extension(p: Person) kind empirical;
relation director(d: Official) kind institutional;
relation revocation_order(d: Official, p: Person) kind empirical;
relation accreditation_revoked(p: Person) kind institutional;
relation fine_order(d: Official, p: Person) kind empirical;
relation damage_recorded(p: Person) kind empirical;
relation fine_imposed(p: Person) kind institutional;
relation self_reported_damage(p: Person) kind empirical;
external judgment relation ethics_breach(p: Person) {
    authority Commission;
}
```

## A ban that is not violated by itself

A ban is sugar over a duty with a forbearance aim: "not to perform an
action in a window".

```law
rule NoPhotographyRule strict {
    for p: Person;
    for from, to: Date;
    when visit_registered(p, from, to);
    then prohibition NoPhotography {
        bearer p;
        action photographs(p);
        window [from, to];
    };
}
```

| `legal_time` | Facts beyond the visit | `NoPhotography` |
|---|---|---|
| 15 March | photography | `ACTIVE` |
| 10 April | photography | `EXPIRED` |

The reader photographed inside the window, yet the ban stayed `ACTIVE`.
This is no defect of the example: forbearance means
maintaining the action's absence, but the core draws no such conclusion —
an established fact of action inside the window does not read as
a violation, and after the window the position simply expires. A ban in
the corpus is needed for something else: weak permission and
conflict with a liberty over the same action.

A ban's violation is written as a **paired maintenance duty** with
a condition that has a negative-support producer — the same device as
with duty and negation:

```law
rule NoPhotographyDuty strict {
    for p: Person;
    for from, to: Date;
    when visit_registered(p, from, to);
    then duty KeepNoPhotography {
        bearer p;
        goal maintenance {
            condition no_photography(p);
            window [from, to];
        }
    };
}

rule PhotographyBreaks strict {
    for p: Person;
    when photographs(p);
    then not no_photography(p);
}
```

| `legal_time` | Facts beyond the visit | `KeepNoPhotography` |
|---|---|---|
| 15 March | photography | `VIOLATED` |
| 15 March | — | `ACTIVE` |

The ban is kept alongside: one construction says the action is banned,
the other that performing it yields a violation.

## Liberty

Liberty is a strong permission: the action is allowed to the
holder, and nobody may hinder her. It derives not a fact but a position
with three window states.

```law
rule ExtensionLiberty strict {
    for p: Person;
    for from, to: Date;
    when visit_registered(p, from, to);
    then liberty MayRequestExtension {
        holder p;
        action requests_extension(p);
        window [from, to];
    };
}
```

| `legal_time` | `MayRequestExtension` |
|---|---|
| 15 February | `CREATED` |
| 15 March | `ACTIVE` |
| 10 April | `EXPIRED` |

Asking "may Ivanova request an extension" means asking a position's
status, not a predicate's truth. A liberty, like a ban, has neither
`SATISFIED` nor `VIOLATED`: it is not fulfilled or violated but used or
not. A liberty's `against` is optional; when named, it is the one who
may not hinder.

## Power in two steps

Power is the authority to change another's legal position. It
fires in two steps: a rule creates the position, while the effect
materialises only when both the exercise and the validity condition are
established.

```law
rule FinePower strict {
    for d: Official;
    for p: Person;
    when director(d) and in_researcher_registry(p);
    then power ImposeFine {
        holder d;
        over p;
        exercise fine_order(d, p);
        valid_when damage_recorded(p);
        effect create(fine_imposed(p));
    };
}
```

Four fields are mandatory: `holder` — who is empowered; `exercise` —
the exercise event, here the director's order; `valid_when` — the
validity condition, here the damage record; `effect` — what is created.
`over` is the subjected one, and the rule must bind her: a power "over
someone" with no value source for that someone is rejected by the
compiler.

| Facts | `fine_imposed` | Document |
|---|---|---|
| order and record | `TRUE_ONLY` | — |
| order only | `NEITHER` | issue `POWER_INVALID_EXERCISE` |
| record only | `NEITHER` | — |

The first row is the test from this page, byte for byte:

```law
test "штраф: приказ при акте о повреждении — штраф наложен" {
    given {
        context {
            decision_time @2026-05-01T09:00:00+05:00;
            knowledge_time @2026-05-01T09:00:00+05:00;
            legal_time @2026-03-15;
            timezone "Asia/Almaty";
        }
        assert in_researcher_registry(entity_ref("urn:tutorial:ivanova")) {
            id "assert-reg";
            origin case_input;
        }
        assert director(entity_ref("urn:tutorial:director")) {
            id "assert-director";
            origin case_input;
        }
        assert fine_order(entity_ref("urn:tutorial:director"), entity_ref("urn:tutorial:ivanova")) {
            id "assert-fine";
            origin case_input;
        }
        assert damage_recorded(entity_ref("urn:tutorial:ivanova")) {
            id "assert-damage";
            origin case_input;
        }
    }
    evaluate truth(fine_imposed(entity_ref("urn:tutorial:ivanova")));
    expect truth_status == TRUE_ONLY;
    expect evaluation_status == COMPUTED;
}
```

The test name reads: "Fine: an order with a damage record — the fine is imposed."

The second and third rows differ not in the answer but in the document.
An order without grounds is an invalid exercise, and the document
carries the `POWER_INVALID_EXERCISE` issue: the director acted but had
no right to. Grounds without an order mean the power was simply not
exercised, and there is nothing to complain of. Both rows are pinned by
scenes with an exact issue composition.

## When the ground is not the engine's to decide

Revoking accreditation is valid upon an ethics breach, and the breach is
established by the committee. The validity condition is a judgment
relation, and the engine does not decide for the committee.

```law
rule RevocationPower strict {
    for d: Official;
    for p: Person;
    when director(d) and in_researcher_registry(p);
    then power RevokeAccreditation {
        holder d;
        over p;
        exercise revocation_order(d, p);
        valid_when ethics_breach(p);
        effect create(accreditation_revoked(p));
    };
}
```

| Facts | `accreditation_revoked` | `evaluation_status` |
|---|---|---|
| order | `NEITHER` | `REQUIRES_JUDGMENT` |
| order and the committee's decision | `TRUE_ONLY` | `COMPUTED` |

The first row's `NEITHER` must not be read as "the power is invalid":
the computation status says the authority has not yet spoken, and the
document carries a judgment request to the named authority. No
`POWER_INVALID_EXERCISE` issue is emitted here for the same reason. Look
at `evaluation_status`, not only at `truth_status`. The committee's
decision arrives in the case as a statement with `origin adjudicated`
and closes the condition.

## Immunity and priority

Immunity shields the holder from another power's effect. A reader
who reported damage herself is not subject to the fine.

```law
rule SelfReportImmunity strict {
    for p: Person;
    for d: Official;
    when self_reported_damage(p) and director(d);
    then immunity NoFineAfterSelfReport {
        holder p;
        against d;
        protected_effect fine_imposed(p);
        window [@2026-01-01, @2026-12-31];
    };
}

priority SelfReportOverFine {
    prefer SelfReportImmunity over FinePower;
    reason lex_specialis;
}
```

| What is in the package | Order, record, report | `fine_imposed` | Document |
|---|---|---|---|
| immunity and priority | yes | `NEITHER` | issue `EFFECT_BLOCKED_BY_IMMUNITY` |
| immunity without priority | yes | `NEITHER` | issue `UNRESOLVED_NORMATIVE_CONFLICT` |

Without priority, a valid power meeting an active immunity is a proven
conflict the core does not resolve by itself: the effect gets
no support, both positions stay `ACTIVE`, and the document names the
conflict unresolved. Priority with a named ground does what it did in
the defeat tutorial: the effect is locked, the document names the cause
with one informational issue, the power stays `ACTIVE` — its status is
not what was defeated but the effect's materialisation. Both rows of
the table come from compiling the page as is and without the
`priority` block.

## Compiler refusals

Each modality has its mandatory fields, with a refusal for each missing:

```text
error LDC-E1305: prohibition "NoPhotography" без action (§130; §124 требует поле схемой)
error LDC-E1305: liberty "MayRequestExtension" без обязательного поля "holder" (§125/§127/§128)
error LDC-E1305: power "ImposeFine" без обязательного поля "validWhen" (§125/§127/§128)
error LDC-E1305: immunity "NoFineAfterSelfReport" без обязательного поля "protectedEffect" (§125/§127/§128)
```

The diagnostics read: prohibition without `action`; liberty without the mandatory holder field; power without the mandatory validWhen field; immunity without the mandatory protectedEffect field.

A power's subjected one is a payload variable, bound by the body. Remove
`in_researcher_registry(p)` from `RevocationPower`'s body:

```text
error LDC-E4101: RevocationPower: норм-голова "RevokeAccreditation" (поля:
over, exercise, valid_when, effect) использует несвязанные переменные [p]
```

The diagnostic reads: 'RevocationPower: the "RevokeAccreditation" norm head (fields: over, exercise, valid_when, effect) uses unbound variables [p]'.

All five refusals belong to the language. Write the position with
`duty`, naming its `bearer` and `beneficiary`.

## Next

The four modalities are derived by rules and so may be the subject of
a reading dispute: one edition reads "may" as a liberty, another as
a power. How to hold such a dispute in a package without choosing sides
for the lawyer is the readings tutorial. This page's layer is L3: the
layer view names power and immunity disputed constructions, an honest
measure of how much in them the engine does not decide.

The exercise for this page is [/tutorials/exercise-modalities/](/tutorials/exercise-modalities/).