@takk/bayesoutputgate 1.0.0

package/dist/dimensions/index.cjs

@@ -0,0 +1,106 @@
+'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/dimensions/index.ts
+function dependenceDiagnostic(history, options = {}) {
+  const threshold = options.threshold ?? 0.5;
+  invariant(
+    Number.isFinite(threshold) && threshold >= 0 && threshold <= 1,
+    "INVALID_CONFIG",
+    `threshold must be in [0, 1], got ${threshold}`
+  );
+  invariant(
+    history.length >= 2,
+    "INVALID_OBSERVATION",
+    "dependence diagnostic needs at least two score vectors"
+  );
+  const dimensionSet = /* @__PURE__ */ new Set();
+  for (const vector of history) {
+    for (const score of vector) {
+      dimensionSet.add(score.dimension);
+    }
+  }
+  const dimensions = [...dimensionSet].sort();
+  const rows = history.map((vector) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const score of vector) {
+      map.set(score.dimension, score.value);
+    }
+    return map;
+  });
+  const pairs = [];
+  for (let i = 0; i < dimensions.length; i++) {
+    for (let j = i + 1; j < dimensions.length; j++) {
+      const a = dimensions[i];
+      const b = dimensions[j];
+      const xs = [];
+      const ys = [];
+      for (const row of rows) {
+        const x = row.get(a);
+        const y = row.get(b);
+        if (x !== void 0 && y !== void 0) {
+          xs.push(x);
+          ys.push(y);
+        }
+      }
+      if (xs.length >= 2) {
+        const correlation = pearson(xs, ys);
+        if (Number.isFinite(correlation)) {
+          pairs.push({ a, b, correlation, samples: xs.length });
+        }
+      }
+    }
+  }
+  pairs.sort((left, right) => Math.abs(right.correlation) - Math.abs(left.correlation));
+  const maxAbsCorrelation = pairs.length > 0 ? Math.abs(pairs[0].correlation) : 0;
+  const flagged = pairs.filter((pair) => Math.abs(pair.correlation) >= threshold);
+  return {
+    dimensions,
+    pairs,
+    flagged,
+    maxAbsCorrelation,
+    independenceAssumptionSafe: flagged.length === 0
+  };
+}
+function pearson(xs, ys) {
+  const n = xs.length;
+  let sumX = 0;
+  let sumY = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += xs[i];
+    sumY += ys[i];
+  }
+  const meanX = sumX / n;
+  const meanY = sumY / n;
+  let covariance = 0;
+  let varianceX = 0;
+  let varianceY = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = xs[i] - meanX;
+    const dy = ys[i] - meanY;
+    covariance += dx * dy;
+    varianceX += dx * dx;
+    varianceY += dy * dy;
+  }
+  if (varianceX === 0 || varianceY === 0) {
+    return 0;
+  }
+  return covariance / Math.sqrt(varianceX * varianceY);
+}
+
+exports.dependenceDiagnostic = dependenceDiagnostic;

package/dist/dimensions/index.d.cts

@@ -0,0 +1,33 @@
+import { S as ScoreVector } from '../types-bMjn1j4e.cjs';
+
+/** Pearson correlation between the scores of two dimensions across the history. */
+interface DimensionCorrelation {
+    readonly a: string;
+    readonly b: string;
+    readonly correlation: number;
+    readonly samples: number;
+}
+/** The result of measuring dependence between dimensions over a score history. */
+interface DependenceDiagnostic {
+    readonly dimensions: readonly string[];
+    /** All dimension pairs with a defined correlation, sorted by absolute correlation descending. */
+    readonly pairs: readonly DimensionCorrelation[];
+    /** Pairs whose absolute correlation is at or above the threshold. */
+    readonly flagged: readonly DimensionCorrelation[];
+    readonly maxAbsCorrelation: number;
+    /** True when no pair crosses the threshold, so the independence assumption is reasonable. */
+    readonly independenceAssumptionSafe: boolean;
+}
+/** Options for {@link dependenceDiagnostic}. */
+interface DependenceOptions {
+    /** Absolute correlation at or above which a pair is flagged. Defaults to 0.5. */
+    readonly threshold?: number;
+}
+/**
+ * Measure pairwise dependence between dimensions across a history of score vectors. Correlation for
+ * a pair is computed over the rows where both dimensions are present. A flagged pair warns that the
+ * combined Bayes Factor will double-count evidence from those dimensions.
+ */
+declare function dependenceDiagnostic(history: readonly ScoreVector[], options?: DependenceOptions): DependenceDiagnostic;
+
+export { type DependenceDiagnostic, type DependenceOptions, type DimensionCorrelation, dependenceDiagnostic };

