linked-rolls 0.42.0 → 0.44.0

package/lib/readers/phillipsEroll.d.ts

@@ -14,7 +14,22 @@ import { Millimeters, Seconds } from "../Quantity";
  * elapsed time, not paper, and the take-up spool accelerates the paper
  * as it fills, so `placeAt` has to put the time back onto the paper.
  * And a switch stays open longer than its perforation is long, so a
- * hole read here runs past the punched one.
+ * hole read here runs past the punched one: Phillips measures the
+ * pneumatic on-time as exceeding the apparent length of a perforation
+ * (p. 178), and names what it depends on as the length of the
+ * perforation, the height of the tracker bar hole and the paper speed
+ * (p. 180).
+ *
+ * That extension is not subtracted. Doing so would need the absolute
+ * hole height of the Welte bar, where he gives only the 0.5 mm by which
+ * it exceeds the Licensee's. So the end of a hole on this copy is a
+ * pneumatic on-time where the end of a scanned copy's hole is a punched
+ * slot, and the two are not the same quantity. It shows in a collation:
+ * across welte225.org his notes run about 1.8 mm longer than the other
+ * copies read them, while the onsets agree. Until it is corrected, a
+ * comparison of hole ends against this copy measures the reader as much
+ * as the roll, and `offsetEnd` on the derivation absorbs the systematic
+ * part of it.
  */
 /**
  * He numbers his files by two rules at once, which his free samples

package/lib/readers/phillipsEroll.js

@@ -18,7 +18,22 @@ import { inMetersPerMinute, mm, seconds, track } from "../Quantity";
  * elapsed time, not paper, and the take-up spool accelerates the paper
  * as it fills, so `placeAt` has to put the time back onto the paper.
  * And a switch stays open longer than its perforation is long, so a
- * hole read here runs past the punched one.
+ * hole read here runs past the punched one: Phillips measures the
+ * pneumatic on-time as exceeding the apparent length of a perforation
+ * (p. 178), and names what it depends on as the length of the
+ * perforation, the height of the tracker bar hole and the paper speed
+ * (p. 180).
+ *
+ * That extension is not subtracted. Doing so would need the absolute
+ * hole height of the Welte bar, where he gives only the 0.5 mm by which
+ * it exceeds the Licensee's. So the end of a hole on this copy is a
+ * pneumatic on-time where the end of a scanned copy's hole is a punched
+ * slot, and the two are not the same quantity. It shows in a collation:
+ * across welte225.org his notes run about 1.8 mm longer than the other
+ * copies read them, while the onsets agree. Until it is corrected, a
+ * comparison of hole ends against this copy measures the reader as much
+ * as the roll, and `offsetEnd` on the derivation absorbs the systematic
+ * part of it.
  */
 /**
  * He numbers his files by two rules at once, which his free samples

package/lib/scatter.d.ts

@@ -0,0 +1,164 @@
+import { Belief } from "./Assumption";
+import { BothEnds, CollationTolerance, Displacement } from "./Collation";
+import { EditionView } from "./EditionView";
+import { Millimeters } from "./Quantity";
+import { Histogram, Spread, Tail } from "./statistics";
+import { AnySymbol } from "./Symbol";
+/**
+ * How far the copies of a roll disagree about where a symbol lies, and
+ * the collation tolerance that follows from it.
+ *
+ * The tolerance decides what counts as a reading at all, and a number
+ * someone picks decides it by fiat. The disagreement between copies is
+ * measurable, and in the material examined so far it is close to
+ * normal, so a displacement an editor put there is recognisable as a
+ * departure from that curve rather than as a value above a guess. What
+ * the measurement yields is a screen: it says which readings the curve
+ * does not account for, and an editor says which of those are acts.
+ */
+/** Where one copy puts a symbol, against where the copies read with it put it. */
+export interface Reading {
+    symbol: Readonly<AnySymbol>;
+    /** The copies under test less the rest, at either end of the symbol. */
+    displacement: Displacement;
+}
+/**
+ * How far the named copies put each of the symbols from where the
+ * remaining copies put it.
+ *
+ * The comparison is between copies and not between two texts, because
+ * a collated symbol is one symbol carrying the features of every copy
+ * that reads it: no second symbol is left to match it against. Which
+ * copies a version was established from is therefore not something the
+ * edition still states once the collation has run, and the caller
+ * names them.
+ *
+ * A symbol only one side carries measures nothing and is passed over,
+ * which leaves out exactly the insertions and the deletions.
+ */
+export declare const readingsOf: (view: EditionView, symbols: readonly Readonly<AnySymbol>[], copies: ReadonlySet<string>) => Reading[];
+/**
+ * What sample a reading belongs to. Notes and expressions are taken
+ * apart by default, since in the present material they scatter
+ * differently.
+ *
+ * That split is a stopgap and no distinction in the model. What it
+ * stands in for is a skew: the offset between two copies runs across
+ * the width of the paper, and the expression punches sit at the two
+ * margins, where the gradient is largest and of opposite sign, while
+ * the notes sit between them. Grouped by where the punch sits rather
+ * than by what it says, the expression punches are no noisier than the
+ * notes. Once the alignment carries a skew term, one sample will do,
+ * which is why this is a parameter of the estimator and not a field
+ * anywhere.
+ */
+export type Grouping = (symbol: Readonly<AnySymbol>) => string;
+export interface ScatterOptions {
+    /** What sample a reading belongs to. By default what the symbol is: a note, an expression, a text. */
+    groupOf?: Grouping;
+    /** The width of the histogram's bins. */
+    binWidth?: Millimeters;
+    /** The tolerance the edition states at present, against which each departure is reported as still admitted or not. */
+    stated?: CollationTolerance;
+}
+/** A reading the calculated tolerance does not admit. */
+export interface Departure {
+    /** The symbol read. */
+    symbol: string;
+    /** How far the copies under test put it from where the rest put it. */
+    displacement: Displacement;
+    /** That displacement in units of the scatter, at either end. */
+    z: BothEnds<number>;
+    /**
+     * Which end put the reading outside the window. At least one is
+     * true, and a reading far out at both is true twice.
+     *
+     * It is worth seeing apart. The onset, with the kind, decides
+     * whether two copies read one command; the end decides whether that
+     * command was lengthened or shortened. A separation the end alone
+     * makes is as often a punch measured badly as a punch genuinely
+     * prolonged, and an editor cannot tell the two apart without being
+     * told which test did it.
+     */
+    separatedBy: BothEnds<boolean>;
+    /** Whether the tolerance the edition states at present still admits it. Absent where none was given to compare against. */
+    admittedAsStated?: boolean;
+}
+/** How far a sample departs from the normal shape the tolerance assumes of it. */
+export interface Normality {
+    /** How much heavier its tails are than a normal sample's. Nothing for a normal shape. */
+    excessKurtosis: number;
+    /** What it puts beyond two, three and four times the scatter, against what a normal sample would. */
+    tails: Tail[];
+}
+/** A histogram with the curve its counts are held to follow. */
+export interface FittedHistogram extends Histogram<'mm'> {
+    /**
+     * The normal curve, in the counts' own units, so that an overlay is
+     * drawn from these numbers rather than fitted a second time:
+     * `area / (sigma * sqrt(2 * PI)) * exp(-(((x - centre) / sigma) ** 2) / 2)`.
+     */
+    curve: {
+        centre: Millimeters;
+        sigma: Millimeters;
+        area: number;
+    };
+}
+/** How far one sample of readings scatters, and the tolerance that follows from it. */
+export interface Scatter {
+    /** The sample, as the grouping named it. */
+    group: string;
+    /** Where the readings sit and how far they scatter, at either end. */
+    spread: BothEnds<Spread<'mm'>>;
+    /**
+     * How many times the scatter a reading must lie out before it is
+     * taken for a departure rather than for chance. It is fixed by the
+     * size of the sample and not at a round three, so that fewer than
+     * one of the sample's own readings is expected to pass it.
+     */
+    k: number;
+    /** The window that follows: `k` times the scatter, centred on the median. */
+    tolerance: CollationTolerance;
+    /** How far the sample departs from the normal shape, at either end. */
+    normality: BothEnds<Normality>;
+    /** The sample as counts per bin, with the curve to draw over it. */
+    histogram: BothEnds<FittedHistogram>;
+    /** The readings the calculated tolerance does not admit, the furthest out first. */
+    departures: Departure[];
+}
+/**
+ * How far out a reading must lie before it is held a departure: the
+ * point beyond which fewer than one reading of a sample of this size is
+ * expected to fall by chance. For the samples an edge of the stemma
+ * yields, some hundreds of readings, this lands between 3.0 and 3.2.
+ */
+export declare const departureThreshold: (n: number) => number;
+/**
+ * How the readings scatter, one sample per group. A group whose
+ * readings all sit at one place yields nothing, since no scatter can be
+ * read off such a sample.
+ */
+export declare const scatterOf: (readings: readonly Reading[], options?: ScatterOptions) => Scatter[];
+/** How one copy's readings of a version's text scatter against the readings of the copies it is collated with. */
+export declare const scatterOfCopy: (view: EditionView, versionId: string, copyId: string, options?: ScatterOptions) => Scatter[];
+/**
+ * One window admitting what every sample's own window admits. A
+ * derivation states a single tolerance while the samples differ, and
+ * covering them keeps each sample within the budget of chance
+ * departures its own threshold was chosen for. Nothing where there is
+ * no sample.
+ */
+export declare const toleranceAcross: (scatters: readonly Scatter[]) => CollationTolerance | undefined;
+/**
+ * The belief a calculated tolerance rests on, to annotate the
+ * derivation's `collationTolerance` with: an inference from the scatter
+ * of the readings, the size of the sample and the rule that fixed the
+ * threshold. `used` names what the inference worked on, such as the
+ * copies compared.
+ *
+ * It is held likely rather than true. The tolerance follows from the
+ * sample only as far as the sample is normal, and a sample far from
+ * that shape makes the number unreliable rather than wrong, which is
+ * what `normality` is reported for.
+ */
+export declare const inferredTolerance: (scatters: readonly Scatter[], used?: readonly string[]) => Belief;

