# A defeater blocks every ground of the head

## Intention

I want to keep an independent ground by shielding it from a general defeater.

An independent ground survives a general defeater only with an established priority.

## Incorrect form and why it stays silent

```law title="Incorrect form"
rule Block defeater { for p: Person; when special(p); defeat allowed(p); }
// Без приоритета он блокирует и Independent.
```

A defeater addresses the conclusion, not the name of one rule. Priority of Independent over it preserves the independent ground.

## Correct form

```law
language "law.core" version "0.2";
package recipes.b.r04 version "0.1.0";
namespace "urn:recipe:b-rules:04";

entity Person;
relation eligible(p: Person);
relation special(p: Person);
relation allowed(p: Person);
relation independent(p: Person);
rule General defeasible { for p: Person; when eligible(p); then allowed(p); }
rule Independent defeasible { for p: Person; when independent(p); then allowed(p); }
rule Block defeater { for p: Person; when special(p); defeat allowed(p); }
priority KeepIndependent { prefer Independent over Block; reason explicit_exception; }
```

## Frozen execution scene

| Facts and choice | Question | Answer |
|---|---|---|
| general ground lifted | `truth(allowed(entity_ref("urn:recipe:b-rules:04:p")))` | `NEITHER` / `COMPUTED` |
| independent ground shielded | `truth(allowed(entity_ref("urn:recipe:b-rules:04:p")))` | `TRUE_ONLY` / `COMPUTED` |
| shield removed | `truth(allowed(entity_ref("urn:recipe:b-rules:04:p")))` | `NEITHER` / `COMPUTED` |

```law
test "general ground defeated" {
    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 eligible(entity_ref("urn:recipe:b-rules:04:p")); assert special(entity_ref("urn:recipe:b-rules:04:p"));
    }
    evaluate truth(allowed(entity_ref("urn:recipe:b-rules:04:p")));
    expect truth_status == NEITHER;
    expect evaluation_status == COMPUTED;
}
```

```law
test "independent ground protected" {
    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 eligible(entity_ref("urn:recipe:b-rules:04:p")); assert special(entity_ref("urn:recipe:b-rules:04:p")); assert independent(entity_ref("urn:recipe:b-rules:04:p"));
    }
    evaluate truth(allowed(entity_ref("urn:recipe:b-rules:04:p")));
    expect truth_status == TRUE_ONLY;
    expect evaluation_status == COMPUTED;
}
```

```law
test "protection removed" {
    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 eligible(entity_ref("urn:recipe:b-rules:04:p")); assert special(entity_ref("urn:recipe:b-rules:04:p")); assert independent(entity_ref("urn:recipe:b-rules:04:p"));
    }
    evaluate truth(allowed(entity_ref("urn:recipe:b-rules:04:p")));
    expect truth_status == NEITHER;
    expect evaluation_status == COMPUTED;
}
```

## Counterfactual

Mutation: `defeat allowed(p);` → `defeat eligible(p);`; rejection LDC-E4112. Scenes that delete a fragment are marked explicitly in the table.

## Boundary

If the exception concerns only one ground, the grounds can be split across predicates. Priority must follow the rule, not the desired answer.

## Pitfall

A defeater blocks every ground of its head: without an established priority, the independent ground does not survive.