Remove unused select() method from PowerRanker (#115)

The select() method has been superseded by activeSelect(), which uses a more sophisticated multi-signal approach (coverage, proximity, position) instead of simple variance weighting.
Remove dead code: select(), getVariances(), getVariance(), SelectOptions, ImpactTransform.
Update README to document the actual bidirectional encoding and activeSelect() API.

Co-authored-by: Claude Haiku 4.5 <noreply@anthropic.com>

Author: kronosapiens

backend/src/lib/power/PowerRanker.test.ts

@@ -168,54 +168,6 @@ describe('PowerRanker', () => {
     });
   });
 
-  describe('generating variances', () => {
-    test('returns uniform variances with no preferences', () => {
-      const ranker = new PowerRanker({
-        items: makeItems(ITEM_A, ITEM_B, ITEM_C),
-        options: { k: K },
-      });
-
-      const pairs = ranker.select();
-
-      // 3 items → 3 pairs
-      expect(pairs).toHaveLength(3);
-
-      // With pseudocount k=0.15, off-diagonal cells are 0.15
-      // Beta(0.15 + 1, 0.15 + 1) = Beta(1.15, 1.15)
-      // Variance = (a * b) / ((a + b + 1) * (a + b)^2)
-      const a = 0.15 + 1;
-      const b = 0.15 + 1;
-      const expectedVar = (a * b) / ((a + b + 1) * (a + b) ** 2);
-
-      for (const p of pairs) {
-        expect(p.weight).toBeCloseTo(expectedVar);
-      }
-    });
-
-    test('variances decrease with preferences', () => {
-      const ranker = new PowerRanker({
-        items: makeItems(ITEM_A, ITEM_B, ITEM_C),
-        options: { k: K },
-      });
-
-      const beforePairs = ranker.select();
-
-      ranker.addPreferences([pref(ITEM_A, ITEM_B, 1)]);
-
-      const afterPairs = ranker.select();
-
-      // The A-B pair should have lower variance (more data)
-      const abBefore = beforePairs.find(
-        (p) => p.alpha === String(ITEM_A) && p.beta === String(ITEM_B)
-      )!;
-      const abAfter = afterPairs.find(
-        (p) => p.alpha === String(ITEM_A) && p.beta === String(ITEM_B)
-      )!;
-
-      expect(abAfter.weight).toBeLessThan(abBefore.weight);
-    });
-  });
-
   describe('without pseudocounts', () => {
     test('strong preferences converge sharply without k', () => {
       const ranker = new PowerRanker({
@@ -233,186 +185,6 @@ describe('PowerRanker', () => {
       expect(score(rankings, ITEM_C)).toBeCloseTo(0, 10);
     });
   });
-
-  describe('selecting pairs', () => {
-    test('selects the requested number of pairs', () => {
-      const ranker = new PowerRanker({ items: new Set(['1', '2', '3']) });
-      const pairs = ranker.select({ num: 2 });
-      expect(pairs).toHaveLength(2);
-    });
-
-    test('returns all pairs when num exceeds available', () => {
-      const ranker = new PowerRanker({ items: new Set(['1', '2', '3']) });
-      const pairs = ranker.select({ num: 10 });
-      // 3 items → 3 pairs
-      expect(pairs).toHaveLength(3);
-    });
-
-    test('selects without replacement', () => {
-      // 5 items → 10 pairs; request 5 — must be unique
-      const ranker = new PowerRanker({ items: new Set(['1', '2', '3', '4', '5']) });
-      const pairs = ranker.select({ num: 5 });
-      const keys = pairs.map((p) => pairKey(p.alpha, p.beta));
-      expect(pairs).toHaveLength(5);
-      expect(new Set(keys).size).toBe(5);
-    });
-
-    test('excludes specified pairs', () => {
-      const ranker = new PowerRanker({ items: new Set(['1', '2', '3']) });
-      const exclude = new Set(['1:2', '2:3']);
-      const pairs = ranker.select({ num: 10, exclude });
-
-      expect(pairs).toHaveLength(1);
-      expect(pairs[0].alpha).toBe('1');
-      expect(pairs[0].beta).toBe('3');
-    });
-
-    test('returns empty when all pairs excluded', () => {
-      const ranker = new PowerRanker({ items: new Set(['1', '2', '3']) });
-      const exclude = new Set(['1:2', '1:3', '2:3']);
-      const pairs = ranker.select({ num: 5, exclude });
-      expect(pairs).toHaveLength(0);
-    });
-
-    test('preferences shift which pairs are selected more often', () => {
-      const ranker = new PowerRanker({ items: new Set(['a', 'b', 'c']) });
-
-      // Strong preference for a over b — reduces a:b variance
-      ranker.addPreferences([
-        { target: 'a', source: 'b', value: 1 },
-        { target: 'a', source: 'b', value: 1 },
-        { target: 'a', source: 'b', value: 1 },
-      ]);
-
-      // Over many single-pair selections, a:b should appear least often
-      const counts: Record<string, number> = { 'a:b': 0, 'a:c': 0, 'b:c': 0 };
-      for (let i = 0; i < 1000; i++) {
-        const [pair] = ranker.select({ num: 1 });
-        counts[pairKey(pair.alpha, pair.beta)]++;
-      }
-
-      expect(counts['a:b']).toBeLessThan(counts['a:c']);
-      expect(counts['a:b']).toBeLessThan(counts['b:c']);
-    });
-
-    test('exclude simulates judge-already-voted', () => {
-      const ranker = new PowerRanker({ items: new Set(['a', 'b', 'c']) });
-
-      const judgedPairs = new Set([pairKey('a', 'b'), pairKey('a', 'c')]);
-      const pairs = ranker.select({ num: 10, exclude: judgedPairs });
-
-      expect(pairs).toHaveLength(1);
-      expect(pairs[0]).toMatchObject({ alpha: 'b', beta: 'c' });
-    });
-
-    test('impact weighting prioritizes pairs between high-ranked items', () => {
-      // Use pseudocounts so all items retain nonzero weight
-      const ranker = new PowerRanker({ items: new Set(['a', 'b', 'c']), options: { k: K } });
-
-      // Strong preference: a > b > c (clear hierarchy)
-      ranker.addPreferences([
-        { target: 'a', source: 'b', value: 1 },
-        { target: 'b', source: 'c', value: 1 },
-      ]);
-
-      // With impact: a:b should be favored over b:c because a and b have higher weights
-
-      const counts: Record<string, number> = { 'a:b': 0, 'a:c': 0, 'b:c': 0 };
-      for (let i = 0; i < 1000; i++) {
-        const [pair] = ranker.select({ num: 1, impact: ['weight'] });
-        counts[pairKey(pair.alpha, pair.beta)]++;
-      }
-
-      // b:c involves the two lowest-ranked items, so should be selected least
-      expect(counts['b:c']).toBeLessThan(counts['a:b']);
-      expect(counts['b:c']).toBeLessThan(counts['a:c']);
-    });
-
-    test('impact weighting works with no preferences (uniform weights)', () => {
-      const ranker = new PowerRanker({ items: new Set(['a', 'b', 'c']) });
-
-      // With uniform weights, impact should behave like plain variance selection
-      const pairs = ranker.select({ num: 3, impact: ['weight'] });
-      expect(pairs).toHaveLength(3);
-      const keys = pairs.map((p) => pairKey(p.alpha, p.beta));
-      expect(new Set(keys).size).toBe(3);
-    });
-
-    test('coverage transform prioritizes under-observed items', () => {
-      const ranker = new PowerRanker({ items: new Set(['a', 'b', 'c', 'd']) });
-
-      // Heavily observe a and b (many preferences between them)
-      for (let i = 0; i < 10; i++) {
-        ranker.addPreferences([{ target: 'a', source: 'b', value: 1 }]);
-      }
-
-      const pairs = ranker.select({ impact: ['coverage'] });
-
-      // Find pairs involving c:d (both unobserved) vs a:b (both heavily observed)
-      const cd = pairs.find((p) => p.alpha === 'c' && p.beta === 'd')!;
-      const ab = pairs.find((p) => p.alpha === 'a' && p.beta === 'b')!;
-
-      // c:d should have higher weight — both items are unobserved
-      expect(cd.weight).toBeGreaterThan(ab.weight);
-    });
-
-    test('even votes (0.5) reduce both coverage and variance weights', () => {
-      const ranker = new PowerRanker({ items: new Set(['a', 'b', 'c']) });
-
-      // Get baseline weights with coverage
-      const before = ranker.select({ impact: ['coverage'] });
-      const abBefore = before.find((p) => p.alpha === 'a' && p.beta === 'b')!;
-
-      // Add an "even" vote — with bidirectional flow, 0.5 adds 0.5 to both directions
-      ranker.addPreferences([{ target: 'a', source: 'b', value: 0.5 }]);
-
-      const after = ranker.select({ impact: ['coverage'] });
-      const abAfter = after.find((p) => p.alpha === 'a' && p.beta === 'b')!;
-
-      // With coverage, weight should decrease (items now have observations)
-      expect(abAfter.weight).toBeLessThan(abBefore.weight);
-
-      // With bidirectional flow, 0.5 adds symmetric flow which also changes beta variance
-      const afterPlain = ranker.select();
-      const abPlain = afterPlain.find((p) => p.alpha === 'a' && p.beta === 'b')!;
-      const beforePlain = before.find((p) => p.alpha === 'a' && p.beta === 'b')!;
-      expect(abPlain.weight).toBeLessThan(beforePlain.weight);
-    });
-
-    test('composable transforms apply multiplicatively', () => {
-      const ranker = new PowerRanker({
-        items: new Set(['a', 'b', 'c']),
-        options: { k: K },
-      });
-
-      ranker.addPreferences([
-        { target: 'a', source: 'b', value: 1 },
-        { target: 'b', source: 'c', value: 1 },
-      ]);
-
-      const plain = ranker.select();
-      const withWeight = ranker.select({ impact: ['weight'] });
-      const withCoverage = ranker.select({ impact: ['coverage'] });
-      const withBoth = ranker.select({ impact: ['weight', 'coverage'] });
-
-      // All should return 3 pairs
-      expect(plain).toHaveLength(3);
-      expect(withWeight).toHaveLength(3);
-      expect(withCoverage).toHaveLength(3);
-      expect(withBoth).toHaveLength(3);
-
-      // Combined weights should be strictly less than either single transform
-      const abBoth = withBoth.find((p) => p.alpha === 'a' && p.beta === 'b')!;
-      const abWeight = withWeight.find((p) => p.alpha === 'a' && p.beta === 'b')!;
-      const abCoverage = withCoverage.find((p) => p.alpha === 'a' && p.beta === 'b')!;
-      const abPlain = plain.find((p) => p.alpha === 'a' && p.beta === 'b')!;
-
-      // Both transforms applied should produce smaller weight than either alone
-      expect(abBoth.weight).toBeLessThan(abPlain.weight);
-      expect(abBoth.weight).toBeLessThan(abWeight.weight);
-      expect(abBoth.weight).toBeLessThan(abCoverage.weight);
-    });
-  });
 });
 
 describe('activeSelect', () => {

backend/src/lib/power/PowerRanker.ts

@@ -28,14 +28,6 @@ export interface PairWeight {
   weight: number;
 }
 
-export type ImpactTransform = 'weight' | 'coverage';
-
-export interface SelectOptions {
-  num?: number;
-  exclude?: Set<string>;
-  impact?: ImpactTransform[];
-}
-
 export type ActiveImpactTerm = 'coverage' | 'proximity' | 'position';
 
 export interface ActiveSelectOptions {
@@ -139,66 +131,6 @@ export class PowerRanker {
     return edges;
   }
 
-  private getVariances(): PairWeight[] {
-    const variances: PairWeight[] = [];
-
-    for (let i = 0; i < this.items.length; i++) {
-      for (let j = i + 1; j < this.items.length; j++) {
-        const weight = this.getVariance(i, j);
-        variances.push({ alpha: this.items[i], beta: this.items[j], weight });
-      }
-    }
-
-    return variances;
-  }
-
-  /**
-   * Select pairs via variance-weighted sampling.
-   *
-   * With num specified, samples without replacement weighted by variance.
-   * Without num, returns all pairs with their weights (useful for diagnostics).
-   * impact is an optional array of transforms applied multiplicatively:
-   *   - 'weight': multiply by geometric mean of posterior rank weights (upsamples high-ranked pairs)
-   *   - 'coverage': multiply by 1/(1+n/N) per item (upsamples under-observed items)
-   * Optionally excludes pairs (e.g. already judged).
-   */
-  select({ num, exclude, impact }: SelectOptions = {}): PairWeight[] {
-    const variances = this.getVariances();
-    const transforms = impact ?? [];
-
-    const weights = transforms.includes('weight') ? this.run() : new Map<string, number>();
-
-    // Build candidate pool with sampling weights
-    const candidates: PairWeight[] = [];
-
-    for (const v of variances) {
-      if (exclude && exclude.has(pairKey(v.alpha, v.beta))) {
-        continue;
-      }
-
-      let weight = v.weight;
-
-      if (transforms.includes('weight')) {
-        weight *= Math.sqrt(weights.get(v.alpha)! * weights.get(v.beta)!);
-      }
-
-      if (transforms.includes('coverage')) {
-        const nAlpha = this.itemObservations[v.alpha] ?? 0;
-        const nBeta = this.itemObservations[v.beta] ?? 0;
-        weight *= (1 / (1 + nAlpha)) * (1 / (1 + nBeta));
-      }
-
-      candidates.push({ alpha: v.alpha, beta: v.beta, weight });
-    }
-
-    // Without num, return all candidates
-    if (num === undefined) {
-      return candidates;
-    } else {
-      return this.selectWithoutReplacement(candidates, num);
-    }
-  }
-
   /**
    * Select pairs using coverage × proximity × top-bias.
    *
@@ -325,14 +257,6 @@ export class PowerRanker {
     return vec.getRow(0);
   }
 
-  private getVariance(i: number, j: number): number {
-    // Model as a Beta distribution with a (1, 1) prior
-    const a = this.matrix.get(i, j) + 1;
-    const b = this.matrix.get(j, i) + 1;
-
-    return (a * b) / ((a + b + 1) * (a + b) ** 2);
-  }
-
   private selectWithoutReplacement(candidates: PairWeight[], num: number): PairWeight[] {
     // Weighted sampling without replacement
     const remaining = [...candidates];

backend/src/lib/power/README.md

@@ -7,8 +7,8 @@ Ported from [zaratanDotWorld/choreWheel](https://github.com/zaratanDotWorld/chor
 
 ### Ranking
 
-Pairwise preferences are accumulated into an N×N matrix where `matrix[i][j]` represents the strength of preference for item j over item i.
-Preferences are scaled from the input range [0, 1] to [-1, 1] centered at 0.5 (no preference).
+Pairwise preferences are accumulated into an N×N matrix using bidirectional encoding: a score `s` adds `s` to `matrix[source][target]` and `1-s` to `matrix[target][source]`.
+This means every observation informs both items — a strong preference (s=1) flows entirely toward the winner, while an even vote (s=0.5) splits equally.
 
 The diagonal holds each item's total received preference (column sum), making it a self-reinforcing signal.
 The matrix is row-normalized into a stochastic matrix, then power iteration finds the dominant eigenvector — the stationary distribution that becomes the ranking.
@@ -17,11 +17,14 @@ Optional Bayesian pseudocounts (`k`) initialize off-diagonal cells, regularizing
 
 ### Active pair selection
 
-`select()` chooses which pairs to present next using variance-weighted sampling without replacement.
-Each pair's uncertainty is modeled as a Beta distribution: `Beta(matrix[i][j] + 1, matrix[j][i] + 1)`.
-Higher variance means less certainty about the relative ranking — so those pairs are sampled more often.
+`activeSelect()` chooses which pairs to present next using three composable signals:
 
-With `impact: true`, the variance is multiplied by `weight_a * weight_b` (the eigenvector scores), prioritizing uncertain pairs between high-ranked items.
+- **coverage** (`1/√(1+n_i) × 1/√(1+n_j)`) — dominates early when observations are sparse.
+- **proximity** (`1/(1+|pos_i-pos_j|)`) — favors pairs that are close in rank.
+- **position** (`1/√(pos_i×pos_j)`) — favors pairs near the top of the ranking.
+
+A regularization parameter `r` (0–1) controls how strongly these signals influence selection via a power transform.
+At `r=0`, selection is uniform; at `r=1` (default), the full weighting applies.
 
 ## API
 
@@ -40,19 +43,20 @@ ranker.addPreferences([
 // Get rankings (Map<string, number>, values sum to 1)
 const rankings = ranker.run();
 
-// Get all pairs with their variance weights
-const allPairs = ranker.select();
+// Get all pairs with their selection weights
+const allPairs = ranker.activeSelect();
 
 // Select pairs for a judging session (weighted sampling without replacement)
-const pairs = ranker.select({
+const pairs = ranker.activeSelect({
   num: 5,
   exclude: new Set(['a:b']), // pairs already judged
-  impact: true, // weight by item importance
+  terms: ['coverage', 'proximity', 'position'], // default: all three
+  r: 0.9, // regularization strength
 });
 ```
 
 ## Files
 
 - `PowerRanker.ts` — Implementation
-- `PowerRanker.test.ts` — Tests (20 cases)
+- `PowerRanker.test.ts` — Tests
 - `index.ts` — Re-exports