faiss 0.6.2 → 0.6.4

data/vendor/faiss/faiss/IndexHNSW.h

@@ -18,7 +18,6 @@
 #include <faiss/IndexScalarQuantizer.h>
 #include <faiss/impl/HNSW.h>
 #include <faiss/impl/Panorama.h>
-#include <faiss/impl/hnsw/LockVector.h>
 #include <faiss/utils/utils.h>
 
 namespace faiss {
@@ -53,11 +52,6 @@ struct IndexHNSW : Index {
     // See impl/VisitedTable.h.
     std::optional<bool> use_visited_hashset;
 
-    // Per-node locks for HNSW graph construction.
-    LockVector locks;
-    // locks are freed after each call to add() unless this flag is set.
-    bool retain_locks = false;
-
     explicit IndexHNSW(int d = 0, int M = 32, MetricType metric = METRIC_L2);
     explicit IndexHNSW(Index* storage, int M = 32);
 
@@ -216,6 +210,36 @@ struct IndexHNSWSQ : IndexHNSW {
             MetricType metric = METRIC_L2);
 };
 
+/** HNSW index whose storage is RaBitQ-compressed.
+ *
+ * The graph is built directly from the compressed codes. Neighbor-diversity
+ * pruning uses a fast 1-bit symmetric L2 estimator, including when the storage
+ * contains multi-bit codes.
+ *
+ * With nb_bits >= 2 the codes carry a per-vector error factor, so search uses
+ * the staged search method: a 1-bit estimate for every neighbor and the full
+ * multi-bit distance only for candidates the error bound cannot rule out.
+ * nb_bits = 1 has no error factor and uses ordinary HNSW search.
+ */
+struct IndexHNSWRaBitQ : IndexHNSW {
+    IndexHNSWRaBitQ();
+    IndexHNSWRaBitQ(
+            int d,
+            int M,
+            uint8_t nb_bits = 1,
+            MetricType metric = METRIC_L2);
+
+    IndexHNSWRaBitQ& operator=(const IndexHNSWRaBitQ&) = delete;
+
+   private:
+    // clone_index() replaces the shallow-copied storage with a deep copy
+    // before returning it. Keep ordinary C++ copies from sharing ownership.
+    IndexHNSWRaBitQ(const IndexHNSWRaBitQ&) = default;
+#ifndef SWIG
+    friend IndexHNSW* clone_IndexHNSW(const IndexHNSW* index);
+#endif
+};
+
 /** 2-level code structure with fast random access
  */
 struct IndexHNSW2Level : IndexHNSW {
@@ -253,7 +277,7 @@ struct IndexHNSWCagra : IndexHNSW {
     /// searches only the base level knn graph of the HNSW index.
     /// This parameter selects the entry point by randomly selecting
     /// some points and using the best one.
-    int num_base_level_search_entrypoints = 32;
+    int num_base_level_search_entrypoints = 256;
 
     void add(idx_t n, const float* x) override;
 

data/vendor/faiss/faiss/IndexIDMap.cpp

@@ -138,7 +138,8 @@ void IndexIDMapTemplate<IndexT>::add_sa_codes(
         idx_t n,
         const uint8_t* codes,
         const idx_t* xids) {
-    index->add_sa_codes(n, codes, xids);
+    // don't pass the ids to the sub-index, they are kept in id_map
+    index->add_sa_codes(n, codes, nullptr);
     for (idx_t i = 0; i < n; i++) {
         id_map.push_back(xids[i]);
     }
@@ -228,15 +229,20 @@ void IndexIDMapTemplate<IndexT>::range_search(
         typename IndexT::distance_t radius,
         RangeSearchResult* result,
         const SearchParameters* params) const {
-    if (params) {
-        SearchParameters internal_search_parameters;
-        IDSelectorTranslated id_selector_translated(id_map, params->sel);
-        internal_search_parameters.sel = &id_selector_translated;
+    IDSelectorTranslated this_idtrans(this->id_map, nullptr);
+    ScopedSelChange sel_change;
 
-        index->range_search(n, x, radius, result, &internal_search_parameters);
-    } else {
-        index->range_search(n, x, radius, result);
+    if (params && params->sel) {
+        auto idtrans = dynamic_cast<const IDSelectorTranslated*>(params->sel);
+
+        if (!idtrans) {
+            // Preserve the concrete params type and its index-specific fields.
+            auto params_non_const = const_cast<SearchParameters*>(params);
+            this_idtrans.sel = params->sel;
+            sel_change.set(params_non_const, &this_idtrans);
+        }
     }
+    index->range_search(n, x, radius, result, params);
 
     const idx_t id_map_size = static_cast<idx_t>(id_map.size());
 #pragma omp parallel for
@@ -329,6 +335,18 @@ void IndexIDMap2Template<IndexT>::add_with_ids(
             xids);
 }
 
+template <typename IndexT>
+void IndexIDMap2Template<IndexT>::add_sa_codes(
+        idx_t n,
+        const uint8_t* codes,
+        const idx_t* xids) {
+    idx_t prev_ntotal = this->ntotal;
+    IndexIDMapTemplate<IndexT>::add_sa_codes(n, codes, xids);
+    for (idx_t i = prev_ntotal; i < this->ntotal; i++) {
+        rev_map[this->id_map[i]] = i;
+    }
+}
+
 template <typename IndexT>
 void IndexIDMap2Template<IndexT>::check_consistency() const {
     FAISS_THROW_IF_NOT(rev_map.size() == this->id_map.size());

data/vendor/faiss/faiss/IndexIDMap.h

@@ -110,6 +110,8 @@ struct IndexIDMap2Template : IndexIDMapTemplate<IndexT> {
             NumericType numeric_type,
             const idx_t* xids) override;
 
+    void add_sa_codes(idx_t n, const uint8_t* x, const idx_t* xids) override;
+
     size_t remove_ids(const IDSelector& sel) override;
 
     void reconstruct(idx_t key, component_t* recons) const override;

data/vendor/faiss/faiss/IndexIVF.cpp

@@ -6,6 +6,7 @@
  */
 
 #include <faiss/IndexIVF.h>
+#include <faiss/SuperKMeans.h>
 
 #include <omp.h>
 #include <atomic>
@@ -17,7 +18,6 @@
 #include <cstdio>
 #include <limits>
 
-#include <faiss/utils/hamming.h>
 #include <faiss/utils/utils.h>
 
 #include <faiss/IndexFlat.h>
@@ -79,13 +79,27 @@ void Level1Quantizer::train_q1(
             printf("Training level-1 quantizer on %zd vectors in %zdD\n", n, d);
         }
 
-        Clustering clus(static_cast<int>(d), static_cast<int>(nlist), cp);
+        FAISS_THROW_IF_MSG(
+                cp.use_super_kmeans && clustering_index,
+                "cp.use_super_kmeans is incompatible with a user-provided "
+                "clustering_index: SuperKMeans assigns with its own index");
+
         quantizer->reset();
-        if (clustering_index) {
-            clus.train(n, x, *clustering_index);
+        if (cp.use_super_kmeans) {
+            SuperKMeansParameters super_cp;
+            static_cast<ClusteringParameters&>(super_cp) = cp;
+            SuperKMeans clus(
+                    static_cast<int>(d), static_cast<int>(nlist), super_cp);
+            clus.train(n, x);
             quantizer->add(nlist, clus.centroids.data());
         } else {
-            clus.train(n, x, *quantizer);
+            Clustering clus(static_cast<int>(d), static_cast<int>(nlist), cp);
+            if (clustering_index) {
+                clus.train(n, x, *clustering_index);
+                quantizer->add(nlist, clus.centroids.data());
+            } else {
+                clus.train(n, x, *quantizer);
+            }
         }
         quantizer->is_trained = true;
     } else if (quantizer_trains_alone == 2) {
@@ -501,7 +515,7 @@ void IndexIVF::search_preassigned(
                 if (!do_heap_init) {
                     return;
                 }
-                if (metric_type == METRIC_INNER_PRODUCT) {
+                if (is_similarity_metric(metric_type)) {
                     heap_heapify<HeapForIP>(k, simi, idxi);
                 } else {
                     heap_heapify<HeapForL2>(k, simi, idxi);
@@ -512,7 +526,7 @@ void IndexIVF::search_preassigned(
                                          const idx_t* local_idx,
                                          float* simi,
                                          idx_t* idxi) {
-                if (metric_type == METRIC_INNER_PRODUCT) {
+                if (is_similarity_metric(metric_type)) {
                     heap_addn<HeapForIP>(
                             k, simi, idxi, local_dis, local_idx, k);
                 } else {
@@ -525,7 +539,7 @@ void IndexIVF::search_preassigned(
                 if (!do_heap_init) {
                     return;
                 }
-                if (metric_type == METRIC_INNER_PRODUCT) {
+                if (is_similarity_metric(metric_type)) {
                     heap_reorder<HeapForIP>(k, simi, idxi);
                 } else {
                     heap_reorder<HeapForL2>(k, simi, idxi);
@@ -599,7 +613,7 @@ void IndexIVF::search_preassigned(
 
                     size_t old_scan_cnt = 0;
                     size_t old_heap_updates = 0;
-                    if (metric_type == METRIC_INNER_PRODUCT) {
+                    if (is_similarity_metric(metric_type)) {
                         HeapResultHandler<HeapForIP, false> handler(
                                 k, simi, idxi);
                         old_scan_cnt = handler.stats.scan_cnt;
@@ -1056,7 +1070,19 @@ InvertedListScanner* IndexIVF::get_InvertedListScanner(
 
 void IndexIVF::reconstruct(idx_t key, float* recons) const {
     idx_t lo = direct_map.get(key);
-    reconstruct_from_offset(lo_listno(lo), lo_offset(lo), recons);
+    const size_t list_no = lo_listno(lo);
+    const size_t offset = lo_offset(lo);
+    FAISS_THROW_IF_NOT_FMT(
+            list_no < nlist,
+            "IndexIVF::reconstruct: list_no %zd out of range (nlist=%zd)",
+            list_no,
+            nlist);
+    FAISS_THROW_IF_NOT_FMT(
+            offset < invlists->list_size(list_no),
+            "IndexIVF::reconstruct: offset %zd out of range (list_size=%zd)",
+            offset,
+            invlists->list_size(list_no));
+    reconstruct_from_offset(list_no, offset, recons);
 }
 
 void IndexIVF::reconstruct_n(idx_t i0, idx_t ni, float* recons) const {

data/vendor/faiss/faiss/IndexIVFAdditiveQuantizer.cpp

@@ -283,7 +283,7 @@ InvertedListScanner* IndexIVFAdditiveQuantizer::get_InvertedListScanner(
         bool store_pairs,
         const IDSelector* sel,
         const IVFSearchParameters*) const {
-    FAISS_THROW_IF_NOT(!sel);
+    FAISS_THROW_IF_MSG(sel, "id selector not supported for this index");
     if (metric_type == METRIC_INNER_PRODUCT) {
         if (aq->search_type == AdditiveQuantizer::ST_decompress) {
             return new AQInvertedListScannerDecompress<true>(

data/vendor/faiss/faiss/IndexIVFAdditiveQuantizerFastScan.cpp

@@ -48,8 +48,8 @@ void IndexIVFAdditiveQuantizerFastScan::init(
         MetricType metric,
         int bbs_,
         bool own_invlists_) {
-    FAISS_THROW_IF_NOT(aq_ != nullptr);
-    FAISS_THROW_IF_NOT(!aq_->nbits.empty());
+    FAISS_THROW_IF_NOT(aq_);
+    FAISS_THROW_IF_MSG(aq_->nbits.empty(), "quantizer nbits must not be empty");
     FAISS_THROW_IF_NOT(aq_->nbits[0] == 4);
     if (metric == METRIC_INNER_PRODUCT) {
         FAISS_THROW_IF_NOT_MSG(
@@ -310,8 +310,7 @@ void IndexIVFAdditiveQuantizerFastScan::search(
         float* distances,
         idx_t* labels,
         const SearchParameters* params) const {
-    FAISS_THROW_IF_NOT_MSG(
-            !params, "search params not supported for this index");
+    FAISS_THROW_IF_MSG(params, "search params not supported for this index");
 
     FAISS_THROW_IF_NOT(k > 0);
     bool rescale = (rescale_norm && norm_scale > 1 && metric_type == METRIC_L2);

data/vendor/faiss/faiss/IndexIVFEDEN.cpp

@@ -0,0 +1,302 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <faiss/IndexIVFEDEN.h>
+
+#include <omp.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <vector>
+
+#include <faiss/impl/EDENQuantizer.h>
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/expanded_scanners.h>
+
+namespace faiss {
+
+IndexIVFEDEN::IndexIVFEDEN(
+        Index* quantizer_in,
+        const size_t d_in,
+        const size_t nlist_in,
+        MetricType metric,
+        bool own_invlists_in,
+        uint8_t nb_bits_in,
+        EDENScaleType scale_type_in)
+        : IndexIVF(quantizer_in, d_in, nlist_in, 0, metric, own_invlists_in),
+          sq(d_in, eden_utils::quantizer_type_for_bits(nb_bits_in)),
+          scale_type(scale_type_in) {
+    FAISS_THROW_IF_NOT_MSG(
+            scale_type == EDENScaleType_UNBIASED ||
+                    scale_type == EDENScaleType_BIASED,
+            "invalid EDEN scale type");
+    sq.train(0, nullptr);
+    code_size = eden_utils::code_size(d, sq.bits);
+    if (own_invlists_in) {
+        invlists->code_size = code_size;
+    }
+    is_trained = false;
+    by_residual = true;
+}
+
+IndexIVFEDEN::IndexIVFEDEN() {
+    by_residual = true;
+}
+
+void IndexIVFEDEN::train_encoder(
+        idx_t n,
+        const float* x,
+        const idx_t* /*assign*/) {
+    sq.train(n, x);
+}
+
+void IndexIVFEDEN::encode_vectors(
+        idx_t n,
+        const float* x,
+        const idx_t* list_nos,
+        uint8_t* codes,
+        bool include_listnos) const {
+    const size_t coarse_size = include_listnos ? coarse_code_size() : 0;
+    memset(codes, 0, (code_size + coarse_size) * n);
+
+#pragma omp parallel if (n > 1000)
+    {
+        std::vector<float> centroid(d);
+
+#pragma omp for
+        for (idx_t i = 0; i < n; i++) {
+            const int64_t list_no = list_nos[i];
+            if (list_no >= 0) {
+                const float* xi = x + i * d;
+                uint8_t* code = codes + i * (code_size + coarse_size);
+
+                quantizer->reconstruct(list_no, centroid.data());
+                eden_utils::compute_codes(
+                        sq,
+                        metric_type,
+                        scale_type,
+                        xi,
+                        code + coarse_size,
+                        1,
+                        centroid.data());
+
+                if (coarse_size) {
+                    encode_listno(list_no, code);
+                }
+            }
+        }
+    }
+}
+
+void IndexIVFEDEN::decode_vectors(
+        idx_t n,
+        const uint8_t* codes,
+        const idx_t* listnos,
+        float* x) const {
+#pragma omp parallel
+    {
+        std::vector<float> centroid(d);
+
+#pragma omp for
+        for (idx_t i = 0; i < n; i++) {
+            const uint8_t* code = codes + i * code_size;
+            const int64_t list_no = listnos[i];
+            float* xi = x + i * d;
+
+            quantizer->reconstruct(list_no, centroid.data());
+            eden_utils::decode(sq, code, xi, 1, centroid.data());
+        }
+    }
+}
+
+void IndexIVFEDEN::add_core(
+        idx_t n,
+        const float* x,
+        const idx_t* xids,
+        const idx_t* precomputed_idx,
+        void* inverted_list_context) {
+    FAISS_THROW_IF_NOT(is_trained);
+
+    DirectMapAdd dm_add(direct_map, n, xids);
+
+#pragma omp parallel
+    {
+        std::vector<uint8_t> one_code(code_size);
+        std::vector<float> centroid(d);
+
+        const int nt = omp_get_num_threads();
+        const int rank = omp_get_thread_num();
+
+        for (idx_t i = 0; i < n; i++) {
+            const int64_t list_no = precomputed_idx[i];
+            if (list_no >= 0 && list_no % nt == rank) {
+                const int64_t id = xids ? xids[i] : ntotal + i;
+                const float* xi = x + i * d;
+
+                quantizer->reconstruct(list_no, centroid.data());
+                eden_utils::compute_codes(
+                        sq,
+                        metric_type,
+                        scale_type,
+                        xi,
+                        one_code.data(),
+                        1,
+                        centroid.data());
+
+                const size_t ofs = invlists->add_entry(
+                        list_no, id, one_code.data(), inverted_list_context);
+                dm_add.add(i, list_no, ofs);
+            } else if (rank == 0 && list_no == -1) {
+                dm_add.add(i, -1, 0);
+            }
+        }
+    }
+
+    ntotal += n;
+}
+
+namespace {
+
+struct EDENInvertedListScanner : InvertedListScanner {
+    using InvertedListScanner::scan_codes;
+
+    const IndexIVFEDEN& ivf_eden;
+    std::vector<float> reconstructed_centroid;
+    std::vector<float> query_vector;
+    std::unique_ptr<FlatCodesDistanceComputer> dc;
+
+    explicit EDENInvertedListScanner(
+            const IndexIVFEDEN& ivf_eden_in,
+            bool store_pairs_in = false,
+            const IDSelector* sel_in = nullptr)
+            : InvertedListScanner(store_pairs_in, sel_in),
+              ivf_eden(ivf_eden_in) {
+        keep_max = is_similarity_metric(ivf_eden.metric_type);
+        code_size = ivf_eden.code_size;
+    }
+
+    void set_query(const float* query_vector_in) override {
+        query_vector.assign(query_vector_in, query_vector_in + ivf_eden.d);
+        internal_try_setup_dc();
+    }
+
+    void set_list(idx_t list_no_in, float /*coarse_dis*/) override {
+        list_no = list_no_in;
+
+        reconstructed_centroid.resize(ivf_eden.d);
+        ivf_eden.quantizer->reconstruct(
+                list_no_in, reconstructed_centroid.data());
+        internal_try_setup_dc();
+    }
+
+    float distance_to_code(const uint8_t* code) const final {
+        return dc->distance_to_code(code);
+    }
+
+    size_t scan_codes(
+            size_t list_size,
+            const uint8_t* codes,
+            const idx_t* ids,
+            ResultHandler& handler) const override {
+        return run_scan_codes(*this, list_size, codes, ids, handler);
+    }
+
+    void internal_try_setup_dc() {
+        if (!query_vector.empty() && !reconstructed_centroid.empty()) {
+            dc.reset(
+                    eden_utils::get_distance_computer(
+                            ivf_eden.sq,
+                            ivf_eden.metric_type,
+                            reconstructed_centroid.data()));
+            dc->set_query(query_vector.data());
+        }
+    }
+};
+
+} // namespace
+
+InvertedListScanner* IndexIVFEDEN::get_InvertedListScanner(
+        bool store_pairs,
+        const IDSelector* sel,
+        const IVFSearchParameters* /*params*/) const {
+    return new EDENInvertedListScanner(*this, store_pairs, sel);
+}
+
+void IndexIVFEDEN::reconstruct_from_offset(
+        int64_t list_no,
+        int64_t offset,
+        float* recons) const {
+    const uint8_t* code = invlists->get_single_code(list_no, offset);
+
+    std::vector<float> centroid(d);
+    quantizer->reconstruct(list_no, centroid.data());
+    eden_utils::decode(sq, code, recons, 1, centroid.data());
+
+    invlists->release_codes(list_no, code);
+}
+
+void IndexIVFEDEN::sa_decode(idx_t n, const uint8_t* bytes, float* x) const {
+    const size_t coarse_size = coarse_code_size();
+
+#pragma omp parallel
+    {
+        std::vector<float> centroid(d);
+
+#pragma omp for
+        for (idx_t i = 0; i < n; i++) {
+            const uint8_t* code = bytes + i * (code_size + coarse_size);
+            const int64_t list_no = decode_listno(code);
+            float* xi = x + i * d;
+
+            quantizer->reconstruct(list_no, centroid.data());
+            eden_utils::decode(sq, code + coarse_size, xi, 1, centroid.data());
+        }
+    }
+}
+
+struct IVFEDENDistanceComputer : DistanceComputer {
+    const float* q = nullptr;
+    const IndexIVFEDEN* parent = nullptr;
+
+    void set_query(const float* x) override {
+        q = x;
+    }
+
+    float operator()(idx_t i) override {
+        const idx_t lo = parent->direct_map.get(i);
+        const uint64_t list_no = lo_listno(lo);
+        const uint64_t offset = lo_offset(lo);
+        const uint8_t* code =
+                parent->invlists->get_single_code(list_no, offset);
+
+        std::vector<float> centroid(parent->d);
+        parent->quantizer->reconstruct(list_no, centroid.data());
+
+        std::unique_ptr<FlatCodesDistanceComputer> dc(
+                eden_utils::get_distance_computer(
+                        parent->sq, parent->metric_type, centroid.data()));
+        dc->set_query(q);
+        const float distance = dc->distance_to_code(code);
+
+        parent->invlists->release_codes(list_no, code);
+        return distance;
+    }
+
+    float symmetric_dis(idx_t /*i*/, idx_t /*j*/) override {
+        FAISS_THROW_MSG("Not implemented");
+    }
+};
+
+DistanceComputer* IndexIVFEDEN::get_distance_computer() const {
+    IVFEDENDistanceComputer* dc = new IVFEDENDistanceComputer;
+    dc->parent = this;
+    return dc;
+}
+
+} // namespace faiss

data/vendor/faiss/faiss/IndexIVFEDEN.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include <faiss/IndexIVF.h>
+#include <faiss/impl/EDENQuantizer.h>
+
+namespace faiss {
+
+struct IndexIVFEDEN : IndexIVF {
+    ScalarQuantizer sq;
+    EDENScaleType scale_type = EDENScaleType_UNBIASED;
+
+    // Factory strings: IVF<nlist>,EDEN, IVF<nlist>,EDEN<n>, and the same
+    // forms with the BIASED suffix for EDEN's MSE-minimizing scale.
+    IndexIVFEDEN(
+            Index* quantizer,
+            const size_t d,
+            const size_t nlist,
+            MetricType metric = METRIC_L2,
+            bool own_invlists = true,
+            uint8_t nb_bits = 1,
+            EDENScaleType scale_type = EDENScaleType_UNBIASED);
+
+    IndexIVFEDEN();
+
+    void train_encoder(idx_t n, const float* x, const idx_t* assign) override;
+
+    void encode_vectors(
+            idx_t n,
+            const float* x,
+            const idx_t* list_nos,
+            uint8_t* codes,
+            bool include_listnos = false) const override;
+
+    void decode_vectors(
+            idx_t n,
+            const uint8_t* codes,
+            const idx_t* list_nos,
+            float* x) const override;
+
+    void add_core(
+            idx_t n,
+            const float* x,
+            const idx_t* xids,
+            const idx_t* precomputed_idx,
+            void* inverted_list_context = nullptr) override;
+
+    InvertedListScanner* get_InvertedListScanner(
+            bool store_pairs,
+            const IDSelector* sel,
+            const IVFSearchParameters* params) const override;
+
+    void reconstruct_from_offset(int64_t list_no, int64_t offset, float* recons)
+            const override;
+
+    void sa_decode(idx_t n, const uint8_t* bytes, float* x) const override;
+
+    DistanceComputer* get_distance_computer() const override;
+};
+
+} // namespace faiss

data/vendor/faiss/faiss/IndexIVFFastScan.cpp

@@ -376,9 +376,8 @@ void IndexIVFFastScan::search_preassigned(
         cur_nprobe = params->nprobe;
     }
 
-    FAISS_THROW_IF_NOT_MSG(
-            !store_pairs, "store_pairs not supported for this index");
-    FAISS_THROW_IF_NOT_MSG(!stats, "stats not supported for this index");
+    FAISS_THROW_IF_MSG(store_pairs, "store_pairs not supported for this index");
+    FAISS_THROW_IF_MSG(stats, "stats not supported for this index");
     FAISS_THROW_IF_NOT(k > 0);
     FastScanDistancePostProcessing empty_context{};
 
@@ -404,8 +403,8 @@ void IndexIVFFastScan::range_search(
                 params->max_lists_num == 0,
                 "max_lists_num is a knn knob and is not honored by "
                 "fastscan range search");
-        FAISS_THROW_IF_NOT_MSG(
-                !params->ensure_topk_full,
+        FAISS_THROW_IF_MSG(
+                params->ensure_topk_full,
                 "ensure_topk_full is a knn knob and is not honored by "
                 "fastscan range search");
         FAISS_THROW_IF_NOT_MSG(
@@ -1592,7 +1591,7 @@ void IndexIVFFastScan::reconstruct_from_offset(
 }
 
 void IndexIVFFastScan::reconstruct_orig_invlists() {
-    FAISS_THROW_IF_NOT(orig_invlists != nullptr);
+    FAISS_THROW_IF_NOT(orig_invlists);
     FAISS_THROW_IF_NOT(orig_invlists->list_size(0) == 0);
 
 #pragma omp parallel for if (nlist > 100)