@lapxo/obligations 0.4.3 → 0.4.5

package/contracts/m0-allocation.json

@@ -0,0 +1,6 @@
+{
+  "scope": "m0-allocation",
+  "form": "statement",
+  "status": "unsigned-preparation",
+  "value": "floor_quota_bounds: K>=1, named nonnegative weights summing to one, p in (1/2,1), c in [0,1). Set W_i=sum_{j<i}w_j, n_i(N)=floor(N W_{i+1})-floor(N W_i). Lean proves sum n_i=N, -1<n_i-Nw_i<1, n_i/N tends to w_i, positive-share counts tend to infinity and zero-share counts vanish. Transport counts, membership and weights under permutation."
+}

package/contracts/m0-finite-grid.json

@@ -0,0 +1,6 @@
+{
+  "scope": "m0-finite-grid",
+  "form": "statement",
+  "status": "unsigned-preparation",
+  "value": "Finite law by enumeration: K=1..4, p=11/20..19/20, c=1/20..20/20, uniform shares. All 720 closed scores equal exact binary-configuration enumeration and lie in [0,1]. This is a static score formula, not a proof of the N-limit. The false WF expected-floor monotonicity is rejected by a normalized 21-state counterexample at N=5,p=3/4,c=9/10,w=(3,1,1)/5."
+}

package/contracts/m0-limit-diag.json

@@ -0,0 +1,6 @@
+{
+  "scope": "m0-limit-diag",
+  "form": "statement",
+  "status": "unsigned-preparation",
+  "value": "floor_limit_diag: vector plus written proof, NOT a general Lean theorem. For 0<=c<1, p in (1/2,1), cumulative-floor quotas and S(A)=1/2, variance is order N and quota mean shift is O(1); the standard independent-array normal approximation yields error tending to 1/2. Finite vector: K=1,p=3/4,c=1/3,w=[1], N=1..12; A=0 has q=1/2, A=1 has q=5/6, target floor=1/8. The finite unbiased diagonal identity is kernel-checked; it does not establish a general limit. theta=0 belongs to this diagonal and retains mass (1-p)^K/2. c=1 is excluded: its zero conditional variance needs a separate tie-preserving allocation contract."
+}

package/contracts/m0-limit-offdiag.json

@@ -0,0 +1,6 @@
+{
+  "scope": "m0-limit-offdiag",
+  "form": "statement",
+  "status": "unsigned-preparation",
+  "value": "floor_limit_offdiag_M0 and floor_limit_offdiag_mixture: conditional on each fixed latent A, actual jointly independent Bernoulli lineage draws with mean q_l=(1-c)p+c A_l satisfy lineage_lgn. The proved cumulative-floor allocation gives member_average_lgn. If S(A)=sum w_l q_l differs from 1/2, the fair-majority loss tends almost surely to 1{S<1/2}; dominated convergence gives its probability limit. The mixture theorem requires no S(A)=1/2 for every latent state. Technical hypotheses: integrability, identical distribution, independence and measurability are explicit in the formal statement. No ConditionalTailLimits or CLT is assumed by the off-diagonal theorem. The Lean probability formulation uses actual lineage arrays and integrals; equivalence to the separate computational binomial-sum definition is not kernel-proved here."
+}

package/contracts/m0-pair-coincidence.json

@@ -0,0 +1,6 @@
+{
+  "scope": "m0-pair-coincidence",
+  "form": "statement",
+  "status": "unsigned-preparation",
+  "value": "Exact M0 independent-Bernoulli expectation gives R2=p^2+(1-p)^2+2c^2 p(1-p) sum w^2 for normalized declared shares; this identity is checked generally in Lean by expect_quadratic and pair_coincidence. Triple agreement satisfies R3=(3R2-1)/2 and adds no independent equation. Population agreement is not majority error or causal identification. Finite distinct-member sampling needs gamma_N, and observed data still need calibration, justified reference and uncertainty."
+}

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

@@ -30,3 +30,7 @@ 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

@@ -14,3 +14,5 @@ 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/docs/contracts/m0-allocation.md

