@lapxo/obligations 0.4.2 → 0.4.4

package/dist/measures/cofailure-pairs.d.ts

@@ -0,0 +1,113 @@
+import { type ValueReading, type TruthReading, type CoincidenceReference } from './coincidence.ts';
+import { type RationalInput } from './rational.ts';
+export type PairReference = Readonly<{
+    model: 'independent-categorical@1';
+    marginals: readonly Readonly<{
+        origin: string;
+        probabilities: readonly Readonly<{
+            value: string;
+            p: RationalInput;
+        }>[];
+    }>[];
+}>;
+export type PairSampling = Readonly<{
+    model: 'iid-cells@1';
+    epsilon: RationalInput;
+}>;
+type Common = Readonly<{
+    origins: readonly string[];
+    values: readonly string[];
+    T?: number;
+    theta?: RationalInput;
+    budget: string;
+    sampling?: PairSampling;
+}>;
+export type CofailureModel = Common & (Readonly<{
+    variant: 'oracle-false-rate';
+    truth: readonly TruthReading[];
+    reference: CoincidenceReference;
+}> | Readonly<{
+    variant: 'categorical-match-excess';
+    reference?: PairReference;
+    truth?: never;
+}>);
+export declare function cofailurePairs(rows: readonly ValueReading[], model: CofailureModel): {
+    status: "unmeasured";
+    cause: string;
+    required?: undefined;
+    events?: undefined;
+    T?: undefined;
+    variant?: undefined;
+    theta?: undefined;
+    origins?: undefined;
+    pairs?: undefined;
+    components?: undefined;
+    uncertainty?: undefined;
+    scoreMeaning?: undefined;
+    interpretation?: undefined;
+} | {
+    status: "unmeasured";
+    cause: string;
+    required: string;
+    events?: undefined;
+    T?: undefined;
+    variant?: undefined;
+    theta?: undefined;
+    origins?: undefined;
+    pairs?: undefined;
+    components?: undefined;
+    uncertainty?: undefined;
+    scoreMeaning?: undefined;
+    interpretation?: undefined;
+} | {
+    status: "unmeasured";
+    cause: string;
+    events: number;
+    T: number;
+    required?: undefined;
+    variant?: undefined;
+    theta?: undefined;
+    origins?: undefined;
+    pairs?: undefined;
+    components?: undefined;
+    uncertainty?: undefined;
+    scoreMeaning?: undefined;
+    interpretation?: undefined;
+} | {
+    status: "measured";
+    variant: "oracle-false-rate" | "categorical-match-excess";
+    T: number;
+    theta: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    origins: string[];
+    pairs: {
+        origins: readonly [string, string];
+        observed: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        expected: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        excess: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        score: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        edge: boolean;
+    }[];
+    components: string[][];
+    uncertainty: unknown;
+    scoreMeaning: string;
+    interpretation: "descriptive threshold components, not identified causes or probability of truth";
+    cause?: undefined;
+    required?: undefined;
+    events?: undefined;
+};
+export {};

package/dist/measures/cofailure-pairs.js

