diff --git a/src/collocatordb.cc b/src/collocatordb.cc
index f327c4b..4da2e06 100644
--- a/src/collocatordb.cc
+++ b/src/collocatordb.cc
@@ -191,9 +191,15 @@
                (o22 > 0 ? o22 * log(o22 / e22) : 0)));
 }
 
+// The Dice coefficient relates the co-occurrence frequency to how often the two
+// words occur at all, so its denominator sums marginal word frequencies. It
+// therefore takes no window size factor, unlike the scores above, which need one
+// in their expected frequency: w1 * window_size would count window positions
+// rather than word tokens, and adding that to w2 would also make the coefficient
+// asymmetric.
 static double ca_dice(uint64_t w1, uint64_t w2, uint64_t w12, uint64_t n,
                              uint64_t window_size) {
-  double r1 = (double)w1 * window_size, c1 = w2;
+  double r1 = (double)w1, c1 = w2;
   return 2 * w12 / (c1 + r1);
 }
 
@@ -203,6 +209,25 @@
 // Advances in Slavonic Natural Language Processing, RASLAN, 6–9.
 static double ca_logdice(uint64_t w1, uint64_t w2, uint64_t w12,
                                 uint64_t n, uint64_t window_size) {
+  double r1 = (double)w1, c1 = w2;
+  return 14 + log2(2 * w12 / (c1 + r1));
+}
+
+// The auto focus score, reported as LDaf: its maximum over all selections of
+// positions both picks the auto focus window and is the value shown for it. It
+// used to be computed by ca_logdice(), which is why that one carried a window
+// size factor.
+//
+// It is Dice-like, but it is not logDice and the two are not on a common scale:
+// multiplying f1 by the number of positions penalizes wide windows. That
+// penalty is the point. It makes the score sensitive to how concentrated a pair
+// is, which is what tells actual collocations from words that merely share
+// contexts, and is why LDaf orders collocates more usefully than the other
+// measures. logDice itself cannot serve here: its denominator does not depend
+// on the window while the co-occurrence count only grows as positions are
+// added, so the widest window would always win.
+static double ca_focus_score(uint64_t w1, uint64_t w2, uint64_t w12, uint64_t n,
+                             uint64_t window_size) {
   double r1 = (double)w1 * window_size, c1 = w2;
   return 14 + log2(2 * w12 / (c1 + r1));
 }
@@ -776,8 +801,13 @@
          md_nws = ca_md(f1, f2, sum, total, 2 * WINDOW_SIZE),
          ld = ca_logdice(f1, f2, sum, total, true_window_size);
 
+  // LDaf is the auto focus score itself, i.e. the highest value that any
+  // selection of positions reaches. It is deliberately not logDice of the
+  // selected window: the width penalty is what makes the score sensitive to
+  // how concentrated a pair is, and that sensitivity is why LDaf orders
+  // collocates more usefully than the other measures.
   int bestWindow = usedPositions;
-  double bestAF = ld;
+  double bestFocus = ca_focus_score(f1, f2, sum, total, true_window_size);
   //          if(f1<75000000)
   // #pragma omp parallel for reduction(max:bestAF)
   // #pragma omp target teams distribute parallel for reduction(max:bestAF)
@@ -792,10 +822,10 @@
       if (((1 << pos) & bitmask & usedPositions) != 0)
         currentWindowSum += sumWindow[pos];
     }
-    double currentAF = ca_logdice(f1, f2, currentWindowSum, total,
-                                  __builtin_popcount(bitmask));
-    if (currentAF > bestAF) {
-      bestAF = currentAF;
+    double currentAF = ca_focus_score(f1, f2, currentWindowSum, total,
+                                      __builtin_popcount(bitmask));
+    if (currentAF > bestFocus) {
+      bestFocus = currentAF;
       bestWindow = bitmask;
     }
   }
@@ -815,7 +845,7 @@
              ca_pmi(f1, f2, sumWindow[WINDOW_SIZE - 1], total, 1),
              ca_dice(f1, f2, sum, total, true_window_size),
              ld,
-             bestAF,
+             bestFocus,
              usedPositions,
              bestWindow};
 }