Appendix A: Formula Sheet

00-START-HERE · 01-READING-ROUTES · 41_end_to_end_design_drills · A2_question_bank This appendix is a compact derivation and interview-use guide for eight formula groups used in Retrieval-Augmented Generation (RAG) that preserves the source equations, numeric examples, conditions, and rules of thumb while translating Best Matching 25 (BM25), Reciprocal Rank Fusion (RRF), Mean Reciprocal Rank (MRR), normalized Discounted Cumulative Gain (nDCG), modularity, Product Quantization (PQ), floating-point operations (FLOPs) with latency, and end-to-end index memory into operational decisions.

TL;DR

• Carry units through every derivation. Most design-round arithmetic failures are unit failures.
• Cross-check each result against a published rule or a known system before defending it.
• BM25 separates inverse document frequency, term-frequency saturation, and document-length normalization.
• RRF rewards agreement without requiring comparable scores, while MRR and nDCG measure different ranking goals.
• Modularity compares connectivity with a degree-preserving expectation, while PQ obtains exponential combinations from linearly many centroids.
• FLOP, key-value cache, and Low-Rank Adaptation arithmetic turn model choices into latency and memory budgets.
• Index capacity must include vectors, identifiers, graph links, rebuild headroom, replication, text payload, and metadata.

The story

Treat the appendix as a cockpit checklist for a RAG design interview. A number such as $3.38680485\times10^{13}$ becomes a compute quantity only when labeled FLOPs. Dividing it by an assumed achieved FLOP/s rate gives an idealized compute time, not a latency benchmark. BM25 separately shows rarity, saturation and document-length effects. RRF is the sensor combiner. It merges rank signals without pretending that a lexical score and a cosine score share a scale. MRR is the first-hit warning light. It cares only about the first relevant result. nDCG is the ranked-load gauge. It keeps graded relevance and gives later useful results nonzero credit. Modularity is the route-map gauge. It asks whether a proposed community has more internal connection than degree alone would predict. PQ is the cargo compressor. It splits one large vector into smaller subspaces, stores a modest codebook for each, and represents combinations it never stores explicitly. The FLOP and latency panel converts model size, token count, context length, cache shape, and adapter rank into time and memory. The final capacity card counts everything loaded on the aircraft. Vector bytes alone are not the fleet. Identifiers, graph links, replication, rebuild copies, text payload, and metadata all travel too. A safe pilot can rebuild every reading when a constraint changes. Memorizing the final number without its units, condition, and sanity check is not enough. After two weeks of preparation, continued reliance on the card is a reason to re-derive each formula rather than re-read it.

Decoder table

Core mechanics

Mathematical conventions

Use decimal units $1\,\mathrm{GB}=10^9\,\mathrm B$ and $1\,\mathrm{TB}=10^{12}\,\mathrm B$; binary units are explicitly $1\,\mathrm{KiB}=2^{10}\,\mathrm B$ and $1\,\mathrm{MiB}=2^{20}\,\mathrm B$. Keep full precision until the reported result and use $\approx$ for rounding or a compute/storage model. Natural logarithms are written $\ln$; DCG uses $\log_2$. Ranked lists have positive integer ranks and a declared tie rule, identity/deduplication policy and depth. Define missing-hit and zero-IDCG behavior. Modularity below is for an undirected unweighted graph with $m\gt 0$ edges, including diagonal null-model terms; optimization is heuristic, not a global-optimum certificate. Compute is a dense-model FLOP proxy, not measured latency. Attention architecture, causal masking, achieved throughput, batching, memory traffic, communication and queueing matter. Storage equations are scoped byte ledgers: count only applicable index components, distinguish expected allocated link slots from realized links, and state which artifacts are replicated or rebuilt. A ceiling of aggregate bytes is a capacity lower bound, not a deployable shard/replica plan.

A.1 BM25

Formula and symbols

Section $18.3$ derives BM25, which scores one query-document pair by summing over query terms.

Here $\mathcal T(q)$ is the set of distinct analyzed query terms; repeated-query weighting is omitted. Require $N\ge1$, $0\le n_t\le N$, $\mathop{\mathrm{avgdl}}\nolimits\gt 0$, $k_1\gt 0$ and $0\le b\le1$. This shifted natural-log IDF is positive even for a term in every document; it is not the unshifted Robertson IDF. The source defaults are:

Define the dimensionless length ratio and adjusted denominator term as:

At $b=0$, document length is ignored. At $b=1$, the length ratio is charged in full.

