acceptodds
Under review as a conference paper at ICLR 2027

PANORAMA: Fast-Track Nearest Neighbors

Abstract

Retrieval-augmented generation (RAG) has put nearest-neighbor search over learned embeddings on the inference path of language models via purpose-built vector indexes. An index narrows a query result to a set of candidates, each of which must be verified by its -dimensional distance. As embeddings grow wider, this verification comes to dominate query time over index traversal. Most of this verification overhead is wasted: a distance is computed only to decide whether a candidate enters the top- set; for most candidates the answer is “no”. We introduce Panorama, a verification module that verifies candidates progressively. It rotates vectors into an orthogonal basis fitted to the data, accumulates distances in a piecewise manner, and abandons a candidate as soon as a Cauchy–Schwarz lower bound on its unread remainder pushes its distance past the running top- threshold. As energy concentrates in a few principal directions, the bound becomes decisive after a small fraction of the coordinates is read. While Panorama’s strict mode returns exactly the top- of the supplied candidates, one parameter trades recall for throughput. A cost model ties the pruning effect to the spectral decay of the fitted basis. Panorama sits on top of an unmodified index: we realize the bound within inverted-list, product-quantized, graph, reranking, and RaBitQ indexes with layouts that keep the pruning loop vectorized. Across image descriptors and text embeddings, the gain grows with dimension and is largest on the wide embeddings that RAG systems search.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
approximate nearest neighbor search, vector search, candidate verification, progressive distance bounds, quantization

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_ACsJOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

To ground the model in additional knowledge RAG based system uses nearest neighbour search (with respect to the embedded query vector) among the provided the top k data passages (embedded as vectors). These top k passages are used as context for the query vector. Much of the work for finding k-nearest neighbours is spent on unqualified candidates. The paper therefore proposes an efficient approach to find the top k- candidates. The idea is to measure distance in a lower-dimensional orthogonal bases of the data for the pruning of non-qualified candidates. PCA is applied to obtain the orthogonal bases of the query vector. The candidate vectors are rotated into this orthogonal bases, Distance is computed in this bases to prune some candidates more efficiently. There is some approximation done for more efficient pruning which is not very clear. Also the paper uses terms like "splitting coordinates", "using tail energies ", which it never defines.

Critical strengths
  1. The paper concerns an interesting problem.
  2. The approach generally seems to make sense
Critical weaknesses
  1. Terms are used without being defined which makes the paper hard to read. For instance , what is "tail energy"? What does "splitting coordinates" mean? What are "level-major" batches? What does "spreading energy" mean?
  2. I am not sure of how efficient this approach is? It changes the problem to distance computation in an orthogonal bases. The distance computation may become faster but what about the work done to obtain the data transforms. Also how is \ell chosen?
  3. While the paper conveys the key idea, it is difficult to follow. There are two major reasons for that. First, the paper uses vocabulary it never defines. Second the sentences are too long. For instance, a single sentence covers lines 219 till 223. There are many other such examples in the paper.
Questions for authors

Please see the weaknesses.

In addition, please explain how exactly your approach is more efficient than k-nearest neighbour search. You do get benefit if the distance computation is faster in teh new bases. But you still need to parse through all candidates and do some work for each.

4 comments
AuthorsOpenReview ↗

On review summary

(Part 1/3)

We thank the reviewer for the time invested to read the paper carefully. First, we provide answers to three implicit questions in the reviewer's summary and then to explicit questions:

S1. The idea is to measure distance in a lower-dimensional orthogonal bases of the data.

PANORAMA does not use lower-dimensional bases. It keeps all dd coordinates, reads them in decreasing order for each candidate, and stops when it determines that the candidate cannot be among the top-kk set. The revised manuscript states this clarification in Section 3 ("The bound").

S2. PCA is applied to obtain the orthogonal bases of the query vector. The candidate vectors are rotated into this orthogonal bases.

PCA is applied once and offline on the data, preserving distances due to orthogonality. At query time, the query is rotated into the data's orthogonal basis by one matrix–vector product. We stated this in Section 3 ("Learning the basis").

S3. There is some approximation done for more efficient pruning which is not very clear.

PANORAMA's strict mode involves no approximation. The Cauchy-Schwarz lower bound holds for each vector:

∥q−x∥2  ≥  ∑j≤m(q~j−x~j)2⏟coordinates read so far+(Rq(m)−Rx(m))2,\|q-x\|^2 \;\ge\; \underbrace{\textstyle\sum_{j\le m}(\tilde q_j-\tilde x_j)^2}_{\text{coordinates read so far}} + \big(\sqrt{R_q(m)}-\sqrt{R_x(m)}\big)^2 ,

PANORAMA in strict mode returns the same top-kk set as fully computing each distance (Proposition 3.1). In relaxed mode, PANORAMA conducts an approximation via a parameter ε<1\varepsilon < 1 that tightens the bound at the risk of incurring false negatives. We report the tradeoff via recall–throughput curves. We stated this in the introduction, Definition 3.1, and Proposition 3.1.

(Part 2/3)

Q1. Terms are used without being defined ... what is "tail energy" ... "splitting coordinates" ... "level-major" batches ... "spreading energy"? ... the paper uses vocabulary it never defines.

We added a notation box to Section 3 and the full glossary below to Appendix I (Table 24).

Notation: TT is an orthogonal d×dd\times d matrix (here PCA); a vector is always stored and compared after rotation, x~=Tx\tilde x = Tx.

