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

## Incorrect form and why it stays silent

```law title="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

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

```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;
}
```

```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;
}
```

```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:

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