@lapxo/obligations 0.4.2 → 0.4.4

package/dist/measures/mix-loss.js

@@ -0,0 +1,101 @@
+import { add, div, one, pack, probability, rational, zero } from "./rational.js";
+const refuse = (why) => { throw Error('REFUSE·mix-loss ' + why); };
+const exact = (input, asProbability = false) => {
+    try {
+        return asProbability ? probability(input) : rational(input);
+    }
+    catch {
+        return refuse('invalid ' + (asProbability ? 'prior probability' : 'factor weight'));
+    }
+};
+const logInteger = (n) => { const shift = Math.max(0, n.toString(2).length - 53); return Math.log2(Number(n >> BigInt(shift))) + shift; };
+const logQ = (p) => logInteger(p[0]) - logInteger(p[1]);
+const numeric = (p) => p[0] === 0n ? 0 : 2 ** logQ(p);
+const entropy = (ps) => ps.reduce((sum, p) => p[0] === 0n ? sum : sum - numeric(p) * logQ(p), 0);
+const uniqueNames = (names, what) => {
+    if (!Array.isArray(names) || !names.length || names.some(n => typeof n !== 'string' || !n.trim()) || new Set(names).size !== names.length)
+        refuse('distinct nonempty ' + what + ' required');
+};
+export function mixProjectionLoss(model, policy) {
+    if (!policy || policy.logarithm !== 'binary64-log2' || typeof policy.budget !== 'string' || !/^\d+$/.test(policy.budget))
+        refuse('logarithm and work budget required');
+    if (!model || !Array.isArray(model.factors) || !Array.isArray(model.alphabet) || !Array.isArray(model.configurations))
+        refuse('declared factors, alphabet and configuration support required');
+    uniqueNames(model.factors.map(f => f?.id), 'factor IDs');
+    uniqueNames(model.alphabet, 'alphabet values');
+    uniqueNames(model.configurations.map(c => c?.id), 'configuration IDs');
+    const alphabet = new Set(model.alphabet);
+    const patterns = new Set();
+    for (const c of model.configurations) {
+        if (!Array.isArray(c.values) || c.values.length !== model.factors.length || c.values.some(v => !alphabet.has(v)))
+            refuse('configuration outside declared factor/alphabet domain');
+        const pattern = JSON.stringify(c.values);
+        if (patterns.has(pattern))
+            refuse('duplicate named-factor configuration');
+        patterns.add(pattern);
+    }
+    const weights = model.factors.map(f => exact(f.weight));
+    if (weights.some(w => w[0] < 0n) || weights.every(w => w[0] === 0n))
+        refuse('nonnegative weights with positive total required');
+    const parameters = { m: model.factors.length, factors: model.factors.map((f, i) => ({ id: f.id, weight: pack(weights[i]) })),
+        alphabet: [...model.alphabet], configurations: model.configurations.map(c => ({ id: c.id, values: [...c.values] })) };
+    if (!model.prior)
+        return { status: 'unmeasured', cause: 'mix-loss/prior-required', parameters, policy };
+    const required = BigInt(model.configurations.length);
+    if (required > BigInt(policy.budget))
+        return { status: 'unmeasured', cause: 'mix-loss/work-budget',
+            parameters, policy, required: String(required), workUnit: 'declared-configurations' };
+    let prior;
+    if (model.prior.kind === 'uniform')
+        prior = model.configurations.map(() => div(one, [BigInt(model.configurations.length), 1n]));
+    else if (model.prior.kind === 'explicit') {
+        const entries = model.prior.probabilities;
+        if (!Array.isArray(entries) || entries.length !== model.configurations.length || entries.some(e => !e || typeof e.configuration !== 'string') ||
+            new Set(entries.map(e => e.configuration)).size !== entries.length)
+            refuse('one prior probability per configuration required');
+        const byId = new Map(entries.map(e => [e.configuration, exact(e.p, true)]));
+        if (model.configurations.some(c => !byId.has(c.id)))
+            refuse('prior support differs from declared configurations');
+        prior = model.configurations.map(c => byId.get(c.id));
+        const total = prior.reduce(add, zero);
+        if (total[0] !== total[1])
+            refuse('prior probabilities must sum exactly to one');
+    }
+    else
+        return refuse('declared prior kind required');
+    const fibers = new Map();
+    const configurations = model.configurations.map((c, i) => {
+        const totals = new Map(model.alphabet.map(v => [v, zero]));
+        c.values.forEach((v, j) => totals.set(v, add(totals.get(v), weights[j])));
+        let best = zero;
+        for (const total of totals.values())
+            if (total[0] * best[1] > best[0] * total[1])
+                best = total;
+        const winners = model.alphabet.filter(v => { const t = totals.get(v); return t[0] * best[1] === best[0] * t[1]; });
+        const output = winners.length === 1 ? { kind: 'value', value: winners[0] } : { kind: 'tie', values: winners };
+        const key = output.kind === 'tie' ? 'tie' : JSON.stringify(['value', output.value]);
+        const fiber = fibers.get(key) ?? { output: output.kind === 'tie' ? { kind: 'tie', values: [] } : output, indices: [] };
+        fiber.indices.push(i);
+        fibers.set(key, fiber);
+        return { id: c.id, probability: pack(prior[i]), mix: output.kind === 'tie' ? { kind: 'tie' } : output,
+            fork: model.factors.map((f, j) => ({ factor: f.id, value: c.values[j] })) };
+    });
+    const outputs = [...fibers.values()].map(f => {
+        const mass = f.indices.map(i => prior[i]).reduce(add, zero);
+        const posterior = mass[0] === 0n ? [] : f.indices.map(i => ({ configuration: model.configurations[i].id, p: div(prior[i], mass) }));
+        return { output: f.output.kind === 'tie' ? { kind: 'tie' } : f.output, probability: pack(mass),
+            configurations: f.indices.map(i => model.configurations[i].id),
+            posterior: posterior.map(p => ({ configuration: p.configuration, p: pack(p.p) })),
+            conditionalBits: mass[0] === 0n ? null : entropy(posterior.map(p => p.p)), mass };
+    });
+    const configurationBits = entropy(prior), mixBits = entropy(outputs.map(o => o.mass));
+    const lossBits = outputs.reduce((sum, o) => sum + (o.conditionalBits === null ? 0 : numeric(o.mass) * o.conditionalBits), 0);
+    return { status: 'measured', model: 'declared-weighted-mix-projection@1', parameters,
+        prior: { kind: model.prior.kind, probabilities: model.configurations.map((c, i) => ({ configuration: c.id, p: pack(prior[i]) })) },
+        policy, unit: 'bits', approximation: 'binary64-log2', configurationBits, mixBits, lossBits,
+        entropyDifferenceBits: configurationBits - mixBits, forkLossBits: 0,
+        mixInjectiveOnConfigurations: [...fibers.values()].every(f => f.indices.length === 1),
+        mixInjectiveOnPositiveSupport: [...fibers.values()].every(f => f.indices.filter(i => prior[i][0] > 0n).length <= 1),
+        configurations, outputs: outputs.map(({ mass, ...o }) => o),
+        meaning: 'conditional entropy of the declared configuration given its deterministic mix output; named fork is injective' };
+}

