@lapxo/obligations 0.3.4 → 0.4.0

package/dist/measures/identification.js

@@ -0,0 +1,107 @@
+import { add, sub, mul, div, q, zero, one, equal, pack, probability, refuse } from "./rational.js";
+const key = (a, b) => JSON.stringify([a, b].sort());
+const gcd = (a, b) => b ? gcd(b, a % b) : a;
+const integerPower = (a, n) => n < 0n ? q(a[1] ** (-n), a[0] ** (-n)) : q(a[0] ** n, a[1] ** n);
+function exactRoot(a, n) {
+    if (a === 0n || a === 1n || n === 1n)
+        return a;
+    if (n > BigInt(a.toString(2).length))
+        return undefined;
+    let low = 1n, high = a;
+    while (low <= high) {
+        const middle = (low + high) / 2n, p = middle ** n;
+        if (p === a)
+            return middle;
+        if (p < a)
+            low = middle + 1n;
+        else
+            high = middle - 1n;
+    }
+    return undefined;
+}
+function monomial(bases, powers) {
+    let degree = 1n;
+    for (const p of powers)
+        degree = degree / gcd(degree, p[1]) * p[1];
+    let radicand = one;
+    for (let i = 0; i < bases.length; i++)
+        radicand = mul(radicand, integerPower(bases[i], powers[i][0] * (degree / powers[i][1])));
+    const a = exactRoot(radicand[0], degree), b = exactRoot(radicand[1], degree);
+    return { radicand: pack(radicand), degree: String(degree), rational: a === undefined || b === undefined ? undefined : pack(q(a, b)) };
+}
+export function identifyM3(input, policy) {
+    if (!input || !Array.isArray(input.witnesses) || !Array.isArray(input.factors) || !Array.isArray(input.pairs) || !policy || !/^\d+$/.test(policy.budget))
+        refuse('invalid identification inputs');
+    const ids = input.witnesses.map(w => w?.id);
+    if (!ids.length || ids.some(id => typeof id !== 'string' || !id) || new Set(ids).size !== ids.length)
+        refuse('invalid identification witnesses');
+    if (input.factors.some(f => !f || typeof f.id !== 'string' || !f.id || !Array.isArray(f.members) || new Set(f.members).size !== f.members.length || f.members.some(id => !ids.includes(id))) || new Set(input.factors.map(f => f.id)).size !== input.factors.length)
+        refuse('invalid declared sharing structure');
+    const s = input.witnesses.map(w => probability(w.correct));
+    const shared = input.factors.filter(f => f.members.length > 1), rows = input.pairs.length, columns = shared.length;
+    const metadata = { model: 'M/3', parameters: input, conditions: ['population-moments', 'declared-sharing-sets', 'positive-correctness', 'full-column-rank', 'singleton-private-unresolved'], policy };
+    if (s.some(p => p[0] === 0n))
+        return { ...metadata, status: 'unmeasured', cause: 'zero correctness; unidentified' };
+    const seen = new Set(), bases = [], matrix = [];
+    for (const pair of input.pairs) {
+        if (!pair || pair.a === pair.b || !ids.includes(pair.a) || !ids.includes(pair.b) || seen.has(key(pair.a, pair.b)))
+            refuse('invalid identification pair');
+        seen.add(key(pair.a, pair.b));
+        const a = s[ids.indexOf(pair.a)], b = s[ids.indexOf(pair.b)], joint = probability(pair.correctTogether);
+        if (joint[0] === 0n || sub(joint, a)[0] > 0n || sub(joint, b)[0] > 0n || sub(joint, sub(add(a, b), one))[0] < 0n)
+            return { ...metadata, status: 'unmeasured', cause: 'model/M misfit' };
+        bases.push(div(joint, mul(a, b)));
+        matrix.push(shared.map(f => f.members.includes(pair.a) && f.members.includes(pair.b) ? one : zero));
+    }
+    const work = BigInt(rows) * BigInt(columns) * BigInt(rows + columns + 1);
+    if (work > BigInt(policy.budget))
+        return { ...metadata, status: 'unmeasured', cause: 'identification/budget', required: String(work) };
+    const transform = matrix.map((_, i) => matrix.map((__, j) => i === j ? one : zero));
+    let rank = 0;
+    const pivots = [];
+    for (let column = 0; column < columns; column++) {
+        const pivot = matrix.findIndex((row, i) => i >= rank && row[column][0] !== 0n);
+        if (pivot < 0)
+            continue;
+        [matrix[rank], matrix[pivot]] = [matrix[pivot], matrix[rank]];
+        [transform[rank], transform[pivot]] = [transform[pivot], transform[rank]];
+        const divisor = matrix[rank][column];
+        matrix[rank] = matrix[rank].map(v => div(v, divisor));
+        transform[rank] = transform[rank].map(v => div(v, divisor));
+        for (let i = 0; i < rows; i++)
+            if (i !== rank) {
+                const amount = matrix[i][column];
+                matrix[i] = matrix[i].map((v, j) => sub(v, mul(amount, matrix[rank][j])));
+                transform[i] = transform[i].map((v, j) => sub(v, mul(amount, transform[rank][j])));
+            }
+        pivots.push(column);
+        rank++;
+    }
+    if (rank !== columns)
+        return { ...metadata, status: 'unmeasured', cause: 'rank-deficient declared sharing system', rank, columns };
+    for (let i = rank; i < rows; i++) {
+        const residual = monomial(bases, transform[i]);
+        if (!equal(q(BigInt(residual.radicand.numerator), BigInt(residual.radicand.denominator)), one))
+            return { ...metadata, status: 'unmeasured', cause: 'model/M misfit', rank, columns };
+    }
+    const factors = shared.map((factor, j) => {
+        const powers = transform[pivots.indexOf(j)], inverseSurvival = monomial(bases, powers);
+        const radicand = q(BigInt(inverseSurvival.radicand.numerator), BigInt(inverseSurvival.radicand.denominator));
+        if (sub(radicand, one)[0] < 0n)
+            return { id: factor.id, misfit: true };
+        const survival = monomial(bases, powers.map(p => q(-p[0], p[1])));
+        return { id: factor.id, survival, probability: survival.rational ? pack(sub(one, q(BigInt(survival.rational.numerator), BigInt(survival.rational.denominator)))) : undefined };
+    });
+    if (factors.some(f => 'misfit' in f))
+        return { ...metadata, status: 'unmeasured', cause: 'model/M misfit', rank, columns };
+    const residualSurvival = input.witnesses.map((w, i) => {
+        const powers = bases.map(() => zero);
+        shared.forEach((f, j) => { if (f.members.includes(w.id))
+            transform[pivots.indexOf(j)].forEach((p, k) => { powers[k] = add(powers[k], p); }); });
+        const r = monomial([s[i], ...bases], [one, ...powers]);
+        return { witness: w.id, r, privateSingletonDecomposition: 'unresolved' };
+    });
+    if (residualSurvival.some(w => sub(q(BigInt(w.r.radicand.numerator), BigInt(w.r.radicand.denominator)), one)[0] > 0n))
+        return { ...metadata, status: 'unmeasured', cause: 'model/M misfit', rank, columns };
+    return { ...metadata, status: 'identified', rank, columns, factors, residualSurvival, representation: 'positive exact rational roots' };
+}

