diff --git a/R/association-scores.R b/R/association-scores.R
index fec7991..7807c08 100644
--- a/R/association-scores.R
+++ b/R/association-scores.R
@@ -14,6 +14,36 @@
 #' Functions to calculate different collocation association scores between
 #' a node (target word) and words in a window around the it.
 #' The functions are primarily used by [collocationScoreQuery()].
+#'
+#' @section Salience versus surprise:
+#'
+#' `logDice` is the only one of these scores that does not compare the observed
+#' co-occurrence frequency to an expected one. As it merely puts `O` into the
+#' numerator of the Dice coefficient, the difference between the score of a pair
+#' and the score that same pair would get if it co-occurred exactly as often as
+#' expected is precisely the pointwise mutual information:
+#'
+#' `logDice(O) - logDice(E) = log2(O / E) = pmi`
+#'
+#' The level a pair starts from therefore depends on the marginal frequencies
+#' alone, and it is high whenever both words are frequent. Collocates of *Grund*
+#' in DeReKo, in a window of five words to each side, illustrate this:
+#'
+#' * *triftiger* is rare, so it starts from a logDice of -4.60 and reaches 3.96,
+#'   exceeding what is expected by a `pmi` of 8.57
+#' * *Berlin* is frequent, so it starts from 5.58 and still reaches 3.84, while
+#'   co-occurring 1.74 bits *less* often than expected
+#'
+#' A frequent collocate can thus reach a respectable logDice although the node
+#' does not attract it at all. logDice measures how salient a pair is, given how
+#' often its words occur, rather than how surprising it is. That is what it was
+#' designed for (Rychlý 2008), and it is why its values do not depend on the
+#' corpus size and are comparable across corpora.
+#'
+#' When ranking or thresholding by logDice, as [collocationAnalysis()] does by
+#' default, it is therefore worth discarding pairs that are not attested more
+#' often than expected, with `dplyr::filter(O > E)`, or requiring a minimum
+#' `pmi` or `ll`.
 NULL
 #' NULL
 
diff --git a/R/collocationAnalysis.R b/R/collocationAnalysis.R
index 2d68636..34dc550 100644
--- a/R/collocationAnalysis.R
+++ b/R/collocationAnalysis.R
@@ -95,7 +95,12 @@
 #' @param maxRecurse             apply collocation analysis recursively `maxRecurse` times
 #' @param addExamples            If TRUE, examples for instances of collocations will be added in a column `example`. This makes a difference in particular if `node` is given as a lemma query.
 #' @param thresholdScore         association score function (see \code{\link{association-score-functions}}) to use for computing the threshold that is applied for recursive collocation analysis calls (only applied when \code{maxRecurse > 0})
-#' @param threshold              minimum value of `thresholdScore` function call to apply collocation analysis recursively (only applied when \code{maxRecurse > 0})
+#' @param threshold              minimum value of `thresholdScore` function call to apply collocation analysis recursively (only applied when \code{maxRecurse > 0}).
+#'   Note that the default score, `logDice`, expresses how salient a pair is
+#'   rather than how surprising, so that a frequent collocate can pass it while
+#'   co-occurring less often than expected. Adding `dplyr::filter(O > E)`, or a
+#'   minimum `pmi` or `ll`, removes those. See the "Salience versus surprise"
+#'   section of \code{\link{association-score-functions}}.
 #' @param localStopwords         vector of stopwords that will not be considered as collocates in the current function call, but that will not be passed to recursive calls
 #' @param collocateFilterRegex   allow only collocates matching the regular expression
 #' @param queryMissingScores     if TRUE, attempt to retrieve corpus-based association scores for vc/collocate combinations that would otherwise be imputed, by re-querying the KorAP backend without applying the collocate frequency threshold
diff --git a/Readme.md b/Readme.md
index 21de106..d7d2e97 100644
--- a/Readme.md
+++ b/Readme.md
@@ -147,7 +147,7 @@
 |Grund |guter     | 12902.50|   2713.24|    6.06|  2.25| 19938.70|
 |Grund |Berlin    |  7865.50|  26212.26|    3.84| -1.74| 17790.28|
 