Plain-language mechanics

IDF raises rare terms. TF saturation gives the first few occurrences most of the benefit. Length normalization changes the saturation denominator instead of applying a hard score penalty. The two knobs are independent. $k_1$ controls saturation speed. $b$ controls length sensitivity.

Worked saturation grid

At average document length, $\ell=1$, and $k_1=1.2$, the TF factor becomes:

The second occurrence adds $0.375$. Ten additional occurrences, from $f=10$ to $f=20$, add approximately $0.111186$, about $29.65\%$ of that second-occurrence increment. The final column is the limit, not a finite-frequency score.

Worked length normalization

For a document twice the mean length with one term occurrence:

The TF factor is approximately $29.0323\%$ below its average-length, one-occurrence value of $1$. The length adjustment acts inside the denominator; the percentage is the resulting score-factor decrease, not a denominator discount.

Conditions, failures, and rules

• Treat $k_1=1.2$ and $b=0.75$ as example starting values, not universal implementation defaults or optima.
• A lower $b$, such as $0.3$, can be tested when length reflects additional useful content. Document genre alone does not determine the best value.
• The unshifted IDF $\ln((N-n_t+0.5)/(n_t+0.5))$ is negative above half the collection. The displayed shifted form is positive and must not be confused with flooring the unshifted form.
• BM25 and hybrid retrieval remain baselines to evaluate on the actual relevance task, including exact entities and rare terms.

A.2 Reciprocal Rank Fusion

Formula and symbols

Section $21.6$ derives RRF, which assigns one reciprocal contribution for every list that contains document $d$.

A missing document contributes nothing. This is equivalent to sending its rank to infinity. The conventional default is:

Within one list, rank $r$ has weight relative to that list’s first result:

That ratio is exactly one-half at:

For $L$ equal-weight lists and $k\ge0$, assume a document is present at the same rank $r$ in every list. Compare it with a competitor present only at rank $1$ in one list:

Plain-language mechanics

RRF combines ranks rather than claiming comparable raw scores. Require $k+r\gt 0$ and consistent document identity. Raising $k$ flattens within-list weights; it does not establish that agreement is independent or correct. Correlated lists can repeat the same error. Unequal list weights or different ranks need their actual sums, not the equal-rank shortcut.

Worked crossover cases

With two lists and $k=60$:

Under that equal-rank comparison, a common document at rank $61$ or better in both lists beats the competitor present only at one list’s first position. At rank $62$ the scores tie. List depth must be sufficient to observe those ranks. With two lists and $k=0$:

Against a competitor present only at one list’s first position, strict victory requires a common rank of $1$. A common rank-$2$ item ties it. This inequality does not imply that all $k=0$ RRF rankings reduce to interleaving the list heads. With three lists and $k=60$:

Conditions, failures, and rules

• Treat $k=60$ as a common evaluated convention, not a derived optimum.
• Use RRF when rank aggregation suits the task; normalized score fusion is an alternative to validate, not something justified by normalization alone.
• Fusion depth $100$ followed by a final depth $10$ is an example. Tune candidate coverage, latency and judged quality together.
• Shallow lists may hide useful consensus. An added weak or correlated list may also promote errors; extra agreement is not an automatic quality gain.

A.3 Mean Reciprocal Rank

Formula and symbols

Section $32.2$ derives Reciprocal Rank, which depends only on the first relevant result for query $q$.

Here $r_q$ is the first relevant rank, $K\ge1$ is the evaluation cutoff, and the query set is nonempty. MRR averages those per-query values; multiple relevant items are permitted but only the first contributes:

A missing relevant result in the evaluated prefix receives zero. Unbounded MRR uses a declared complete ranking or another explicit missing-hit convention.

Plain-language mechanics

MRR asks one question: how far down is the first relevant document? It ignores every relevant result after the first.

Worked examples

A ten-document list with relevant results at ranks one and ten has:

A list with only one relevant result at rank one receives the same score. The following calculation is not MRR:

It sums every relevant hit and divides by list length. A metric that changes when a second relevant document appears cannot be RR for that query.

Rank $2$ earns half the rank-$1$ reciprocal credit. Rank $5$ still earns $0.2$ and rank $10$ earns $0.1$; calling these “failure” is a task judgment, not a property of the formula.

Conditions, failures, and rules