package/dist/measures/index.d.ts

@@ -0,0 +1,18 @@
+export { errorMatrix, covariance, errorCovariance, participationRatio } from './error-events.ts';
+export type { ErrorEvent, ErrorMatrix, Covariance, Unmeasured, Scalar, ObservationPolicy } from './error-events.ts';
+export { spectrum, commonMass, loadings, commonMassOf } from './spectrum.ts';
+export type { Spectrum, NumericalPolicy } from './spectrum.ts';
+export { unanimityFloor, unanimityThreshold, descentCount, modelRequired } from './model.ts';
+export type { UnanimityModel, Descent } from './model.ts';
+export { dissentExperiment, interestExperiment } from './experiments.ts';
+export type { ExperimentPolicy, ConditionalRate } from './experiments.ts';
+export { evaluateM3, probeUpdate, dissentCertificate } from './m3.ts';
+export type { Witness, Factor, ModelM3, EvaluationPolicy, Conditional } from './m3.ts';
+export { roundHalfEven } from './rational.ts';
+export type { Rational, RationalInput } from './rational.ts';
+export { identifyM3 } from './identification.ts';
+export type { IdentificationInput, IdentificationPolicy } from './identification.ts';
+export { experimentM3 } from './m3-experiment.ts';
+export type { M3ExperimentPolicy } from './m3-experiment.ts';
+export { fitM3 } from './fitting.ts';
+export type { FitStructure, FitPolicy } from './fitting.ts';

