@lapxo/obligations 0.4.1 → 0.4.2

package/dist/lattice/obligatory.js

@@ -18,6 +18,7 @@ export function restOf(c, world = new Map()) {
     const out = [];
     const held = new Set();
     const edge = [...c.restsOn];
+    const above = new Map();
     for (let i = 0; i < edge.length; i += 1) {
         const name = edge[i];
         if (name === own)
@@ -26,7 +27,34 @@ export function restOf(c, world = new Map()) {
             continue;
         held.add(name);
         out.push(name);
-        edge.push(...(world.get(name)?.restsOn ?? []));
+        const rests = world.get(name)?.restsOn ?? [];
+        above.set(name, rests);
+        for (const ancestor of rests)
+            edge.push(ancestor);
+    }
+    const status = new Map();
+    for (const name of out) {
+        if (status.has(name))
+            continue;
+        status.set(name, 'visiting');
+        const path = [{ name, next: 0 }];
+        while (path.length) {
+            const head = path[path.length - 1];
+            const rests = above.get(head.name);
+            if (head.next === rests.length) {
+                status.set(head.name, 'done');
+                path.pop();
+                continue;
+            }
+            const ancestor = rests[head.next++];
+            const seen = status.get(ancestor);
+            if (seen === 'visiting')
+                throw new UnitError('rest-cycle', `obligations: REFUSE·rest ${own} reaches a cycle at ${ancestor}: an order of rest with a cycle has no fold to reach`, { at: own });
+            if (seen === undefined) {
+                status.set(ancestor, 'visiting');
+                path.push({ name: ancestor, next: 0 });
+            }
+        }
     }
     return out;
 }

package/dist/measures/capacity.d.ts

@@ -28,6 +28,28 @@ export declare function capacityBound(n: number, c: RationalInput, policy: Logar
     value: number;
     meaning: "upper bound for every k; achievability depends on the private channel";
 };
+export declare function commonCauseCapacityBound(n: number, c: RationalInput, accuracy: RationalInput, policy: LogarithmPolicy): {
+    model: "single-covering-symmetric-cause@1";
+    parameters: {
+        n: number;
+        c: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        q: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+    }>;
+    status: "measured";
+    unit: "bits";
+    conditions: readonly ["uniform-truth", "cause-indicator-independent-of-truth", "active-cause-copies-one-symmetric-channel", "inactive-private-channel-unrestricted"];
+    value: number;
+    meaning: "upper bound after revealing cause indicator; copies do not add; no achievability claim";
+};
 export declare function capacityP0(n: number, c: RationalInput, policy: LogarithmPolicy): {
     value: number;
     meaning: "mutual information at p=0 for every positive k";

package/dist/measures/capacity.js

@@ -29,6 +29,22 @@ export function capacityBound(n, c, policy) {
         status: 'measured', unit: 'bits', value: Math.log2(n) - numeric(factor) * Math.log2(n - 1),
         meaning: 'upper bound for every k; achievability depends on the private channel' };
 }
+export function commonCauseCapacityBound(n, c, accuracy, policy) {
+    cardinality(n);
+    logPolicy(policy);
+    if (accuracy === undefined || accuracy === null)
+        refuse('common-cause accuracy q required');
+    const factor = probability(c), correct = probability(accuracy), wrong = sub(one, correct);
+    const uniform = correct[0] * BigInt(n) === correct[1];
+    const channel = uniform ? 0 : correct[0] === 0n ? Math.log1p(1 / (n - 1)) / Math.LN2 :
+        Math.max(0, Math.log2(n) - entropy([correct, wrong]) - numeric(wrong) * Math.log2(n - 1));
+    return { model: 'single-covering-symmetric-cause@1',
+        parameters: { n, c: pack(factor), q: pack(correct) }, policy, status: 'measured', unit: 'bits',
+        conditions: ['uniform-truth', 'cause-indicator-independent-of-truth',
+            'active-cause-copies-one-symmetric-channel', 'inactive-private-channel-unrestricted'],
+        value: numeric(sub(one, factor)) * Math.log2(n) + numeric(factor) * channel,
+        meaning: 'upper bound after revealing cause indicator; copies do not add; no achievability claim' };
+}
 export function capacityP0(n, c, policy) {
     const bound = capacityBound(n, c, policy), factor = probability(c);
     return { ...bound, value: bound.value - entropy([factor, sub(one, factor)]), meaning: 'mutual information at p=0 for every positive k' };

package/dist/measures/confidence.d.ts

@@ -0,0 +1,73 @@
+import { type RationalInput } from './rational.ts';
+export type DeclaredFailure = Readonly<{
+    id: string;
+    p: RationalInput;
+    justification: string;
+}>;
+export declare function unionBoundConfidence(failures: readonly DeclaredFailure[]): {
+    model: "declared-failure-union-bound@1";
+    status: "conditional-bound";
+    unit: "probability";
+    conditions: readonly ["common-probability-space", "each-failure-probability-justified"];
+    declarations: {
+        id: string;
+        p: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        justification: string;
+    }[];
+    failureSum: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    value: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    trivial: boolean;
+    meaning: "lower bound for all declared events succeeding; references are not verified";
+};
+export declare function tolerantCountConfidence(failures: readonly DeclaredFailure[], k: number): {
+    model: "declared-failure-count-bound@1";
+    allowedFailures: number;
+    totalDeclarations: number;
+    exclusionOrder: string[];
+    candidates: {
+        excludedCount: number;
+        threshold: number;
+        remainingFailureSum: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        failureUpperBound: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+    }[];
+    failureUpperBound: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    value: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+    trivial: boolean;
+    meaning: "lower bound for at most k declared failures; references are not verified";
+    status: "conditional-bound";
+    unit: "probability";
+    conditions: readonly ["common-probability-space", "each-failure-probability-justified"];
+    declarations: {
+        id: string;
+        p: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        justification: string;
+    }[];
+    failureSum: Readonly<{
+        numerator: string;
+        denominator: string;
+    }>;
+};

package/dist/measures/confidence.js

@@ -0,0 +1,52 @@
+import { add, sub, div, q, rational, zero, one, pack, probability } from "./rational.js";
+const refuse = (cause) => { throw new Error('REFUSE·confidence ' + cause); };
+export function unionBoundConfidence(failures) {
+    if (!Array.isArray(failures))
+        refuse('declared failures required');
+    let sum = zero;
+    const names = new Set();
+    const declarations = Array.from(failures, failure => {
+        if (!failure || typeof failure.id !== 'string' || failure.id.trim() === '')
+            refuse('failure identity required');
+        if (names.has(failure.id))
+            refuse('duplicate failure identity');
+        names.add(failure.id);
+        if (typeof failure.justification !== 'string' || failure.justification.trim() === '')
+            refuse('justification reference required');
+        if (failure.p === undefined || failure.p === null)
+            refuse('declared failure probability required');
+        const p = probability(failure.p);
+        sum = add(sum, p);
+        return { id: failure.id, p: pack(p), justification: failure.justification };
+    });
+    const trivial = sum[0] >= sum[1];
+    return { model: 'declared-failure-union-bound@1', status: 'conditional-bound',
+        unit: 'probability', conditions: ['common-probability-space', 'each-failure-probability-justified'],
+        declarations, failureSum: pack(sum), value: pack(trivial ? zero : sub(one, sum)), trivial,
+        meaning: 'lower bound for all declared events succeeding; references are not verified' };
+}
+export function tolerantCountConfidence(failures, k) {
+    const base = unionBoundConfidence(failures), m = base.declarations.length;
+    if (!Number.isSafeInteger(k) || k < 0 || k > m)
+        refuse('allowed failure count must be an integer in 0..m');
+    const ordered = base.declarations.map(entry => ({ entry, p: probability(entry.p) })).sort((a, b) => {
+        const difference = a.p[0] * b.p[1] - b.p[0] * a.p[1];
+        return difference > 0n ? -1 : difference < 0n ? 1 : 0;
+    });
+    let remaining = rational(base.failureSum), upper = k === m ? zero : one;
+    const candidates = [];
+    if (k < m)
+        for (let j = 0; j <= k; j++) {
+            const threshold = k + 1 - j, ratio = div(remaining, q(BigInt(threshold)));
+            const capped = ratio[0] >= ratio[1] ? one : ratio;
+            if (capped[0] * upper[1] < upper[0] * capped[1])
+                upper = capped;
+            candidates.push({ excludedCount: j, threshold, remainingFailureSum: pack(remaining), failureUpperBound: pack(capped) });
+            if (j < k)
+                remaining = sub(remaining, ordered[j].p);
+        }
+    return { ...base, model: 'declared-failure-count-bound@1', allowedFailures: k,
+        totalDeclarations: m, exclusionOrder: ordered.map(({ entry }) => entry.id), candidates,
+        failureUpperBound: pack(upper), value: pack(sub(one, upper)), trivial: upper[0] === upper[1],
+        meaning: 'lower bound for at most k declared failures; references are not verified' };
+}

package/dist/measures/index.d.ts

@@ -16,9 +16,11 @@ export { experimentM3 } from './m3-experiment.ts';
 export type { M3ExperimentPolicy } from './m3-experiment.ts';
 export { fitM3 } from './fitting.ts';
 export type { FitStructure, FitPolicy } from './fitting.ts';
-export { capacityBound, capacityP0, mutualInformation, unanimityNoFactor, decisionInformation } from './capacity.ts';
+export { commonCauseCapacityBound, capacityBound, capacityP0, mutualInformation, unanimityNoFactor, decisionInformation } from './capacity.ts';
 export type { CapacityModel, LogarithmPolicy, CapacityPolicy, DecisionRule } from './capacity.ts';
 export { fitUnanimityModel } from './unanimity-fit.ts';
 export type { UnanimityCount, UnanimityGroup, UnanimityCurve, UnanimityFitPolicy } from './unanimity-fit.ts';
 export { coincidenceExcess } from './coincidence.ts';
 export type { ValueReading, TruthReading, CoincidenceReference, CoincidencePolicy } from './coincidence.ts';
+export { unionBoundConfidence, tolerantCountConfidence } from './confidence.ts';
+export type { DeclaredFailure } from './confidence.ts';

package/dist/measures/index.js

@@ -7,6 +7,7 @@ export { roundHalfEven } from "./rational.js";
 export { identifyM3 } from "./identification.js";
 export { experimentM3 } from "./m3-experiment.js";
 export { fitM3 } from "./fitting.js";
-export { capacityBound, capacityP0, mutualInformation, unanimityNoFactor, decisionInformation } from "./capacity.js";
+export { commonCauseCapacityBound, capacityBound, capacityP0, mutualInformation, unanimityNoFactor, decisionInformation } from "./capacity.js";
 export { fitUnanimityModel } from "./unanimity-fit.js";
 export { coincidenceExcess } from "./coincidence.js";
+export { unionBoundConfidence, tolerantCountConfidence } from "./confidence.js";

package/docs/measures.md

@@ -194,4 +194,20 @@ Helly is a property of a declared geometric family, not a probabilistic independ
 
 ## 17. Publication and stability
 
-Every new operation is linked to its contract, yes/no data and native Bound 0.1.7 captures in two places. Validation readers are maintained TypeScript worlds with ordinary modular compilation; no .mjs bundle or private executor ships in this library. Their implementation inventory is retained once by digest. The installed archive must expose the same public exports, preserve the four states, match all published bytes and close native receipts without a private store. Declaring these requirements does not pay them.
+The historical nine publication groups are linked to their contracts, yes/no data and declared Bound 0.1.7 captures in two places. The 0.4.2 operations below require new captures under their selected reader; historical implementation-bound receipts do not cover changed bytes. Validation readers are maintained TypeScript worlds with ordinary modular compilation; no .mjs bundle or private executor ships in this library. Their implementation inventory is retained once by digest. The installed archive must expose the same public exports, preserve the four states, match all published bytes and close native receipts without a private store. Declaring these requirements does not pay them.
+
+## 18. Declared failure bounds
+
+`unionBoundConfidence(failures)` requires distinct nonempty IDs, explicit rational probabilities in [0,1], and nonempty justification references. The caller must establish every failure bound in one probability space. References are retained, not verified. The returned lower bound for all events succeeding is max(0,1−Σp_i), with exact rational arithmetic. The empty family gives 1; Σp_i≥1 gives the trivial bound 0. No independence, truth probability, or algebraic state is inferred.
+
+`tolerantCountConfidence(failures,k)` requires a safe integer 0≤k≤m. For k<m it bounds failure by min(1,min_{0≤j≤k}(Σ of the m−j smallest p_i)/(k+1−j)); its exact success lower bound is the complement. For k=m success is certain. For m=3,k=1 and all p_i=1/10 the result is 17/20, not an inferred success rate. The distinct subset-intersection guarantee gives the weaker bound 7/10. Three disjoint paired failures among six events, each pair having probability 1/10, refute the former 4/5 claim: success is 7/10.
+
+These operations compute conditional probability bounds. They select neither a geometric tolerance nor a consumer policy. Count-tolerant intersection T_k and widened-interval intersection T_eps remain named forms; tolerant-choice remains open.
+
+## 19. Declared covering cause
+
+`commonCauseCapacityBound(n,c,q,{logarithm:'binary64-log2'})` requires integer n≥2 and explicit rational c,q in [0,1]. Truth is uniform; the covering-cause indicator is independent of truth; when active, every report copies one symmetric channel with accuracy q. The inactive private channel is unrestricted. Revealing the indicator gives the upper bound log2(n)−c[h(q)+(1−q)log2(n−1)] in approximate bits. Copy count is no input. This is neither finite-sample mutual information nor an achievability claim.
+
+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.

package/package.json

@@ -1 +1 @@
-{"name":"@lapxo/obligations","version":"0.4.1","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.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"}}