@takk/bayesoutputgate 1.0.0

package/dist/likelihood/index.cjs

@@ -0,0 +1,137 @@
+'use strict';
+
+// src/errors.ts
+var BayesOutputGateError = class _BayesOutputGateError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "BayesOutputGateError";
+    this.code = code;
+    Object.setPrototypeOf(this, _BayesOutputGateError.prototype);
+  }
+};
+function invariant(condition, code, message) {
+  if (!condition) {
+    throw new BayesOutputGateError(code, message);
+  }
+}
+
+// src/mathspecial.ts
+var LN_SQRT_2PI = 0.9189385332046728;
+var LANCZOS_G = 7;
+var LANCZOS_COEFFICIENTS = [
+  0.9999999999998099,
+  676.5203681218851,
+  -1259.1392167224028,
+  771.3234287776531,
+  -176.6150291621406,
+  12.507343278686905,
+  -0.13857109526572012,
+  9984369578019572e-21,
+  15056327351493116e-23
+];
+function lgamma(x) {
+  if (!Number.isFinite(x) || x <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `lgamma requires a positive finite argument, got ${x}`
+    );
+  }
+  const z = x - 1;
+  let acc = LANCZOS_COEFFICIENTS[0];
+  for (let i = 1; i < LANCZOS_COEFFICIENTS.length; i++) {
+    acc += LANCZOS_COEFFICIENTS[i] / (z + i);
+  }
+  const t = z + LANCZOS_G + 0.5;
+  return LN_SQRT_2PI + (z + 0.5) * Math.log(t) - t + Math.log(acc);
+}
+function lbeta(a, b) {
+  return lgamma(a) + lgamma(b) - lgamma(a + b);
+}
+function betaLogDensity(x, a, b) {
+  if (a <= 0 || b <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `Beta shape parameters must be positive, got a=${a}, b=${b}`
+    );
+  }
+  if (x < 0 || x > 1 || !Number.isFinite(x)) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (x === 0) {
+    if (a < 1) return Number.POSITIVE_INFINITY;
+    if (a > 1) return Number.NEGATIVE_INFINITY;
+    return -lbeta(a, b) + (b - 1) * Math.log(1);
+  }
+  if (x === 1) {
+    if (b < 1) return Number.POSITIVE_INFINITY;
+    if (b > 1) return Number.NEGATIVE_INFINITY;
+    return -lbeta(a, b);
+  }
+  return (a - 1) * Math.log(x) + (b - 1) * Math.log1p(-x) - lbeta(a, b);
+}
+function logMarginalBernoulli(successes, trials, a, b) {
+  if (successes < 0 || trials < 0 || successes > trials) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `invalid Bernoulli counts: ${successes} successes in ${trials} trials`
+    );
+  }
+  if (a <= 0 || b <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `Beta prior parameters must be positive, got a=${a}, b=${b}`
+    );
+  }
+  return lbeta(successes + a, trials - successes + b) - lbeta(a, b);
+}
+
+// src/likelihood/index.ts
+function logScoreLikelihood(score, params) {
+  return betaLogDensity(score, params.a, params.b);
+}
+function logBinaryMarginalLikelihood(successes, trials, prior) {
+  return logMarginalBernoulli(successes, trials, prior.a, prior.b);
+}
+function toScoreMap(scores) {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of scores) {
+    invariant(
+      Number.isFinite(s.value) && s.value >= 0 && s.value <= 1,
+      "INVALID_SCORE",
+      `score for "${s.dimension}" must be a finite number in [0, 1], got ${s.value}`
+    );
+    invariant(
+      !map.has(s.dimension),
+      "INVALID_SCORE",
+      `duplicate score for dimension "${s.dimension}"`
+    );
+    map.set(s.dimension, s.value);
+  }
+  return map;
+}
+function logVectorLikelihood(scores, models, kind) {
+  const map = toScoreMap(scores);
+  let logLikelihood = 0;
+  let matched = 0;
+  for (const model of models) {
+    const value = map.get(model.dimension);
+    if (value === void 0) {
+      continue;
+    }
+    invariant(
+      Number.isFinite(model.weight) && model.weight >= 0,
+      "INVALID_CONFIG",
+      `weight for "${model.dimension}" must be a non-negative finite number, got ${model.weight}`
+    );
+    const params = kind === "high" ? model.high : model.low;
+    logLikelihood += model.weight * betaLogDensity(value, params.a, params.b);
+    matched += 1;
+  }
+  return { logLikelihood, matched };
+}
+
+exports.logBinaryMarginalLikelihood = logBinaryMarginalLikelihood;
+exports.logScoreLikelihood = logScoreLikelihood;
+exports.logVectorLikelihood = logVectorLikelihood;
+exports.toScoreMap = toScoreMap;