package/dist/measures/index.js

@@ -0,0 +1,9 @@
+export { errorMatrix, covariance, errorCovariance, participationRatio } from "./error-events.js";
+export { spectrum, commonMass, loadings, commonMassOf } from "./spectrum.js";
+export { unanimityFloor, unanimityThreshold, descentCount, modelRequired } from "./model.js";
+export { dissentExperiment, interestExperiment } from "./experiments.js";
+export { evaluateM3, probeUpdate, dissentCertificate } from "./m3.js";
+export { roundHalfEven } from "./rational.js";
+export { identifyM3 } from "./identification.js";
+export { experimentM3 } from "./m3-experiment.js";
+export { fitM3 } from "./fitting.js";

package/dist/measures/m3-experiment.d.ts

@@ -0,0 +1,69 @@
+import { type ModelM3 } from './m3.ts';
+export type M3ExperimentPolicy = Readonly<{
+    prng: 'xorshift32';
+    seed: number;
+    trials: number;
+    randomWords: number;
+}>;
+export declare function experimentM3(model: ModelM3, policy: M3ExperimentPolicy): {
+    status: "unmeasured";
+    cause: string;
+    words: number;
+    model: "M/3";
+    parameters: Readonly<{
+        cell: string;
+        cardinality: number;
+        witnesses: readonly import("./m3.ts").Witness[];
+        factors: readonly import("./m3.ts").Factor[];
+        selection: readonly string[];
+    }>;
+    policy: Readonly<{
+        prng: "xorshift32";
+        seed: number;
+        trials: number;
+        randomWords: number;
+    }>;
+    conditions: readonly ["controlled-simulation", "declared-xorshift32-stream", "exact-rational-event-sampling", "not-a-law"];
+} | {
+    status: "measured";
+    words: number;
+    counts: {
+        true: number;
+        false: number;
+        fired: number;
+        dissent: number;
+        majorityTrue: number;
+        majorityFalse: number;
+        majorityNone: number;
+    };
+    unanimity: {
+        numerator: number;
+        denominator: number;
+        rate: number | "unmeasured";
+    };
+    falseMajorityGivenDissent: {
+        numerator: number;
+        denominator: number;
+        rate: number | "unmeasured";
+    };
+    falseMajorityGivenMajorityAndDissent: {
+        numerator: number;
+        denominator: number;
+        rate: number | "unmeasured";
+    };
+    model: "M/3";
+    parameters: Readonly<{
+        cell: string;
+        cardinality: number;
+        witnesses: readonly import("./m3.ts").Witness[];
+        factors: readonly import("./m3.ts").Factor[];
+        selection: readonly string[];
+    }>;
+    policy: Readonly<{
+        prng: "xorshift32";
+        seed: number;
+        trials: number;
+        randomWords: number;
+    }>;
+    conditions: readonly ["controlled-simulation", "declared-xorshift32-stream", "exact-rational-event-sampling", "not-a-law"];
+};