@@ -0,0 +1,129 @@
+import { coincidenceExcess } from "./coincidence.js";
+import { unionBoundConfidence } from "./confidence.js";
+import { add, sub, mul, div, q, zero, one, pack, rational, probability } from "./rational.js";
+const refuse = (cause) => { throw Error('REFUSE·cofailure ' + cause); };
+const named = (v) => typeof v === 'string' && v.trim().length > 0;
+const compare = (a, b) => a[0] * b[1] < b[0] * a[1] ? -1 : a[0] * b[1] > b[0] * a[1] ? 1 : 0;
+const max = (a, b) => compare(a, b) >= 0 ? a : b;
+const min = (a, b) => compare(a, b) <= 0 ? a : b;
+export function cofailurePairs(rows, model) {
+    if (!model || model.T === undefined || model.theta === undefined)
+        return { status: 'unmeasured', cause: 'cofailure/T-and-theta-required' };
+    if (!Number.isSafeInteger(model.T) || model.T < 1)
+        refuse('invalid-T');
+    if (!Array.isArray(rows) || !Array.isArray(model.origins) || model.origins.length < 2 || model.origins.some(id => !named(id)) || new Set(model.origins).size !== model.origins.length)
+        refuse('invalid-origins-or-rows');
+    if (!Array.isArray(model.values) || model.values.length < 2 || model.values.some(v => !named(v)) || new Set(model.values).size !== model.values.length)
+        refuse('invalid-alphabet');
+    if (model.variant !== 'oracle-false-rate' && model.variant !== 'categorical-match-excess')
+        refuse('declared-variant-required');
+    if (typeof model.budget !== 'string' || !/^\d+$/.test(model.budget))
+        refuse('budget-required');
+    const theta = rational(model.theta);
+    if (compare(theta, one) > 0 || compare(theta, model.variant === 'oracle-false-rate' ? zero : q(-1n)) < 0)
+        refuse('invalid-threshold');
+    const origins = [...model.origins].sort(), M = origins.length * (origins.length - 1) / 2;
+    const truth = model.variant === 'oracle-false-rate' ? model.truth : [];
+    if (!Array.isArray(truth))
+        refuse('truth-array-required');
+    if (model.variant === 'categorical-match-excess' && Object.hasOwn(model, 'truth'))
+        refuse('non-oracle-truth-input');
+    const required = BigInt(M) * (3n * BigInt(rows.length) + BigInt(truth.length) + BigInt(model.values.length) + 2n) + BigInt(rows.length) + BigInt(model.T) * BigInt(origins.length);
+    if (required > BigInt(model.budget))
+        return { status: 'unmeasured', cause: 'cofailure/budget', required: String(required) };
+    const alphabet = new Set(model.values), selected = new Set(origins), events = new Map();
+    for (const row of rows) {
+        if (!row || !named(row.event) || !named(row.origin) || !alphabet.has(row.value))
+            refuse('invalid-value-reading');
+        if (!selected.has(row.origin))
+            continue;
+        const at = events.get(row.event) ?? new Map();
+        if (at.has(row.origin) && at.get(row.origin) !== row.value)
+            refuse('conflicting-value ' + row.event + '/' + row.origin);
+        at.set(row.origin, row.value);
+        events.set(row.event, at);
+    }
+    if (events.size !== model.T || [...events.values()].some(at => at.size !== origins.length))
+        return { status: 'unmeasured', cause: 'cofailure/incomplete-declared-frame', events: events.size, T: model.T };
+    const marginals = new Map();
+    if (model.variant === 'oracle-false-rate' && model.reference?.marginals === 'handed') {
+        const errors = model.reference.errors;
+        if (!Array.isArray(errors) || errors.length !== origins.length || errors.some(e => !e) || new Set(errors.map(e => e.origin)).size !== origins.length || errors.some(e => !selected.has(e.origin)))
+            refuse('oracle-reference-origins');
+    }
+    if (model.variant === 'categorical-match-excess') {
+        if (!model.reference)
+            return { status: 'unmeasured', cause: 'cofailure/reference-required' };
+        if (model.reference.model !== 'independent-categorical@1' || !Array.isArray(model.reference.marginals) || model.reference.marginals.length !== origins.length)
+            refuse('categorical-reference-required');
+        for (const row of model.reference.marginals) {
+            if (!row || !selected.has(row.origin) || marginals.has(row.origin) || !Array.isArray(row.probabilities) || row.probabilities.length !== alphabet.size)
+                refuse('reference-origins-or-values');
+            const values = new Map();
+            for (const p of row.probabilities) {
+                if (!p || !alphabet.has(p.value) || values.has(p.value))
+                    refuse('reference-origins-or-values');
+                values.set(p.value, probability(p.p));
+            }
+            const total = [...values.values()].reduce(add, zero);
+            if (compare(total, one) !== 0)
+                refuse('reference-not-normalized');
+            marginals.set(row.origin, values);
+        }
+    }
+    const pairs = [];
+    for (let i = 0; i < origins.length; i++)
+        for (let j = i + 1; j < origins.length; j++) {
+            const a = origins[i], b = origins[j];
+            let observed, expected;
+            if (model.variant === 'oracle-false-rate') {
+                if (!model.reference || !Array.isArray(model.reference.values) || model.reference.values.length !== alphabet.size || model.reference.values.some(v => !alphabet.has(v)))
+                    refuse('oracle-reference-alphabet');
+                const reference = model.reference.marginals === 'handed' ? { ...model.reference, errors: model.reference.errors.filter(e => e.origin === a || e.origin === b) } : model.reference;
+                const reading = coincidenceExcess(rows, truth, [a, b], reference, { minEvents: model.T, minEventsPerTruth: 1, budget: model.budget });
+                if (reading.status !== 'measured')
+                    return { status: 'unmeasured', cause: 'cofailure/oracle ' + reading.cause };
+                observed = rational(reading.observed);
+                expected = rational(reading.expected);
+            }
+            else {
+                let count = 0;
+                for (const row of events.values())
+                    if (row.get(a) === row.get(b))
+                        count++;
+                observed = q(BigInt(count), BigInt(model.T));
+                expected = model.values.map(v => mul(marginals.get(a).get(v), marginals.get(b).get(v))).reduce(add, zero);
+            }
+            const excess = sub(observed, expected), score = model.variant === 'oracle-false-rate' ? observed : excess;
+            pairs.push({ origins: [a, b], observed: pack(observed), expected: pack(expected), excess: pack(excess), score: pack(score), edge: compare(score, theta) > 0 });
+        }
+    const parent = origins.map((_, i) => i), find = (i) => parent[i] === i ? i : find(parent[i]);
+    for (const p of pairs)
+        if (p.edge)
+            parent[find(origins.indexOf(p.origins[0]))] = find(origins.indexOf(p.origins[1]));
+    const groups = new Map();
+    origins.forEach((id, i) => { const key = find(i); groups.set(key, [...(groups.get(key) ?? []), id]); });
+    const components = [...groups.values()].sort((a, b) => a[0].localeCompare(b[0]));
+    let uncertainty = { status: 'unmeasured', cause: 'cofailure/sampling-design-required' };
+    if (model.sampling) {
+        if (model.sampling.model !== 'iid-cells@1')
+            refuse('sampling-model-required');
+        const epsilon = probability(model.sampling.epsilon);
+        if (compare(epsilon, zero) <= 0)
+            refuse('positive-epsilon-required');
+        const failure = min(one, div(one, mul(q(4n * BigInt(model.T)), mul(epsilon, epsilon))));
+        const confidence = unionBoundConfidence(pairs.map((p, i) => ({ id: 'pair-' + i, p: pack(failure), justification: 'Chebyshev: declared iid Bernoulli indicators, variance <= 1/4; fixed handed reference' })));
+        const intervals = pairs.map(p => {
+            const score = rational(p.score), expected = rational(p.expected), low = model.variant === 'oracle-false-rate' ? zero : sub(zero, expected), high = model.variant === 'oracle-false-rate' ? one : sub(one, expected);
+            const lo = max(low, sub(score, epsilon)), hi = min(high, add(score, epsilon));
+            return { origins: p.origins, lo: pack(lo), hi: pack(hi), decision: compare(lo, theta) > 0 ? 'above' : compare(hi, theta) < 0 ? 'below' : 'unresolved' };
+        });
+        uncertainty = { status: 'conditional', model: model.sampling.model, epsilon: pack(epsilon), perPairFailureUpper: pack(failure), confidence,
+            intervals, thresholdGraphResolved: intervals.every(i => i.decision !== 'unresolved'),
+            conditionalGraphCertificate: !confidence.trivial && intervals.every(i => i.decision !== 'unresolved'),
+            meaning: 'fixed-frame threshold graph only, conditional on the handed iid design; neither causal grouping nor iid was inferred' };
+    }
+    return { status: 'measured', variant: model.variant, T: model.T, theta: pack(theta), origins, pairs, components, uncertainty,
+        scoreMeaning: model.variant === 'oracle-false-rate' ? 'same wrong answer / T' : 'same answer / T minus handed independent-categorical reference',
+        interpretation: 'descriptive threshold components, not identified causes or probability of truth' };
+}