@@ -0,0 +1 @@
+floor_quota_bounds: K>=1, named nonnegative weights summing to one, p in (1/2,1), c in [0,1). Set W_i=sum_{j<i}w_j, n_i(N)=floor(N W_{i+1})-floor(N W_i). Lean proves sum n_i=N, -1<n_i-Nw_i<1, n_i/N tends to w_i, positive-share counts tend to infinity and zero-share counts vanish. Transport counts, membership and weights under permutation.

package/docs/contracts/m0-finite-grid.md

@@ -0,0 +1 @@
+Finite law by enumeration: K=1..4, p=11/20..19/20, c=1/20..20/20, uniform shares. All 720 closed scores equal exact binary-configuration enumeration and lie in [0,1]. This is a static score formula, not a proof of the N-limit. The false WF expected-floor monotonicity is rejected by a normalized 21-state counterexample at N=5,p=3/4,c=9/10,w=(3,1,1)/5.

package/docs/contracts/m0-limit-diag.md

@@ -0,0 +1 @@
+floor_limit_diag: vector plus written proof, NOT a general Lean theorem. For 0<=c<1, p in (1/2,1), cumulative-floor quotas and S(A)=1/2, variance is order N and quota mean shift is O(1); the standard independent-array normal approximation yields error tending to 1/2. Finite vector: K=1,p=3/4,c=1/3,w=[1], N=1..12; A=0 has q=1/2, A=1 has q=5/6, target floor=1/8. The finite unbiased diagonal identity is kernel-checked; it does not establish a general limit. theta=0 belongs to this diagonal and retains mass (1-p)^K/2. c=1 is excluded: its zero conditional variance needs a separate tie-preserving allocation contract.

package/docs/contracts/m0-limit-offdiag.md

@@ -0,0 +1 @@
+floor_limit_offdiag_M0 and floor_limit_offdiag_mixture: conditional on each fixed latent A, actual jointly independent Bernoulli lineage draws with mean q_l=(1-c)p+c A_l satisfy lineage_lgn. The proved cumulative-floor allocation gives member_average_lgn. If S(A)=sum w_l q_l differs from 1/2, the fair-majority loss tends almost surely to 1{S<1/2}; dominated convergence gives its probability limit. The mixture theorem requires no S(A)=1/2 for every latent state. Technical hypotheses: integrability, identical distribution, independence and measurability are explicit in the formal statement. No ConditionalTailLimits or CLT is assumed by the off-diagonal theorem. The Lean probability formulation uses actual lineage arrays and integrals; equivalence to the separate computational binomial-sum definition is not kernel-proved here.

package/docs/contracts/m0-pair-coincidence.md

@@ -0,0 +1 @@
+Exact M0 independent-Bernoulli expectation gives R2=p^2+(1-p)^2+2c^2 p(1-p) sum w^2 for normalized declared shares; this identity is checked generally in Lean by expect_quadratic and pair_coincidence. Triple agreement satisfies R3=(3R2-1)/2 and adds no independent equation. Population agreement is not majority error or causal identification. Finite distinct-member sampling needs gamma_N, and observed data still need calibration, justified reference and uncertainty.

package/docs/measures.md