package/dist/measures/m3-experiment.js

@@ -0,0 +1,70 @@
+import { validateM3 } from "./m3.js";
+import { probability, refuse } from "./rational.js";
+export function experimentM3(model, policy) {
+    validateM3(model);
+    if (!policy || policy.prng !== 'xorshift32' || !Number.isInteger(policy.seed) || policy.seed <= 0 || policy.seed > 0xffffffff || !Number.isSafeInteger(policy.trials) || policy.trials < 1 || !Number.isSafeInteger(policy.randomWords) || policy.randomWords < 0)
+        refuse('invalid experiment policy');
+    const metadata = { model: 'M/3', parameters: model, policy, conditions: ['controlled-simulation', 'declared-xorshift32-stream', 'exact-rational-event-sampling', 'not-a-law'] };
+    let x = policy.seed >>> 0, words = 0;
+    const exhausted = Symbol('experiment/random-words');
+    const word = () => { if (words === policy.randomWords)
+        throw exhausted; words++; x ^= x << 13; x ^= x >>> 17; x ^= x << 5; return BigInt(x >>> 0); };
+    const below = (n) => { if (n === 1n)
+        return 0n; const bits = BigInt((n - 1n).toString(2).length), mask = (1n << bits) - 1n; for (;;) {
+        let r = 0n;
+        for (let b = 0n; b < bits; b += 32n)
+            r = (r << 32n) | word();
+        r &= mask;
+        if (r < n)
+            return r;
+    } };
+    const bernoulli = (p) => p[0] === 0n ? false : p[0] === p[1] ? true : below(p[1]) < p[0];
+    const factors = [...model.factors].filter(f => f.members.some(id => model.selection.includes(id))).sort((a, b) => a.index - b.index);
+    const c = factors.map(f => probability(f.probability)), p = model.selection.map(id => probability(model.witnesses.find(w => w.id === id).privateError)), k = model.selection.length;
+    const counts = { true: 0, false: 0, fired: 0, dissent: 0, majorityTrue: 0, majorityFalse: 0, majorityNone: 0 };
+    try {
+        for (let trial = 0; trial < policy.trials; trial++) {
+            const governors = model.selection.map(() => -1);
+            let fired = false;
+            factors.forEach((f, i) => { if (bernoulli(c[i])) {
+                fired = true;
+                model.selection.forEach((id, j) => { if (governors[j] === -1 && f.members.includes(id))
+                    governors[j] = i; });
+            } });
+            const labels = new Map(), values = new Map();
+            const wrong = () => Number(below(BigInt(model.cardinality - 1))) + 1;
+            governors.forEach((g, i) => { let value = 0; if (g !== -1) {
+                if (!labels.has(g))
+                    labels.set(g, wrong());
+                value = labels.get(g);
+            }
+            else if (bernoulli(p[i]))
+                value = wrong(); values.set(value, (values.get(value) ?? 0) + 1); });
+            if (values.size === 1) {
+                if (values.has(0))
+                    counts.true++;
+                else {
+                    counts.false++;
+                    if (fired)
+                        counts.fired++;
+                }
+            }
+            else {
+                counts.dissent++;
+                if (2 * (values.get(0) ?? 0) > k)
+                    counts.majorityTrue++;
+                else if ([...values].some(([value, count]) => value !== 0 && 2 * count > k))
+                    counts.majorityFalse++;
+                else
+                    counts.majorityNone++;
+            }
+        }
+    }
+    catch (error) {
+        if (error !== exhausted)
+            throw error;
+        return { ...metadata, status: 'unmeasured', cause: 'experiment/random-words', words };
+    }
+    const conditional = (numerator, denominator) => ({ numerator, denominator, rate: denominator ? numerator / denominator : 'unmeasured' });
+    return { ...metadata, status: 'measured', words, counts, unanimity: conditional(counts.false, counts.true + counts.false), falseMajorityGivenDissent: conditional(counts.majorityFalse, counts.dissent), falseMajorityGivenMajorityAndDissent: conditional(counts.majorityFalse, counts.majorityTrue + counts.majorityFalse) };
+}

