@lapxo/obligations 0.3.4 → 0.4.0

package/dist/measures/error-events.d.ts

@@ -0,0 +1,27 @@
+export type ErrorEvent = Readonly<{
+    event: string;
+    origin: string;
+    error: 0 | 1;
+}>;
+export type Unmeasured = Readonly<{
+    status: 'unmeasured';
+    cause: string;
+}>;
+export type ErrorMatrix = Readonly<{
+    status: 'measured';
+    origins: readonly string[];
+    events: readonly string[];
+    matrix: readonly (readonly number[])[];
+}>;
+export type Covariance = ErrorMatrix;
+export type Scalar = Readonly<{
+    status: 'measured';
+    value: number;
+}> | Unmeasured;
+export type ObservationPolicy = Readonly<{
+    minCells: number;
+}>;
+export declare function errorMatrix(rows: readonly ErrorEvent[], policy: ObservationPolicy, requested?: readonly string[]): ErrorMatrix | Unmeasured;
+export declare function covariance(reading: ErrorMatrix | Unmeasured): Covariance | Unmeasured;
+export declare const errorCovariance: (rows: readonly ErrorEvent[], policy: ObservationPolicy) => Covariance | Unmeasured;
+export declare function participationRatio(reading: Covariance | Unmeasured): Scalar;

package/dist/measures/error-events.js

@@ -0,0 +1,43 @@
+export function errorMatrix(rows, policy, requested) {
+    if (!Number.isSafeInteger(policy.minCells) || policy.minCells < 2)
+        throw new Error('REFUSE·measure invalid minimum cells');
+    const cells = new Map();
+    for (const row of rows) {
+        if (!row.event || !row.origin || (row.error !== 0 && row.error !== 1))
+            throw new Error('REFUSE·measure invalid error event');
+        const at = cells.get(row.event) ?? new Map();
+        if (at.has(row.origin) && at.get(row.origin) !== row.error)
+            throw new Error('REFUSE·measure conflicting error event');
+        at.set(row.origin, row.error);
+        cells.set(row.event, at);
+    }
+    const origins = [...new Set(requested ?? rows.map(row => row.origin))].sort();
+    if (origins.some(origin => !origin))
+        throw new Error('REFUSE·measure invalid origin');
+    const events = [...cells.keys()].filter(event => origins.some(origin => cells.get(event).has(origin))).sort();
+    if (events.length < policy.minCells || !origins.length)
+        return { status: 'unmeasured', cause: 'insufficient observed events' };
+    if (events.some(event => origins.some(origin => !cells.get(event).has(origin))))
+        return { status: 'unmeasured', cause: 'incomplete shared event observations' };
+    return { status: 'measured', origins, events, matrix: events.map(event => origins.map(origin => cells.get(event).get(origin))) };
+}
+export function covariance(reading) {
+    if (reading.status === 'unmeasured')
+        return reading;
+    const n = reading.events.length, m = reading.origins.length;
+    if (!n || !m || reading.matrix.length !== n || reading.matrix.some(row => row.length !== m || row.some(x => x !== 0 && x !== 1)) || new Set(reading.events).size !== n || new Set(reading.origins).size !== m)
+        throw new Error('REFUSE·measure invalid error matrix');
+    const mean = reading.origins.map((_, i) => reading.matrix.reduce((sum, row) => sum + row[i], 0) / n);
+    const matrix = Array.from({ length: m }, (_, i) => Array.from({ length: m }, (_, j) => reading.matrix.reduce((sum, row) => sum + (row[i] - mean[i]) * (row[j] - mean[j]), 0) / n));
+    return { ...reading, matrix };
+}
+export const errorCovariance = (rows, policy) => covariance(errorMatrix(rows, policy));
+export function participationRatio(reading) {
+    if (reading.status === 'unmeasured')
+        return reading;
+    const trace = reading.matrix.reduce((sum, row, i) => sum + row[i], 0);
+    const square = reading.matrix.reduce((sum, row) => sum + row.reduce((n, value) => n + value * value, 0), 0);
+    if (square === 0)
+        return { status: 'unmeasured', cause: 'zero observed variation; dependence unidentified' };
+    return { status: 'measured', value: trace * trace / square };
+}