package/dist/measures/phase-defect.d.ts

@@ -0,0 +1,40 @@
+import type { LogarithmPolicy } from './capacity.ts';
+export type PhaseDefectInterpretation = 'phase-defect' | 'information';
+export declare function phaseDefect(n: number, p: number, s: number, policy: LogarithmPolicy, interpretation?: PhaseDefectInterpretation): {
+    model: "F4-integer-phase-defect@1";
+    parameters: {
+        n: number;
+        p: number;
+        s: number;
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+    }>;
+    status: "measured";
+    meaning: "phase defect; information interpretation open";
+    regime: "nonnegative" | "may-be-negative";
+    value: number;
+};
+export declare function phaseDefectExtrema(n: number, p: number, policy: LogarithmPolicy): {
+    model: "F4-integer-phase-defect@1";
+    parameters: {
+        n: number;
+        p: number;
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+    }>;
+    status: "measured";
+    minimum: {
+        value: number;
+        shifts: number[];
+    };
+    maximum: {
+        value: number;
+        shifts: number[];
+    };
+    nonzeroMaximum: {
+        value: number;
+        shifts: number[];
+    } | null;
+};

package/dist/measures/phase-defect.js

@@ -0,0 +1,33 @@
+const refuse = (cause) => { throw new Error('REFUSE·phase-defect ' + cause); };
+function domain(n, p, policy) {
+    if (!Number.isSafeInteger(n) || n < 1 || !Number.isSafeInteger(p) || p < 1 || n % p !== 0)
+        refuse('positive integer divisor domain required');
+    if (!policy || policy.logarithm !== 'binary64-log2')
+        refuse('logarithm policy required');
+}
+function shift(p, s) {
+    if (!Number.isSafeInteger(s) || s < 0 || s >= p)
+        refuse('integer shift domain required');
+}
+function binaryEntropy(t) {
+    return t === 0 || t === 1 ? 0 : -t * Math.log2(t) - (1 - t) * Math.log2(1 - t);
+}
+export function phaseDefect(n, p, s, policy, interpretation = 'phase-defect') {
+    domain(n, p, policy);
+    shift(p, s);
+    if (interpretation !== 'phase-defect')
+        refuse('information interpretation unsupported');
+    return { model: 'F4-integer-phase-defect@1', parameters: { n, p, s }, policy,
+        status: 'measured', meaning: 'phase defect; information interpretation open',
+        regime: n / p >= 2 ? 'nonnegative' : 'may-be-negative',
+        value: Math.log2(n / p) - binaryEntropy(s / p) };
+}
+export function phaseDefectExtrema(n, p, policy) {
+    domain(n, p, policy);
+    const middle = Math.floor(p / 2), minimumShifts = p === 1 ? [0] : p % 2 === 0 ? [middle] : [middle, middle + 1];
+    return { model: 'F4-integer-phase-defect@1', parameters: { n, p }, policy,
+        status: 'measured',
+        minimum: { value: Math.log2(n / p) - binaryEntropy(middle / p), shifts: minimumShifts },
+        maximum: { value: Math.log2(n / p), shifts: [0] },
+        nonzeroMaximum: p === 1 ? null : { value: Math.log2(n / p) - binaryEntropy(1 / p), shifts: p === 2 ? [1] : [1, p - 1] } };
+}