Term in the paperDefinition
Energy of a block of coordinatesThe squared norm of those coordinates, e.g. ∑j∈Bx~j2\sum_{j\in B}\tilde x_j^2.
Tail energy Rx(m)R_x(m)The energy of the coordinates not yet read: Rx(m)=∑j>mx~j2R_x(m) = \sum_{j>m}\tilde x_j^2; it is computed once per stored vector at build time.
Levels, splitting coordinates, cutpointsWe split the dd coordinates into LL consecutive blocks ("levels") at positions m1<m2<⋯<mL=dm_1 < m_2 < \dots < m_L = d (the "cutpoints" or "splitting coordinates"). The bound is checked after each level, not after each coordinate. ℓ\ell indexes the level.
Level-major batchA memory layout. For a batch of BB vectors, we store level 1 of all BB vectors, then level 2 of all BB, and so on. One level is then one contiguous array, processed in one SIMD pass over the candidates that are still alive.
Spreading energyThe effect of a random rotation (as in RaBitQ), which makes coordinates carry similar energy, as opposed to PCA, which concentrates energy in the first coordinates.
VerificationComputing a candidate's exact distance to decide whether it enters the current top-kk. This is the step PANORAMA accelerates.
Candidate streamThe sequence of candidate vectors an index (IVF list, graph neighbors, PQ codes) hands to verification.
Running kk-th-best threshold τ\tauThe distance of the current kk-th-best result; a candidate can enter the top-kk only if its distance is below τ\tau.
Early abandoning / pruningStopping a candidate's distance computation as soon as a lower bound on its distance exceeds τ\tau.
SidecarA small side array holding each vector's suffix energies (L+1L+1 floats), indexed by vector ID, used when the index keeps its own vector layout (graphs, reranking).
Spectral decay, α\alphaHow fast the PCA eigenvalues fall. We model the normalized suffix energy as E(m)≈e−αm/dE(m)\approx e^{-\alpha m/d}; a larger α\alpha means the bound becomes decisive earlier.
Shaping, κ\kappaFor PQ codes: limiting how unequal the per-level energies may be (cap κ\kappa), so PQ's codebooks are not starved in later levels.
Sign-prefix gate, popcountFor RaBitQ codes (1 bit per coordinate): a cheap bound computed from the number of matching sign bits (popcount) in the prefix, applied before RaBitQ's own scorer.
Fixed-width specializationCompiling a separate kernel for each level width so loop bounds are compile-time constants.
Underfilled candidate groupsIn graph search, candidates arrive in small groups. When too few remain, we hand them to the standard exact kernel instead of running the batched one.
Frontier / matched recallThe throughput–recall curve of a method. "Matched recall" compares two methods' throughput at the same recall.

Q2. Please explain how exactly your approach is more efficient than kk-nearest neighbour search ... you still need to parse through all candidates and do some work for each.

Yes, PANORAMA does some work for each candidate, yet reads only a fraction of most of them. The fraction of coordinates it reads over all candidates in strict mode is:

Deep (96-d)SIFT (128-d)arXiv (768-d)GIST (960-d)Ada (1536-d)Large (3072-d)
32.9%17.1%10.7%6.5%13.3%9.0%

For example, on Large, a candidate is read for about 275 of its 3072 coordinates on average. Faiss reads all 3072. Strict PANORAMA is 1.8–14.6× faster than Faiss's SIMD exact scan, depending on dataset and recall (IVF-Flat, matched recall 0.80–0.99). Table 2 in Section 5 reports the fraction of coordinates read at the paper's ε\varepsilon.

AuthorsOpenReview ↗

Q3, Q4, Q5

(Part 3/3)

Q3. What about the work done to obtain the data transforms?

We added these costs to Appendix F.2 (Tables 14 and 15) and Section 5, reproduced below. They are small and mostly one-off. Measured on Ada (1M vectors, 1536-d):

  • Once, at build time: fitting PCA takes 4.7 s, and transforming the 1M database vectors takes 5.1 s. For comparison, Faiss's IVFPQ build takes 149 s.
  • Per query: rotating a query costs 38 µs when queries arrive in batches, which is 0.3–0.8% of query time. Answering one query at a time, it is a single matrix–vector product (0.30 ms). All our time measurements include this cost.
  • Memory: the transform matrix is 9.4 MB per index, plus L+1L+1 floats (about 70 B) of suffix energies per vector. On Ada that is +6–9% over Faiss in total.

Other datasets (all measured): the database transform takes 1–16 s, and the PCA fit 2–3 s (31 s on the 3072-d Large), once per index. Batched query rotation is at most 1.5% of IVF query time on each dataset. Memory overhead is +8.6–12.4% for IVF-Flat and +6–10% for IVFPQ on the embedding datasets. These measurements are reported in Appendix F.2 (Table 14 for bytes, Table 15 for build and rotation time) and Section 5 (rotation cost).

Q4. How is ℓ\ell chosen?

The chosen parameter is the number of levels (i.e., blocks of coordinates) LL, indexed by ℓ\ell. A larger LL checks the bound more often, hence prunes earlier at the cost of bookkeeping. Throughput forms a broad plateau around the chosen value (Appendix D, Figure 10). We pick LL once per dataset from a small grid (Table 5, between 4 and 32). We conducted new sensitivity results on arXiv, GIST, Ada and Large (in strict mode, LL from 4 to 64), and found that the paper's LL is within 1.7% of the best LL on each dataset, while L=4L = 4 loses 40–59%. A simple rule of thumb, making levels of 64 coordinates (L=d/64L = d/64) performs within 2.7% of the best. We added this sensitivity study in Appendix G.2 (Table 21) and referenced from the notation box in Section 3.

Q5. The sentences are too long. For instance, a single sentence covers lines 219 till 223.

We rewrote the sentence in Lines 219–223 in four sentences (Section 4, "Contiguous lists"):

IVF-Flat delivers candidates in long runs, one inverted list at a time. PANORAMA groups each list's vectors into batches stored in level-major order: the coordinates of all vectors for level 1 are stored contiguously, then those for level 2, and so on. Processing one level is therefore one vectorized pass over the candidates that are still alive. We keep the distance, bound-update and compaction steps in separate loops so that each of them vectorizes.

We applied the same treatment to the new and revised text (one claim per sentence, at most two clauses), defined each term at first use, and added a notation box in Section 3. We would be grateful if the reviewer would reconsider the overall assessment.

Reviewer_ACsJOpenReview ↗

Response to Authors

Dear Authors,

Thanks for your response. I found your paper really hard to read though I like the problem that you are trying to solve. Talking about readability, the example about long sentences that I gave was just one example. The paper had many such instances. To check if the modifications indeed make it more understandable a full review may be needed. Therefore, for now I keep my score and wait for the discussion period to further update my score.

Reviewer_26pJOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes PANORAMA, a progressive verification method for Approximate Nearest Neighbor Search (ANNS). The problem studied is almost identical to that of recent research on Distance Comparison Operations (DCOs) for ANNS. Compared with prior DCO methods (e.g., DDC, DADE, and ADSampling), the major distinction is perhaps that PANORAMA achieves a deterministic bound when ϵ=1\epsilon = 1. The evaluations are conducted on multiple datasets with diverse data dimensionalities.