package/dist/measures/experiments.d.ts

@@ -0,0 +1,15 @@
+import type { UnanimityModel } from './model.ts';
+export type ExperimentPolicy = Readonly<{
+    seed: number;
+    trials: number;
+}>;
+export type ConditionalRate = Readonly<{
+    events: number;
+    falseEvents: number;
+    rate: number | 'unmeasured';
+}>;
+export declare function dissentExperiment(model: UnanimityModel, k: number, policy: ExperimentPolicy): Readonly<{
+    unanimity: ConditionalRate;
+    majorityWithDissent: ConditionalRate;
+}>;
+export declare function interestExperiment(model: UnanimityModel, bias: number, shared: boolean, policy: ExperimentPolicy): ConditionalRate;

package/dist/measures/experiments.js

@@ -0,0 +1,53 @@
+import { unanimityFloor } from "./model.js";
+function stream(policy) {
+    if (!Number.isInteger(policy.seed) || policy.seed <= 0 || policy.seed > 0xffffffff || !Number.isSafeInteger(policy.trials) || policy.trials < 1)
+        throw new Error('REFUSE·experiment invalid seed or trial count');
+    let x = policy.seed >>> 0;
+    return () => { x ^= x << 13; x ^= x >>> 17; x ^= x << 5; return (x >>> 0) / 4294967296; };
+}
+const rate = (events, falseEvents) => ({ events, falseEvents, rate: events ? falseEvents / events : 'unmeasured' });
+const wrong = (random, n, bias = 0) => random() < bias ? 1 : 1 + Math.floor(random() * (n - 1));
+export function dissentExperiment(model, k, policy) {
+    unanimityFloor(model, k);
+    const random = stream(policy);
+    let unanimous = 0, unanimousFalse = 0, majority = 0, majorityFalse = 0;
+    for (let trial = 0; trial < policy.trials; trial++) {
+        const common = random() < model.c;
+        const counts = new Map();
+        for (let i = 0; i < k; i++) {
+            const value = common ? 1 : random() < model.p ? wrong(random, model.n) : 0;
+            counts.set(value, (counts.get(value) ?? 0) + 1);
+        }
+        for (const [value, count] of counts) {
+            if (count === k) {
+                unanimous++;
+                if (value !== 0)
+                    unanimousFalse++;
+            }
+            else if (count > k / 2) {
+                majority++;
+                if (value !== 0)
+                    majorityFalse++;
+            }
+        }
+    }
+    return { unanimity: rate(unanimous, unanimousFalse), majorityWithDissent: rate(majority, majorityFalse) };
+}
+export function interestExperiment(model, bias, shared, policy) {
+    unanimityFloor(model, 2);
+    if (!Number.isFinite(bias) || bias < 0 || bias > 1)
+        throw new Error('REFUSE·experiment invalid interest bias');
+    const random = stream(policy);
+    let agreed = 0, falseAgreed = 0;
+    for (let trial = 0; trial < policy.trials; trial++) {
+        const common = random() < model.c;
+        const a = common ? 1 : random() < model.p ? wrong(random, model.n, bias) : 0;
+        const b = common ? 1 : random() < model.p ? wrong(random, model.n, shared ? bias : 0) : 0;
+        if (a === b) {
+            agreed++;
+            if (a !== 0)
+                falseAgreed++;
+        }
+    }
+    return rate(agreed, falseAgreed);
+}

package/dist/measures/fitting.d.ts

