Update docs.

Author: kernelmethod

docs/make.jl

@@ -13,7 +13,7 @@ makedocs(
     modules  = [LSHFunctions],
     pages    = ["Home" => "index.md",
                 "The LSHFunction API" => "lshfunction_api.md",
-                "Similarity functions" => [
+                "Similarity statistics" => [
                     "Cosine similarity" => joinpath("similarities", "cosine.md"),
                     "``\\ell^p`` distance" => joinpath("similarities", "lp_distance.md"),
                     "Jaccard similarity" => joinpath("similarities", "jaccard.md"),

docs/src/lshfunction_api.md

@@ -6,7 +6,7 @@
 ## LSHFunction
 The `LSHFunctions` module exposes a relatively easy interface for constructing new hash functions. Namely, you call [`LSHFunction`](@ref) with 
 
-- the similarity function you want to use;
+- the similarity statistic you want to hash on;
 - the number of hash functions you want to generate; and
 - keyword parameters specific to the LSH function family that you're sampling from.
 

src/LSHBase.jl

@@ -68,13 +68,19 @@ Compute the probability of hash collision between two inputs with similarity `si
 - `sim`: a similarity (or vector of similarities), computed using the similarity function returned by `similarity(hashfn)`.
 
 # Keyword arguments
-- `n_hashes::Union{Symbol,Integer}` (default: `:auto`): the number of hash functions to use to compute the probability of collision. If the probability that a single hash collides is ``p``, then the probability that `n_hashes` hashes simultaneously collide is
+- `n_hashes::Union{Symbol,Integer}` (default: `:auto`): the number of hash functions to use to compute the probability of collision. If the probability that a single hash collides is `p`, then the probability that `n_hashes` hashes simultaneously collide is `p^n_hashes`. As a result,
 
-  ```math
-  p^{\\text{n_hashes}}
+  ```
+  collision_probability(hashfn, sim; n_hashes=N)
+  ```
+
+  is the same as
+
+  ```
+  collision_probability(hashfn, sim; n_hashes=1).^N
   ```
 
-  As a result, `collision_probability(hashfn, sim; n_hashes=N)` is the same as `collision_probability(hashfn, sim; n_hashes=1).^N`. If `n_hashes = :auto` then this function will select the number of hashes to be `n_hashes(hashfn)` (using the [`n_hashes`](@ref) function from the [`LSHFunction`](@ref) API).
+  If `n_hashes = :auto` then this function will select the number of hashes to be `n_hashes(hashfn)` (using the [`n_hashes`](@ref) function from the [`LSHFunction`](@ref) API).
 
 # Examples
 The probability that a single MinHash hash function causes a hash collision between inputs `A` and `B` is equal to `jaccard(A,B)`:

src/function_hashing/monte_carlo.jl

@@ -80,11 +80,11 @@ join(
 Given an input function ``f\\in L^p_{\\mu}(\\Omega)``, `MonteCarloHash` works by sampling ``f`` at some randomly-selected points in ``\\Omega``, and then hashing those samples.
 
 # Arguments
-- `sim`: the similarity function you want to hash on.
+- `sim`: the similarity statistic you want to hash on.
 - `ω`: a function that takes no inputs and samples a single point from ``\\Omega``. Alternatively, it can be viewed as a random variable with probability measure
 
 ```math
-\\frac{\\mu}{\\text{vol}_{\\mu}(\\Omega)} = \\mu\\left(\\int_{\\Omega} d\\mu\\right)^{-1}
+\\frac{\\mu}{\\text{vol}_{\\mu}(\\Omega)} = \\frac{\\mu}{\\int_{\\Omega} d\\mu}
 ```
 
 - `args...`: arguments to pass on when building the `LSHFunction` instance underlying the returned `MonteCarloHash` struct.