Markdown for LLMs
From case material to admitted support
The source Markdown for this article. Copy it into your assistant or download it as a text file.
# From case material to admitted support
Until now a fact entered the case with the word `assert`, and the engine
believed it: `origin case_input` means "so says the party", and that was
enough. In a dispute it is not enough. Ivanova claims she returned the
document; the archive claims the opposite. The question is no longer
"what follows from the facts" but "what counts as established at all" —
and the core answers it with a separate phase before any normative
derivation. The executable profile of this phase,
`law.core.evidence-policy/0.1`, appeared in
September 2026; in the corpus 48 `support` edges still lie as transport,
and the only executable policy is the teaching package
`expense-evidence`. This page is the second.
The legal frame: admitting a support and the burden of proof are
different things. Admission says what counts as established on what was
presented; the burden says who had to present and what happens if they
did not. The profile does the first, not the second.
```law
language "law.core" version "0.2";
package tutorial.archive version "0.11.0";
namespace "urn:law:tutorial:archive";
entity Person;
entity ReturnReceipt;
relation document_lent(p: Person) kind empirical;
relation document_returned(p: Person) kind empirical;
relation loan_closed(p: Person) kind institutional;
```
## Four words
The core tells apart four things colloquially called by one word,
"evidence":
| Word | What it is | Where it lives |
|---|---|---|
| `assert` | a statement: a literal with polarity and an `origin` provenance | case |
| `evidence` | a document: publisher, dates, term, hash, content fields | case |
| `support` | a support: "document X supports (or refutes) statement P" | case |
| admission | the decision that a support counts — and only an admitted one gives the literal support | package policy |
The unit of decision is the support, not the document and not the fact.
One document may be admitted as support of one statement and
rejected as support of another; a rejected support gives support to
neither polarity and **is not proof of the denial**.
## A norm that reads return
An issue is closed when the document is issued and returned.
```law
rule LoanClosed strict {
for p: Person;
when document_lent(p) and document_returned(p);
then loan_closed(p);
}
```
While no policy is selected, all is as in the earlier tutorials:
| Facts | `document_returned` | `loan_closed` |
|---|---|---|
| issued, return stated by the case | `TRUE_ONLY` | `TRUE_ONLY` |
| issued | `NEITHER` | `NEITHER` |
| issued, receipt and support presented, no policy selected | `NEITHER` | `NEITHER` |
The third row is the first thing to grasp about evidence in the core.
With no policy selected, a document and a support are transport: they
are stored in the case, enter its hash, but give the literal no support.
The answer bytes are the same as if the document were absent.
Only the case can switch the phase on — via the `evidence_policy`
context axis.
## Evidence policy
The archive rules: a document's return is confirmed by a receipt issued
by the issue desk, whose authenticity the registry verified. All this is
**package** rules, not engine: the implementations hold not a line about
registries, receipts, or archives.
First — what the profile turns the case's raw material into. Projection
slots bind to the package's ordinary relations: the author
sees a signature, the compiler checks it.
```law
relation ev_edge(edge: Text, document: Text, link: Text) kind empirical;
relation ev_issuer(document: Text, issuer: Text) kind empirical;
relation ev_available(document: Text) kind empirical;
relation ev_authentic(document: Text, verifier: Text, outcome: Text) kind empirical;
relation doc_kind(document: Text, kind: Text) kind empirical;
relation doc_reader(document: Text, reader: Person) kind empirical;
relation edge_reader(edge: Text, reader: Person) kind empirical;
relation edge_is_return(edge: Text) kind empirical;
relation sound_receipt(document: Text) kind institutional;
relation accepted_support(edge: Text) kind institutional;
const ARCHIVE_DESK: Text = "urn:tutorial:archive:reading-desk";
const ARCHIVE_REGISTRY: Text = "urn:tutorial:archive:registry";
```
Then — the admission rules. A document is sound if available at
knowledge time, issued by the issue desk, and hash-verified by the
registry. A support is admitted if it is a receipt about the same reader
the statement is about. A non-return act is admitted as a `refutes`
support under the same conditions.
```law
rule SoundReceipt strict {
for d: Text;
when ev_available(d)
and ev_issuer(d, ARCHIVE_DESK)
and ev_authentic(d, ARCHIVE_REGISTRY, "verified");
then sound_receipt(d);
}
rule AcceptReturnReceipt strict {
for edge: Text;
for d: Text;
for p: Person;
when ev_edge(edge, d, "supports")
and edge_is_return(edge)
and edge_reader(edge, p)
and sound_receipt(d)
and doc_kind(d, "return_receipt")
and doc_reader(d, p);
then accepted_support(edge);
}
rule AcceptNonReturnAct strict {
for edge: Text;
for d: Text;
for p: Person;
when ev_edge(edge, d, "refutes")
and edge_is_return(edge)
and edge_reader(edge, p)
and sound_receipt(d)
and doc_kind(d, "non_return_act")
and doc_reader(d, p);
then accepted_support(edge);
}
```
And the carrier — the policy declaration. It names everything
affecting the result, and nothing beyond: it has no open metadata.
```law
evidence policy ArchiveReturnEvidence {
profile "law.core.evidence-policy/0.1";
accepts accepted_support;
protects document_returned;
input edge ev_edge;
input issuer ev_issuer;
input available ev_available;
input authentic ev_authentic;
field kind doc_kind;
field reader doc_reader;
arg 0 edge_reader;
target document_returned edge_is_return;
rule SoundReceipt, AcceptReturnReceipt, AcceptNonReturnAct;
}
```
| Item | What it does |
|---|---|
| `accepts` | the decision head: a support is admitted if `accepted_support(edge)` is derived |
| `protects` | the protected predicate: it enters support only via an admitted support |
| `input` | a projection slot: edge, issuer, knowledge-time availability, authenticity check |
| `field` | a document-content key — `kind`, `reader` — as a relation with a declared type |
| `arg 0` | the support statement's zeroth argument, parsed down to a value: whom the support is about |
| `target` | the "support addresses `document_returned`" marker |
| `rule` | the closed list of phase rules — only it executes |
List rules must be strict and read only projection slots and each
other's heads. Case facts — `document_lent`, anything
normative — the phase does not see: it decides what is established and
may not depend on a derivation it itself makes possible. The page's layer
does not change with the policy: the layer view still answers `L0`.
## What is admitted and why
Ivanova handed the document in; the desk issued a receipt, the registry
checked its hash and recorded the check. The case presents three things —
a document, a verification, and a support — and selects the policy via
the context axis.
| Facts | `document_returned` | `loan_closed` |
|---|---|---|
| issued, desk receipt, registry check, support | `TRUE_ONLY` | `TRUE_ONLY` |
The test from this page, byte for byte:
```law
test "квитанция архива проверена — возврат установлен принятой опорой" {
given {
context {
decision_time @2026-04-10T09:00:00+05:00;
knowledge_time @2026-04-10T09:00:00+05:00;
legal_time @2026-04-10;
timezone "Asia/Almaty";
evidence_policy ArchiveReturnEvidence;
}
assert document_lent(entity_ref("urn:tutorial:ivanova")) {
id "assert-lent";
origin case_input;
}
evidence RECEIPT: ReturnReceipt {
id "doc-receipt";
status verified;
issuer "urn:tutorial:archive:reading-desk";
observed_at @2026-04-02T15:00:00+05:00;
recorded_at @2026-04-02T15:00:05+05:00;
valid [@2026-04-02, infinity);
content_hash "sha256:1111111111111111111111111111111111111111111111111111111111111111";
kind "return_receipt";
reader entity_ref("urn:tutorial:ivanova");
}
verification VRECEIPT {
evidence RECEIPT;
document_hash "sha256:1111111111111111111111111111111111111111111111111111111111111111";
verifier "urn:tutorial:archive:registry";
outcome verified;
recorded @2026-04-03T10:00:00+05:00;
}
support RECEIPT supports document_returned(entity_ref("urn:tutorial:ivanova"));
}
evaluate truth(document_returned(entity_ref("urn:tutorial:ivanova")));
expect truth_status == TRUE_ONLY;
expect evaluation_status == COMPUTED;
}
```
The test name reads: "The archive receipt is verified — return is established by an admitted support."
Three inputs are three different objects. A document describes itself:
publisher, dates, content hash, fields. A verification is a pinned result
of someone else's work: the registry checked the document against the
hash and recorded the outcome; the core does not compute authenticity but
accepts the result only on a hash match. A support links
a document to a statement. The document's own `status verified` field
grants no privilege: a document does not certify itself.
Admission is a proven transition, not an unconditional leaf. In the proof
graph, `document_returned` now has no `assertion` node; it has
a `support_admission` node naming the support, the document, the policy,
and the rules by which the support was admitted. Forging an
established fact without presenting a document and a rule is structurally
impossible.
## A rejected support is no refuted fact
Five ways to present a receipt so that it is not admitted.
| What is wrong with the receipt | `document_returned` | Report cause |
|---|---|---|
| Ivanova wrote it herself | `NEITHER` | `NO_ACCEPTANCE_RULE_APPLIED` |
| no registry check | `NEITHER` | `AUTHENTICATION_MISSING` |
| check hash mismatched the document | `NEITHER` | `AUTHENTICATION_HASH_MISMATCH` |
| check recorded past knowledge time | `NEITHER` | `AUTHENTICATION_NOT_AVAILABLE` |
| receipt about another reader | `NEITHER` | `NO_ACCEPTANCE_RULE_APPLIED` |
In all five rows the answer is `NEITHER`, not `FALSE_ONLY`. A rejected
support proves nothing — including that the document was not returned.
This is not softness but a boundary: "the receipt is no good" and "there
was no return" are different statements, and the second needs its own
support.
Causes live not in the graph but in the result's typed `evidenceAcceptance`
report: each support gets a decision and a closed list of causes, each
document availability, currency on the date of law, and authenticity
checks with a hash-binding flag. The `NO_ACCEPTANCE_RULE_APPLIED` cause
is unfolded by policy rules: for each, applicability and the conjunct
states, with the same analysis as `why_not` but over the phase
store. The table's first row looks in the report like this (shortened):
```text
evidenceAcceptance
policy …#ArchiveReturnEvidence profile law.core.evidence-policy/0.1
decisions
…#support/7cad87a0… evidence …#doc-receipt relation supports
decision rejected reasons [NO_ACCEPTANCE_RULE_APPLIED]
blockers
…#AcceptReturnReceipt APPLICABLE trigger UNDETERMINED sound_receipt: UNDETERMINED …
…#AcceptNonReturnAct APPLICABLE trigger UNDETERMINED ev_edge: UNDETERMINED …
documents
…#doc-receipt available true current true
authentications [VRECEIPT: verifier …#registry, outcome verified, bound true]
```
The document here is available, current, and authentic — the publisher
did not fit: `sound_receipt` requires the issue desk, while the reader
wrote the receipt. Naming the mismatched requisite is the engine
report's duty, not the host's guess.
## A bare statement of a protected predicate
What if a party presents no document but simply writes return into
the case?
| Case statement | Policy | `document_returned` | Document |
|---|---|---|---|
| `document_returned`, `origin case_input` | selected | `NEITHER` | issue `PROTECTED_ASSERTION_BLOCKED` |
| `document_returned`, `origin adjudicated` | selected | `NEITHER` | issue `PROTECTED_ASSERTION_BLOCKED` |
| `document_returned`, `origin case_input` | not selected | `TRUE_ONLY` | — |
| `document_returned`, `origin assumed_for_simulation` | not selected | `NEITHER` | issue `ASSERTION_NOT_ACCEPTED` |
With a policy selected, a protected predicate enters support under no
`origin`: neither `case_input` nor even `adjudicated`. The
report cause is `PROTECTED_PREDICATE_REQUIRES_EVIDENCE`, the document an
informational issue. The fourth row is another, older mechanism: an
origin outside those admissible in regulatory mode yields
`ASSERTION_NOT_ACCEPTED` regardless of any policy. Two issues are two
different questions: "is this statement admissible by the case at all?"
and "may this fact be established without a document?".
## Refutation by document
Negative support arrives by document too: a non-return act, admitted as
a `refutes` support, gives `document_returned` an "against" support.
| Documents | `document_returned` |
|---|---|
| non-return act, admitted | `FALSE_ONLY` |
| receipt and act, both admitted | `BOTH` |
The second row is `BOTH`, not `NEITHER`: two admitted supports
of different polarities both survive, and this is a genuine dispute —
a literal's state, not a third decision about a
support. Unpicking the dispute is the business of a norm, a priority, or
an authority, not of the admission phase.
## Admission is not burden
The profile answers "is it established on what was presented". Who had
to present is a norm's question, written as a position over an
epistemic aim:
```law
rule ReaderProvesReturn defeasible {
for p: Person;
when document_lent(p) and return_disputed(p);
then duty ProveReturn {
bearer p;
goal achievement {
condition document_returned(p);
window [@2026-04-01, @2026-05-01);
}
};
}
```
This is the same `duty` from [the duty tutorial](/tutorials/duty/): it
has a bearer, an aim, and a window, and its status — `ACTIVE`,
`SATISFIED`, or `UNDETERMINED` — counts by the same rules. If Ivanova
presented no sound receipt in time, the duty is unfulfilled — but that is
still no `FALSE_ONLY` on return: unfulfilled burden and refuted fact are
different layers, and the core builds no "unproven, hence absent" bridge.
The act itself builds it: by a closure or by an authority's decision
via the judgment channel.
## Compiler refusals
Four refusals belong to the language.
A phase rule is not strict:
```text
error LDC-E4702: evidence policy urn:law:tutorial:archive#ArchiveReturnEvidence:
правило urn:law:tutorial:archive#AcceptReturnReceipt не strict —
acceptance-фаза исполняет только строгий фрагмент §103 (§78.2.5)
```
The diagnostic reads: 'rule …#AcceptReturnReceipt is not strict — the acceptance phase executes only the strict fragment'.
A protected predicate in an ordinary norm's head — put `document_returned`
as `LoanClosed`'s head:
```text
error LDC-E4703: evidence policy urn:law:tutorial:archive#ArchiveReturnEvidence:
правило urn:law:tutorial:archive#LoanClosed выводит защищённый предикат
urn:law:tutorial:archive#document_returned — защищённый факт входит в
поддержку только принятой опорой (§78.2.4)
```
The diagnostic reads: 'rule …#LoanClosed derives the protected predicate …#document_returned — a protected fact enters support only via an admitted support'.
A phase rule reads a case fact — add `document_lent(p)` to
`AcceptReturnReceipt`'s body:
```text
error LDC-E4701: evidence policy urn:law:tutorial:archive#ArchiveReturnEvidence:
правило urn:law:tutorial:archive#AcceptReturnReceipt читает
urn:law:tutorial:archive#document_lent — предикат не является ни слотом
проекции политики, ни головой правила её перечня. Acceptance не вправе
зависеть от нормативного вывода, начальную допустимость которого она
определяет (EPISTEMIC_ACCEPTANCE_CYCLE, §78.1/§78.2.5)
```
The diagnostic reads: 'rule …#AcceptReturnReceipt reads …#document_lent — the predicate is neither a policy projection slot nor a head of a rule in its list. Acceptance may not depend on the normative derivation whose initial admissibility it determines (EPISTEMIC_ACCEPTANCE_CYCLE)'.
A structural ban: an `accept P because duty(P)` cycle is caught statically,
however many links lie between admission and derivation. And an unknown
profile version:
```text
error LDC-E4705: evidence policy "ArchiveReturnEvidence": профиль
"law.core.evidence-policy/0.9" не поддержан; известны:
law.core.evidence-policy/0.1 (§78.2.1)
```
The diagnostic reads: 'profile "law.core.evidence-policy/0.9" is not supported; known: law.core.evidence-policy/0.1'.
The fifth refusal is shown as text. A closure over a protected
predicate would materialise a negation past the phase:
```text
error LDC-E4704: evidence policy urn:law:tutorial:archive#ArchiveReturnEvidence:
замыкание urn:law:tutorial:archive#ReturnClosure закрывает защищённый
предикат urn:law:tutorial:archive#document_returned — материализованный
негатив обошёл бы acceptance-фазу (§78.2.4)
```
The diagnostic reads: 'closure …#ReturnClosure closes the protected predicate …#document_returned — a materialised negative would bypass the acceptance phase'.
## Next
An established fact, an admitted support, and the burden of proof are
three layers, each now in its place. Next is procedure: an attempted
procedural action, an admissible transition, and a reached state, where
"the party filed" and "the filing took place" will also turn out
different things.
The exercise for this page is [/tutorials/exercise-evidence/](/tutorials/exercise-evidence/).