@@ -0,0 +1,243 @@
+import { type ErrorEvent, type ObservationPolicy } from './error-events.ts';
+export type FitStructure = Readonly<{
+    factors: readonly Readonly<{
+        id: string;
+        members: readonly string[];
+    }>[];
+}>;
+export type FitPolicy = Readonly<{
+    observation: ObservationPolicy;
+    activeSets: string;
+    solveTolerance: number;
+    residualTolerance: number;
+    bootstrap: Readonly<{
+        B: number;
+        seed: number;
+        prng: 'xorshift32';
+        randomWords: number;
+    }>;
+}>;
+export declare function fitM3(rows: readonly ErrorEvent[], structure: FitStructure, policy: FitPolicy): {
+    status: "unmeasured";
+    cause: string;
+    model: "M/3";
+    parameters: {
+        rows: readonly Readonly<{
+            event: string;
+            origin: string;
+            error: 0 | 1;
+        }>[];
+        structure: Readonly<{
+            factors: readonly Readonly<{
+                id: string;
+                members: readonly string[];
+            }>[];
+        }>;
+    };
+    policy: Readonly<{
+        observation: ObservationPolicy;
+        activeSets: string;
+        solveTolerance: number;
+        residualTolerance: number;
+        bootstrap: Readonly<{
+            B: number;
+            seed: number;
+            prng: "xorshift32";
+            randomWords: number;
+        }>;
+    }>;
+    conditions: readonly ["one-declared-parameter-population", "declared-sharing-sets", "finite-data", "no-pseudocounts", "fitted-not-handed"];
+    procedure: "constrained-log-least-squares/active-set@1";
+} | {
+    status: "unmeasured";
+    cause: string;
+    required: string;
+    model: "M/3";
+    parameters: {
+        rows: readonly Readonly<{
+            event: string;
+            origin: string;
+            error: 0 | 1;
+        }>[];
+        structure: Readonly<{
+            factors: readonly Readonly<{
+                id: string;
+                members: readonly string[];
+            }>[];
+        }>;
+    };
+    policy: Readonly<{
+        observation: ObservationPolicy;
+        activeSets: string;
+        solveTolerance: number;
+        residualTolerance: number;
+        bootstrap: Readonly<{
+            B: number;
+            seed: number;
+            prng: "xorshift32";
+            randomWords: number;
+        }>;
+    }>;
+    conditions: readonly ["one-declared-parameter-population", "declared-sharing-sets", "finite-data", "no-pseudocounts", "fitted-not-handed"];
+    procedure: "constrained-log-least-squares/active-set@1";
+} | {
+    status: "unmeasured";
+    cause: string;
+    residuals: number[];
+    factors?: undefined;
+    residualSumSquares?: undefined;
+    residualSurvival?: undefined;
+    model: "M/3";
+    parameters: {
+        rows: readonly Readonly<{
+            event: string;
+            origin: string;
+            error: 0 | 1;
+        }>[];
+        structure: Readonly<{
+            factors: readonly Readonly<{
+                id: string;
+                members: readonly string[];
+            }>[];
+        }>;
+    };
+    policy: Readonly<{
+        observation: ObservationPolicy;
+        activeSets: string;
+        solveTolerance: number;
+        residualTolerance: number;
+        bootstrap: Readonly<{
+            B: number;
+            seed: number;
+            prng: "xorshift32";
+            randomWords: number;
+        }>;
+    }>;
+    conditions: readonly ["one-declared-parameter-population", "declared-sharing-sets", "finite-data", "no-pseudocounts", "fitted-not-handed"];
+    procedure: "constrained-log-least-squares/active-set@1";
+} | {
+    bootstrap: {
+        status: "unmeasured";
+        cause: string;
+        words: number;
+        replicates?: undefined;
+    };
+    status: "fitted";
+    factors: {
+        id: string;
+        probability: number;
+    }[];
+    residuals: number[];
+    residualSumSquares: number;
+    residualSurvival: {
+        id: string;
+        r: number;
+        privateSingletonDecomposition: "unresolved";
+    }[];
+    cause?: undefined;
+    model: "M/3";
+    parameters: {
+        rows: readonly Readonly<{
+            event: string;
+            origin: string;
+            error: 0 | 1;
+        }>[];
+        structure: Readonly<{
+            factors: readonly Readonly<{
+                id: string;
+                members: readonly string[];
+            }>[];
+        }>;
+    };
+    policy: Readonly<{
+        observation: ObservationPolicy;
+        activeSets: string;
+        solveTolerance: number;
+        residualTolerance: number;
+        bootstrap: Readonly<{
+            B: number;
+            seed: number;
+            prng: "xorshift32";
+            randomWords: number;
+        }>;
+    }>;
+    conditions: readonly ["one-declared-parameter-population", "declared-sharing-sets", "finite-data", "no-pseudocounts", "fitted-not-handed"];
+    procedure: "constrained-log-least-squares/active-set@1";
+} | {
+    bootstrap: {
+        status: "unmeasured" | "measured";
+        cause: string | undefined;
+        words: number;
+        replicates: ({
+            status: "unmeasured";
+            cause: string;
+            residuals?: undefined;
+            factors?: undefined;
+            residualSumSquares?: undefined;
+            residualSurvival?: undefined;
+        } | {
+            status: "unmeasured";
+            cause: string;
+            residuals: number[];
+            factors?: undefined;
+            residualSumSquares?: undefined;
+            residualSurvival?: undefined;
+        } | {
+            status: "fitted";
+            factors: {
+                id: string;
+                probability: number;
+            }[];
+            residuals: number[];
+            residualSumSquares: number;
+            residualSurvival: {
+                id: string;
+                r: number;
+                privateSingletonDecomposition: "unresolved";
+            }[];
+            cause?: undefined;
+        })[];
+    };
+    quantities: "Φ and D require handed parameters; never reported from this fit";
+    status: "fitted";
+    factors: {
+        id: string;
+        probability: number;
+    }[];
+    residuals: number[];
+    residualSumSquares: number;
+    residualSurvival: {
+        id: string;
+        r: number;
+        privateSingletonDecomposition: "unresolved";
+    }[];
+    cause?: undefined;
+    model: "M/3";
+    parameters: {
+        rows: readonly Readonly<{
+            event: string;
+            origin: string;
+            error: 0 | 1;
+        }>[];
+        structure: Readonly<{
+            factors: readonly Readonly<{
+                id: string;
+                members: readonly string[];
+            }>[];
+        }>;
+    };
+    policy: Readonly<{
+        observation: ObservationPolicy;
+        activeSets: string;
+        solveTolerance: number;
+        residualTolerance: number;
+        bootstrap: Readonly<{
+            B: number;
+            seed: number;
+            prng: "xorshift32";
+            randomWords: number;
+        }>;
+    }>;
+    conditions: readonly ["one-declared-parameter-population", "declared-sharing-sets", "finite-data", "no-pseudocounts", "fitted-not-handed"];
+    procedure: "constrained-log-least-squares/active-set@1";
+};