=======================================================================================

The author feedback has addressed my major concerns, so I raised my rating to Weak Accept.

Critical strengths

S1. The studied problem is important for ANNS.
S2. The deterministic bound is meaningful for retaining high recall.
S3. The evaluation is conducted on several datasets.

Critical weaknesses

W1. Section 1 should justify the motivation and limitations of prior DCO methods in more detail.
W2. A key distinction (deterministic bound when ϵ=1\epsilon = 1) over existing methods is under-supported in the experimental study.
W3. More experimental comparisons and analysis are required to verify the advantages of PANORAMA.
W4. The technical novelty is incremental.

Questions for authors

Q1. The studied problem is closely related to Distance Comparison Operations (DCOs) [Gao & Long, 2023], but the introduction does not adequately discuss this line of research. At a minimum, the introduction should acknowledge prior efforts in this area and summarize the limitations of existing DCO methods. Without a careful analysis of prior methods, it is unclear why a new solution is still necessary.

Q2. The paper lacks a formal problem definition. If the definition is essentially the same as that of DCO, it should be properly cited. Otherwise, the difference should be clarified.

Q3. In my opinion, the overall technical novelty is incremental for the following reasons:
(1) PCA rotation has been used in prior DCO methods to enable early-stopping dimension scanning.
(2) The distance lower bound is similar to that used in DDC, although the error term (i.e., the suffix energies in this submission) is estimated differently.
(3) The level-major batching and SIMD kernels in Section 4 are engineering optimizations. While effective, they are system-level techniques rather than new algorithmic insights. In fact, dimension batching with SIMD has been explored in existing work on DCOs [R1].
(4) Section 2 discusses the difference from prior DCO methods. A key distinction is the deterministic bound (when ϵ=1\epsilon = 1), but this setting is not fully supported by the experimental setup.

Q4. In the main frontier experiments, only Deep and SIFT use ϵ=1\epsilon = 1. Can you provide strict-mode frontier curves using ϵ=1\epsilon = 1 for the other datasets? If an external URL is not allowed, you can report QPS at matched recall against the baselines.

Q5. Why is DDC omitted from the graph experiments? In particular, prior experimental work on DCOs has already evaluated DDC on graph indexes.

Q6. Can you re-conduct the experiment of Figure 8a on the higher-dimensional datasets, Large and Ada?

Q7. Please report the time complexity of PANORAMA. In particular, what is the time cost of the PCA rotation? Moreover, can you provide a detailed breakdown of PANORAMA into two parts, PCA rotation and dimension scanning, on high-dimensional datasets (e.g., Large and Ada)?

Q8. For A1 in Figure 8b, is SIMD enabled or not?

Q9. Since prior DCO methods have conducted experiments without SIMD, I wonder whether PANORAMA’s advantage over them (with either ϵ=1\epsilon = 1 or ϵ<1\epsilon < 1) still holds without SIMD.

Reference:
[R1] Distance Comparison Operations are not Silver Bullets in Vector Similarity Search: A Benchmark Study on their Merits and Limits, ICDE 2026.
[R2] Distance Comparison Operation Optimization in ANNS A Survey and Experimental Evaluation, EDBT 2026.

7 comments
AuthorsOpenReview ↗

Q1, Q2, Q3

(Part 1/4)

We thank the reviewer for the concrete questions and the time invested to thoroughly review of our work. We answer each question below and report changes in the revised manuscript (in blue).

Q1. The studied problem is closely related to Distance Comparison Operations (DCOs) [Gao & Long, 2023], but the introduction does not adequately discuss this line of research. [R1] Distance Comparison Operations are not Silver Bullets in Vector Similarity Search: A Benchmark Study on their Merits and Limits, ICDE 2026. [R2] Distance Comparison Operation Optimization in ANNS A Survey and Experimental Evaluation, EDBT 2026.

We revised the introduction to highlight Distance Comparison Operations (DCOs) (Section 1, in blue), which compare a candidate's distance to the current kk-th-best distance. As shown in [R1, R2], recent methods answer DCOs probabilistically: ADSampling tests randomly rotated prefixes, DADE calibrates the test with PCA, DDC learns a residual correction, and PDX runs such pruners over a columnar layout. Contrarily, PANORAMA answers DCOs with a deterministic lower bound (in its default strict mode) and thus returns the same top-kk as full verification, and remains 1.8–14.6× faster than Faiss's SIMD IVF-Flat scan at matched recall. A relaxation ε<1\varepsilon < 1 trades this guarantee for speed.*

As [R1] observes, and we now discuss in Section 2, DCOs can be slower than full-distance computation while probabilistic DCOs degrade on out-of-distribution queries; contrarily, strict PANORAMA is 1.8–14.6× faster than Faiss's SIMD IVF-Flat scan at matched recall on all six datasets and its exactness holds for any query, as its bound is deterministic.

Q2. The paper lacks a formal problem definition.

We stated the Distance Comparison Operation definition formally in Definition 3.1, Section 3. PANORAMA in strict mode is an exact DCO procedure. Contrariwise, ADSampling, DADE and DDC are probabilistic DCO procedures. As Proposition 3.1 states, a kkNN search with exact DCOs returns the same top-kk as full verification.

Q3.1 PCA rotation has been used in prior DCO methods to enable early-stopping dimension scanning.

PANORAMA's novelty lies in deriving a deterministic suffix-energy bound from the PCA basis, which minimizes the unread energy at each prefix length by the Ky Fan maximum principle (Appendix B.2).

Q3.2 The distance lower bound is similar to that used in DDC, although the error term (i.e., the suffix energies in this submission) is estimated differently.

Yes, the error term differs. DDC estimates the error term statisticallly, whereas PANORAMA (in strict mode) derives an exact lower bound from stored suffix energies and the Cauchy–Schwarz inequality. Consequently, strict PANORAMA returns the exact top-kk set, while DDC does not, hence tops out at recall 0.980 on Ada and 0.989–0.990 on Large.

Q3.3 The level-major batching and SIMD kernels in Section 4 are engineering optimizations ... dimension batching with SIMD has been explored in existing work on DCOs [R1].

