anchor.diff:          },
           "my_minhash_filter": {
             "type": "min_hash",
  -          "hash_count": 1,   <2>
  -          "bucket_count": 512, <3>
  -          "hash_set_size": 1, <4>
  -          "with_rotation": true <5>
  +          "hash_count": 1,          <2>
  +          "bucket_count": 512,      <3>
  +          "hash_set_size": 1,       <4>
  +          "with_rotation": true     <5>
           }
         },
         "analyzer": {
  
positive.code: The minimum hash codes from all hash functions are combined
  to form a signature for the document.
  
  
  ==== Example of setting MinHash Token Filter in Elasticsearch
  Here is an example of setting up a `min_hash` filter:
  
  [source,js]
  --------------------------------------------------
  POST /index1
  {
    "settings": {
      "analysis": {
        "filter": {
          "my_shingle_filter": { <1>
            "type": "shingle",
            "min_shingle_size": 5,
            "max_shingle_size": 5,
  
negative.code: <titleabbrev>MinHash</titleabbrev>
  ++++
  
  Uses the https://en.wikipedia.org/wiki/MinHash[MinHash] technique to produce a
  signature for a token stream. You can use MinHash signatures to estimate the
  similarity of documents. See <<analysis-minhash-tokenfilter-similarity-search>>.
  
  The `min_hash` filter performs the following operations on a token stream in
  order:
  
  . Hashes each token in the stream.
  . Assigns the hashes to buckets, keeping only the smallest hashes of each
    bucket.
  . Outputs the smallest hash from each bucket as a token stream.
  
  This filter uses Lucene's
  {lucene-analysis-docs}/minhash/MinHashFilter.html[MinHashFilter].
  
  [[analysis-minhash-tokenfilter-configure-parms]]
  ==== Configurable parameters
  
  `bucket_count`::
  (Optional, integer)
  Number of buckets to which hashes are assigned. Defaults to `512`.
  
  `hash_count`::
  (Optional, integer)
  Number of ways to hash each token in the stream. Defaults to `1`.
  
  `hash_set_size`::
  (Optional, integer)
  Number of hashes to keep from each bucket. Defaults to `1`.
  +
  Hashes are retained by ascending size, starting with the bucket's smallest hash
  first.
  
  `with_rotation`::
  (Optional, boolean)
  If `true`, the filter fills empty buckets with the value of the first non-empty
  bucket to its circular right if the `hash_set_size` is `1`. If the
  `bucket_count` argument is greater than `1`, this parameter defaults to `true`.
  Otherwise, this parameter defaults to `false`.
  
  [[analysis-minhash-tokenfilter-configuration-tips]]
  ==== Tips for configuring the `min_hash` filter
  
  * `min_hash` filter input tokens should typically be k-words shingles produced
  from <<analysis-shingle-tokenfilter,shingle token filter>>. You should
  choose `k` large enough so that the probability of any given shingle
  occurring in a document is low. At the same time, as
  internally each shingle is hashed into to 128-bit hash, you should choose
  `k` small enough so that all possible
  different k-words shingles can be hashed to 128-bit hash with
  minimal collision.
  
  * We recommend you test different arguments for the `hash_count`, `bucket_count` and
    `hash_set_size` parameters:
  
  ** To improve precision, increase the `bucket_count` or
     `hash_set_size` arguments. Higher `bucket_count` and `hash_set_size` values
     increase the likelihood that different tokens are indexed to different
     buckets.
  
  ** To improve the recall, increase the value of the `hash_count` argument. For
     example, setting `hash_count` to `2` hashes each token in two different ways,
     increasing the number of potential candidates for search.
  
  * By default, the `min_hash` filter produces 512 tokens for each document. Each
  token is 16 bytes in size. This means each document's size will be increased by
  around 8Kb.
  
  * The `min_hash` filter is used for Jaccard similarity. This means
  that it doesn't matter how many times a document contains a certain token,
  only that if it contains it or not.
  
  [[analysis-minhash-tokenfilter-similarity-search]]
  ==== Using the `min_hash` token filter for similarity search
  
  The `min_hash` token filter allows you to hash documents for similarity search.
  Similarity search, or nearest neighbor search is a complex problem.
  A naive solution requires an exhaustive pairwise comparison between a query
  document and every document in an index. This is a prohibitive operation
  