package/dist/measures/tolerant-subsets.d.ts

@@ -0,0 +1,79 @@
+import { type DeclaredFailure } from './confidence.ts';
+export declare function tolerantSubsetConfidence(failures: readonly DeclaredFailure[], k: number, probabilitySpace: string): {
+    model: "declared-failure-subset-bound@1";
+    status: "conditional-bound";
+    unit: "probability";
+    probabilitySpace: string;
+    declarations: {
+        id: string;
+        p: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        justification: string;
+    }[];
+    allowedFailures: number;
+    totalDeclarations: number;
+    conditions: readonly ["common-probability-space", "declared-marginal-upper-bounds"];
+    referencesVerified: false;
+    terms: {
+        id: string;
+        subsets: string;
+        contribution: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+    }[];
+    uncappedFailureBound: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    failureUpperBound: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    value: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    trivial: boolean;
+};
+export type JointIndependenceDeclaration = Readonly<{
+    probabilitySpace: string;
+    jointIndependence: true;
+    justification: string;
+}>;
+export declare function independentCountConfidence(failures: readonly DeclaredFailure[], k: number, declaration: JointIndependenceDeclaration): {
+    model: "declared-joint-independent-count-bound@1";
+    status: "conditional-bound";
+    unit: "probability";
+    probabilitySpace: string;
+    declarations: {
+        id: string;
+        p: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        justification: string;
+    }[];
+    allowedFailures: number;
+    totalDeclarations: number;
+    jointIndependence: {
+        declared: true;
+        justification: string;
+    };
+    referencesVerified: false;
+    bernoulliEnvelope: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>[];
+    failureUpperBound: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    value: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    trivial: boolean;
+};

package/dist/measures/tolerant-subsets.js