Yes, prior work explored dimension batching with SIMD, yet falls short of the gains PANORAMA brings. For instance, PDX applies dimension-batched SIMD with a trivial deterministic BOND lower bound of accumulated distance, without a correction term. Strict PANORAMA is 1.83–9.1× faster than PDX-BOND on all datasets (see table below).

Q3.4 A key distinction [from prior DCO methods] is the deterministic bound (when ε=1\varepsilon = 1), but this setting is not fully supported by the experimental setup.

We added evaluations of the strict mode on all six datasets (Figure 1 and Appendix E).

We revised the novelty claims in Section 3 to credit the form of the bound to DDC and clarify that DDC only estimates the residual term, while PANORAMA calculates a deterministic, analytical, and (in strict mode with ε=1\varepsilon = 1) exact lower bound, while the PCA ordering is optimal for the bound at each prefix and permits a level-major execution.

(Part 2/4)

Q4. ...only Deep and SIFT use ε=1\varepsilon = 1. Can you provide strict-mode frontier curves for the other datasets?

We added strict-mode frontiers for all data sets in Figure 1 (Section 5) and Appendix E (Table 7), also reproduced below.

Strict PANORAMA beats ADSampling, DADE and DDC (including the DDC authors' own AVX-512 build) and the deterministic PDX-BOND at every recall target from 0.80 to 0.99 on all six datasets. The one baseline it does not always beat is PDX with its probabilistic ADSampling pruner, at high recall on the text embeddings (see below). QPS of strict PANORAMA ÷ QPS of each baseline, at matched recall@10 (IVF-Flat, paper parameters, interpolated on each method's Pareto frontier):

Datasetvs.0.800.900.950.980.99
Deepbest of ADSampling / DADE / DDC†2.572.532.552.342.35
SIFT2.132.242.322.422.48
arXiv2.262.522.542.262.19
GIST1.111.261.131.322.42
Ada1.251.361.702.092.30
Large1.071.221.421.661.73
DeepPDX-BOND (deterministic)1.832.011.992.152.26
SIFT2.342.322.182.282.41
arXiv4.514.744.875.085.24
GIST6.167.047.468.339.08
Ada4.254.905.666.166.48
Large4.705.175.266.336.44
DeepFaiss IVF-Flat (SIMD)1.761.932.072.172.36
SIFT2.913.423.683.844.05
arXiv5.326.247.247.408.17
GIST7.528.879.7711.1212.00
Ada4.125.376.968.619.33
Large6.9610.3113.1114.5613.50

† On arXiv, GIST, Ada and Large, DDC is the authors' own release (Res-Infer IVF, built with their flags -Ofast -mavx512f; we confirmed packed 512-bit FMAs in its hot loop), taking the fastest σ\sigma-multiplier at each recall (three on GIST, Ada and Large; one on arXiv). The authors' build was measured on the four high-dimensional datasets; Deep/SIFT use our adapter. Figure 1 now uses the authors' build for the DDC curves; against it, PANORAMA's margin grows with recall.

