Ban, liberty, power, and immunity

For LLMs7 sections

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.

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”.

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:

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.

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.

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:

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.

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.

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:

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:

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.

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/.

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

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