@lapxo/obligations 0.4.1 → 0.4.3

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,17 @@ 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';
+export { tolerantSubsetConfidence, independentCountConfidence } from './tolerant-subsets.ts';
+export type { JointIndependenceDeclaration } from './tolerant-subsets.ts';
+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';

package/dist/measures/index.js

@@ -7,6 +7,10 @@ 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";
+export { tolerantSubsetConfidence, independentCountConfidence } from "./tolerant-subsets.js";
+export { phaseDefect, phaseDefectExtrema } from "./phase-defect.js";
+export { mixProjectionLoss } from "./mix-loss.js";

package/dist/measures/mix-loss.d.ts

@@ -0,0 +1,187 @@
+import { type RationalInput } from './rational.ts';
+export type NamedConfiguration = Readonly<{
+    id: string;
+    values: readonly string[];
+}>;
+export type ConfigurationPrior = Readonly<{
+    kind: 'uniform';
+}> | Readonly<{
+    kind: 'explicit';
+    probabilities: readonly Readonly<{
+        configuration: string;
+        p: RationalInput;
+    }>[];
+}>;
+export type MixLossModel = Readonly<{
+    factors: readonly Readonly<{
+        id: string;
+        weight: RationalInput;
+    }>[];
+    alphabet: readonly string[];
+    configurations: readonly NamedConfiguration[];
+    prior?: ConfigurationPrior;
+}>;
+export type MixLossPolicy = Readonly<{
+    logarithm: 'binary64-log2';
+    budget: string;
+}>;
+export declare function mixProjectionLoss(model: MixLossModel, policy: MixLossPolicy): {
+    status: "unmeasured";
+    cause: "mix-loss/prior-required";
+    parameters: {
+        m: number;
+        factors: {
+            id: string;
+            weight: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        alphabet: string[];
+        configurations: {
+            id: string;
+            values: string[];
+        }[];
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    required?: undefined;
+    workUnit?: undefined;
+    model?: undefined;
+    prior?: undefined;
+    unit?: undefined;
+    approximation?: undefined;
+    configurationBits?: undefined;
+    mixBits?: undefined;
+    lossBits?: undefined;
+    entropyDifferenceBits?: undefined;
+    forkLossBits?: undefined;
+    mixInjectiveOnConfigurations?: undefined;
+    mixInjectiveOnPositiveSupport?: undefined;
+    configurations?: undefined;
+    outputs?: undefined;
+    meaning?: undefined;
+} | {
+    status: "unmeasured";
+    cause: "mix-loss/work-budget";
+    parameters: {
+        m: number;
+        factors: {
+            id: string;
+            weight: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        alphabet: string[];
+        configurations: {
+            id: string;
+            values: string[];
+        }[];
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    required: string;
+    workUnit: "declared-configurations";
+    model?: undefined;
+    prior?: undefined;
+    unit?: undefined;
+    approximation?: undefined;
+    configurationBits?: undefined;
+    mixBits?: undefined;
+    lossBits?: undefined;
+    entropyDifferenceBits?: undefined;
+    forkLossBits?: undefined;
+    mixInjectiveOnConfigurations?: undefined;
+    mixInjectiveOnPositiveSupport?: undefined;
+    configurations?: undefined;
+    outputs?: undefined;
+    meaning?: undefined;
+} | {
+    status: "measured";
+    model: "declared-weighted-mix-projection@1";
+    parameters: {
+        m: number;
+        factors: {
+            id: string;
+            weight: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        alphabet: string[];
+        configurations: {
+            id: string;
+            values: string[];
+        }[];
+    };
+    prior: {
+        kind: "uniform" | "explicit";
+        probabilities: {
+            configuration: string;
+            p: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+    };
+    policy: Readonly<{
+        logarithm: "binary64-log2";
+        budget: string;
+    }>;
+    unit: "bits";
+    approximation: "binary64-log2";
+    configurationBits: number;
+    mixBits: number;
+    lossBits: number;
+    entropyDifferenceBits: number;
+    forkLossBits: number;
+    mixInjectiveOnConfigurations: boolean;
+    mixInjectiveOnPositiveSupport: boolean;
+    configurations: {
+        id: string;
+        probability: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        mix: Readonly<{
+            kind: "value";
+            value: string;
+        }> | {
+            kind: "tie";
+        };
+        fork: {
+            factor: string;
+            value: string;
+        }[];
+    }[];
+    outputs: {
+        output: Readonly<{
+            kind: "value";
+            value: string;
+        }> | {
+            kind: "tie";
+        };
+        probability: Readonly<{
+            numerator: string;
+            denominator: string;
+        }>;
+        configurations: string[];
+        posterior: {
+            configuration: string;
+            p: Readonly<{
+                numerator: string;
+                denominator: string;
+            }>;
+        }[];
+        conditionalBits: number | null;
+    }[];
+    meaning: "conditional entropy of the declared configuration given its deterministic mix output; named fork is injective";
+    cause?: undefined;
+    required?: undefined;
+    workUnit?: undefined;
+};

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] } };
+}