Range per method over all recall targets 0.80–0.99 (six datasets unless noted): ADSampling 2.40–5.67×, DADE 1.73–3.69×, DDC (authors' build, four datasets) 1.04–2.82×, PDX-BOND 1.83–9.08×, Faiss 1.76–14.56×. Strict PANORAMA also beats PDX with its probabilistic ADSampling pruner at recall 0.80 on every dataset (1.40–2.50×) and at every recall on Deep, SIFT and GIST. At the highest recalls on the text embeddings, PDX is faster by trading exactness for speed. At the paper's ε\varepsilon (IVF-Flat values of Table 5: 1.0 on Deep and SIFT, 0.7 on arXiv and Large, 0.5 on GIST, 0.8 on Ada), PANORAMA matches or beats PDX everywhere (≥ 0.99×).

Strict mode for the other families: IVFPQ strict is 5.0–20.1× Faiss-IVFPQ at matched recall (arXiv, GIST, Ada, Large) and runs at 0.74–0.94× the speed of PANORAMA-IVFPQ at the paper's ε\varepsilon (0.8 on arXiv, GIST and Large; 0.7 on Ada). FastScan+refine strict (arXiv, GIST, Ada, Large) is 1.39–3.50× Faiss FastScan+refine at matched recall 0.80–0.99 and 0.90–0.97× the speed at the paper's ε\varepsilon (0.7; 0.5 on GIST). HNSW (shared Faiss graph, same four datasets) strict is 1.10–3.37× Faiss-HNSW and 0.86–0.97× the speed at the paper's ε\varepsilon (0.7; 0.5 on GIST). Fixed graph: see Q6.

AuthorsOpenReview ↗

Q5, Q6, Q7

(Part 3/4)

Q5. Why is DDC omitted from the graph experiments?

We added the DDC authors' HNSW implementation to the comparison of Figure 3 (Section 5) and to Appendix E.1 (Table 9). We reproduce the details below. It is built with their released code and flags (-Ofast, AVX-512) and the same graph parameters as the other methods (MM = 32, efConstruction = 40). DDC's residual statistics were trained on the learn split, and its σ\sigma-multiplier was tuned on queries, which, if anything, favors DDC. QPS of PANORAMA ÷ QPS of DDC at matched recall@10:

Dataset0.900.940.960.980.99DDC max recall
arXiv2.192.633.013.88–0.989
GIST2.422.762.924.30–0.981
Ada1.552.073.20––0.975
Large1.201.552.224.21–0.983
Deep1.912.292.452.853.720.996
SIFT1.912.072.212.453.160.998

PANORAMA is 1.20–4.30× faster than DDC at recall 0.90–0.99 on every dataset, and the margin grows with recall. DDC's frontier tops out at recall 0.975–0.989 on arXiv, GIST, Ada and Large. We also ran the DADE authors' implementation on a shared graph: PANORAMA is 2.21–3.15× DADE (arXiv, GIST). The revision adds DDC to Figure 3.

Q6. Can you re-conduct the experiment of Figure 8a on the higher-dimensional datasets, Large and Ada?

We added these results to Section 5 (Ablations) and Appendix G (Table 17); we reproduce them below. We used the Fig. 8a protocol: one fixed raw-IVF candidate stream per dataset (recall ≈ 0.90), the same strict scanner with 8 levels, query transform inside the timed region, 3 repetitions. Every arm returns the exhaustive top-10 of its candidates. Throughput relative to raw coordinate order:

DatasetRawDCT-IIHaarPCA
arXiv1.00×1.00×1.00×1.87×
Ada1.00×1.00×0.99×2.28×
Large1.00×0.80×0.83×2.32×
GIST (rerun of Fig. 8a)1.00×1.19×1.17×2.08× (paper: 1.92×)

PCA's advantage carries over to the text embeddings, while the data-independent transforms do not help there (and slow Large down). With the production batched kernel at the paper's LL (Table 5), PCA ÷ raw is 3.68–3.88× on the text datasets (GIST 5.99×).

Related: the fixed-graph strict ablation (Fig. 8c) now covers the text datasets, with identical ordered IDs and recall: arXiv 1.41/1.46×, Ada 1.73/1.81×, Large 1.97/2.09× (GIST 1.43/1.53×; efSearch 64/256). The systems ablation (Fig. 8b) on Ada gives A4/A1 = 4.4×, with identical ordered IDs in every stage; batching alone (A2/A1) gives 3.7×. GIST, re-measured with the same build, gives A4/A1 = 13.2× and A2/A1 = 8.9×. Figure 8b now shows these runs for both GIST and Ada, and Appendix G gives the full numbers (Tables 18 and 19).

Q7. Please report the time complexity of PANORAMA. ... a detailed breakdown into two parts, PCA rotation and dimension scanning, on high-dimensional datasets (e.g., Large and Ada)?

We added the complexity analysis to Section 3 (paragraph "Complexity") and the measured breakdown to Appendix H.1 (Table 22), reproduced below.

Complexity. Let CC be the candidate set, mstop(x)m_{\text{stop}}(x) the number of coordinates read before xx is pruned or completed, and LL the number of levels.

  • Per query: O(d2)O(d^2) for the rotation (one matrix–vector product, or a GEMM for a query batch) + ∑x∈Cmstop(x)+\ \sum_{x\in C} m_{\text{stop}}(x) coordinate operations + O(∣C∣⋅L)+\ O(|C|\cdot L) bound checks. Worst case (nothing pruned): O(d2+∣C∣ d)O(d^2 + |C|\,d), i.e., the cost of exact verification plus one rotation.
  • Offline, once: PCA fit O(nsd2+d3)O(n_s d^2 + d^3) on nsn_s sample rows, database transform O(Nd2)O(N d^2), suffix energies O(Nd)O(N d).
  • Under the paper's spectral model E(m)≃e−αm/dE(m) \simeq e^{-\alpha m/d}, the expected coordinate work per candidate is O(d/α)O(d/\alpha) instead of dd (Section 3).

Measured breakdown (single thread, paper protocol: a batch of 1000 queries, IVF-Flat, nprobe for recall ≈ 0.95 and 0.99, at ε=1\varepsilon = 1 and at the paper's IVF-Flat ε\varepsilon (Table 5: 0.7 on Large and arXiv, 0.8 on Ada, 0.5 on GIST, 1.0 on Deep and SIFT); share of query time):

DatasetRotationCoarse quantizationScan + verification
Large0.40–1.50%0.04–0.11%98.4–99.5%
Ada0.28–0.77%0.06–0.44%99.1–99.7%
GIST0.15–0.41%0.07–0.37%99.4–99.7%
arXiv0.02–0.11%0.04–0.10%≈ 99.8%
Deep, SIFT≤ 0.01%0.19–0.27%99.6–99.8%

For one query at a time (no batching), the rotation is a single matrix–vector product: 0.30 ms on Ada and 1.38 ms on Large. Section 5 now states both costs. The one-time build cost is in our reply to 5QTo Q2 (Ada: 4.7 s PCA fit, 5.1 s database transform).

Reviewer_5QToOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

PANORAMA accelerates the distance verification stage of nearest-neighbor search. Its main verifier orders coordinates using a learned orthogonal basis, processes them progressively, and rejects candidates using a Cauchy-Schwarz lower bound based on the unread suffix energies. The strict setting preserves the exact top-k of a supplied candidate set in the stated arithmetic model; a relaxation parameter trades recall for throughput. The paper develops implementations for contiguous IVF scans, PQ codes, scattered graph candidates, and exact reranking. A separate RaBitQ integration retains the native rotation and scorer, using stored sign counts and a combinatorial suffix bound. Experiments cover six datasets from 96 to 3072 dimensions, multiple index families, matched-recall frontiers, and controlled ablations of the transform and execution strategy.

Critical strengths
  1. A useful verifier with carefully scoped correctness guarantees. The method combines a valid deterministic residual bound with data-adapted coordinate ordering and practical implementations for several index families. The paper distinguishes strict candidate-set correctness from relaxed recall tradeoffs and acknowledges that its main graph integration can alter traversal. The RaBitQ branch is particularly convincing: Appendix C accounts for binary32 arithmetic and guard failures, proves identity relative to the unchanged scorer, and checks exact IDs and distance bit patterns across the evaluated settings. These details make the strict verification contribution credible.
  2. Broad evaluation with meaningful controls and an explicit timing protocol. The experiments use exact-neighbor recall, include query transforms in the timed region, state hardware and threading, and report repeated measurements over six datasets. The fixed-stream transform and systems ablations separate important sources of gain. On the fixed GIST graph, strict verification retains the same ordered results while improving QPS by 1.43x and 1.53x at two search budgets. The paper also reports low-dimensional regressions, unmatched PQ code budgets, and differing graph constructions. This supports a substantive systems contribution within the evaluated CPU setting.
Critical weaknesses
  1. The compressed-index realizations need more complete score and resource accounting. Section 4 does not explicitly state whether IVFPQ total and suffix energies are computed from reconstructed PQ-code vectors or from the original vectors. Orthogonality of the transform alone does not establish a valid lower bound on the asymmetric distance computation (ADC) score after quantization. A precise compressed-score formulation and a strict comparison against the identical fixed PQ scorer would resolve this. The PQ comparisons also use different code budgets on SIFT, GIST, and Large, as the authors acknowledge. Even equal code-byte budgets do not account for the additional suffix-energy sidecar and transformation. Outside RaBitQ, total retained memory and incremental fitting/build costs are not quantified. These omissions limit the practical interpretation of the compressed-search gains.
  2. The marginal benefit of the suffix correction and its transfer to text embeddings are less well isolated. The relevant ingredients have clear precedents in Stepwise, DDC, and PDX, which are appropriately cited. Figure 8 provides valuable controls, but all three ablations use GIST, which has the steepest fitted spectrum. The study does not compare the Cauchy-Schwarz correction with prefix-distance-only pruning while holding the PCA basis, candidate stream, cutpoints, layout, and kernel fixed. Such a comparison on a representative text dataset would establish how much the extra suffix metadata contributes beyond PCA ordering and efficient execution. The cost model is explicitly calibrated from each run and therefore does not independently validate this mechanism across datasets. This limits the evidence for the incremental algorithmic contribution, while leaving the reported overall speedups intact.
Questions for authors
  1. What precise compressed score does the IVFPQ bound lower-bound, and from which vectors are its total and suffix energies computed? At epsilon = 1, does verification reproduce the output of the same fixed PQ index using its ordinary ADC scorer? Please provide the formulation and an output-equality check, distinguishing any floating-point differences.
  2. What are the total retained bytes for each variant, including suffix metadata and the transformation, and the incremental time and peak memory for PCA fitting, transformation, and index construction? For compressed comparisons, can code budget matching be distinguished from total memory matching, with a representative comparison at a common total budget?
  3. With the PCA basis, candidate stream, cutpoints, batching, and SIMD implementation fixed, how much coordinate work and wall clock time does the suffix energy correction save over prefix-distance-only pruning? A strict-mode comparison on one text dataset would complement the existing GIST ablations and materially strengthen the contribution assessment.
3 comments

(Part 1/3)

We thank the reviewer for the precise questions and the time invested to thoroughly review of our work. We answer each question below and report changes in the revised manuscript (in blue).

Q1. [Are] IVFPQ energies computed from reconstructed PQ-code vectors or from the original vectors? ... What precise compressed score does the IVFPQ bound lower-bound, and from which vectors are its total and suffix energies computed? At epsilon = 1, does verification reproduce the output of the same fixed PQ index using its ordinary ADC scorer? Please provide the formulation and an output-equality check, distinguishing any floating-point differences.

All energies are computed from the available data, hence decoded PQ-code data in the IVFPQ case, and the bound lower-bounds Faiss's Asymmetric Distance Computation (ADC) score, with identical output at ε=1\varepsilon = 1. For a candidate xx in list cc with decoded residual r^=decode(code(x))\hat r = \mathrm{decode}(\mathrm{code}(x)), both PANORAMA-IVFPQ and Faiss-IVFPQ compute the score:

ADC(q,x)=∥q−c−r^∥2=∥q−c∥2⏟coarse distance+∥r^∥2+2⟨c,r^⟩⏟stored per vector−2⟨q,r^⟩⏟LUT sums, level by level\mathrm{ADC}(q,x) = \| q - c - \hat r\|^2 = \underbrace{\|q - c\|^2} _ {\text{coarse distance}} + \underbrace{\|\hat r\|^2 + 2\langle c,\hat r\rangle} _ {\text{stored per vector}} - \underbrace{2 \langle q,\hat r\rangle} _ {\text{LUT sums, level by level}}

Whereas PANORAMA-IVFPQ stores ∥r^∥2+2⟨c,r^⟩\|\hat r\|^2 + 2\langle c,\hat r\rangle terms for each candidate vector xx, Faiss-IVFPQ stores the corresponding terms for each of the MM codewords that make up vectors, and aggregates them up for the codeword combination corresponding to each vector xx at query time. After accumulating mm coordinates, PANORAMA-IVFPQ bounds the unread part by the Cauchy–Schwarz inequality:

∑j>mqjr^j≤Rq(m) Rr^(m),Rr^(m)=∑j>mr^j2.\sum_{j>m} q_j \hat r_j \le \sqrt{R_q(m)}\,\sqrt{R_{\hat r}(m)}, \qquad R_{\hat r}(m) = \sum_{j>m}\hat r_j^2 .

Rr^R_{\hat r} is computed at build time from pq.decode(code), and RqR_q from the rotated query.

We added this reply to Section 4 (Eq. 3) and Appendix F.1 (Table 11).

W1. Orthogonality of the transform alone does not establish a valid lower bound on the asymmetric distance computation (ADC) score after quantization.

Yes, orthogonality does not entail a bound, and the bound does not rely on it. The bound follows from the Cauchy-Schwarz inequality applied to the decoded vector, regardless of the preceding transform, so it is valid on the quantized score. For each query, we compare the set of top-10 candidates (i.e., 10,000 {query, neighbor} pairs) and their squared L2 distances (in float32) returned by PANORAMA and Faiss with ε=1\varepsilon = 1, over six datasets and three nprobe values. The returned sets are always identical and identically ordered. We observe a miniscule gap in distance values, which we measure as a unitless ratio of difference relative to the query's 10th-NN distance d10d_{10}: r=∣dPANORAMA−dFaiss∣ / d10r = |d_{\text{PANORAMA}} - d_{\text{Faiss}}| \,/\, d_{10}; the table below shows the median and largest rr over the three nprobe values for each dataset. For reference, float32 resolves relative differences of 2−23≈1.2×10−72^{-23} \approx 1.2\times10^{-7}.

Dataset (nprobe)Queries with identical ordered top-10Median rrMax rr
Deep (8/32/1024)1000/10001.7e-71.1e-4
SIFT (12/64/1024)1000/10002.1e-74.8e-6
arXiv (16/64/256)1000/10004.1e-76.4e-6
GIST (8/24/128)1000/10002.6e-72.1e-5
Ada (4/16/128)1000/10004.8e-71.4e-5
Large (6/24/128)1000/10006.9e-79.4e-6

The median gap is 2 to 9 ULPs (Units in the Last Place or Units of Least Precision), i.e., a few float32 rounding steps. These gaps arise from a natural minor numerical instability, due to the way ADC(q,x)\mathrm{ADC}(q,x) distances are calculated: PANORAMA collects floating-point aggregates level by level, while Faiss sums all distance terms in one pass.

We added the ADC(q,x)\mathrm{ADC}(q,x) formula on decoded residuals to Section 4 (Eq. 3 and the paragraph after it, in blue) and the table above to Appendix F.1 (Table 11).

(Part 2/3)

Q2. What are the total retained bytes for each variant? For compressed comparisons, can code budget matching be distinguished from total memory matching?

First, we need to correct a typo: the IVFPQ comparison in Figure 2 is code-budget matched on all datasets, with both Faiss and PANORAMA using dd-byte codes (M=dM = d, 8-bit); we fixed this typo in Table 5 and added results for Faiss with smaller codes (MM = 32/160/1024 on SIFT/GIST/Large), which preclude high recall: with such smaller codes, in the best case, Faiss's recall@10 reaches 0.714 on SIFT, 0.616 on GIST, and 0.946 on Large. With equal code bytes, PANORAMA-IVFPQ is faster than Faiss-IVFPQ and VAQ across the window on all six datasets. Under matched recall and matched memory, the min/median QPS ratios are as follows (PANORAMA-IVFPQ at the paper's IVFPQ ε\varepsilon from Table 5: 1.0 on Deep, 0.9 on SIFT, 0.8 on arXiv, GIST and Large, 0.7 on Ada):

DeepSIFTarXivGISTAdaLarge
÷ Faiss-IVFPQ1.53 / 1.622.25 / 2.926.28 / 7.839.66 / 11.24.65 / 7.8814.2 / 18.0
÷ VAQ6.70 / 9.56.90 / 9.41.60 / 2.41.85 / 2.41.58 / 2.41.03 / 1.24

Further, the table below shows the total retained bytes per vector; 'padding' refers to the empty vector slots that fill each inverted list up to a multiple of the batch size (1024 vectors for IVF-Flat, 128 for IVFPQ), since PANORAMA stores each list in fixed-size level-major batches; 'transform' refers to the PCA rotation matrix, whose size we count separately as it is computed once for the whole dataset:

Dataset / familyFaissPANORAMAΔof which: sidecar (suffix energies)paddingtransform (d×dd\times d)
Ada IVF-Flat6153 B6684 B+8.6%73 B448 B9.4 MB
Ada IVFPQ1547 B1640 B+6.0%73 B14 B9.4 MB
Large IVF-Flat / IVFPQ12298 / 3085 B13434 / 3286 B+9.2% / +6.5%142 / 133 B952 / 26 B37.8 MB
arXiv IVF-Flat / IVFPQ3080 / 777 B3368 / 852 B+9.3% / +9.6%106 / 69 B181 / 5 B2.4 MB
GIST IVF-Flat / IVFPQ3849 / 970 B4238 / 1053 B+10.1% / +8.3%132 / 69 B253 / 8 B3.7 MB
HNSW (Ada, Large, GIST)+0.6–1.0%36 B0as above

IVFPQ rows exclude the 4 bytes/vector initial distances, which PANORAMA computes at loading time and keeps resident. The resident memory of PANORAMA-HNSW during search is within 1% of that of Faiss-HNSW too. Appendix F.2 (Table 14) provides this table. Besides, Faiss-IVFPQ keeps a precomputed table that stores the ADC term ∥r^∥2+2⟨c,r^⟩\|\hat r\|^2 + 2\langle c, \hat r\rangle for each combination out of nlist\mathit{nlist} centroids, MM subspaces, and 256 codewords. On GIST the size of this table is 128 × 960 × 256 × 4 bytes = 126 MB, i.e., 126 bytes/vector, which are more than PANORAMA's sidecar.

We also compared PANORAMA-IVFPQ against Faiss-IVFPQ with exact refinement (IVFPQR), giving Faiss at least PANORAMA's total bytes on GIST: Faiss-IVFPQR stores 1066 bytes/vector (960 B PQ codes + 96 B refinement codes + 8 B ID + 2.5 B of codebooks and centroids), and PANORAMA-IVFPQ 1053 bytes/vector (960 B codes + 68 B suffix energies + 4 B init-distances + 8 B ID + 8 B padding + 5 B of transform, codebooks and centroids, as in the table above). PANORAMA is 9.1–12.0× faster than Faiss-IVFPQR at matched recall 0.80–0.97 (at both ε\varepsilon = 1 and the paper's ε\varepsilon = 0.8), and still 6.7–7.7× faster than Faiss-IVFPQR at PANORAMA's own maximum recall (0.973–0.974).