package/dist/likelihood/index.d.cts

@@ -0,0 +1,23 @@
+import { b as BetaParams, S as ScoreVector, e as DimensionModel, H as HypothesisKind } from '../types-bMjn1j4e.cjs';
+
+/** Log-likelihood of a single continuous score under a Beta model. */
+declare function logScoreLikelihood(score: number, params: BetaParams): number;
+/**
+ * Log marginal likelihood of `successes` binary passes out of `trials` under a hypothesis's Beta
+ * prior on the pass rate. This is the Beta-Binomial mode, used when outputs are scored pass/fail
+ * rather than on a continuous scale.
+ */
+declare function logBinaryMarginalLikelihood(successes: number, trials: number, prior: BetaParams): number;
+/** Build a validated dimension to score map from a score vector. */
+declare function toScoreMap(scores: ScoreVector): Map<string, number>;
+/**
+ * Weighted log-likelihood of a score vector under one hypothesis, summed over the dimensions that
+ * have both a score and a model. Returns the matched-dimension count so callers can detect an
+ * output that scored no modeled dimension.
+ */
+declare function logVectorLikelihood(scores: ScoreVector, models: readonly DimensionModel[], kind: HypothesisKind): {
+    logLikelihood: number;
+    matched: number;
+};
+
+export { logBinaryMarginalLikelihood, logScoreLikelihood, logVectorLikelihood, toScoreMap };

package/dist/likelihood/index.d.ts

@@ -0,0 +1,23 @@
+import { b as BetaParams, S as ScoreVector, e as DimensionModel, H as HypothesisKind } from '../types-bMjn1j4e.js';
+
+/** Log-likelihood of a single continuous score under a Beta model. */
+declare function logScoreLikelihood(score: number, params: BetaParams): number;
+/**
+ * Log marginal likelihood of `successes` binary passes out of `trials` under a hypothesis's Beta
+ * prior on the pass rate. This is the Beta-Binomial mode, used when outputs are scored pass/fail
+ * rather than on a continuous scale.
+ */
+declare function logBinaryMarginalLikelihood(successes: number, trials: number, prior: BetaParams): number;
+/** Build a validated dimension to score map from a score vector. */
+declare function toScoreMap(scores: ScoreVector): Map<string, number>;
+/**
+ * Weighted log-likelihood of a score vector under one hypothesis, summed over the dimensions that
+ * have both a score and a model. Returns the matched-dimension count so callers can detect an
+ * output that scored no modeled dimension.
+ */
+declare function logVectorLikelihood(scores: ScoreVector, models: readonly DimensionModel[], kind: HypothesisKind): {
+    logLikelihood: number;
+    matched: number;
+};
+
+export { logBinaryMarginalLikelihood, logScoreLikelihood, logVectorLikelihood, toScoreMap };

package/dist/likelihood/index.js