package/dist/measures/fitting.js

@@ -0,0 +1,115 @@
+import { errorMatrix } from "./error-events.js";
+import { refuse } from "./rational.js";
+function solve(matrix, values, tolerance) {
+    const a = matrix.map((row, i) => [...row, values[i]]), n = a.length;
+    for (let j = 0; j < n; j++) {
+        let pivot = j;
+        for (let i = j + 1; i < n; i++)
+            if (Math.abs(a[i][j]) > Math.abs(a[pivot][j]))
+                pivot = i;
+        if (Math.abs(a[pivot][j]) <= tolerance)
+            return undefined;
+        [a[j], a[pivot]] = [a[pivot], a[j]];
+        const d = a[j][j];
+        a[j] = a[j].map(v => v / d);
+        for (let i = 0; i < n; i++)
+            if (i !== j) {
+                const p = a[i][j];
+                a[i] = a[i].map((v, k) => v - p * a[j][k]);
+            }
+    }
+    return a.map(row => row[n]);
+}
+function* subsets(total, max, start = 0, prefix = []) {
+    yield prefix;
+    if (prefix.length === max)
+        return;
+    for (let i = start; i < total; i++)
+        yield* subsets(total, max, i + 1, [...prefix, i]);
+}
+export function fitM3(rows, structure, policy) {
+    if (!policy || !/^\d+$/.test(policy.activeSets) || !Number.isFinite(policy.solveTolerance) || policy.solveTolerance <= 0 || !Number.isFinite(policy.residualTolerance) || policy.residualTolerance < 0 || !policy.bootstrap || policy.bootstrap.prng !== 'xorshift32' || !Number.isInteger(policy.bootstrap.seed) || policy.bootstrap.seed < 1 || policy.bootstrap.seed > 0xffffffff || !Number.isSafeInteger(policy.bootstrap.B) || policy.bootstrap.B < 0 || !Number.isSafeInteger(policy.bootstrap.randomWords) || policy.bootstrap.randomWords < 0)
+        refuse('invalid fitting policy');
+    const reading = errorMatrix(rows, policy.observation), metadata = { model: 'M/3', parameters: { rows, structure }, policy, conditions: ['one-declared-parameter-population', 'declared-sharing-sets', 'finite-data', 'no-pseudocounts', 'fitted-not-handed'], procedure: 'constrained-log-least-squares/active-set@1' };
+    if (reading.status === 'unmeasured')
+        return { ...metadata, ...reading };
+    if (!structure || !Array.isArray(structure.factors) || structure.factors.some(f => !f) || new Set(structure.factors.map(f => f.id)).size !== structure.factors.length || structure.factors.some(f => !f.id || !Array.isArray(f.members) || new Set(f.members).size !== f.members.length || f.members.some((id) => !reading.origins.includes(id))))
+        refuse('invalid fitting sharing structure');
+    const shared = structure.factors.filter(f => f.members.length > 1), n = shared.length, w = reading.origins.length;
+    const pairs = [...reading.origins.flatMap((_, i) => reading.origins.flatMap((__, j) => j > i ? [[i, j]] : []))];
+    const A = pairs.map(([i, j]) => shared.map(f => f.members.includes(reading.origins[i]) && f.members.includes(reading.origins[j]) ? 1 : 0));
+    const H = shared.map((_, i) => shared.map((__, j) => A.reduce((sum, row) => sum + row[i] * row[j], 0)));
+    if (n && !solve(H, Array(n).fill(0), policy.solveTolerance))
+        return { ...metadata, status: 'unmeasured', cause: 'rank-deficient declared sharing system' };
+    let combinations = 1n, term = 1n;
+    for (let k = 1; k <= n; k++) {
+        term = term * BigInt(n + w - k + 1) / BigInt(k);
+        combinations += term;
+    }
+    const required = combinations * BigInt(policy.bootstrap.B + 1);
+    if (required > BigInt(policy.activeSets))
+        return { ...metadata, status: 'unmeasured', cause: 'fitting/active-sets', required: String(required) };
+    const once = (data) => {
+        const s = reading.origins.map((_, i) => data.reduce((sum, row) => sum + (1 - row[i]), 0) / data.length);
+        if (s.some(v => v === 0))
+            return { status: 'unmeasured', cause: 'model/M misfit: zero correct count' };
+        const joints = pairs.map(([i, j]) => data.reduce((sum, row) => sum + (1 - row[i]) * (1 - row[j]), 0) / data.length);
+        if (joints.some(v => v === 0))
+            return { status: 'unmeasured', cause: 'model/M misfit: zero joint-correct count' };
+        const y = joints.map((v, k) => Math.log(v / (s[pairs[k][0]] * s[pairs[k][1]]))), g = shared.map((_, j) => A.reduce((sum, row, i) => sum + row[j] * y[i], 0));
+        const C = [...shared.map((_, i) => shared.map((__, j) => i === j ? -1 : 0)), ...reading.origins.map(id => shared.map(f => f.members.includes(id) ? 1 : 0))], d = [...shared.map(() => 0), ...s.map(v => -Math.log(v))];
+        let best, bestCost = Infinity;
+        for (const active of subsets(n + w, n)) {
+            const size = n + active.length, K = Array.from({ length: size }, () => Array(size).fill(0));
+            for (let i = 0; i < n; i++)
+                for (let j = 0; j < n; j++)
+                    K[i][j] = H[i][j];
+            active.forEach((constraint, k) => C[constraint].forEach((v, j) => { K[n + k][j] = v; K[j][n + k] = v; }));
+            const candidate = solve(K, [...g, ...active.map(i => d[i])], policy.solveTolerance);
+            if (!candidate)
+                continue;
+            const alpha = candidate.slice(0, n), lambda = candidate.slice(n);
+            if (alpha.some(v => v < 0) || lambda.some(v => v < -policy.solveTolerance) || C.some((row, i) => row.reduce((sum, v, j) => sum + v * alpha[j], 0) > d[i] + policy.solveTolerance))
+                continue;
+            const cost = A.reduce((sum, row, i) => sum + (row.reduce((s, v, j) => s + v * alpha[j], 0) - y[i]) ** 2, 0);
+            if (cost < bestCost) {
+                best = alpha;
+                bestCost = cost;
+            }
+        }
+        if (!best)
+            return { status: 'unmeasured', cause: 'model/M misfit: no feasible numerical solution' };
+        const residuals = A.map((row, i) => row.reduce((sum, v, j) => sum + v * best[j], 0) - y[i]);
+        if (residuals.some(v => Math.abs(v) > policy.residualTolerance))
+            return { status: 'unmeasured', cause: 'model/M misfit: residual tolerance', residuals };
+        return { status: 'fitted', factors: shared.map((f, i) => ({ id: f.id, probability: 1 - Math.exp(-best[i]) })), residuals, residualSumSquares: bestCost, residualSurvival: reading.origins.map((id, i) => ({ id, r: s[i] * Math.exp(shared.reduce((sum, f, j) => sum + (f.members.includes(id) ? best[j] : 0), 0)), privateSingletonDecomposition: 'unresolved' })) };
+    };
+    const fit = once(reading.matrix);
+    if (fit.status !== 'fitted')
+        return { ...metadata, ...fit };
+    let x = policy.bootstrap.seed >>> 0, words = 0;
+    const exhausted = Symbol('bootstrap/random-words');
+    const index = () => { const N = reading.matrix.length, limit = Math.floor(4294967296 / N) * N; for (;;) {
+        if (words === policy.bootstrap.randomWords)
+            throw exhausted;
+        words++;
+        x ^= x << 13;
+        x ^= x >>> 17;
+        x ^= x << 5;
+        const r = x >>> 0;
+        if (r < limit)
+            return r % N;
+    } };
+    const replicates = [];
+    try {
+        for (let b = 0; b < policy.bootstrap.B; b++)
+            replicates.push(once(reading.matrix.map(() => reading.matrix[index()])));
+    }
+    catch (error) {
+        if (error !== exhausted)
+            throw error;
+        return { ...metadata, ...fit, bootstrap: { status: 'unmeasured', cause: 'bootstrap/random-words', words } };
+    }
+    const complete = policy.bootstrap.B > 0 && replicates.every(r => r.status === 'fitted');
+    return { ...metadata, ...fit, bootstrap: { status: complete ? 'measured' : 'unmeasured', cause: complete ? undefined : policy.bootstrap.B ? 'model/M misfit in bootstrap replicates' : 'no bootstrap replicates requested', words, replicates }, quantities: 'Φ and D require handed parameters; never reported from this fit' };
+}