The table below presents construction time on Ada (1M × 1536; built with 32 threads, search with 1):

StepTimePeak RAM increase
Faiss IVF-Flat train + add (reference)3.2 s–
Faiss IVFPQ train + add (reference)148.7 s–
PCA fit (exact covariance, 900k rows)4.7 s+0.04 GB
Transform the database5.1 s0 (in place; whole build +0.95 GB)
Suffix energies (1 thread)1.3 s–
Extra add time, IVFPQ (shaping/sidecar)+14.9 s (+14%)–
Query rotation, batch of 1000 (paper protocol)38 µs / query–
Query rotation, one query at a time0.30 ms / query (one matrix–vector product)–
Other five datasetsPCA fit 1.7–2.6 s (dd ≤ 960), 31 s (Large); transform 1.1–16.2 s; extra IVFPQ add +12–14%; rotation one query at a time from 4 µs (Deep) to 1.4 ms (Large)PCA fit ≤ +0.32 GB

On Ada, relative to IVFPQ, PANORAMA adds about 16% to the offline build (other datasets: +14–16%, Large +25%). For IVF-Flat, the one-time overhead is 3–10 s on five datasets and 47 s on the 3072-d Large (mostly the PCA fit). This is paid only once per dataset.

We added the resource tables for all six datasets and both families to Appendix F.2 (Table 14: bytes; Table 15: build and query-rotation cost), the smaller Faiss codes to Table 5 and Appendix F.2 (Table 13), and the IVFPQR total-budget comparison to Appendix F.2 (Table 16).