• MRR suits first-success objectives even when several relevant items exist. It is not a complete multi-evidence retrieval metric.
• Report cutoff, relevance criterion, query denominator and tie handling.
• Pair rank metrics with recall and, for multi-hop RAG, coverage of the full sufficient evidence set. “At least one gold hit” and “all required evidence retrieved” are different events.
• The value of a rank improvement versus a recall improvement depends on the downstream task and costs.

A.4 nDCG

Formula and symbols

Section $32.2$ derives the ranking metrics, beginning with Cumulative Gain, which ignores order.

Discounted Cumulative Gain divides each grade by a log-rank term.

Normalize by IDCG computed from the same nonnegative gain function, cutoff and judgment universe. For positive IDCG:

Under those conditions, and with the ideal ordering formed from the same candidate/judgment universe:

Plain-language mechanics

CG ignores position and DCG discounts later gains. The $+1$ makes rank $1$ undiscounted under $\log_2$. IDCG uses a declared judgment universe, ideally all available relevant judgments rather than just the returned items. A score of $1$ means an ideal ranking relative to that universe; it does not prove exhaustive labeling of the corpus. For zero IDCG, explicitly exclude the query or assign a stated convention such as zero.

Worked discount grid

At rank 10, DCG still assigns $0.289$ while RR assigns $0.100$. A useful document at rank four or five retains material credit.

Gain choice and judgment conditions

The displayed formula uses direct relevance grades. An alternative uses exponential gain:

Exponential gain emphasizes higher grades more strongly, but does not make ordinal labels cardinal ground truth. State gain, cutoff and averaging. Treating unjudged items as zero gain is a common evaluation policy, not evidence of non-relevance; shallow pools can bias comparisons.

Conditions, failures, and rules

• Report cutoff, gain function, relevance judgments, zero-IDCG policy and macro/micro averaging.
• Binary nDCG and graded nDCG are different metrics. Choose exponential gain only when that weighting matches the objective.
• Pair reranker nDCG with retrieval recall at a declared candidate cutoff, and evaluate end-to-end evidence sufficiency.
• nDCG can penalize missing judged relevant documents as well as poor ordering. Recomputing IDCG only from returned hits can conceal retrieval failure.

A.5 Modularity

Formula and symbols

For an undirected unweighted graph with $m\gt 0$, the following is standard modularity at resolution $1$. Louvain and Leiden are optimization heuristics; neither name alone guarantees a global maximum.

Here $m$ counts undirected edges once, the sum over $i,j$ is ordered and includes the diagonal, $A_{ij}$ is binary adjacency, and $k_i$ is node degree. The delta selects pairs assigned to the same community. The configuration-model expectation is:

Modularity therefore measures connectivity beyond chance at fixed degree. It does not measure absolute connectivity.

Worked four-node partition

Nodes one, two, and three form a triangle. Node four has one edge to node three.

For partition A, the triangle and singleton contributions are:

Thus:

For partition B, all four nodes are together.

The modularity gain is:

For these two partitions, adding the dangling edge changes a tie into a $0.03125$ preference for merging. This does not claim that the selected partition is uniquely optimal over all partitions.

Conditions, failures, and rules

• Under the standard assumptions in the Leiden analysis, completed iterations provide connected-community guarantees that Louvain lacks. They do not guarantee semantic coherence or a globally optimal partition.[1]
• The modularity null model uses whole-graph degrees and edge count. Updates can change optimal partitions outside the edited neighborhood, but do not force every community to change or every implementation to rebuild globally.
• Compare GraphRAG and LightRAG maintenance policies and measured workloads; global modularity alone proves no universal cost ordering.
• Generic relations can distort communities, while capping them can remove useful evidence. Audit the effect rather than assuming semantic value always collapses.
• Modularity has a resolution limit, but no universal internal-edge cutoff guarantees absorption at every hierarchy level. A more precise pairwise merge condition is:

Here $e_{AB}$ counts edges between two communities and $K_A,K_B$ are their degree sums. For a single bridge and equal degree sums, merging is favorable when $K_A=K_B\lt \sqrt{2m}$. Translating that into internal-edge counts depends on external degrees; the classic symmetric examples have a $\sqrt{m/2}$ scale. Resolution and hierarchy choices can change the outcome.[2]

A.6 Product Quantization sizing

Formula and symbols

Section $16.1$ derives Product Quantization. Split a $d$-dimensional vector into $m$ subvectors, each with width:

For equal subspaces, require positive integer $m$ dividing $d$. With $k=2^{b_{\mathrm{sub}}}$ centroids, each sub-code uses $b_{\mathrm{sub}}$ bits and total packed code length is:

The number of representable vectors is:

The number of stored centroids is:

Each centroid has dimension $\frac{d}{m}$, so fp32 codebook memory is:

For fixed $k$, $d$ and centroid precision, this shared codebook payload is independent of $m$. That is not true if changing $m$ changes $k$, adds transforms or adds per-subquantizer metadata. In a deliberately simplified operation count, building the query lookup table costs $2kd$ and each candidate lookup costs $m$, versus $2d$ for a direct distance. The equality break-even is:

candidate distances, provided $2d\gt m$. Strict savings require more candidates than $N^*$. Cache behavior, SIMD, residual/coarse-distance tables and actual kernels can change the measured break-even.

Why the mechanism compresses

Representable combinations grow as $k^m$. Stored centroids grow only as $k\times m$. This asymmetry is the compression mechanism.

Worked 768-dimensional design

Start with:

One fp32 vector uses:

The PQ code uses:

Compression is:

Representable combinations are:

Stored centroids are:

The codebook contains $196{,}608$ fp32 values and occupies:

This is $786.432\,\mathrm{kB}=768\,\mathrm{KiB}$. The source’s “$768\,\mathrm{kB}$” label must not be treated as a decimal-unit equality. The break-even candidate count is:

Equality occurs at a noninteger count, so the first whole candidate count with strict savings is $274$ in this proxy. A list shorter than that may not amortize the table on its own; aggregating probes and reusing tables depends on the implementation. The rounded $273$ is not the strict threshold.

Why one codebook loses

A single $b$-bit codebook needs:

For $b=32$ in 768 dimensions:

This is the full-centroid payload for a hypothetical single $32$-bit codebook in $768$ dimensions, not $32$ bytes per vector. A claim of “400 times the corpus” needs a specified corpus size and representation; it does not follow from codebook size alone.

Conditions, failures, and rules

• Default to $k=256$, which gives one byte per subvector.
• Choose $m$ to divide $d$ evenly and meet the byte budget.
• A common starting point is:

• Keep $k$ and centroid precision fixed when claiming codebook independence from $m$.
• At $k=256$, code storage is $m\,\mathrm B$ per vector, before identifiers and other structures. A Faiss IVF-PQ posting normally adds an eight-byte identifier.[3]
• The Faiss warning default is $39$ training points per centroid; at $256$ centroids this is $9{,}984$ original training vectors, projected into each subspace. It is a warning heuristic, not a statistical guarantee or $9{,}984m$ distinct required source vectors.[4]

A.7 FLOPs and latency

Compute formulas

For a dense Transformer, count a multiply-add as two FLOPs and use $N$ as an approximate active parameter count. The usual parameter-matmul proxies are:

Generation has no backward pass, but its $2N$ parameter-matmul proxy omits context-dependent attention, memory bandwidth, batching effects and other overhead. MoE active parameters, tied embeddings and architecture details need their own ledger. For an idealized causal prefill over $s$ tokens, counting both attention matrix products over all causal pairs, a compatible proxy is:

The second term is quadratic and approaches $2L_{\mathrm{layers}}s^2d_{\mathrm{hidden}}$ for large $s$. Full bidirectional attention instead uses approximately $4L_{\mathrm{layers}}s^2d_{\mathrm{hidden}}$. Real kernels may exploit masking and attention variants differently. Doubling context adds a superlinear attention component but does not double every serving cost.

Memory formulas

Weight memory is:

Nominal payload bytes per scalar are $4$ for fp32, $2$ for bf16, $1$ for int8 and $0.5$ for packed int4. Quantization scales, zero points, alignment, unquantized layers and runtime state are additional. KV cache per token is:

Multiply by cached tokens and independent request sequences when no prefix sharing applies. Count allocated pages, variable lengths, sliding windows, tensor-parallel placement and cache precision separately. LoRA trainable parameters for one adapted matrix are:

Worked weight and cache examples

Treating the nominal “27B” parameter count as exactly $27\times10^9$ for illustration gives this fp32 weight payload:

An $80\,\mathrm{GB}$ usable device budget cannot hold that fp32 payload. The same rounded-count payload is $54\,\mathrm{GB}$ at bf16 and $27\,\mathrm{GB}$ at int8 before quantization metadata, KV cache and runtime overhead; it is not an all-in fit guarantee for a named checkpoint. For Llama $3.1$ 8B with 32 layers, eight key-value heads, head dimension 128, and bf16:

A 2,048-token context uses:

per concurrent request. The source labels this $256\,\mathrm{MB}$ even though its KiB-based arithmetic yields $256\,\mathrm{MiB}$.

Worked latency examples

For an 8B model with 32 layers, hidden size $4{,}096$, and context $2{,}048$:

At the stipulated achieved throughput $3.4\times10^{14}\,\mathrm{FLOP\,s^{-1}}$, the compute proxy is:

For a nominal $110$-million-parameter cross-encoder over $50$ total query-document pairs of $256$ tokens each, parameter-matmul work alone is:

At the same stipulated throughput, before attention and all serving overhead:

Worked LoRA example

Use rank 16 adapters on query and output projections of size $4{,}096$ by $4{,}096$ across 32 layers:

The corresponding two full square projections per layer contain $4{,}096^2\times2\times32=1{,}073{,}741{,}824$ parameters. Comparing only those adapted matrices:

Conditions, failures, and rules

• Prefill is often compute-limited at useful batch sizes; low-batch decode is often memory-bandwidth-limited. These are regimes to measure, not universal identities.
• Extra context affects prefill, KV capacity and decode attention/traffic. It need not leave decode tokens/s unchanged.
• The illustrative $99.611907\,\mathrm{ms}$ prefill and $8.282353\,\mathrm{ms}$ linear-only rerank use one stipulated rate. They are not observed wall times.
• LoRA reduces trainable adapted-matrix parameters by $128$ here, not total-model training FLOPs or total GPU memory by that factor.
• Size weights, cache and runtime for target concurrency and utilization. There is no universal two-to-three-times conversion from peak to achieved throughput.

A.8 Index memory, end to end

Per-vector and total formulas

Sections $16.5$ and $15.2$ derive total index memory and the HNSW link term. Per-vector data bytes are:

Posting identifiers use:

Under independent geometric HNSW layer allocation $\Pr(\ell\ge j)=M^{-j}$, four-byte neighbor slots, $2M$ base slots and $M$ slots per allocated upper layer, the expected slot payload is:

This graph term is zero for a plain IVF index, but not necessarily for an IVF coarse quantizer that itself uses HNSW. Layer counters, offsets, actual containers and unused slot capacity are not covered by the expression. Include only the structures present in the chosen implementation; a separate posting ID can be absent when positions supply identity. For IVF/PQ indicators and a remainder covering transforms, precomputed tables, maps and metadata:

For $R$ live index copies and index-only rebuild overlap fraction $h_I$, payload replication $R_P$ and payload rebuild fraction $h_P$, one explicit fleet ledger is:

HNSW link derivation

Layer zero stores up to:

The expected number of allocated upper layers is a geometric tail sum, not an exact layer count for every node:

At $M=32$:

The base-layer-only slot payload is $256\,\mathrm B$ at $M=32$. The expected upper-layer addition is approximately $4.129032\,\mathrm B$, or $1.612903\%$ of that base payload. This is not a complete all-in Faiss memory rule. The next table deliberately compares only vector/code and base-layer slots; IVF adds its stated posting IDs.[3]

Ten-million-vector comparison

Use 10 million chunks and $d=768$.

The compressed-HNSW subtotal has $128/192=2/3$ of its bytes in base-layer links. With this link allocation fixed, sending vector payload to zero can reduce that subtotal by at most $192/128=1.5$ further. Link widths and topology can be redesigned, so “incompressible” is not an information-theoretic claim. A four-byte-ID toy IVF-PQ posting would be $100\,\mathrm B$ and $1.00\,\mathrm{GB}$, unlike the eight-byte Faiss posting.

Rebuild, replication, and payload

If a full old and new index coexist in the declared capacity domain, index-only overlap can require:

A separate build host moves that memory elsewhere in the fleet. A target reserve such as the following is a planning assumption, not a consequence of hot swapping:

At $400$ tokens/chunk, stipulate four UTF-8 bytes/token, not merely four Unicode characters/token. Uncompressed text then uses $1{,}600\,\mathrm B=1.6\,\mathrm{kB}$ per chunk. At $10^7$ chunks:

Metadata at $200\,\mathrm B$ per chunk adds $2\,\mathrm{GB}$, giving an $18\,\mathrm{GB}$ payload before compression, object overhead and additional copies. Using only the $1.04\,\mathrm{GB}$ Faiss posting subtotal, two live copies, full index-only rebuild overlap, two payload copies and no payload rebuild gives:

If the $18\,\mathrm{GB}$ payload is instead one shared resident copy, the corresponding subtotal is $2\times2\times1.04+18=22.16\,\mathrm{GB}$. The old $22\,\mathrm{GB}$ figure additionally used the four-byte-ID toy $1\,\mathrm{GB}$ index. All versions omit remaining index/runtime memory; neither proves fit or availability.

Conditions, failures, and rules

• Separate capacity, per-query service demand, traffic, replication and failover. Chapter 41’s ceiling estimates are lower bounds rather than a claim that a fixed two-node cluster suffices.
• Aggregate-memory ceiling division gives only:

• Shards are logical partitions; replicas are copies. Aggregate bytes alone do not assign partitions, traffic or failure domains.
• Text can dominate after compression, but the crossover depends on chunk size, representation, compression and replication; “30 times” is not universal.
• State identifiers, graph slots, codebooks, coarse centroids, rebuild overlap, payload copies and runtime. A $32$-fold vector-code reduction is not a $32$-fold whole-fleet reduction.

Diagrams

Source visual accounting is 0 figures and 0 tables in the manifest. The source contains display equations and unnumbered numeric grids, not captioned source visuals. This appendix preserves those items as equations and Markdown grids without inventing figure or table numbers.

Whiteboard pack

What to draw

1. Draw a ranking lane with BM25, RRF, MRR, and nDCG in source order.
2. Under BM25, split IDF from saturating and length-normalized TF.
3. Under RRF, draw two ranked lists meeting at the crossover inequality.
4. Under MRR and nDCG, contrast first-hit credit with graded log-discounted credit.
5. Draw modularity as observed adjacency minus degree-based expected adjacency.
6. Draw one vector split into $m$ PQ subspaces and label $k^m$ versus $k\times m$.
7. Draw compute, weight, KV cache, and LoRA formulas as a model-serving block.
8. Finish with the memory stack: vector, id, links, centroids, replicas, rebuild, payload.
9. Add units to every intermediate value and circle each independent sanity check.

Spoken script

Start with lexical scoring and rank aggregation, then first-hit and graded ranking metrics. State gain, cutoff and missing-judgment policy. Draw modularity as observed connectivity minus a degree-based expectation, with no semantic or global-optimum guarantee. Next show PQ code bits, shared codebooks and scoped memory. Convert model FLOPs into an idealized compute time only under a declared achieved rate. Add attention, weight precision, KV cache and adapter parameters. Finish with a ledger for index structures, payload replication, rebuild copies and runtime; byte ceilings are capacity lower bounds, not deployment plans.

Interview traps

1. Why is a numerically correct answer still wrong?

A value without units, scope, or achieved hardware rate is not defensible. Track bytes versus bits, decimal GB versus KiB, per-token versus per-request cache, per-vector versus fleet memory, and FLOPs versus FLOPs per second. State which local meaning of $N$, $k$, $m$, $b$, or $Q$ applies before substituting.

2. Which ranking formula is being misused?

BM25 length normalization belongs inside the saturation denominator, while RRF uses ranks because source scores are incomparable. MRR reads only the first relevant result, whereas nDCG needs a cutoff, gain scale, and judgment-pool caveat. Diagnose the objective before tuning a constant.

3. Which sanity ablation exposes a false metric or graph claim?

Add a second relevant hit after rank $1$: RR remains $1$. Permute unequal grades: CG stays fixed while DCG can change. Remove the dangling edge from the four-node graph: both displayed partitions then have modularity $0$, a tie rather than a forced reversal. Generic relations may still yield communities, but semantic quality requires its own audit.

4. Why did compression or latency miss the estimate?

For PQ, check whether codebook memory was confused with per-vector codes and whether $m$ divides $d$. For latency, use achieved rather than peak FLOPs per second and include quadratic attention. For index memory, add identifiers, HNSW links, rebuild overlap, replicas, payload, and metadata because a 32 times vector compression does not imply 32 times fleet compression.

5. What claim limits must be said aloud?

The RRF constant is a convention, not an optimum. nDCG needs positive IDCG or an explicit zero-IDCG rule. Modularity has graph- and resolution-dependent limits. The toy PQ operation model gives $N^*\approx273.066667$ and first strict integer saving at $274$. The compute times use unrounded arithmetic and one assumed rate; metadata, payload copies, model architecture and batching can change the answer.

Key numbers

00-START-HERE · 01-READING-ROUTES · 41_end_to_end_design_drills · A2_question_bank