package/lib/scatter.js

@@ -0,0 +1,171 @@
+import { v4 } from "uuid";
+import { admits, offsetEndOf, offsetStartOf } from "./Collation";
+import { mean, mm } from "./Quantity";
+import { excessKurtosisOf, histogramOf, normalQuantile, spreadOf, standardise, tailOf } from "./statistics";
+import { groupBy } from "./utils";
+const placeOf = (carriers) => ({
+    from: mean(carriers.map(carrier => carrier.horizontal.from)),
+    to: mean(carriers.map(carrier => carrier.horizontal.to))
+});
+const sitsOn = (view, copies) => (feature) => {
+    const copy = view.copyOf(feature.id);
+    return copy !== undefined && copies.has(copy.id);
+};
+/**
+ * How far the named copies put each of the symbols from where the
+ * remaining copies put it.
+ *
+ * The comparison is between copies and not between two texts, because
+ * a collated symbol is one symbol carrying the features of every copy
+ * that reads it: no second symbol is left to match it against. Which
+ * copies a version was established from is therefore not something the
+ * edition still states once the collation has run, and the caller
+ * names them.
+ *
+ * A symbol only one side carries measures nothing and is passed over,
+ * which leaves out exactly the insertions and the deletions.
+ */
+export const readingsOf = (view, symbols, copies) => {
+    const tested = sitsOn(view, copies);
+    return symbols.flatMap((symbol) => {
+        const carriers = view.carriersOf(symbol);
+        const here = carriers.filter(tested);
+        const there = carriers.filter(carrier => !tested(carrier));
+        if (here.length === 0 || there.length === 0)
+            return [];
+        const ours = placeOf(here);
+        const theirs = placeOf(there);
+        return [{ symbol, displacement: { from: mm(ours.from - theirs.from), to: mm(ours.to - theirs.to) } }];
+    });
+};
+const byWhatItIs = symbol => symbol.type;
+/** The distances from the centre a sample's normality is read at. */
+const TAILS = [2, 3, 4];
+const DEFAULT_BIN_WIDTH = mm(0.25);
+/**
+ * How far out a reading must lie before it is held a departure: the
+ * point beyond which fewer than one reading of a sample of this size is
+ * expected to fall by chance. For the samples an edge of the stemma
+ * yields, some hundreds of readings, this lands between 3.0 and 3.2.
+ */
+export const departureThreshold = (n) => normalQuantile(1 - 1 / (2 * n));
+const estimate = (values, binWidth) => {
+    const spread = spreadOf(values);
+    const histogram = histogramOf(values, binWidth);
+    if (!spread || !histogram || spread.sigma === 0)
+        return undefined;
+    const standardised = values.map(value => standardise(value, spread));
+    return {
+        spread,
+        standardised,
+        normality: {
+            excessKurtosis: excessKurtosisOf(standardised),
+            tails: TAILS.map(beyond => tailOf(standardised, beyond))
+        },
+        histogram: {
+            ...histogram,
+            curve: { centre: spread.median, sigma: spread.sigma, area: spread.n * binWidth }
+        }
+    };
+};
+const furthestOut = (departure) => Math.max(Math.abs(departure.z.from), Math.abs(departure.z.to));
+const departuresIn = (sample, standardised, k, stated) => sample
+    .map((reading, i) => {
+    const z = { from: standardised.from[i], to: standardised.to[i] };
+    return {
+        symbol: reading.symbol.id,
+        displacement: reading.displacement,
+        z,
+        separatedBy: { from: Math.abs(z.from) > k, to: Math.abs(z.to) > k },
+        ...(stated && { admittedAsStated: admits(stated, reading.displacement) })
+    };
+})
+    .filter(departure => furthestOut(departure) > k)
+    .sort((a, b) => furthestOut(b) - furthestOut(a));
+const scatterIn = (group, sample, { binWidth = DEFAULT_BIN_WIDTH, stated }) => {
+    const from = estimate(sample.map(reading => reading.displacement.from), binWidth);
+    const to = estimate(sample.map(reading => reading.displacement.to), binWidth);
+    if (!from || !to)
+        return [];
+    const k = departureThreshold(sample.length);
+    return [{
+            group,
+            spread: { from: from.spread, to: to.spread },
+            k,
+            tolerance: {
+                offsetStart: from.spread.median,
+                offsetEnd: to.spread.median,
+                toleranceStart: mm(k * from.spread.sigma),
+                toleranceEnd: mm(k * to.spread.sigma)
+            },
+            normality: { from: from.normality, to: to.normality },
+            histogram: { from: from.histogram, to: to.histogram },
+            departures: departuresIn(sample, { from: from.standardised, to: to.standardised }, k, stated)
+        }];
+};
+/**
+ * How the readings scatter, one sample per group. A group whose
+ * readings all sit at one place yields nothing, since no scatter can be
+ * read off such a sample.
+ */
+export const scatterOf = (readings, options = {}) => [...groupBy(readings, reading => (options.groupOf ?? byWhatItIs)(reading.symbol))]
+    .flatMap(([group, sample]) => scatterIn(group, sample, options));
+/** How one copy's readings of a version's text scatter against the readings of the copies it is collated with. */
+export const scatterOfCopy = (view, versionId, copyId, options = {}) => scatterOf(readingsOf(view, view.snapshot(versionId), new Set([copyId])), options);
+const covering = (windows) => {
+    const lowest = Math.min(...windows.map(window => window.offset - window.tolerance));
+    const highest = Math.max(...windows.map(window => window.offset + window.tolerance));
+    return { offset: mm((lowest + highest) / 2), tolerance: mm((highest - lowest) / 2) };
+};
+/**
+ * One window admitting what every sample's own window admits. A
+ * derivation states a single tolerance while the samples differ, and
+ * covering them keeps each sample within the budget of chance
+ * departures its own threshold was chosen for. Nothing where there is
+ * no sample.
+ */
+export const toleranceAcross = (scatters) => {
+    if (scatters.length === 0)
+        return undefined;
+    const start = covering(scatters.map(({ tolerance }) => ({ offset: offsetStartOf(tolerance), tolerance: tolerance.toleranceStart })));
+    const end = covering(scatters.map(({ tolerance }) => ({ offset: offsetEndOf(tolerance), tolerance: tolerance.toleranceEnd })));
+    return {
+        offsetStart: start.offset,
+        toleranceStart: start.tolerance,
+        offsetEnd: end.offset,
+        toleranceEnd: end.tolerance
+    };
+};
+const inMillimetres = (value) => `${value.toFixed(2)} mm`;
+const sampleDescribed = (scatter) => `${scatter.group}: ${scatter.spread.from.n} readings, scattering by `
+    + `${inMillimetres(scatter.spread.from.sigma)} at the start and ${inMillimetres(scatter.spread.to.sigma)} at the end `
+    + `about a median of ${inMillimetres(scatter.spread.from.median)} and ${inMillimetres(scatter.spread.to.median)}, `
+    + `with a threshold of ${scatter.k.toFixed(2)} times the scatter`;
+const warrantFor = (scatters) => 'The tolerance is calculated from the scatter of the readings themselves, taken as the median absolute '
+    + 'deviation of how far the collated copies put each symbol from where the copies read with it put it. '
+    + `${scatters.map(sampleDescribed).join('. ')}. `
+    + 'Each threshold is the point beyond which fewer than one reading of a sample of that size is expected to '
+    + 'fall by chance, and the window is the threshold times the scatter about its median.';
+/**
+ * The belief a calculated tolerance rests on, to annotate the
+ * derivation's `collationTolerance` with: an inference from the scatter
+ * of the readings, the size of the sample and the rule that fixed the
+ * threshold. `used` names what the inference worked on, such as the
+ * copies compared.
+ *
+ * It is held likely rather than true. The tolerance follows from the
+ * sample only as far as the sample is normal, and a sample far from
+ * that shape makes the number unreliable rather than wrong, which is
+ * what `normality` is reported for.
+ */
+export const inferredTolerance = (scatters, used = []) => ({
+    type: 'belief',
+    id: v4(),
+    certainty: 'likely',
+    reasons: [{
+            type: 'inference',
+            premises: [],
+            ...(used.length > 0 && { used: [...used] }),
+            note: warrantFor(scatters)
+        }]
+});

