RFC-048: A Cell Answers Through a Reduction, and the Process Combines the Answers

Context

Some answers are in what an organization recorded earlier, not in the law:

• The head grants leave “slechts eenmaal … per schooljaar” (Leerplichtwet 1969 art. 13a lid 2). Earlier grants are in the school’s own decisions.
• Leave must fall “buiten de schoolvakanties” (art. 11 onder f). The holidays depend on where the school is established, a fact the school recorded.
• An examination may be skipped if “aan de aanvrager eerder een gehandicaptenparkeerkaart is verstrekt” (Regeling gehandicaptenparkeerkaart art. 2 lid 2). Another municipality or the CBR may have issued it.

The law leaves such terms to the authority and does not say how the authority reads its records back. The position paper does: “Reductie vindt altijd plaats ín de cel waar de betreffende chronolexogrammen zijn vastgelegd”, and “Synthese gebeurt bij de afnemer, niet bij de bron”. The source is the cell. The consumer is the law together with the policy of the authority that decides: the law asks, the policy says where the answer comes from.

Decision

Chronolexography shows this at work.

1. A reduction is a named answer of its cell

How a cell reduces is up to the cell. The engine only asks it for an answer by name (§2). The cell in packages/cel uses what the engine offers: a reduction in the law format, regulatory_layer: REDUCTIE. It sits in the corpus with the rest of the rulework, at corpus/regulation/nl/reducties/<id>/<valid_from>.yaml, and names its holder, the body whose chronicle it reads, in competent_authority. Each output is an answer. A reduction fills no open term, so it has no implements.

