@lapxo/obligations 0.4.3 → 0.4.4

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

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

package/dist/measures/cofailure-pairs.js

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

package/dist/measures/index.d.ts

@@ -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/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/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.4","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","vectors/laws/f1/path-witness.json","vectors/laws/f1/finite-arithmetic.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"}}

package/proofs/cofailure-pairs.json

@@ -0,0 +1,26 @@
+{
+  "id":"cofailure-pairs/two-declared-observables",
+  "classification":"two descriptive measures with declared models; finite counterexamples, not a law identifying causes",
+  "oracle":{"score":"number of complete cells with Y_i=Y_j!=truth divided by declared T","reference":"Published coincidenceExcess supplies this pair rate and its independent-uniform-wrong baseline, with handed or truth-estimated error marginals. The graph uses the raw false rate, not the excess.","thetaUnit":"false-coincidence probability"},
+  "withoutTruth":{"score":"number of complete cells with Y_i=Y_j divided by T, minus sum_v q_i(v)*q_j(v)","reference":"independent-categorical@1 with fixed, normalized, handed per-origin categorical marginals over the named alphabet. No truth or estimated error marginal is read.","thetaUnit":"excess probability, in [-1,1]","absentReference":"unmeasured; never silently estimate a null from this batch","Head":"This is the candidate observable available without truth; no Head or Bound change is made, and no causal interpretation is supplied."},
+  "existingBoundary":"The published coincidenceExcess itself requires truth. Its no-truth reading stays unmeasured. This candidate is a different observable, not a relabel of that API.",
+  "frame":"T and theta are explicit and mandatory: absence is unmeasured. T counts distinct complete selected events. Missing cells are unmeasured; identical redelivery is idempotent; conflicting event/origin values refuse by name. Budget is checked before indexing rows.",
+  "graph":"An edge is score>theta. Connected components are a descriptive projection; a path of above-threshold edges does not establish a common cause or a clique.",
+  "populationRecovery":"For a handed target partition, require max score_outside < theta < min score_inside over every pair. A threshold between the two means is insufficient. The partition itself and population scores are not inferred by this rule.",
+  "finiteUncertainty":{
+    "sampling":"Optional iid-cells@1, with epsilon in (0,1], fixed frame, selected origins, epsilon and (for the non-oracle observable) null marginals fixed before observing the batch. The caller supplies these premises; the instrument does not verify them.",
+    "chain":["For each pair's Bernoulli event, Var(mean)<=1/(4T) under the declared independent cells.","Chebyshev gives P(|observed-population|>=epsilon)<=min(1,1/(4*T*epsilon^2)). Subtracting a fixed handed baseline preserves the deviation.","The existing unionBoundConfidence combines these failures for all M=m(m-1)/2 pairs; no independence between pairs is required.","Exact rational intervals score+-epsilon are clipped to their probability support. Resolve an edge only if the whole interval is strictly above or below theta. Unresolved intervals and trivial bounds stay visible.","This bounds simultaneous threshold decisions under the handed model. Causal recovery requires the separate population partition and strict gap premises."],
+    "arithmetic":"rational, no logarithmic or directed-rounding approximation; conservative Chebyshev bound, not an optimal interval",
+    "reference":"https://theory.stanford.edu/~blynn/pr/markov.html"
+  },
+  "counterexamples":[
+    {"id":"truth-relabel","claimRefuted":"the no-truth statistic identifies which coincidences are wrong","witness":"Identical response rows, truth all zero versus truth copied from a: observational output is unchanged but oracle edges differ."},
+    {"id":"shared-question","claimRefuted":"positive categorical excess proves shared error lineage","witness":"All sources answer a balanced binary question correctly. Oracle false rate is zero; a handed marginal 1/2 reference gives observed agreement 1 and excess 1/2. Conditional errors are degenerate zero, while the shared question drives unconditional agreement."},
+    {"id":"between-means","claimRefuted":"threshold between mean within and outside rates suffices","witness":"Within rates 0.8 and 0.2; outside 0.21,0.21,0,0. Theta=0.15 lies between means 0.5 and 0.105 but merges the handed groups; max outside exceeds min inside."},
+    {"id":"c-e-finite-confusion","claimRefuted":"finite exact subgroup recovery whenever shared c is comparable to private e","witness":"With c=e=1/4, the all-correct T=4 batch has probability [(3/4)^5]^4>0; it has no above-threshold oracle edges. Its confidence bound is trivial, not a certificate of no common factor."}
+  ],
+  "alreadyKnown":"Cooccurrence relative to a declared null, Chebyshev concentration and union bounds are standard. The published package already has truth-conditioned coincidenceExcess and exact unionBoundConfidence.",
+  "addsHere":"The oracle-free observable and its explicit null, pair graph with threshold units, and model-separating fixtures. No c is identified, no M/3-M/4 hypothesis changes, and no algebraic act or wire field is introduced.",
+  "publication":"new candidate module only; existing signed public exports, TARGET, receipts and derived docs remain unchanged",
+  "open":["Choice of an adequate observable-context reference for Head; this marginal null can be confounded by shared questions.","No causal subgroup identification from these statistics alone.","No iid certificate, population-margin estimate, or guarantee without the declared sampling premises."]
+}