package/lib/schema.json

@@ -204,15 +204,23 @@
             "type": "string"
         },
         "CollationTolerance": {
-            "description": "Tolerance used in collation of roll copies: the acceptable deviation at either end when aligning features across copies.",
+            "description": "The window two readings of one feature must fall in to be collated: how far apart they may lie at either end, and where that window is centred.\n\nThe centre is worth stating. Two copies of one roll differ by a systematic offset as well as by scatter, and a window centred on nothing has to be widened by the whole of that offset before it admits what the offset alone displaces. Naming the offset lets the tolerance stand for the scatter only. A window that names none is centred on nothing, which is what every window written before the offset was held here means.",
             "properties": {
+                "offsetEnd": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "The same at the end of a feature."
+                },
+                "offsetStart": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "How much later the collated copy puts the start of a feature than the copy it is read against, where the two differ systematically. Nothing where they do not."
+                },
                 "toleranceEnd": {
                     "$ref": "#/definitions/Millimeters",
-                    "description": "Tolerance at the end position of a feature."
+                    "description": "How far they may lie apart at the end, measured from `offsetEnd`."
                 },
                 "toleranceStart": {
                     "$ref": "#/definitions/Millimeters",
-                    "description": "Tolerance at the start position of a feature."
+                    "description": "How far the two readings may lie apart at the start of a feature, measured from `offsetStart`."
                 }
             },
             "required": [
@@ -222,34 +230,66 @@
             "type": "object"
         },
         "Concept": {
-            "description": "A term from a vocabulary, such as a roll system or a kind of paper. A term the type vocabulary knows carries its IRI as `id`.",
-            "properties": {
-                "name": {
-                    "description": "The name, e.g. \"Grünfeld, Alfred\", \"Wien\", \"M. Welte & Söhne\".",
-                    "type": "string",
-                    "ontology": "rdfs:label"
-                },
-                "sameAs": {
-                    "description": "Authority records for the same thing: GND, Wikidata, geonames or similar.",
-                    "examples": [
-                        "https://d-nb.info/gnd/116888652"
-                    ],
-                    "items": {
-                        "type": "string"
+            "anyOf": [
+                {
+                    "properties": {
+                        "name": {
+                            "description": "The name, e.g. \"Grünfeld, Alfred\", \"Wien\", \"M. Welte & Söhne\".",
+                            "type": "string",
+                            "ontology": "rdfs:label"
+                        },
+                        "sameAs": {
+                            "description": "Authority records for the same thing: GND, Wikidata, geonames or similar.",
+                            "examples": [
+                                "https://d-nb.info/gnd/116888652"
+                            ],
+                            "items": {
+                                "type": "string"
+                            },
+                            "type": "array",
+                            "ontology": "owl:sameAs"
+                        },
+                        "@id": {
+                            "description": "A unique identifier for this object.",
+                            "type": "string"
+                        }
                     },
-                    "type": "array",
-                    "ontology": "owl:sameAs"
+                    "required": [
+                        "@id"
+                    ],
+                    "type": "object"
                 },
-                "@id": {
-                    "description": "A unique identifier for this object.",
-                    "type": "string"
+                {
+                    "properties": {
+                        "name": {
+                            "description": "The name, e.g. \"Grünfeld, Alfred\", \"Wien\", \"M. Welte & Söhne\".",
+                            "type": "string",
+                            "ontology": "rdfs:label"
+                        },
+                        "sameAs": {
+                            "description": "Authority records for the same thing: GND, Wikidata, geonames or similar.",
+                            "examples": [
+                                "https://d-nb.info/gnd/116888652"
+                            ],
+                            "items": {
+                                "type": "string"
+                            },
+                            "type": "array",
+                            "ontology": "owl:sameAs"
+                        },
+                        "@id": {
+                            "description": "A unique identifier for this object.",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "name",
+                        "sameAs"
+                    ],
+                    "type": "object"
                 }
-            },
-            "required": [
-                "name",
-                "sameAs"
             ],
-            "type": "object",
+            "description": "A term from a vocabulary, such as a roll system, a procedure or a kind of paper.\n\nA term the type vocabulary declares is named by its IRI, and what it is called stands in the vocabulary rather than in the edition, so it needs no name of its own; `nameOf` reads one either way. A term the vocabulary does not have is given by name, which is then all there is to go on.",
             "ontology": "crm:E55 Type"
         },
         "DateAssignment": {
@@ -382,8 +422,8 @@
                     "type": "object"
                 },
                 "collationTolerance": {
-                    "$ref": "#/definitions/CollationTolerance",
-                    "description": "The tolerance at which the derived version was collated against the one it is based on. A derivation written before the tolerance was held here states none. Not exported to RDF."
+                    "$ref": "#/definitions/ObjectAssumption%3CCollationTolerance%3E",
+                    "description": "The tolerance at which the derived version was collated against the one it is based on. A derivation written before the tolerance was held here states none. Not exported to RDF.\n\nIt is an object assumption, so that a tolerance calculated from the scatter of the readings can carry the inference it was drawn by. It is the one quantity in the edition that decides what counts as a reading at all, and a number arrived at by a method should say so."
                 },
                 "@id": {
                     "description": "A unique identifier for this object.",
@@ -544,7 +584,8 @@
             "properties": {
                 "collationTolerance": {
                     "$ref": "#/definitions/CollationTolerance",
-                    "description": "The tolerance parameters used when collating (aligning) the different roll copies for this edition. Not exported to RDF."
+                    "deprecated": true,
+                    "description": "The tolerance every version of the edition was collated at, before each derivation stated its own. How precisely two copies place a symbol depends on which two they are, so the tolerance belongs to the derivation, `Derivation.collationTolerance`, and migration writes this one onto every derivation that gives none. Nothing else reads it. A window's offset is the displacement between two particular copies and so can never be stated here. Not exported to RDF."
                 },
                 "editors": {
                     "description": "The persons who prepared the edition, each with the part they took in the editorial work. An edition written before this field existed carries none.",
@@ -1867,6 +1908,51 @@
             ],
             "type": "object"
         },
+        "ObjectAssumption<CollationTolerance>": {
+            "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
+            "properties": {
+                "@annotation": {
+                    "description": "An optional annotation expressing a belief about this assumption. Uses the JSON-LD-star `@annotation` mechanism to attach epistemic metadata (certainty and reasons) to any triple.",
+                    "properties": {
+                        "belief": {
+                            "$ref": "#/definitions/Belief",
+                            "description": "The belief held about the annotated statement.",
+                            "ontology": "crminf:J4i is subject of"
+                        },
+                        "@id": {
+                            "description": "A unique identifier for this object.",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "belief",
+                        "@id"
+                    ],
+                    "type": "object"
+                },
+                "offsetEnd": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "The same at the end of a feature."
+                },
+                "offsetStart": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "How much later the collated copy puts the start of a feature than the copy it is read against, where the two differ systematically. Nothing where they do not."
+                },
+                "toleranceEnd": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "How far they may lie apart at the end, measured from `offsetEnd`."
+                },
+                "toleranceStart": {
+                    "$ref": "#/definitions/Millimeters",
+                    "description": "How far the two readings may lie apart at the start of a feature, measured from `offsetStart`."
+                }
+            },
+            "required": [
+                "toleranceEnd",
+                "toleranceStart"
+            ],
+            "type": "object"
+        },
         "ObjectAssumption<ConditionState<\"general\">>": {
             "description": "An object assumption wraps a complex object with an optional annotation. Used for structured values (e.g. persons, conditions) whose properties may be uncertain.",
             "properties": {
@@ -3011,12 +3097,6 @@
                     },
                     "type": "array"
                 },
-                "siglum": {
-                    "deprecated": true,
-                    "description": "A label a document carries from before the sigla were computed. Nothing should write one here and nothing should show one: what a version is called comes from `siglaOf`.",
-                    "type": "string",
-                    "ontology": "reo:siglum"
-                },
                 "system": {
                     "$ref": "#/definitions/Concept",
                     "description": "The reproducing system this version is coded for. One roll was often issued for several of them, and a version is a reading in one system's words: its expression types are that system's vocabulary and its notes sit on that bar's positions. A system the type vocabulary knows carries the IRI of its concept as `id`, from which the export takes the system's own context.",

package/lib/statistics.d.ts

@@ -0,0 +1,71 @@
+import { Quantity } from "./Quantity";
+/**
+ * The statistics a sample of measurements is described with.
+ *
+ * The centre and the scatter are taken from the median rather than from
+ * the mean, because the departures a measurement over an edition looks
+ * for are in the sample it is taken over. A mean and a standard
+ * deviation would grow towards those departures until they no longer
+ * stood out; a median and a median absolute deviation leave them out of
+ * account.
+ */
+/** The middle of a sample, the mean of the two middle values where it has an even number of them. */
+export declare const medianOf: <U extends string>(values: readonly Quantity<U>[]) => Quantity<U> | undefined;
+/** Where a sample sits and how far it scatters. */
+export interface Spread<U extends string> {
+    /** How many measurements it was taken over. */
+    n: number;
+    /** The middle measurement. */
+    median: Quantity<U>;
+    /**
+     * The scatter about the median, as the median absolute deviation
+     * scaled to the standard deviation a normal sample of that scatter
+     * would have. It is zero where more than half the sample sits at
+     * one value, and no scatter can be read off such a sample.
+     */
+    sigma: Quantity<U>;
+}
+/** Where the sample sits and how far it scatters, or nothing for an empty sample. */
+export declare const spreadOf: <U extends string>(values: readonly Quantity<U>[]) => Spread<U> | undefined;
+/** How far the value lies from the centre of the spread, in units of its scatter. */
+export declare const standardise: <U extends string>(value: Quantity<U>, spread: Spread<U>) => number;
+/** The share of a normal sample lying below `z` standard deviations. */
+export declare const normalBelow: (z: number) => number;
+/** The share of a normal sample lying further than `z` standard deviations from its centre, on either side. */
+export declare const normalBeyond: (z: number) => number;
+/**
+ * How many standard deviations out the given share of a normal sample
+ * lies below, after Acklam's rational approximation, whose relative
+ * error stays below 1.15e-9. The inverse of `normalBelow`.
+ */
+export declare const normalQuantile: (share: number) => number;
+/**
+ * How much heavier the tails of a standardised sample are than a normal
+ * sample's. Zero for a normal shape, positive where more of the sample
+ * lies far out than the curve allows.
+ */
+export declare const excessKurtosisOf: (standardised: readonly number[]) => number;
+/** How much of a sample lies beyond a given distance from its centre, against how much would under a normal curve. */
+export interface Tail {
+    /** The distance from the centre, in standard deviations. */
+    beyond: number;
+    /** How many of the sample lie further out than that. */
+    observed: number;
+    /** How many a normal sample of the same size would put there. */
+    expected: number;
+}
+/** What the sample puts beyond the given distance, against what a normal sample would. */
+export declare const tailOf: (standardised: readonly number[], beyond: number) => Tail;
+/** A sample counted into bins of one width. */
+export interface Histogram<U extends string> {
+    /** The bounds of the bins, in order, one more of them than there are counts. */
+    edges: Quantity<U>[];
+    /** How many of the sample fall in each bin. */
+    counts: number[];
+}
+/**
+ * The sample counted into bins of the given width, laid out on
+ * multiples of that width so that two histograms of one width share
+ * their bounds. Nothing for an empty sample or a width of nothing.
+ */
+export declare const histogramOf: <U extends string>(values: readonly Quantity<U>[], binWidth: Quantity<U>) => Histogram<U> | undefined;