package/dist/measures/identification.d.ts

@@ -0,0 +1,156 @@
+import { type RationalInput } from './rational.ts';
+export type IdentificationInput = Readonly<{
+    witnesses: readonly Readonly<{
+        id: string;
+        correct: RationalInput;
+    }>[];
+    factors: readonly Readonly<{
+        id: string;
+        members: readonly string[];
+    }>[];
+    pairs: readonly Readonly<{
+        a: string;
+        b: string;
+        correctTogether: RationalInput;
+    }>[];
+}>;
+export type IdentificationPolicy = Readonly<{
+    budget: string;
+}>;
+export declare function identifyM3(input: IdentificationInput, policy: IdentificationPolicy): {
+    status: "unmeasured";
+    cause: string;
+    model: "M/3";
+    parameters: Readonly<{
+        witnesses: readonly Readonly<{
+            id: string;
+            correct: RationalInput;
+        }>[];
+        factors: readonly Readonly<{
+            id: string;
+            members: readonly string[];
+        }>[];
+        pairs: readonly Readonly<{
+            a: string;
+            b: string;
+            correctTogether: RationalInput;
+        }>[];
+    }>;
+    conditions: readonly ["population-moments", "declared-sharing-sets", "positive-correctness", "full-column-rank", "singleton-private-unresolved"];
+    policy: Readonly<{
+        budget: string;
+    }>;
+} | {
+    status: "unmeasured";
+    cause: string;
+    required: string;
+    model: "M/3";
+    parameters: Readonly<{
+        witnesses: readonly Readonly<{
+            id: string;
+            correct: RationalInput;
+        }>[];
+        factors: readonly Readonly<{
+            id: string;
+            members: readonly string[];
+        }>[];
+        pairs: readonly Readonly<{
+            a: string;
+            b: string;
+            correctTogether: RationalInput;
+        }>[];
+    }>;
+    conditions: readonly ["population-moments", "declared-sharing-sets", "positive-correctness", "full-column-rank", "singleton-private-unresolved"];
+    policy: Readonly<{
+        budget: string;
+    }>;
+} | {
+    status: "unmeasured";
+    cause: string;
+    rank: number;
+    columns: number;
+    model: "M/3";
+    parameters: Readonly<{
+        witnesses: readonly Readonly<{
+            id: string;
+            correct: RationalInput;
+        }>[];
+        factors: readonly Readonly<{
+            id: string;
+            members: readonly string[];
+        }>[];
+        pairs: readonly Readonly<{
+            a: string;
+            b: string;
+            correctTogether: RationalInput;
+        }>[];
+    }>;
+    conditions: readonly ["population-moments", "declared-sharing-sets", "positive-correctness", "full-column-rank", "singleton-private-unresolved"];
+    policy: Readonly<{
+        budget: string;
+    }>;
+} | {
+    status: "identified";
+    rank: number;
+    columns: number;
+    factors: ({
+        id: string;
+        misfit: true;
+        survival?: undefined;
+        probability?: undefined;
+    } | {
+        id: string;
+        survival: {
+            radicand: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+            degree: string;
+            rational: Readonly<{
+                numerator: string;
+                denominator: string;
+            }> | undefined;
+        };
+        probability: Readonly<{
+            numerator: string;
+            denominator: string;
+        }> | undefined;
+        misfit?: undefined;
+    })[];
+    residualSurvival: {
+        witness: string;
+        r: {
+            radicand: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+            degree: string;
+            rational: Readonly<{
+                numerator: string;
+                denominator: string;
+            }> | undefined;
+        };
+        privateSingletonDecomposition: "unresolved";
+    }[];
+    representation: "positive exact rational roots";
+    model: "M/3";
+    parameters: Readonly<{
+        witnesses: readonly Readonly<{
+            id: string;
+            correct: RationalInput;
+        }>[];
+        factors: readonly Readonly<{
+            id: string;
+            members: readonly string[];
+        }>[];
+        pairs: readonly Readonly<{
+            a: string;
+            b: string;
+            correctTogether: RationalInput;
+        }>[];
+    }>;
+    conditions: readonly ["population-moments", "declared-sharing-sets", "positive-correctness", "full-column-rank", "singleton-private-unresolved"];
+    policy: Readonly<{
+        budget: string;
+    }>;
+};