From case material to admitted support

For LLMs10 sections

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.

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.

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.

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.

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.

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:

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

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:

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

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:

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:

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:

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:

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

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

Documentation for Arxo. Writings — blog.arxo.io.

Anonymous visit counts on stats.arxo.io, no cookies.