-`O` is the observed and `E` the expected co-occurrence frequency. *Triftiger* is by far the most strongly attracted of the three (highest `pmi`), while *Berlin* co-occurs with *Grund* less often than chance would predict, which is what a negative `pmi` expresses. `logDice`, in contrast, does not compare against an expected frequency but relates the co-occurrence frequency to how often the two words occur at all, which is why the frequent *guter Grund* leads there.
+`O` is the observed and `E` the expected co-occurrence frequency. *Triftiger* is by far the most strongly attracted of the three (highest `pmi`), while *Berlin* co-occurs with *Grund* less often than chance would predict, which is what a negative `pmi` expresses. `logDice`, in contrast, does not compare against an expected frequency but relates the co-occurrence frequency to how often the two words occur at all, which is why the frequent *guter Grund* leads there – and why *Berlin*, although it co-occurs with *Grund* less often than expected, still scores nearly as high as *triftiger*. When ranking by `logDice`, as `collocationAnalysis` does by default, `dplyr::filter(O > E)` or a minimum `pmi` discards such pairs.
 
 ### Identify *in … setzen* light verb constructions using `collocationAnalysis`
 
diff --git a/man/association-score-functions.Rd b/man/association-score-functions.Rd
index 78b5ec4..ce83ef9 100644
--- a/man/association-score-functions.Rd
+++ b/man/association-score-functions.Rd
@@ -65,6 +65,39 @@
 words occur at all, and \code{O1} and \code{O2} count word tokens, while a window size
 factor would count window positions.
 }
+\section{Salience versus surprise}{
+
+
+\code{logDice} is the only one of these scores that does not compare the observed
+co-occurrence frequency to an expected one. As it merely puts \code{O} into the
+numerator of the Dice coefficient, the difference between the score of a pair
+and the score that same pair would get if it co-occurred exactly as often as
+expected is precisely the pointwise mutual information:
+
+\code{logDice(O) - logDice(E) = log2(O / E) = pmi}
+
+The level a pair starts from therefore depends on the marginal frequencies
+alone, and it is high whenever both words are frequent. Collocates of \emph{Grund}
+in DeReKo, in a window of five words to each side, illustrate this:
+\itemize{
+\item \emph{triftiger} is rare, so it starts from a logDice of -4.60 and reaches 3.96,
+exceeding what is expected by a \code{pmi} of 8.57
+\item \emph{Berlin} is frequent, so it starts from 5.58 and still reaches 3.84, while
+co-occurring 1.74 bits \emph{less} often than expected
+}
+
+A frequent collocate can thus reach a respectable logDice although the node
+does not attract it at all. logDice measures how salient a pair is, given how
+often its words occur, rather than how surprising it is. That is what it was
+designed for (Rychlý 2008), and it is why its values do not depend on the
+corpus size and are comparable across corpora.
+
+When ranking or thresholding by logDice, as \code{\link[=collocationAnalysis]{collocationAnalysis()}} does by
+default, it is therefore worth discarding pairs that are not attested more
+often than expected, with \code{dplyr::filter(O > E)}, or requiring a minimum
+\code{pmi} or \code{ll}.
+}
+
 \examples{
 \dontrun{
 
diff --git a/man/collocationAnalysis-KorAPConnection-method.Rd b/man/collocationAnalysis-KorAPConnection-method.Rd
index 734a2f6..5a0a43d 100644
--- a/man/collocationAnalysis-KorAPConnection-method.Rd
+++ b/man/collocationAnalysis-KorAPConnection-method.Rd
@@ -71,7 +71,12 @@
 
 \item{thresholdScore}{association score function (see \code{\link{association-score-functions}}) to use for computing the threshold that is applied for recursive collocation analysis calls (only applied when \code{maxRecurse > 0})}
 
-\item{threshold}{minimum value of \code{thresholdScore} function call to apply collocation analysis recursively (only applied when \code{maxRecurse > 0})}
+\item{threshold}{minimum value of \code{thresholdScore} function call to apply collocation analysis recursively (only applied when \code{maxRecurse > 0}).
+Note that the default score, \code{logDice}, expresses how salient a pair is
+rather than how surprising, so that a frequent collocate can pass it while
+co-occurring less often than expected. Adding \code{dplyr::filter(O > E)}, or a
+minimum \code{pmi} or \code{ll}, removes those. See the "Salience versus surprise"
+section of \code{\link{association-score-functions}}.}
 
 \item{localStopwords}{vector of stopwords that will not be considered as collocates in the current function call, but that will not be passed to recursive calls}