Markdown for LLMs

Strict rules: corpus forms

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

# Strict rules: corpus forms

Breakdown of real fragments: package identifier, human act name, form rating
(exemplary / debatable / wrong form choice) and why.

## Law

### 1. Civil Code of Kazakhstan — strict rule with header parameters (exemplary)

Package `kz.corpus.civilcode` (Civil Code of Kazakhstan), natural persons:

```law
rule CitizenForeignCitizenOrStatelessPersonIsNaturalPerson(person: Person) strict {
    when person_is_kazakhstan_citizen_foreign_citizen_or_stateless(person);
    then person_recognised_as_natural_person_under_civil_code(person);
}
```

Exemplary: qualification without exceptions — strict strength; the variable
is bound by a header parameter, the body is a single
literal. Same chapter: a strict rule with two `when` clauses, the
second a negative literal
`not code_exception_to_chapter_two_person_provisions(person)`:
the body is a conjunction, not an “exception” — `strict` has
no exceptions.

### 2. Civil Code of Kazakhstan, liquidation — defeasible norm next to strict ones (exemplary)

Package `kz.corpus.civilcode` (Civil Code of Kazakhstan), liquidation and bankruptcy:

```law
rule InsufficientPropertyDistributedProRataWithinQueue(demand: CreditorDemand) defeasible { ...; when liquidated_entity_property_insufficient_for_queue(demand);
```

Exemplary as a strength choice: the article text contains “unless otherwise
provided by statute” — a norm with a proviso is written `defeasible`, not
`strict` hoping nobody raises the proviso. The criterion from the [strict-rules page](/constructs/rule-strict/):
exceptions possible in principle — therefore not `strict`.

### 3. Administrative Offences Code of Kazakhstan — strict rule as a prohibition without priority (exemplary)

Strict opposite support defeats a defeasible candidate on its own:
prohibiting trade in prohibited goods needs no `priority` over the
permission. Exemplary: declaring priority over a strict rule is forbidden
(`LDC-E4105`), and the corpus contains no such edges.

## International law

### 4. Geneva Convention III of 1949 — defeater as a neighbour of the strict form (exemplary)

Package `intl.ihl.geneva_1949` (Geneva Convention III of 1949, prisoners of war), status:

```law
rule TribunalDeterminationEndsPendingStatus(person: Person) defeater {
    label en official "Article 5 III: once a competent tribunal has determined the status, it is no longer pending";
    when tribunal_denied_pow_status(person);
    defeat status_pending_determination(person);
}
```

Exemplary as a form choice: the tribunal removes the interim status,
asserting nothing in return — a defeater, not a strict negative
head. After defeat the answer is Not established, not refuted, not Refuted: the case stays
open for a subsequent determination of status.

## Standards and science

### 5. Corpus measurement: 87 % of rules are strict

48 094 `rule … strict` in 487 packages; `defeasible` — 6 707 in 278;
`defeater` — 478 in 75. Conclusion for the author: strict strength is the
corpus default by frequency, but not by meaning: the mass is explained by
qualifications and structural consequences (the typical pair — a strict
definition with a guard and a defeasible norm above it). Taking `strict`
“because everyone writes it that way” without checking for exceptions is
debatable.

### 5a. Remaining rule forms

`then duty { … }` and other norm heads — 3 023 in 234 packages (a duty as
a rule inference); `then not p(x)` — 2 515 in 271 (a refusal-norm:
explicit negative support); a comparison in the body — 5 518 in 293 (a
threshold, term, or amount — a guard on numbers); `unless` in a rule — 584
in 77 (an exception inside the block); `effective` in a rule — 1 402 in 56
(an effect window by law date); `scope` in a rule — 15 in 2 (a context
condition; almost never used).

## Teaching packages

### 6. This section’s examples (runs green)

Package `research.rule_strict.strict_guard` — a strict rule with a numeric guard:
`check OK`, `law test` 2/2 (Established /
Not established, not refuted).
Package `research.rule_strict.strict_conflict` — two strict rules with
opposite heads: `check OK`, `law test` 2/2 (Contradiction /
Established). The pair fixes the strict-beats-defeasible boundary in executable form.