• source.decisions (<regulation>#<article>): one row per decision, with fields, outputs and id.
• source.facts (<regulation>#<article>#<fact>): one row per recorded fact (RFC-051). The last # separates the fact.
• combine: ONLY on a FOREACH: the one result the filter leaves; null for none, an error for two.
• A reduction may call policy or law with source.regulation for a norm, and passes what it found in the chronicle as parameters. Above, the head’s policy says which school year the leave falls in; the reduction applies it to the rows.

The cell’s cel.yaml is its catalogue: per answer the reduction that gives it. It holds no logic.

2. The decider’s policy binds a term to an answer

The law asks no cell. Which term an answer fills is the consumer’s choice, made in the UITVOERINGSBELEID of the authority that decides. One article fills the term with implements and takes the answer as an input:

A caller may give an execution an answerer (OpenTermAnswerer, in a Call). Wherever the binding runs, at any depth, the engine asks it for the answer by name with the parameters the binding passes. During a decision the cell is the answerer. It runs the reduction its catalogue names and returns the value with its provenance.

• The binding is policy like any other, so the order of precedence is unchanged: policy, then the finding, then the default (RFC-045 §5). Where the cell answers, its answer sets a finding aside.
• Without an answer the input is null (hence nullable: true). On a term with a default or decided_per_case_by, the binding is then silent and the term falls back; a term decided per case without a finding fails the execution, so a missing answer never grants anything. On a term with neither, null is its value.
• The binding passes only the parameters it names. The cell refuses one the reduction does not declare, and a declared one the binding leaves out unless it is required: false.
• Should the term occur in another article, or in another law the same authority carries out, the policy gets a second article with the same source. The reduction stays as it is.
• The engine never runs a reduction itself; a REDUCTIE stays out of its implements index.

3. Only a reduction reads a chronicle

The loader (load_check::reject_misplaced_reduction) keeps the chronicle out of law and policy:

• source.decisions and source.facts only in a REDUCTIE, alone in their source;
• in a REDUCTIE no implements, hooks, overrides, execution.produces or open_terms;
• source.reduction only in an article with implements, in a UITVOERINGSBELEID that names one holder by name, from schema v0.8.9, and beside no other key of source except parameters and combine;
• combine in a source only beside reduction, fitting the input’s type.

Schema v0.8.5 to v0.8.8 allowed implements on a REDUCTIE. The loader still accepts it under a $schema of those versions and gives it no meaning; a reduction without $schema is held to the current version.

The cell refuses an answer from a reduction the service does not hold, from one that is no REDUCTIE, and from one whose competent_authority is not the cell. A cell directory with reducties/ does not open, since a reduction sits in the corpus. Before the first valid_from of a reduction the cell is silent, so a decision from before it replays with the authority’s finding. Cell::answers lists the catalogue. Declaring it is a RegelRecht addition (RFC-022 §4.1); in the paper a cell reduces on request and declares nothing.

4. The process combines the answers of competent cells

A decision may take other cells along: its sphere. Which cells the engine asks for a binding’s answer follows from the term it fills:

• the term names competent_authority: every answerer of the call it names, an INSTANCE by name and a CATEGORY by category, in name order and without short-circuit;
• otherwise: the cell of the policy’s holder.

This holds wherever the binding runs. RFC-052 routed on competence only for a term reached through source.regulation; with the answer named in policy that limit had no work left to do.

Every cell is asked for the same answer name. A cell whose catalogue lacks it is silent, as is one that answers null.

The law’s combine wins, since it says how the law weighs several competent actors. The binding’s serves a term that names none.

5. Who answered is in the result, why is with the cell

ArticleResult.open_terms reports filled_by: {answer: {law_id, article, answers}}: the binding’s policy and article, and per answer the cell, the answer’s name, the reduction with its version, and how far it read the chronicle. The trace has a node per answer under the binding’s input, null answers included; a cell without the answer is named in the input’s message. Why is the cell’s to show (Cell::explain_answer), with the steps of the policy the reduction calls; that trace is not stored.

6. Replay and reconsideration

On replay (RFC-046) the cell answers from its chronicle as it stood before the decision. Sphere cells answer from what they recorded up to its day. Only that day is stored. When Awb 7:11 calls a decision anew, the binding runs in that call and the cell answers without the contested decision. Revoked decisions stay in the rows; the reduction leaves them out.

Where each choice comes from

Why

Benefits

• Law and policy say nothing about the chronicle. A jurist reads both without knowing what a cell is; the policy names an answer in words.
• The source is not tied to one question. The consumer binds the answer where it needs it.
• A norm such as the school year is written once, in policy, and the reduction applies it.
• Anyone can answer, however it reduces: a cell, or a scenario with the authority’s finding.
• A reduction is type-checked and traced like any article.
• The engine knows no cells; it asks for an answer by name and compares names.

Tradeoffs

• An authority’s finding on a term the cell answers is set aside; the trace says so.
• A decision’s trace shows who answered, not why. For why, ask the cell.
• The catalogue is the only record of which answers are the cell’s. A cell opened from the wrong directory, whose catalogue lacks the answer, replays it as the authority’s finding with the same outcome.

Open points are listed in Open Points in Chronolexography.

Alternatives Considered

• The reduction returns a list; policy computes. Policy would hold logic that exists only for the chronicle.
• A reduction or binding language in cell configuration (PR #1689, RFC-022 §4.1). A second language without type checker or trace.
• The article asks the answer as a parameter (first version). Lost in nested calls, invisible in the trace.
• The engine runs the reduction as an implementation (16–17 October 2026). That put the reduction’s FOREACH in the decision’s trace.
• The reduction fills the term with implements (schema v0.8.5 to v0.8.8). It works, but ties the source to one question of one law.
• Policy reads the chronicle itself. That removes the line between consumer and source.
• The cell drops revoked decisions from the rows. The reduction would not see the whole picture.
• A list of answers as a value, with FOREACH in the law. The law would see cells.
• A composite answerer in packages/cel. Rule and competence in Rust; the engine would see one source.

Implementation

Engine: answer.rs (OpenTermAnswerer::answer, AnswerRequest, Answer, AnswerProvenance, Call, Authority), resolve_open_term, resolve_answer, combine_with, combine_only, FilledBy::Answer, load_check::chronicle_read, load_check::reject_misplaced_reduction; tests in packages/engine/tests/reduction.rs and synthesis.rs. Cell: cel.yaml with answers, Cell::answers, reading (bindings, bound_terms, Reader), Cell::explain_answer. Corpus: seven reductions under corpus/regulation/nl/reducties/, bound in fictief_beleid_vakantieverlof_obs_de_klimop and in the parking-card policy of Wilgendaal. Not built: calling an article per FOREACH element, so a reduction asks policy once for the case and compares each row with that.

References

• Leerplichtwet 1969 art. 11 onder f, 13a; Regeling gehandicaptenparkeerkaart art. 2; BABW art. 49
• Chronolexografie position paper: Reductie & Lexostatus, Chronolexosfeer & Synthese
• Inversion of Control