package/dist/measures/index.d.ts

@@ -24,3 +24,13 @@ export { coincidenceExcess } from './coincidence.ts';
 export type { ValueReading, TruthReading, CoincidenceReference, CoincidencePolicy } from './coincidence.ts';
 export { unionBoundConfidence, tolerantCountConfidence } from './confidence.ts';
 export type { DeclaredFailure } from './confidence.ts';
+export { tolerantSubsetConfidence, independentCountConfidence } from './tolerant-subsets.ts';
+export type { JointIndependenceDeclaration } from './tolerant-subsets.ts';
+export { phaseDefect, phaseDefectExtrema } from './phase-defect.ts';
+export type { PhaseDefectInterpretation } from './phase-defect.ts';
+export { mixProjectionLoss } from './mix-loss.ts';
+export type { NamedConfiguration, ConfigurationPrior, MixLossModel, MixLossPolicy } from './mix-loss.ts';
+export { cofailurePairs } from './cofailure-pairs.ts';
+export type { PairReference, PairSampling, CofailureModel } from './cofailure-pairs.ts';
+export { marginalInformation } from './marginal-information.ts';
+export type { MarginalSource, JointAtom, MarginalModel } from './marginal-information.ts';

package/dist/measures/index.js

@@ -11,3 +11,8 @@ export { commonCauseCapacityBound, capacityBound, capacityP0, mutualInformation,
 export { fitUnanimityModel } from "./unanimity-fit.js";
 export { coincidenceExcess } from "./coincidence.js";
 export { unionBoundConfidence, tolerantCountConfidence } from "./confidence.js";
+export { tolerantSubsetConfidence, independentCountConfidence } from "./tolerant-subsets.js";
+export { phaseDefect, phaseDefectExtrema } from "./phase-defect.js";
+export { mixProjectionLoss } from "./mix-loss.js";
+export { cofailurePairs } from "./cofailure-pairs.js";
+export { marginalInformation } from "./marginal-information.js";

package/dist/measures/marginal-information.d.ts

@@ -0,0 +1,78 @@
+import { type MixLossPolicy } from './mix-loss.ts';
+import { type RationalInput } from './rational.ts';
+export type MarginalSource = Readonly<{
+    id: string;
+    lineage: string;
+    values: readonly string[];
+}>;
+export type JointAtom = Readonly<{
+    id: string;
+    truth: string;
+    values: Readonly<Record<string, string>>;
+    p?: RationalInput;
+}>;
+export type MarginalModel = Readonly<{
+    model: 'finite-declared-joint@1';
+    truthValues: readonly string[];
+    sources: readonly MarginalSource[];
+    atoms: readonly JointAtom[];
+}>;
+export declare function marginalInformation(model: MarginalModel, orders: readonly (readonly string[])[], policy: MixLossPolicy): {
+    status: "unmeasured";
+    cause: string;
+    required?: undefined;
+    workUnit?: undefined;
+    model?: undefined;
+    unit?: undefined;
+    approximation?: undefined;
+    truthEntropy?: undefined;
+    declaredAtoms?: undefined;
+    computedSubsets?: undefined;
+    policy?: undefined;
+    readings?: undefined;
+    meaning?: undefined;
+} | {
+    status: "unmeasured";
+    cause: string;
+    required: string;
+    workUnit: "declared-support-scans";
+    model?: undefined;
+    unit?: undefined;
+    approximation?: undefined;
+    truthEntropy?: undefined;
+    declaredAtoms?: undefined;
+    computedSubsets?: undefined;
+    policy?: undefined;
+    readings?: undefined;
+    meaning?: undefined;
+} | {
+    status: "measured";
+    model: "finite-declared-joint@1";
+    unit: "bits";
+    approximation: "binary64-log2";
+    truthEntropy: number;
+    declaredAtoms: number;
+    computedSubsets: number;
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    workUnit: "declared-support-scans";
+    required: string;
+    readings: {
+        additionOrder: string[];
+        steps: {
+            source: string;
+            lineage: string;
+            priorSources: string[];
+            deltaInformation: number;
+            cumulativeInformation: number;
+            remainingConditionalEntropy: number;
+        }[];
+        totalInformation: number;
+        sumMarginals: number;
+        telescopingResidual: number;
+    }[];
+    meaning: "I(truth; new source | previous sources) under one unchanged declared joint prior; lineage labels supply no ordering or independence";
+    cause?: undefined;
+};

package/dist/measures/marginal-information.js

@@ -0,0 +1,71 @@
+import { mixProjectionLoss } from "./mix-loss.js";
+import { add, probability, pack, zero } from "./rational.js";
+const refuse = (why) => { throw Error('REFUSE·marginal ' + why); };
+const names = (xs) => Array.isArray(xs) && xs.length > 0 && xs.every(x => typeof x === 'string' && x.trim().length > 0) && new Set(xs).size === xs.length;
+export function marginalInformation(model, orders, policy) {
+    if (!model || model.model !== 'finite-declared-joint@1' || !Array.isArray(model.atoms))
+        return { status: 'unmeasured', cause: 'marginal/joint-model-required' };
+    if (!names(model.truthValues) || !Array.isArray(model.sources) || !model.sources.length || !names(model.sources.map(s => s?.id)))
+        refuse('declared-domain-required');
+    if (model.sources.some(s => !s || typeof s.lineage !== 'string' || !s.lineage.trim() || !names(s.values)))
+        refuse('declared-source-domain-required');
+    if (!policy || policy.logarithm !== 'binary64-log2' || typeof policy.budget !== 'string' || !/^\d+$/.test(policy.budget))
+        refuse('numeric-policy-required');
+    const ids = model.sources.map(s => s.id);
+    if (!Array.isArray(orders) || !orders.length || orders.some(o => !Array.isArray(o) || o.length !== ids.length || new Set(o).size !== ids.length || o.some(id => !ids.includes(id))))
+        refuse('order-must-be-permutation');
+    if (!model.atoms.length || !names(model.atoms.map(a => a?.id)))
+        refuse('unique-atom-ids-required');
+    if (model.atoms.some(a => !a || a.p === undefined || a.p === null))
+        return { status: 'unmeasured', cause: 'marginal/prior-required' };
+    const required = BigInt(model.atoms.length) * BigInt(ids.length + 1) * BigInt(1 + orders.length * (ids.length + 1));
+    if (required > BigInt(policy.budget))
+        return { status: 'unmeasured', cause: 'marginal/budget', required: String(required), workUnit: 'declared-support-scans' };
+    const probabilities = model.atoms.map(a => probability(a.p));
+    const total = probabilities.reduce(add, zero);
+    if (total[0] !== total[1])
+        refuse('prior-must-sum-to-one');
+    for (const a of model.atoms) {
+        if (!model.truthValues.includes(a.truth) || !a.values || Object.keys(a.values).length !== ids.length || model.sources.some(s => !Object.hasOwn(a.values, s.id) || !s.values.includes(a.values[s.id])))
+            refuse('atom-outside-domain');
+    }
+    const cached = new Map();
+    function conditional(selected) {
+        const coordinates = [...selected].sort(), key = JSON.stringify(coordinates), held = cached.get(key);
+        if (held !== undefined)
+            return held;
+        const states = new Map();
+        model.atoms.forEach((a, i) => {
+            const truth = JSON.stringify(['truth', a.truth]), tuple = JSON.stringify(['selected', coordinates.map(id => a.values[id])]), name = JSON.stringify([truth, tuple]);
+            const previous = states.get(name);
+            states.set(name, { truth, tuple, mass: add(previous?.mass ?? zero, probabilities[i]) });
+        });
+        const values = [...states.values()], alphabet = [...new Set(values.flatMap(v => [v.truth, v.tuple]))];
+        const result = mixProjectionLoss({ factors: [{ id: 'truth-coordinate', weight: '0' }, { id: 'selected-coordinate', weight: '1' }], alphabet,
+            configurations: values.map((v, i) => ({ id: String(i), values: [v.truth, v.tuple] })),
+            prior: { kind: 'explicit', probabilities: values.map((v, i) => ({ configuration: String(i), p: pack(v.mass) })) } }, policy);
+        if (result.status !== 'measured')
+            return refuse('projection-budget');
+        cached.set(key, result.lossBits);
+        return result.lossBits;
+    }
+    const truthEntropy = conditional([]);
+    const readings = orders.map(additionOrder => {
+        const selected = [];
+        let before = truthEntropy, sumMarginals = 0;
+        const steps = additionOrder.map(source => {
+            const priorSources = [...selected];
+            selected.push(source);
+            const after = conditional(selected), delta = before - after;
+            sumMarginals += delta;
+            before = after;
+            return { source, lineage: model.sources.find(s => s.id === source).lineage, priorSources,
+                deltaInformation: delta, cumulativeInformation: truthEntropy - after, remainingConditionalEntropy: after };
+        });
+        const totalInformation = truthEntropy - before;
+        return { additionOrder: [...additionOrder], steps, totalInformation, sumMarginals, telescopingResidual: sumMarginals - totalInformation };
+    });
+    return { status: 'measured', model: model.model, unit: 'bits', approximation: 'binary64-log2',
+        truthEntropy, declaredAtoms: model.atoms.length, computedSubsets: cached.size, policy, workUnit: 'declared-support-scans',
+        required: String(required), readings, meaning: 'I(truth; new source | previous sources) under one unchanged declared joint prior; lineage labels supply no ordering or independence' };
+}

package/dist/measures/mix-loss.d.ts

@@ -0,0 +1,187 @@
+import { type RationalInput } from './rational.ts';
+export type NamedConfiguration = Readonly<{
+    id: string;
+    values: readonly string[];
+}>;
+export type ConfigurationPrior = Readonly<{
+    kind: 'uniform';
+}> | Readonly<{
+    kind: 'explicit';
+    probabilities: readonly Readonly<{
+        configuration: string;
+        p: RationalInput;
+    }>[];
+}>;
+export type MixLossModel = Readonly<{
+    factors: readonly Readonly<{
+        id: string;
+        weight: RationalInput;
+    }>[];
+    alphabet: readonly string[];
+    configurations: readonly NamedConfiguration[];
+    prior?: ConfigurationPrior;
+}>;
+export type MixLossPolicy = Readonly<{
+    logarithm: 'binary64-log2';
+    budget: string;
+}>;
+export declare function mixProjectionLoss(model: MixLossModel, policy: MixLossPolicy): {
+    status: "unmeasured";
+    cause: "mix-loss/prior-required";
+    parameters: {
+        m: number;
+        factors: {
+            id: string;
+            weight: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        alphabet: string[];
+        configurations: {
+            id: string;
+            values: string[];
+        }[];
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    required?: undefined;
+    workUnit?: undefined;
+    model?: undefined;
+    prior?: undefined;
+    unit?: undefined;
+    approximation?: undefined;
+    configurationBits?: undefined;
+    mixBits?: undefined;
+    lossBits?: undefined;
+    entropyDifferenceBits?: undefined;
+    forkLossBits?: undefined;
+    mixInjectiveOnConfigurations?: undefined;
+    mixInjectiveOnPositiveSupport?: undefined;
+    configurations?: undefined;
+    outputs?: undefined;
+    meaning?: undefined;
+} | {
+    status: "unmeasured";
+    cause: "mix-loss/work-budget";
+    parameters: {
+        m: number;
+        factors: {
+            id: string;
+            weight: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        alphabet: string[];
+        configurations: {
+            id: string;
+            values: string[];
+        }[];
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    required: string;
+    workUnit: "declared-configurations";
+    model?: undefined;
+    prior?: undefined;
+    unit?: undefined;
+    approximation?: undefined;
+    configurationBits?: undefined;
+    mixBits?: undefined;
+    lossBits?: undefined;
+    entropyDifferenceBits?: undefined;
+    forkLossBits?: undefined;
+    mixInjectiveOnConfigurations?: undefined;
+    mixInjectiveOnPositiveSupport?: undefined;
+    configurations?: undefined;
+    outputs?: undefined;
+    meaning?: undefined;
+} | {
+    status: "measured";
+    model: "declared-weighted-mix-projection@1";
+    parameters: {
+        m: number;
+        factors: {
+            id: string;
+            weight: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        alphabet: string[];
+        configurations: {
+            id: string;
+            values: string[];
+        }[];
+    };
+    prior: {
+        kind: "uniform" | "explicit";
+        probabilities: {
+            configuration: string;
+            p: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    unit: "bits";
+    approximation: "binary64-log2";
+    configurationBits: number;
+    mixBits: number;
+    lossBits: number;
+    entropyDifferenceBits: number;
+    forkLossBits: number;
+    mixInjectiveOnConfigurations: boolean;
+    mixInjectiveOnPositiveSupport: boolean;
+    configurations: {
+        id: string;
+        probability: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        mix: Readonly<{
+            kind: "value";
+            value: string;
+        }> | {
+            kind: "tie";
+        };
+        fork: {
+            factor: string;
+            value: string;
+        }[];
+    }[];
+    outputs: {
+        output: Readonly<{
+            kind: "value";
+            value: string;
+        }> | {
+            kind: "tie";
+        };
+        probability: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        configurations: string[];
+        posterior: {
+            configuration: string;
+            p: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        conditionalBits: number | null;
+    }[];
+    meaning: "conditional entropy of the declared configuration given its deterministic mix output; named fork is injective";
+    cause?: undefined;
+    required?: undefined;
+    workUnit?: undefined;
+};