package/proofs/coordination.json

@@ -0,0 +1,27 @@
+{
+  "id": "coordination@1",
+  "policy": "vectors/laws/policy.json",
+  "classification": "measure with declared conditional model and exact finite enumeration",
+  "statement": "For all L selected sources under a shared activation of probability f, active outputs equal one named wrong value. Otherwise source errors are jointly independent conditional on truth with rate e, uniform among n-1 wrong labels. Then U_L=f+(1-f)*((1-e)^L+e^L/(n-1)^(L-1)), and wrong unanimity W_L=f+(1-f)*e^L/(n-1)^(L-1).",
+  "hypotheses": [
+    "n>=2, L>=1, declared f and e, fixed truth for wrong-label enumeration; symmetry permits uniform truth extension.",
+    "Activation affects every selected source, no other unmodeled activation or observation channel.",
+    "Joint conditional independence is a model declaration for inactive draws, not inferred from pairwise statistics.",
+    "If n>2 and 0<e<=1, or n=2 and 0<e<1, both private unanimity terms tend to zero, giving limit f; finite values generally exceed f."
+  ],
+  "existing": "U_L is exactly the published fitUnanimityModel single-dominant-factor curve, not a new algebraic law or identification method.",
+  "adds": "Explicit equivalence of scheduled coordinated outputs and a shared-cause output distribution under this specified mixture, exact small-L enumeration, wrong-unanimity distinction and named invalid readings.",
+  "nonIdentification": "The activation schedule is itself a common variable in the joint distribution. No inference about a shared physical process, intent or causal origin follows from the same curve; c_total is a compatible model parameter, not model-free truth.",
+  "negative": [
+    "At e=0 all outputs are unanimously correct when inactive: U_L=1 for every L, so U does not identify f. W_L still equals f.",
+    "Two disjoint groups independently activated at rate f/2 do not obey the all-source single-activation curve with mass f.",
+    "Marginal error rate e without joint conditional independence does not determine private unanimity; n=2, e=1/2, identical private errors give U=1 while iid predicts 2^(1-L)."
+  ],
+  "status": "declared-model measure; finite vectors, no causal identification",
+  "unmeasured": "Missing joint-independence declaration refuses curve interpretation by name; unknown mechanism remains unmeasured.",
+  "references": [
+    "https://www.stat.berkeley.edu/~aldous/206-Exch/"
+  ],
+  "signatures": 0,
+  "admission": false
+}

package/proofs/helly-comb.json

@@ -0,0 +1,17 @@
+{
+  "id": "helly-comb@1",
+  "policy": "vectors/laws/policy.json",
+  "classification": "law by finite counterexample, Lean kernel checked",
+  "statement": "Pairwise intersection does not imply joint intersection for arbitrary finite nonconvex subsets (combs).",
+  "domain": "Finite carrier {0,1,2}; A={0,1}, B={1,2}, C={0,2}. Witnesses AB=1, AC=0, BC=2; ABC empty.",
+  "hypotheses": "No convexity/interval assumption. C has a hole. Does not refute the interval-only T38.",
+  "negative": "Reject promoting pairwise compatibility of these combs to a global witness.",
+  "existing": "Classical Helly theory needs convexity; finite intervals on a line are 2-Helly. The elementary nonconvex counterexample is not a new discovery.",
+  "adds": "Exact finite subset witness and compiled Lean certificate tied to Obligations candidate bytes; no new form or wire encoding.",
+  "references": [
+    "https://www.math.ucdavis.edu/~deloera/TEACHING/MATH114/convexitythy.pdf"
+  ],
+  "status": "finite witness checked; no generalized theorem",
+  "signatures": 0,
+  "admission": false
+}