package/dist/dimensions/index.d.ts

@@ -0,0 +1,33 @@
+import { S as ScoreVector } from '../types-bMjn1j4e.js';
+
+/** Pearson correlation between the scores of two dimensions across the history. */
+interface DimensionCorrelation {
+    readonly a: string;
+    readonly b: string;
+    readonly correlation: number;
+    readonly samples: number;
+}
+/** The result of measuring dependence between dimensions over a score history. */
+interface DependenceDiagnostic {
+    readonly dimensions: readonly string[];
+    /** All dimension pairs with a defined correlation, sorted by absolute correlation descending. */
+    readonly pairs: readonly DimensionCorrelation[];
+    /** Pairs whose absolute correlation is at or above the threshold. */
+    readonly flagged: readonly DimensionCorrelation[];
+    readonly maxAbsCorrelation: number;
+    /** True when no pair crosses the threshold, so the independence assumption is reasonable. */
+    readonly independenceAssumptionSafe: boolean;
+}
+/** Options for {@link dependenceDiagnostic}. */
+interface DependenceOptions {
+    /** Absolute correlation at or above which a pair is flagged. Defaults to 0.5. */
+    readonly threshold?: number;
+}
+/**
+ * Measure pairwise dependence between dimensions across a history of score vectors. Correlation for
+ * a pair is computed over the rows where both dimensions are present. A flagged pair warns that the
+ * combined Bayes Factor will double-count evidence from those dimensions.
+ */
+declare function dependenceDiagnostic(history: readonly ScoreVector[], options?: DependenceOptions): DependenceDiagnostic;
+
+export { type DependenceDiagnostic, type DependenceOptions, type DimensionCorrelation, dependenceDiagnostic };

package/dist/dimensions/index.js

@@ -0,0 +1,104 @@
+// 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/dimensions/index.ts
+function dependenceDiagnostic(history, options = {}) {
+  const threshold = options.threshold ?? 0.5;
+  invariant(
+    Number.isFinite(threshold) && threshold >= 0 && threshold <= 1,
+    "INVALID_CONFIG",
+    `threshold must be in [0, 1], got ${threshold}`
+  );
+  invariant(
+    history.length >= 2,
+    "INVALID_OBSERVATION",
+    "dependence diagnostic needs at least two score vectors"
+  );
+  const dimensionSet = /* @__PURE__ */ new Set();
+  for (const vector of history) {
+    for (const score of vector) {
+      dimensionSet.add(score.dimension);
+    }
+  }
+  const dimensions = [...dimensionSet].sort();
+  const rows = history.map((vector) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const score of vector) {
+      map.set(score.dimension, score.value);
+    }
+    return map;
+  });
+  const pairs = [];
+  for (let i = 0; i < dimensions.length; i++) {
+    for (let j = i + 1; j < dimensions.length; j++) {
+      const a = dimensions[i];
+      const b = dimensions[j];
+      const xs = [];
+      const ys = [];
+      for (const row of rows) {
+        const x = row.get(a);
+        const y = row.get(b);
+        if (x !== void 0 && y !== void 0) {
+          xs.push(x);
+          ys.push(y);
+        }
+      }
+      if (xs.length >= 2) {
+        const correlation = pearson(xs, ys);
+        if (Number.isFinite(correlation)) {
+          pairs.push({ a, b, correlation, samples: xs.length });
+        }
+      }
+    }
+  }
+  pairs.sort((left, right) => Math.abs(right.correlation) - Math.abs(left.correlation));
+  const maxAbsCorrelation = pairs.length > 0 ? Math.abs(pairs[0].correlation) : 0;
+  const flagged = pairs.filter((pair) => Math.abs(pair.correlation) >= threshold);
+  return {
+    dimensions,
+    pairs,
+    flagged,
+    maxAbsCorrelation,
+    independenceAssumptionSafe: flagged.length === 0
+  };
+}
+function pearson(xs, ys) {
+  const n = xs.length;
+  let sumX = 0;
+  let sumY = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += xs[i];
+    sumY += ys[i];
+  }
+  const meanX = sumX / n;
+  const meanY = sumY / n;
+  let covariance = 0;
+  let varianceX = 0;
+  let varianceY = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = xs[i] - meanX;
+    const dy = ys[i] - meanY;
+    covariance += dx * dy;
+    varianceX += dx * dx;
+    varianceY += dy * dy;
+  }
+  if (varianceX === 0 || varianceY === 0) {
+    return 0;
+  }
+  return covariance / Math.sqrt(varianceX * varianceY);
+}
+
+export { dependenceDiagnostic };