package/dist/measures/m3.d.ts

@@ -0,0 +1,139 @@
+import { type Q, type Rational, type RationalInput } from './rational.ts';
+export type Witness = Readonly<{
+    id: string;
+    privateError?: RationalInput;
+}>;
+export type Factor = Readonly<{
+    id: string;
+    index: number;
+    members: readonly string[];
+    probability: RationalInput;
+}>;
+export type ModelM3 = Readonly<{
+    cell: string;
+    cardinality: number;
+    witnesses: readonly Witness[];
+    factors: readonly Factor[];
+    selection: readonly string[];
+}>;
+export type EvaluationPolicy = Readonly<{
+    budget: string;
+}>;
+export type Conditional = Readonly<{
+    status: 'measured';
+    value: Rational;
+    numerator: Rational;
+    denominator: Rational;
+}> | Readonly<{
+    status: 'unmeasured';
+    cause: string;
+    numerator: Rational;
+    denominator: Rational;
+}>;
+export declare const conditions: readonly ["ordered-governance", "independent-factor-indicators", "independent-private-indicators", "independent-uniform-wrong-labels", "handed-parameters"];
+type Prepared = Readonly<{
+    witnesses: readonly Witness[];
+    factors: readonly Factor[];
+    private: readonly Q[];
+    rates: readonly Q[];
+}>;
+export declare function validateM3(model: ModelM3): Prepared;
+export declare function conditional(a: Q, b: Q, cause: string): Conditional;
+export declare function evaluateM3(model: ModelM3, policy: EvaluationPolicy): {
+    status: "unmeasured";
+    cause: string;
+    requiredAtLeast: string;
+    model: "M/3";
+    parameters: Readonly<{
+        cell: string;
+        cardinality: number;
+        witnesses: readonly Witness[];
+        factors: readonly Factor[];
+        selection: readonly string[];
+    }>;
+    conditions: readonly ["ordered-governance", "independent-factor-indicators", "independent-private-indicators", "independent-uniform-wrong-labels", "handed-parameters"];
+    policy: Readonly<{
+        budget: string;
+    }>;
+} | {
+    status: "measured";
+    work: string;
+    probabilities: {
+        true: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        false: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        fired: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        dissent: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        majorityTrue: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        majorityFalse: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        majorityNone: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+    };
+    quantities: {
+        phi: Conditional;
+        D: Conditional;
+        reliability: Conditional;
+        falseMajorityGivenDissent: Conditional;
+        falseMajorityGivenMajorityAndDissent: Conditional;
+    };
+    reliabilityLabel: string;
+    model: "M/3";
+    parameters: Readonly<{
+        cell: string;
+        cardinality: number;
+        witnesses: readonly Witness[];
+        factors: readonly Factor[];
+        selection: readonly string[];
+    }>;
+    conditions: readonly ["ordered-governance", "independent-factor-indicators", "independent-private-indicators", "independent-uniform-wrong-labels", "handed-parameters"];
+    policy: Readonly<{
+        budget: string;
+    }>;
+};
+export declare function probeUpdate(phi: RationalInput, error: RationalInput, cardinality: number): {
+    model: "M/3";
+    conditions: readonly ["independent-private-only-probe", "independent-uniform-wrong-value"];
+    parameters: {
+        phi: RationalInput;
+        error: RationalInput;
+        cardinality: number;
+    };
+    result: Conditional;
+};
+export declare function dissentCertificate(model: ModelM3, fired: readonly string[]): {
+    model: "M/3";
+    parameters: {
+        model: Readonly<{
+            cell: string;
+            cardinality: number;
+            witnesses: readonly Witness[];
+            factors: readonly Factor[];
+            selection: readonly string[];
+        }>;
+        fired: readonly string[];
+    };
+    conditions: readonly ["ordered-governance", "independent-factor-indicators", "independent-private-indicators", "independent-uniform-wrong-labels", "handed-parameters"];
+    unanimityForced: boolean;
+    coveringFactors: string[];
+    meaning: "observed dissent excludes this configuration only";
+};
+export {};

