Strict consequence and a defeasible rule

Intention

I want to separate a strict definition from a rule with an exception.

A strict rule does not admit exceptions.

Correct formFrozen execution sceneBoundary

Incorrect form and why it stays silent

Incorrect form

rule General strict { for p: Person; when eligible(p); then allowed(p); }

Strict support cannot be lifted by a defeater. If General is the only producer, the attempt turns Block into a defeater without a defeasible candidate.

Correct form

Arxo Law

language "law.core" version "0.2";
package recipes.b.r10 version "0.1.0";
namespace "urn:recipe:b-rules:10";

entity Person;
relation eligible(p: Person);
relation special(p: Person);
relation allowed(p: Person);
relation registered(p: Person);
rule Definition strict { for p: Person; when registered(p); then eligible(p); }
rule General defeasible { for p: Person; when eligible(p); then allowed(p); }
rule Block defeater { for p: Person; when special(p); defeat allowed(p); }

Frozen execution scene

Facts and choice	Question	Answer
strict definition	truth(eligible(entity_ref("urn:recipe:b-rules:10:p")))	TRUE_ONLY / COMPUTED
permission without exception	truth(allowed(entity_ref("urn:recipe:b-rules:10:p")))	TRUE_ONLY / COMPUTED
exception to the rule	truth(allowed(entity_ref("urn:recipe:b-rules:10:p")))	NEITHER / COMPUTED

strict definition

Arxo Law

test "strict definition" {
    given {
        context {
            legal_time @2026-09-13;
            decision_time @2026-09-13T09:00:00+05:00;
            knowledge_time @2026-09-13T09:00:00+05:00;
            timezone "Asia/Almaty";
        }
        assert registered(entity_ref("urn:recipe:b-rules:10:p"));
    }
    evaluate truth(eligible(entity_ref("urn:recipe:b-rules:10:p")));
    expect truth_status == TRUE_ONLY;
    expect evaluation_status == COMPUTED;
}

admission without exception

Arxo Law

test "admission without exception" {
    given {
        context {
            legal_time @2026-09-13;
            decision_time @2026-09-13T09:00:00+05:00;
            knowledge_time @2026-09-13T09:00:00+05:00;
            timezone "Asia/Almaty";
        }
        assert registered(entity_ref("urn:recipe:b-rules:10:p"));
    }
    evaluate truth(allowed(entity_ref("urn:recipe:b-rules:10:p")));
    expect truth_status == TRUE_ONLY;
    expect evaluation_status == COMPUTED;
}

exception to the norm

Arxo Law

test "exception to the norm" {
    given {
        context {
            legal_time @2026-09-13;
            decision_time @2026-09-13T09:00:00+05:00;
            knowledge_time @2026-09-13T09:00:00+05:00;
            timezone "Asia/Almaty";
        }
        assert registered(entity_ref("urn:recipe:b-rules:10:p")); assert special(entity_ref("urn:recipe:b-rules:10:p"));
    }
    evaluate truth(allowed(entity_ref("urn:recipe:b-rules:10:p")));
    expect truth_status == NEITHER;
    expect evaluation_status == COMPUTED;
}

Counterfactual

Mutation: rule General defeasible → rule General strict; rejection LDC-E4112. Scenes that delete a fragment are marked explicitly in the table.

Add rule StrictCopy strict { for p: Person; when eligible(p); then allowed(p); } to the original program. The defeasible producer remains, so there is no E4112; the defeater lifts General, but the strict copy keeps TRUE_ONLY. This is an authoring-model error, not an evaluation defect.

This extra scene is executed by the adapter on the mutated program, with both evaluators and a byte comparison:

Arxo Law

test "strict copy survives the defeater" {
    given {
        context {
            legal_time @2026-09-13;
            decision_time @2026-09-13T09:00:00+05:00;
            knowledge_time @2026-09-13T09:00:00+05:00;
            timezone "Asia/Almaty";
        }
        assert registered(entity_ref("urn:recipe:b-rules:10:p")); assert special(entity_ref("urn:recipe:b-rules:10:p"));
    }
    evaluate truth(allowed(entity_ref("urn:recipe:b-rules:10:p")));
    expect truth_status == TRUE_ONLY;
    expect evaluation_status == COMPUTED;
}

Python

>>> import runpy
>>> checks = runpy.run_path("docs/recipes/b-rules/resources/check.py")
>>> checks["check_strength"](https://github.com/arxohq/law/blob/master/docs/recipes/b-rules/10)
'Б10: TRUE_ONLY; lawc = lawref; ошибка выбора силы подтверждена'

Boundary

strict is appropriate for a definition without carve-outs. Reading a defeasible conclusion with a strict rule is still limited: a new strict copy of a legal rule cannot bypass the bound.

Pitfall

Do not attach an exception to a strict rule: strict support cannot be lifted by a defeater.