(Part 3/3)

Q3. How much work and wall clock time does the [Cauchy-Schwarz] suffix energy correction save over prefix-distance-only pruning?

We added this ablation study to Appendix G.1 (Table 20). Everything else being fixed, the suffix energy correction contributes mostly when combined with the ε\varepsilon-relaxation: with ε=0.9\varepsilon = 0.9, it yields 1.09–1.15× over prefix-only pruning; with ε=1\varepsilon = 1 (strict mode), the correction yields a small saving (0.5–2.0% fewer coordinates). The two bounds differ:

  • Prefix-only: prune when ∑j≤m(qj−xj)2≥τ\sum_{j\le m}(q_j-x_j)^2 \ge \tau.
  • PANORAMA: prune when ∑j≤m(qj−xj)2+(Rq(m)−Rx(m))2+2(1−ε)Rq(m)Rx(m)≥τ\sum_{j\le m}(q_j-x_j)^2+(\sqrt{R_q(m)}-\sqrt{R_x(m)})^2+2(1-\varepsilon)\sqrt{R_q(m)R_x(m)} \ge \tau (where the left-hand side rewrites the paper's LBε=∥q∥2+∥x∥2−2pm−2εRq(m)Rx(m)\mathrm{LB}_\varepsilon=\|q\|^2+\|x\|^2-2p_m-2\varepsilon\sqrt{R_q(m)R_x(m)}).
DatasetCoordinates read: PANORAMA ε=1\varepsilon=1 vs. prefix-onlyQPS: ε=1\varepsilon=1 ÷ prefix-onlyQPS: ε=0.9\varepsilon=0.9 ÷ prefix-onlytop-10 at ε=1\varepsilon=1
arXiv−1.2%1.013×1.145× (same top-10)identical
Ada−0.5%1.006×1.092× (same top-10)identical
Large−0.5%1.006×1.115× (same top-10)identical
GIST−2.0%1.026×1.133× (1 query's top-10 differs)identical

The formula indicates the reason for this gap. After PCA, a candidate's and the query's unread energies are nearly equal (median Rx/Rq\sqrt{R_x}/\sqrt{R_q} = 1.00–1.02 on the four datasets), hence (Rq−Rx)2≈0(\sqrt{R_q}-\sqrt{R_x})^2 \approx 0. The stored energies therefore matter in two places:

  1. Relaxation. The term 2(1−ε)RqRx2(1-\varepsilon)\sqrt{R_qR_x} scales with unread energy. With ε=0.9\varepsilon = 0.9 it gives 1.09–1.15× over prefix-distance-only pruning on all four datasets, with the same top-10 on arXiv, Ada and Large (one query differs on GIST). Across ε\varepsilon values, throughput follows the 1/(1+ln⁡ε)1/(1+\ln\varepsilon) law of Appendix B.4.
  2. Validity. In Product Quantization and graph-based search, the inclusion of these energies renders the bound valid for the decoded score.

We clarified this contribution in Section 3 ("Contribution relative to prior DCO-based methods"): our bound is reminiscent of that of the Data-driven Distance Correction method (DDC) [Yang et al., 2025]: both DDC and PANORAMA approximate a query-candidate distance using precomputed squared norms and inner products in a dd-dimensional subspace as dis′=∥q∥2+∥x∥2−2⟨qd,xd⟩dis' = \Vert{} \mathbf{q}\Vert{}^2+\Vert{}\mathbf{x}\Vert{}^2 - 2\langle\mathbf{q}_d,\mathbf{x}_d\rangle, which differs from the exact distance by an unknown residual cross-term 2⟨qr,xr⟩2\langle \mathbf{q}_r, \mathbf{x}_r \rangle in a subspace of r=d−mr=d-m dimensions, and both prune a candidate when its dis′dis' minus a correction term exceeds a threshold τ\tau. However, the two methods differ in that correction term. DDC models ⟨qr,xr⟩\langle \mathbf{q}_r, \mathbf{x}_r \rangle as a zero-mean random variable, assumes independent dimensional fluctuations to obtain its variance as the inner product of the query's squared residual coordinates with precomputed dataset-wide individual dimensional variances, and scales its standard deviation by a multiplier λ\lambda to yield a rough statistical estimate of ⟨qr,xr⟩\langle \mathbf{q}_r, \mathbf{x}_r \rangle as λ⟨qr2,σr2⟩=λ∑i>mqi2σi2\lambda \sqrt{ \langle \mathbf{q} _ r^2, \boldsymbol{\sigma} _ r^2 \rangle } = \lambda \sqrt{ \sum _ {i>m} q _ i^2 \sigma _ i^2}. PANORAMA, on the other hand, uses the geometric product of query and candidate vector residual energies as an analytical correction term that provides a lower bound (in strict mode with ε=1\varepsilon = 1) rooted in the Cauchy-Schwarz inequality: ⟨qr,xr⟩≤∥qr∥2∥xr∥2=(∑i>mqi2)(∑i>mxi2)=Rq(m)Rx(m)\langle \mathbf{q} _ r, \mathbf{x} _ r \rangle \le \sqrt{ \Vert{} \mathbf{q} _ r \Vert{}^2 \Vert{} \mathbf{x} _ r \Vert{}^2 } = \sqrt{ \left( \sum _ {i>m} q _ i^2 \right) \left( \sum _ {i>m} x _ i^2 \right) } = \sqrt{R_q(m)R_x(m)}.

W2a. All ablations use GIST.

Below we present QPS ratios on the same settings as in Fig. 8c on the text datasets, with the HNSW efSearch parameter set to 64 / 256 (Appendix G, Table 19): (also 26pJ Q6)

arXivAdaLargeGIST (paper)
1.41 / 1.461.73 / 1.811.97 / 2.091.43 / 1.53

We included arXiv, Ada, and Large in the transform-only ablation of Figure 8a (where we had only GIST); PCA has an advantage over DCT and Haar on text embeddings too. We also included Ada in the system-components ablation of Figure 8b (where we had only GIST). We present more details and discuss these findings in Appendix G (Table 18).

W2b. The cost model is explicitly calibrated from each run and therefore does not independently validate this mechanism across datasets.

We added a held-out test in Appendix H.2 (Table 23), where we calibrate on other datasets and predict on a held-out one. The median absolute error is 20% in a range of 0.63–1.47× of measured. In Sections 3 and 5, we now present the model only as a qualitative guide rather than an as independent validation.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Looking forward to more engagement

Dear Area Chair,

The single reviewer who responded to our clarifications has increased the score from 2 to 3. As the discussion period is ending soon, we would appreciate any feedback from the other two reviewers on whether their concerns have also been satisfactorily addressed.

Best regards, The authors

Dear Reviewers 5QTo and ACsJ, can you please clarify whether the author response addresses your concerns, and whether that affects your scores?

Participating in discussion period is a part of the duties of the Reviewers.

Thanks in advance.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.