package/dist/measures/m3.js

@@ -0,0 +1,181 @@
+import { add, sub, mul, div, q, zero, one, equal, pack, probability, refuse } from "./rational.js";
+export const conditions = Object.freeze(['ordered-governance', 'independent-factor-indicators', 'independent-private-indicators', 'independent-uniform-wrong-labels', 'handed-parameters']);
+const named = (s) => typeof s === 'string' && s.length > 0;
+export function validateM3(model) {
+    if (!model || !Array.isArray(model.witnesses) || !Array.isArray(model.factors) || !Array.isArray(model.selection) || model.witnesses.some(w => !w) || model.factors.some(f => !f || !Array.isArray(f.members)))
+        refuse('invalid model records');
+    if (!named(model.cell) || !Number.isSafeInteger(model.cardinality) || model.cardinality < 2)
+        refuse('invalid cell or cardinality');
+    const ids = model.witnesses.map(w => w.id);
+    if (ids.some(id => !named(id)) || new Set(ids).size !== ids.length)
+        refuse('duplicate or absent witness');
+    if (!model.selection.length || new Set(model.selection).size !== model.selection.length || model.selection.some(id => !ids.includes(id)))
+        refuse('invalid selection');
+    const factors = [...model.factors].sort((a, b) => a.index - b.index);
+    if (new Set(factors.map(f => f.id)).size !== factors.length || new Set(factors.map(f => f.index)).size !== factors.length)
+        refuse('duplicate factor identity or index');
+    for (const f of factors)
+        if (!named(f.id) || !Number.isSafeInteger(f.index) || new Set(f.members).size !== f.members.length || f.members.some(id => !ids.includes(id)))
+            refuse('invalid sharing set or order');
+    const required = new Set([...model.selection, ...factors.filter(f => f.members.some(id => model.selection.includes(id))).flatMap(f => f.members)]);
+    const allPrivate = model.witnesses.map(w => { if (w.privateError === undefined) {
+        if (required.has(w.id))
+            refuse('private probability absent for ' + w.id);
+        return zero;
+    } return probability(w.privateError); });
+    const allRates = factors.map(f => probability(f.probability));
+    const selected = model.selection.map(id => model.witnesses[ids.indexOf(id)]);
+    const touching = factors.filter(f => f.members.some(id => model.selection.includes(id)));
+    return { witnesses: selected, factors: touching, private: selected.map(w => allPrivate[ids.indexOf(w.id)]), rates: touching.map(f => allRates[factors.indexOf(f)]) };
+}
+function limit(policy) { if (!policy || !/^\d+$/.test(policy.budget))
+    refuse('invalid evaluator/budget'); return BigInt(policy.budget); }
+function bells(n, cap) {
+    let row = [1n];
+    const result = [1n];
+    for (let i = 1; i <= n; i++) {
+        const next = [row[row.length - 1]];
+        for (let j = 1; j <= i; j++)
+            next.push(next[j - 1] + row[j - 1]);
+        row = next;
+        result.push(row[0]);
+        if (row[0] > cap)
+            break;
+    }
+    return result;
+}
+function* configurations(input, masses = true) {
+    const ids = input.witnesses.map(w => w.id), governors = ids.map(() => -1);
+    function* walk(i, mass, fired) {
+        if (i === input.factors.length) {
+            yield { governors: [...governors], mass, fired };
+            return;
+        }
+        yield* walk(i + 1, masses ? mul(mass, sub(one, input.rates[i])) : one, fired);
+        const changed = [];
+        for (let j = 0; j < ids.length; j++)
+            if (governors[j] === -1 && input.factors[i].members.includes(ids[j])) {
+                governors[j] = i;
+                changed.push(j);
+            }
+        yield* walk(i + 1, masses ? mul(mass, input.rates[i]) : one, true);
+        for (const j of changed)
+            governors[j] = -1;
+    }
+    yield* walk(0, one, false);
+}
+function countWork(input, cap) {
+    const k = input.witnesses.length, bell = bells(k + 1, cap);
+    if (bell.length <= k + 1 || bell[k + 1] > cap)
+        return cap + 1n;
+    let factorConfigurations = 1n;
+    for (let i = 0; i < input.factors.length; i++) {
+        factorConfigurations *= 2n;
+        if (factorConfigurations > cap)
+            return cap + 1n;
+    }
+    let total = 0n;
+    for (const c of configurations(input, false)) {
+        const free = c.governors.filter(g => g === -1).length, groups = new Set(c.governors.filter(g => g !== -1)).size;
+        let choose = 1n;
+        for (let r = 0; r <= free; r++) {
+            total += choose * bell[groups + r];
+            if (total > cap)
+                return cap + 1n;
+            choose = choose * BigInt(free - r) / BigInt(r + 1);
+        }
+    }
+    return total;
+}
+export function conditional(a, b, cause) { return b[0] === 0n ? { status: 'unmeasured', cause, numerator: pack(a), denominator: pack(b) } : { status: 'measured', value: pack(div(a, b)), numerator: pack(a), denominator: pack(b) }; }
+export function evaluateM3(model, policy) {
+    const input = validateM3(model), cap = limit(policy), work = countWork(input, cap);
+    const metadata = { model: 'M/3', parameters: model, conditions, policy };
+    if (work > cap)
+        return { ...metadata, status: 'unmeasured', cause: 'evaluator/budget', requiredAtLeast: String(work) };
+    const k = input.witnesses.length, wrong = BigInt(model.cardinality - 1);
+    let truth = zero, falsehood = zero, fired = zero, majorityTrue = zero, majorityFalse = zero, majorityNone = zero;
+    for (const configuration of configurations(input)) {
+        if (configuration.mass[0] === 0n)
+            continue;
+        const grouped = new Map();
+        configuration.governors.forEach(g => { if (g !== -1)
+            grouped.set(g, (grouped.get(g) ?? 0) + 1); });
+        const weights = [...grouped.values()], free = configuration.governors.flatMap((g, i) => g === -1 ? [i] : []);
+        function privatePatterns(i, mass, correct) {
+            if (mass[0] === 0n)
+                return;
+            if (i < free.length) {
+                const p = input.private[free[i]];
+                privatePatterns(i + 1, mul(mass, sub(one, p)), correct + 1);
+                weights.push(1);
+                privatePatterns(i + 1, mul(mass, p), correct);
+                weights.pop();
+                return;
+            }
+            const L = weights.length, blocks = [];
+            function partitions(label) {
+                if (label < L) {
+                    for (let j = 0; j < blocks.length; j++) {
+                        blocks[j] += weights[label];
+                        partitions(label + 1);
+                        blocks[j] -= weights[label];
+                    }
+                    blocks.push(weights[label]);
+                    partitions(label + 1);
+                    blocks.pop();
+                    return;
+                }
+                const b = blocks.length;
+                if (BigInt(b) > wrong)
+                    return;
+                let assignments = 1n;
+                for (let j = 0; j < b; j++)
+                    assignments *= wrong - BigInt(j);
+                const probabilityMass = mul(mass, q(assignments, wrong ** BigInt(L)));
+                if (correct === k) {
+                    truth = add(truth, probabilityMass);
+                    return;
+                }
+                if (correct === 0 && b === 1) {
+                    falsehood = add(falsehood, probabilityMass);
+                    if (configuration.fired)
+                        fired = add(fired, probabilityMass);
+                    return;
+                }
+                if (2 * correct > k)
+                    majorityTrue = add(majorityTrue, probabilityMass);
+                else if (blocks.some(weight => 2 * weight > k))
+                    majorityFalse = add(majorityFalse, probabilityMass);
+                else
+                    majorityNone = add(majorityNone, probabilityMass);
+            }
+            partitions(0);
+        }
+        privatePatterns(0, configuration.mass, 0);
+    }
+    const dissent = sub(sub(one, truth), falsehood), majorityMass = add(majorityTrue, majorityFalse), unanimity = add(truth, falsehood);
+    let closedTruth = one;
+    for (const p of input.private)
+        closedTruth = mul(closedTruth, sub(one, p));
+    for (const c of input.rates)
+        closedTruth = mul(closedTruth, sub(one, c));
+    if (!equal(closedTruth, truth) || !equal(dissent, add(majorityMass, majorityNone)))
+        refuse('partition mass identity');
+    return { ...metadata, status: 'measured', work: String(work), probabilities: { true: pack(truth), false: pack(falsehood), fired: pack(fired), dissent: pack(dissent), majorityTrue: pack(majorityTrue), majorityFalse: pack(majorityFalse), majorityNone: pack(majorityNone) }, quantities: { phi: conditional(falsehood, unanimity, 'no unanimity mass'), D: conditional(fired, unanimity, 'no unanimity mass'), reliability: conditional(truth, unanimity, 'no unanimity mass'), falseMajorityGivenDissent: conditional(majorityFalse, dissent, 'no dissent mass'), falseMajorityGivenMajorityAndDissent: conditional(majorityFalse, majorityMass, 'no majority mass') }, reliabilityLabel: 'P(correct | unanimous) under M/3 with handed parameters' };
+}
+export function probeUpdate(phi, error, cardinality) {
+    if (!Number.isSafeInteger(cardinality) || cardinality < 2)
+        refuse('invalid probe cardinality');
+    const f = probability(phi), p = probability(error), a = div(mul(f, p), q(BigInt(cardinality - 1))), b = mul(sub(one, f), sub(one, p));
+    return { model: 'M/3', conditions: ['independent-private-only-probe', 'independent-uniform-wrong-value'], parameters: { phi, error, cardinality }, result: conditional(a, add(a, b), 'no extended unanimity mass') };
+}
+export function dissentCertificate(model, fired) {
+    validateM3(model);
+    if (!Array.isArray(fired) || new Set(fired).size !== fired.length || fired.some(id => !model.factors.some(f => f.id === id)))
+        refuse('invalid fired configuration');
+    const selected = new Set(model.selection), active = model.factors.filter(f => fired.includes(f.id) && f.members.some(id => selected.has(id)));
+    const covering = active.filter(f => model.selection.every(id => f.members.includes(id)));
+    const witnesses = covering.filter(f => !active.some(earlier => earlier.index < f.index && !model.selection.every(id => earlier.members.includes(id)))).map(f => f.id);
+    return { model: 'M/3', parameters: { model, fired }, conditions, unanimityForced: witnesses.length > 0, coveringFactors: witnesses, meaning: 'observed dissent excludes this configuration only' };
+}

package/dist/measures/model.d.ts

@@ -0,0 +1,14 @@
+import type { Scalar, Unmeasured } from './error-events.ts';
+export type UnanimityModel = Readonly<{
+    c: number;
+    p: number;
+    n: number;
+}>;
+export declare function unanimityFloor(model: UnanimityModel, k: number): Scalar;
+export declare function unanimityThreshold(model: UnanimityModel, searchLimit: number): Scalar;
+export type Descent = Readonly<{
+    scope: string;
+    restsOn: readonly string[];
+}>;
+export declare function descentCount(graph: readonly Descent[], cell: string): Scalar;
+export declare const modelRequired: (measure: string) => Unmeasured;