@@ -219,3 +219,19 @@ L7: conditional bound on one declared common probability space: P(N>k)<=min(1,su
 L8: law by enumeration only for 3<=n<=64, positive integer divisors p|n and integer 0<=s<p. D=log2(n/p)-h(s/p), explicit binary64-log2 approximation. Odd-period minimum uses h(floor(p/2)/p), even-period minimum uses one. Complete maximum at zero; nonzero domain has endpoints 1,p-1, empty when p=1. No information or worst-case interpretation follows from nonnegativity. T87 retains its separate wrapped-phase amplitude identity.
 
 L9: law by counterexample of existence of noninjective weighted mix, and measure with a declared prior on a finite explicitly supplied set of named-factor configurations. Equal-weight ab and ba give the same bottom tie and different named forks. Loss is H(configuration | mix)=H(configuration)-H(mix); a uniform prior must be explicitly selected, absent prior is unmeasured. The four-state uniform example has mean loss 0.5 bits and one bit conditioned on tie; the injective named fork has zero loss. Defines no new algebraic act, governance selection, M/3 or M/4 law, or destroyed field.
+
+## Lineage and delivery: distinct scopes
+
+For n>=2, uniform truth X, the declared n-ary symmetric channel X->Z with crossover probability c in [0,1], and X->Z->reports->aggregate A,
+
+```text
+H(X|Z) = h2(c) + c*log2(n-1) >= h2(c)
+H(X|A) >= H(X|Z)
+I(X;A) <= log2(n) - h2(c) - c*log2(n-1)
+```
+
+Here h2 is binary entropy, with 0*log2(0)=0. The uncertainty floor and information ceiling follow from this symmetric-channel equality and the declared Markov bottleneck. The reports and aggregation have no additional access to truth or a revealed error/cause indicator. This reuses capacityP0; it neither replaces capacityBound nor changes M/3 or M/4. An error rate alone, an asymmetric channel or the existing private-error model does not establish this ceiling. The distinguishing counterexamples and relation to F1 are in [the conditional lineage contract](../proofs/lineage-ceiling.json).
+
+The parameter c denotes the mixture activation or channel crossover specified by the selected model. It is not identified from unanimity without that model, and no equality with the genetic inbreeding coefficient F is asserted. No genetic law follows here.
+
+Cell vacuity is a property of a region under the algebra. Delivery asks whether the bytes named by a digest are available and match it. A vacuous cell neither certifies delivery nor proves that a delivered package is admissible. The relation between these predicates remains the named vacuity-versus-delivery tension.

package/docs/paper.md

@@ -63,7 +63,7 @@ claims that meet outside the bounds      FORBIDDEN  ✕
 | D7-fork | definition | lattice | A2-meet | two incomparable bounds on one cell from two signers; rendered with both, closed only by a signature |  | none | derived by the reader | not a derivation |
 | D8-present | definition | field | A4-epoch, A3-resolution | the present is the meet of overlapping observation bands; there is no instant to certify |  | [yes](../samples/yes/D8-present.json) | derived by the reader | not a derivation |
 | D9-yield | definition | valuation | A5-origin-is-extension, D4-debit-in-bits | an origin's yield is bits it closed minus bits reopened against it, per act, over an epoch |  | [yes](../samples/yes/D9-yield.json) | derived by the reader | not a derivation |
-| H1-uncertainty | conjecture | chain | A3-resolution, A1-encounter | resolution times independent encounters per cell stays above a floor c; the sufficient resolution is where the product saturates |  | [yes](../samples/yes/H1-uncertainty.json) | The falsifier: a cell read at four resolutions whose product of resolution and independent encounters comes out above the floor while the encounters fall away with the sharpening. A product that rises as the reading sharpens would say the floor is not a floor but an accident of how coarsely the cell was read. | not a derivation |
+| H1-uncertainty | conjecture | chain | A3-resolution, A1-encounter | resolution times independent encounters per cell stays above a floor c; the sufficient resolution is where the product saturates |  | [yes](../samples/yes/H1-uncertainty.json) | The falsifier: after declaring a counting model, population, units and a fixed positive floor c before observing the sample, an admissible cell whose resolution times encounters per cell falls below c. A rising product does not refute a lower bound. A decrease refutes monotonicity and an exceedance refutes an upper bound only under their separately declared contracts. H1 remains open without the counting/refinement model and fixed parameters; the increasing sample is an experiment, not a universal bound. | not a derivation |
 | H10-the-period-is-a-line-of-the-region | conjecture | field | T48-epoch-is-phase, T87-the-quarter-turn | the period a phase is read against, the one T48 and T87 turn on, is a line of the region and never a fact of the instrument: a concert, a match and a sensor-s cadence each define theirs, and two heads that read one region with its period agree on its coherence with no clock between them; structural resemblance, one origin, not a claim about the world |  | [yes](../samples/yes/H10-the-period-is-a-line-of-the-region.json) | The falsifier: two heads that read one region, each with the period of its own clock, and agree on its coherence. A period each instrument brought would be the instrument's, and the heads would need a clock between them to agree. | not a derivation |
 | H2-density-attracts | conjecture | field | A1-encounter, A6-vacuity | where reading already is, the next reading lands: over eight epochs of placement in proportion to the origins a cell already carries, the ratio between the densest tenth and the sparsest rises at every epoch and the deserts stay empty, while the same budget placed blind to density holds that ratio near two and touches three times as many cells |  | [yes](../samples/yes/H2-density-attracts.json) | The falsifier: encounters that land independently of the density already there. Then the ratio does not rise with the epochs and the cells touched grow with the budget, which is what the blind placement in the yes sample shows. | not a derivation |
 | H3-a-distant-signature-moves-a-cell-that-did-not-move | conjecture | lattice | T46-a-bound-moves-cells-no-walk-reaches, T47-a-two-pole-object | stated as a hint and never as a claim about the world: if what is is a field of floors and ceilings, a distant signature changes a cell whose own record never moved, and in two hundred trials of one cell holding one value the verdict came out both ways, so nothing stored at the cell explains the difference and what explains it is the bound the cell rests on; the resemblance is structural and never arithmetic, with no continuous amplitudes and no inequality violated by number; structural resemblance, one origin, not a claim about the world |  | [yes](../samples/yes/H3-a-distant-signature-moves-a-cell-that-did-not-move.json) | The falsifier: one act that is both local and non-local — a change that travels a distance and also reaches a cell that does not rest on its bound. The two poles would then be one, and this would be a claim about the world rather than a hint. | not a derivation |
@@ -191,7 +191,7 @@ Five readings:
 
 <details><summary>Every conjecture in full</summary>
 
-Resolution times independent encounters per cell stays above a floor c; the sufficient resolution is where the product saturates. The falsifier: a cell read at four resolutions whose product of resolution and independent encounters comes out above the floor while the encounters fall away with the sharpening. A product that rises as the reading sharpens would say the floor is not a floor but an accident of how coarsely the cell was read.
+Resolution times independent encounters per cell stays above a floor c; the sufficient resolution is where the product saturates. The falsifier: after declaring a counting model, population, units and a fixed positive floor c before observing the sample, an admissible cell whose resolution times encounters per cell falls below c. A rising product does not refute a lower bound. A decrease refutes monotonicity and an exceedance refutes an upper bound only under their separately declared contracts. H1 remains open without the counting/refinement model and fixed parameters; the increasing sample is an experiment, not a universal bound.
 
 Where reading already is, the next reading lands: over eight epochs of placement in proportion to the origins a cell already carries, the ratio between the densest tenth and the sparsest rises at every epoch and the deserts stay empty, while the same budget placed blind to density holds that ratio near two and touches three times as many cells. The falsifier: encounters that land independently of the density already there. Then the ratio does not rise with the epochs and the cells touched grow with the budget, which is what the blind placement in the yes sample shows.
 

package/docs/proofs/floor-limit-diag.proof.json

@@ -0,0 +1,29 @@
+{
+  "id": "floor_limit_diag",
+  "classification": "bounded vector with mathematical proof text, not a general kernel proof",
+  "domain": "M0: finite fixed K, nonnegative normalized fixed w, p in (1/2,1), c in [0,1), cumulative-floor counts, fair ties, conditional independent Bernoulli emissions",
+  "fixedState": "Condition on latent A with S(A)=1/2. Set T_N=sum correct bits, mu_N=E[T_N|A], sigma_N^2=Var(T_N|A).",
+  "steps": [
+    "The proved quotas imply |mu_N-N/2|<=K because every q_l is in (0,1).",
+    "Every q_l >= (1-c)p and 1-q_l >= (1-c)(1-p). Thus sigma_N^2 >= kappa*N with kappa=(1-c)^2*p*(1-p)>0; sigma_N^2<=N/4.",
+    "Centered Bernoulli summands are bounded by 1, so their summed third absolute moments are at most sigma_N^2. Dividing by sigma_N^3 gives at most 1/sqrt(kappa*N), tending to zero.",
+    "Apply the independent, non-identically distributed normal-approximation theorem in dimension one to these standardized summands. Its error on half-lines tends to zero.",
+    "The standardized quota shift (N/2-mu_N)/sigma_N tends to zero. Therefore P(T_N<=N/2|A) tends to 1/2.",
+    "The approximation has a continuous limiting CDF, so the atom P(T_N=N/2|A) tends to zero. Fair tie handling changes the non-strict tail by half of this vanishing atom.",
+    "Hence conditional error tends to 1/2. Sum finitely many latent states with their declared product Bernoulli weights, combining this argument with the kernel-proved off-diagonal theorem."
+  ],
+  "externalTheorem": {
+    "author": "Martin Raič",
+    "title": "A multivariate Berry–Esseen theorem with explicit constants",
+    "url": "https://arxiv.org/pdf/1802.06475",
+    "theorem": "1.1, dimension d=1, independent centered standardized summands; convex half-lines",
+    "dependence": "A prior mathematical result, not a theorem newly established by Obligations. The application and this proof text are not checked in Lean."
+  },
+  "degenerates": {
+    "theta=0": "Retains (1-p)^K/2; not the zero-floor domain.",
+    "c=1": "Excluded: kappa=0 and bounded quota errors need not vanish relative to fluctuations. Separate exact-tie-preserving allocation required.",
+    "p=1": "Separate deterministic case, outside current Domain."
+  },
+  "finiteVector": "proofs/lean/Obligations045/M0Diagonal.lean, N=1..12; actual outputs must be captured",
+  "READY": false
+}

package/docs/reference.md

@@ -361,7 +361,7 @@ flowchart BT
 | D7-fork | definition | lattice | A2-meet | two incomparable bounds on one cell from two signers; rendered with both, closed only by a signature |  | none | derived by the reader | not a derivation |
 | D8-present | definition | field | A4-epoch, A3-resolution | the present is the meet of overlapping observation bands; there is no instant to certify |  | [yes](../samples/yes/D8-present.json) | derived by the reader | not a derivation |
 | D9-yield | definition | valuation | A5-origin-is-extension, D4-debit-in-bits | an origin's yield is bits it closed minus bits reopened against it, per act, over an epoch |  | [yes](../samples/yes/D9-yield.json) | derived by the reader | not a derivation |
-| H1-uncertainty | conjecture | chain | A3-resolution, A1-encounter | resolution times independent encounters per cell stays above a floor c; the sufficient resolution is where the product saturates |  | [yes](../samples/yes/H1-uncertainty.json) | The falsifier: a cell read at four resolutions whose product of resolution and independent encounters comes out above the floor while the encounters fall away with the sharpening. A product that rises as the reading sharpens would say the floor is not a floor but an accident of how coarsely the cell was read. | not a derivation |
+| H1-uncertainty | conjecture | chain | A3-resolution, A1-encounter | resolution times independent encounters per cell stays above a floor c; the sufficient resolution is where the product saturates |  | [yes](../samples/yes/H1-uncertainty.json) | The falsifier: after declaring a counting model, population, units and a fixed positive floor c before observing the sample, an admissible cell whose resolution times encounters per cell falls below c. A rising product does not refute a lower bound. A decrease refutes monotonicity and an exceedance refutes an upper bound only under their separately declared contracts. H1 remains open without the counting/refinement model and fixed parameters; the increasing sample is an experiment, not a universal bound. | not a derivation |
 | H10-the-period-is-a-line-of-the-region | conjecture | field | T48-epoch-is-phase, T87-the-quarter-turn | the period a phase is read against, the one T48 and T87 turn on, is a line of the region and never a fact of the instrument: a concert, a match and a sensor-s cadence each define theirs, and two heads that read one region with its period agree on its coherence with no clock between them; structural resemblance, one origin, not a claim about the world |  | [yes](../samples/yes/H10-the-period-is-a-line-of-the-region.json) | The falsifier: two heads that read one region, each with the period of its own clock, and agree on its coherence. A period each instrument brought would be the instrument's, and the heads would need a clock between them to agree. | not a derivation |
 | H2-density-attracts | conjecture | field | A1-encounter, A6-vacuity | where reading already is, the next reading lands: over eight epochs of placement in proportion to the origins a cell already carries, the ratio between the densest tenth and the sparsest rises at every epoch and the deserts stay empty, while the same budget placed blind to density holds that ratio near two and touches three times as many cells |  | [yes](../samples/yes/H2-density-attracts.json) | The falsifier: encounters that land independently of the density already there. Then the ratio does not rise with the epochs and the cells touched grow with the budget, which is what the blind placement in the yes sample shows. | not a derivation |
 | H3-a-distant-signature-moves-a-cell-that-did-not-move | conjecture | lattice | T46-a-bound-moves-cells-no-walk-reaches, T47-a-two-pole-object | stated as a hint and never as a claim about the world: if what is is a field of floors and ceilings, a distant signature changes a cell whose own record never moved, and in two hundred trials of one cell holding one value the verdict came out both ways, so nothing stored at the cell explains the difference and what explains it is the bound the cell rests on; the resemblance is structural and never arithmetic, with no continuous amplitudes and no inequality violated by number; structural resemblance, one origin, not a claim about the world |  | [yes](../samples/yes/H3-a-distant-signature-moves-a-cell-that-did-not-move.json) | The falsifier: one act that is both local and non-local — a change that travels a distance and also reaches a cell that does not rest on its bound. The two poles would then be one, and this would be a claim about the world rather than a hint. | not a derivation |
@@ -493,3 +493,8 @@ flowchart BT
 | (o, φ) | Origin |
 | s | Act |
 | state | State |
+
+
+## Executable Lean evidence
+
+The Lean proof reading executes the declared compiler against handed source bytes after image preparation. Its input identity includes all Lean sources, lean-toolchain, lakefile.toml, lake-manifest.json, both policy vectors and the selected reader implementation. It checks the compiler version/commit and every dependency revision and tracked worktree. A successful receipt means the declared 16 theorem audits and both negative causes passed. No dependencies are installed inside the reading. Native read/open counters distinguish execution from verified reuse. This proof place is separate from npm consumption: consumers verify portable historical readings without installing Lean. Compiler and cache preparation is reported separately, never charged to an existing proof-reader ceiling. Native reading uses the existing 25-second global limit, with the existing 65536-byte capture boundary. Changes to declared inputs reopen the reading; no prose claim closes it.

package/package.json

@@ -1 +1 @@
-{"name":"@lapxo/obligations","version":"0.4.3","description":"The algebra of a cell: two poles, origins with phase, eight acts.","type":"module","license":"MIT","author":"Lapxo","repository":{"type":"git","url":"git+https://github.com/Lapxo/obligations.git"},"keywords":["obligations","lattice","provenance"],"sideEffects":false,"engines":{"node":">=22.12"},"exports":{".":{"types":"./dist/lattice/index.d.ts","default":"./dist/lattice/index.js"},"./debit":{"types":"./dist/debit/debit.d.ts","default":"./dist/debit/debit.js"},"./encounter":{"types":"./dist/field/encounter.d.ts","default":"./dist/field/encounter.js"},"./field":{"types":"./dist/field/field.d.ts","default":"./dist/field/field.js"},"./forms":{"types":"./dist/lattice/forms.d.ts","default":"./dist/lattice/forms.js"},"./lattice":{"types":"./dist/lattice/lattice.d.ts","default":"./dist/lattice/lattice.js"},"./measures":{"types":"./dist/measures/index.d.ts","default":"./dist/measures/index.js"},"./packed":{"types":"./dist/debit/packed.d.ts","default":"./dist/debit/packed.js"},"./present":{"types":"./dist/field/present.d.ts","default":"./dist/field/present.js"},"./price":{"types":"./dist/lattice/price/index.d.ts","default":"./dist/lattice/price/index.js"},"./replay":{"types":"./dist/replay.d.ts","default":"./dist/replay.js"},"./shuffle":{"types":"./dist/debit/shuffle.d.ts","default":"./dist/debit/shuffle.js"},"./signatures":{"types":"./dist/field/signatures.d.ts","default":"./dist/field/signatures.js"},"./views/field":{"types":"./dist/views/field.d.ts","default":"./dist/views/field.js"},"./views/product":{"types":"./dist/views/product.d.ts","default":"./dist/views/product.js"},"./package.json":"./package.json"},"files":["dist","README.md","LICENSE","TARGET.bound","receipts.bound","docs/measures.md","samples/measures","vectors/measures","samples/yes/algebra-is-closed.json","samples/yes/field-uses-price-and-debit.json","samples/yes/three-theories-one-algebra.json","src/lattice/index.ts","src/field/motion.ts","samples/yes/installed-artifact.json","samples/no/installed-artifact.json","vectors/measures/installed-artifact.cli.json","docs/img","docs/paper.md","docs/reference.md","docs/learn/in-phase.md","docs/learn/price.md","docs/learn/signature.md","docs/learn/thermometer.md","docs/learn/withdrawal.md","vectors/laws/policy.json","vectors/laws/l7-tolerant-k.json","vectors/laws/l8-phase-defect.json","vectors/laws/l9-mix-loss.json","vectors/laws/implementation-043.json"],"scripts":{"build":"tsc --build","test":"node --import ./test/setup.ts --test --test-concurrency=2 test/*.test.ts test/measures/*.test.ts"},"devDependencies":{"@types/node":"^22","typescript":"^5.9.3"}}
+{"name":"@lapxo/obligations","version":"0.4.5","description":"The algebra of a cell: two poles, origins with phase, eight acts.","type":"module","license":"MIT","author":"Lapxo","repository":{"type":"git","url":"git+https://github.com/Lapxo/obligations.git"},"keywords":["obligations","lattice","provenance"],"sideEffects":false,"engines":{"node":">=22.12"},"exports":{".":{"types":"./dist/lattice/index.d.ts","default":"./dist/lattice/index.js"},"./debit":{"types":"./dist/debit/debit.d.ts","default":"./dist/debit/debit.js"},"./encounter":{"types":"./dist/field/encounter.d.ts","default":"./dist/field/encounter.js"},"./field":{"types":"./dist/field/field.d.ts","default":"./dist/field/field.js"},"./forms":{"types":"./dist/lattice/forms.d.ts","default":"./dist/lattice/forms.js"},"./lattice":{"types":"./dist/lattice/lattice.d.ts","default":"./dist/lattice/lattice.js"},"./measures":{"types":"./dist/measures/index.d.ts","default":"./dist/measures/index.js"},"./packed":{"types":"./dist/debit/packed.d.ts","default":"./dist/debit/packed.js"},"./present":{"types":"./dist/field/present.d.ts","default":"./dist/field/present.js"},"./price":{"types":"./dist/lattice/price/index.d.ts","default":"./dist/lattice/price/index.js"},"./replay":{"types":"./dist/replay.d.ts","default":"./dist/replay.js"},"./shuffle":{"types":"./dist/debit/shuffle.d.ts","default":"./dist/debit/shuffle.js"},"./signatures":{"types":"./dist/field/signatures.d.ts","default":"./dist/field/signatures.js"},"./views/field":{"types":"./dist/views/field.d.ts","default":"./dist/views/field.js"},"./views/product":{"types":"./dist/views/product.d.ts","default":"./dist/views/product.js"},"./package.json":"./package.json"},"files":["dist","README.md","LICENSE","TARGET.bound","receipts.bound","docs/measures.md","samples/measures","vectors/measures","samples/yes/algebra-is-closed.json","samples/yes/field-uses-price-and-debit.json","samples/yes/three-theories-one-algebra.json","src/lattice/index.ts","src/field/motion.ts","samples/yes/installed-artifact.json","samples/no/installed-artifact.json","vectors/measures/installed-artifact.cli.json","docs/img","docs/paper.md","docs/reference.md","docs/learn/in-phase.md","docs/learn/price.md","docs/learn/signature.md","docs/learn/thermometer.md","docs/learn/withdrawal.md","vectors/laws/policy.json","vectors/laws/l7-tolerant-k.json","vectors/laws/l8-phase-defect.json","vectors/laws/l9-mix-loss.json","vectors/laws/implementation-043.json","samples/laws/cofailure-pairs/no/sample.json","samples/laws/cofailure-pairs/yes/sample.json","samples/laws/linage-rest/no/sample.json","samples/laws/linage-rest/yes/sample.json","samples/laws/lineage-ceiling/no/sample.json","samples/laws/lineage-ceiling/yes/sample.json","samples/laws/marginal-information/no/sample.json","samples/laws/marginal-information/yes/sample.json","samples/laws/semilattice/no/sample.json","samples/laws/semilattice/yes/sample.json","vectors/laws/cofailure-pairs.json","vectors/laws/cofailure-pairs.native.json","vectors/laws/coordination.json","vectors/laws/f1/finite-arithmetic.json","vectors/laws/f1/path-witness.json","vectors/laws/helly-comb.json","vectors/laws/helly-comb.lean.json","vectors/laws/linage-rest.native.json","vectors/laws/lineage-ceiling.json","vectors/laws/lineage-ceiling.native.json","vectors/laws/marginal-information.json","vectors/laws/marginal-information.native.json","vectors/laws/meet-semilattice.json","vectors/laws/meet-semilattice.native.json","vectors/laws/resolution-encounters.json","proofs/lineage-ceiling.json","proofs/cofailure-pairs.json","proofs/marginal-information.json","proofs/helly-comb.json","proofs/resolution-encounters.json","proofs/coordination.json","proofs/lean/Obligations/Cell.lean","proofs/lean/Obligations/HellyComb.lean","samples/yes/H1-uncertainty.json","samples/no/H1-uncertainty.json","proofs/m0-045/Obligations045/ConsensusGrid.lean","proofs/m0-045/Obligations045/M0Coincidence.lean","proofs/m0-045/Obligations045/M0Diagonal.lean","proofs/m0-045/Obligations045/M0Limit.lean","proofs/m0-045/Obligations045/M0Offdiag.lean","proofs/m0-045/Obligations045.lean","proofs/m0-045/lake-manifest.json","proofs/m0-045/lakefile.toml","proofs/m0-045/lean-toolchain","vectors/laws/m0-allocation.lean.json","contracts/m0-allocation.json","samples/laws/m0-allocation/yes/sample.json","samples/laws/m0-allocation/no/sample.json","vectors/laws/m0-allocation.native.json","docs/contracts/m0-allocation.md","vectors/laws/m0-finite-grid.lean.json","contracts/m0-finite-grid.json","samples/laws/m0-finite-grid/yes/sample.json","samples/laws/m0-finite-grid/no/sample.json","vectors/laws/m0-finite-grid.native.json","docs/contracts/m0-finite-grid.md","vectors/laws/m0-limit-offdiag.lean.json","contracts/m0-limit-offdiag.json","samples/laws/m0-limit-offdiag/yes/sample.json","samples/laws/m0-limit-offdiag/no/sample.json","vectors/laws/m0-limit-offdiag.native.json","docs/contracts/m0-limit-offdiag.md","vectors/laws/m0-limit-diag.lean.json","contracts/m0-limit-diag.json","samples/laws/m0-limit-diag/yes/sample.json","samples/laws/m0-limit-diag/no/sample.json","docs/proofs/floor-limit-diag.proof.json","vectors/laws/m0-limit-diag.native.json","docs/contracts/m0-limit-diag.md","vectors/laws/m0-pair-coincidence.lean.json","contracts/m0-pair-coincidence.json","samples/laws/m0-pair-coincidence/yes/sample.json","samples/laws/m0-pair-coincidence/no/sample.json","vectors/laws/m0-pair-coincidence.native.json","docs/contracts/m0-pair-coincidence.md","CHANGELOG.md"],"scripts":{"build":"tsc --build","test":"node --import ./test/setup.ts --test --test-concurrency=2 test/*.test.ts test/measures/*.test.ts"},"devDependencies":{"@types/node":"^22","typescript":"^5.9.3"}}