@@ -0,0 +1,132 @@
+// src/errors.ts
+var BayesOutputGateError = class _BayesOutputGateError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "BayesOutputGateError";
+    this.code = code;
+    Object.setPrototypeOf(this, _BayesOutputGateError.prototype);
+  }
+};
+function invariant(condition, code, message) {
+  if (!condition) {
+    throw new BayesOutputGateError(code, message);
+  }
+}
+
+// src/mathspecial.ts
+var LN_SQRT_2PI = 0.9189385332046728;
+var LANCZOS_G = 7;
+var LANCZOS_COEFFICIENTS = [
+  0.9999999999998099,
+  676.5203681218851,
+  -1259.1392167224028,
+  771.3234287776531,
+  -176.6150291621406,
+  12.507343278686905,
+  -0.13857109526572012,
+  9984369578019572e-21,
+  15056327351493116e-23
+];
+function lgamma(x) {
+  if (!Number.isFinite(x) || x <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `lgamma requires a positive finite argument, got ${x}`
+    );
+  }
+  const z = x - 1;
+  let acc = LANCZOS_COEFFICIENTS[0];
+  for (let i = 1; i < LANCZOS_COEFFICIENTS.length; i++) {
+    acc += LANCZOS_COEFFICIENTS[i] / (z + i);
+  }
+  const t = z + LANCZOS_G + 0.5;
+  return LN_SQRT_2PI + (z + 0.5) * Math.log(t) - t + Math.log(acc);
+}
+function lbeta(a, b) {
+  return lgamma(a) + lgamma(b) - lgamma(a + b);
+}
+function betaLogDensity(x, a, b) {
+  if (a <= 0 || b <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `Beta shape parameters must be positive, got a=${a}, b=${b}`
+    );
+  }
+  if (x < 0 || x > 1 || !Number.isFinite(x)) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  if (x === 0) {
+    if (a < 1) return Number.POSITIVE_INFINITY;
+    if (a > 1) return Number.NEGATIVE_INFINITY;
+    return -lbeta(a, b) + (b - 1) * Math.log(1);
+  }
+  if (x === 1) {
+    if (b < 1) return Number.POSITIVE_INFINITY;
+    if (b > 1) return Number.NEGATIVE_INFINITY;
+    return -lbeta(a, b);
+  }
+  return (a - 1) * Math.log(x) + (b - 1) * Math.log1p(-x) - lbeta(a, b);
+}
+function logMarginalBernoulli(successes, trials, a, b) {
+  if (successes < 0 || trials < 0 || successes > trials) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `invalid Bernoulli counts: ${successes} successes in ${trials} trials`
+    );
+  }
+  if (a <= 0 || b <= 0) {
+    throw new BayesOutputGateError(
+      "NUMERIC",
+      `Beta prior parameters must be positive, got a=${a}, b=${b}`
+    );
+  }
+  return lbeta(successes + a, trials - successes + b) - lbeta(a, b);
+}
+
+// src/likelihood/index.ts
+function logScoreLikelihood(score, params) {
+  return betaLogDensity(score, params.a, params.b);
+}
+function logBinaryMarginalLikelihood(successes, trials, prior) {
+  return logMarginalBernoulli(successes, trials, prior.a, prior.b);
+}
+function toScoreMap(scores) {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of scores) {
+    invariant(
+      Number.isFinite(s.value) && s.value >= 0 && s.value <= 1,
+      "INVALID_SCORE",
+      `score for "${s.dimension}" must be a finite number in [0, 1], got ${s.value}`
+    );
+    invariant(
+      !map.has(s.dimension),
+      "INVALID_SCORE",
+      `duplicate score for dimension "${s.dimension}"`
+    );
+    map.set(s.dimension, s.value);
+  }
+  return map;
+}
+function logVectorLikelihood(scores, models, kind) {
+  const map = toScoreMap(scores);
+  let logLikelihood = 0;
+  let matched = 0;
+  for (const model of models) {
+    const value = map.get(model.dimension);
+    if (value === void 0) {
+      continue;
+    }
+    invariant(
+      Number.isFinite(model.weight) && model.weight >= 0,
+      "INVALID_CONFIG",
+      `weight for "${model.dimension}" must be a non-negative finite number, got ${model.weight}`
+    );
+    const params = kind === "high" ? model.high : model.low;
+    logLikelihood += model.weight * betaLogDensity(value, params.a, params.b);
+    matched += 1;
+  }
+  return { logLikelihood, matched };
+}
+
+export { logBinaryMarginalLikelihood, logScoreLikelihood, logVectorLikelihood, toScoreMap };