@@ -0,0 +1,60 @@
+import { unionBoundConfidence } from "./confidence.js";
+import { add, sub, mul, q, rational, zero, one, pack } from "./rational.js";
+const refuse = (cause) => { throw new Error('REFUSE·L7 ' + cause); };
+function inputs(failures, k, probabilitySpace) {
+    if (typeof probabilitySpace !== 'string' || probabilitySpace.trim() === '')
+        refuse('common-probability-space-required');
+    const base = unionBoundConfidence(failures), m = base.declarations.length;
+    if (!Number.isSafeInteger(k) || k < 0 || k > m)
+        refuse('allowed-failure-count-outside-0..m');
+    return { base, m };
+}
+function choose(n, k) {
+    if (k > n)
+        return 0n;
+    let c = 1n;
+    for (let j = 1; j <= Math.min(k, n - k); j++)
+        c = c * BigInt(n - j + 1) / BigInt(j);
+    return c;
+}
+export function tolerantSubsetConfidence(failures, k, probabilitySpace) {
+    const { base, m } = inputs(failures, k, probabilitySpace);
+    const ordered = base.declarations.map(entry => ({ entry, p: rational(entry.p) })).sort((a, b) => {
+        const d = a.p[0] * b.p[1] - b.p[0] * a.p[1];
+        return d < 0n ? -1 : d > 0n ? 1 : 0;
+    });
+    let sum = zero;
+    const terms = k === m ? [] : ordered.slice(0, m - k).map(({ entry, p }, j) => {
+        const coefficient = choose(m - j - 1, k), contribution = mul(p, q(coefficient));
+        sum = add(sum, contribution);
+        return { id: entry.id, subsets: String(coefficient), contribution: pack(contribution) };
+    });
+    const trivial = sum[0] >= sum[1], upper = trivial ? one : sum;
+    return { model: 'declared-failure-subset-bound@1', status: 'conditional-bound',
+        unit: 'probability', probabilitySpace, declarations: base.declarations,
+        allowedFailures: k, totalDeclarations: m, conditions: ['common-probability-space', 'declared-marginal-upper-bounds'],
+        referencesVerified: false, terms, uncappedFailureBound: pack(sum), failureUpperBound: pack(upper),
+        value: pack(sub(one, upper)), trivial };
+}
+export function independentCountConfidence(failures, k, declaration) {
+    if (!declaration || declaration.jointIndependence !== true)
+        refuse('joint-independence-required');
+    if (typeof declaration.justification !== 'string' || declaration.justification.trim() === '')
+        refuse('joint-independence-justification-required');
+    const { base, m } = inputs(failures, k, declaration.probabilitySpace);
+    let distribution = [one];
+    for (const entry of base.declarations) {
+        const p = rational(entry.p), next = Array.from({ length: distribution.length + 1 }, () => zero);
+        for (let j = 0; j < distribution.length; j++) {
+            next[j] = add(next[j], mul(distribution[j], sub(one, p)));
+            next[j + 1] = add(next[j + 1], mul(distribution[j], p));
+        }
+        distribution = next;
+    }
+    const upper = distribution.slice(k + 1).reduce(add, zero);
+    return { model: 'declared-joint-independent-count-bound@1', status: 'conditional-bound',
+        unit: 'probability', probabilitySpace: declaration.probabilitySpace, declarations: base.declarations,
+        allowedFailures: k, totalDeclarations: m, jointIndependence: { declared: true, justification: declaration.justification },
+        referencesVerified: false, bernoulliEnvelope: distribution.map(pack), failureUpperBound: pack(upper),
+        value: pack(sub(one, upper)), trivial: upper[0] === upper[1] };
+}

package/docs/measures.md

@@ -211,3 +211,27 @@ These operations compute conditional probability bounds. They select neither a g
 At n=4,c=1,q=1/4 the bound is exactly zero; q=0 gives log2(4/3), and q=1 gives two bits. Missing q refuses. The operational declaration or detection of activation remains open in identification.model. Unconditioned coincidence does not identify q.
 
 M/3 and M/4 retain their existing definitions. Partial-factor governance proposals do not supply a conditional joint observation and selection law. The information carried by dissent, including a bottom symbol, is open for those unspecified proposals.
+
+## Obligations 0.4.3 — proposed conditional measures
+
+L7: conditional bound on one declared common probability space: P(N>k)<=min(1,sum over |S|=k+1 of min p_i), with rational declared marginal failure upper bounds and 0<=k<=m. Trivial iff computed upper bound is one. Counterexamples refute the former top-k+1 success guarantee. Joint-independent Bernoulli convolution is a separate declared hypothesis; rho=0 and pairwise independence do not supply it. Existing stronger 0.4.2 count bound is unchanged and needs no joint independence.
+
+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.2","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"],"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
+}