HyperLogLog

in reviewThis lesson is complete and being validated before release - details may still change.

HyperLogLog

Loading interactive demo…

Each bar is a register and its height is the register's rank: the longest run of leading zeros any key in it has shown, plus one. The strip beneath the bars is the current hash's top 16 bits, the index bits first and the coin flips after them. The plot tracks the running estimate against the true distinct count after every item, with 0 exact and the top line double; the model recomputes it from the registers as they fill with the same formula the library uses, because the library itself counts only once, at the end. The last strip is the registers; tap one to read what set it.Take the tour, or press and explore. Legend:

The panel beside the stage is the real HyperLogLog class from the published library executing in your browser, with the current line highlighted.

A register's rank, and a register raised at least once in the strip.
The register the current item lands in, and the bits of its coin flips: the zero run and the first 1.
The hash's top p bits, the index that picks the register.
The register you tapped.
The faint curve is the finished run's estimate against the truth.

items counts what has been hashed so far, repeats included; distinct is the truth so far, which the sketch never stores; estimate and error are the final count and its gap from the truth once the library has read the registers; registers is how many have been raised at least once.

The code panel shows bare executable code by default. The bar above it names the file (hover the name for the full published path); options holds the toggles: comments, the tracer instrumentation that produces this visualization, and verbose names for the terse identifiers (display only: the default is the byte-exact published file). The view switch adds plain-English narration: both interleaves it with the code, pseudo shows only the pseudocode. hide code collapses the panel; the rail it leaves behind brings it back.

Keys: Space play/pause · ←/→ step · Home/End jump · R reset · F fullscreen · G guided tour

The exact answer costs a set. Counting distinct items means remembering which ones you have seen: a hash set grows with the answer, so a billion distinct visitors cost gigabytes. HyperLogLog keeps a handful of registers instead and never stores a key. The price is that the count is an estimate, and the lesson is why the estimate is good.

Leading zeros as evidence. Hash every item to 32 well-mixed bits. Read the bits after the index as fair coin flips: the chance that a hash begins with $k$ zeros followed by a 1 is $2^{-(k+1)}$ , so a run of $r - 1$ zeros, which the stage calls rank $r$ , is a 1-in- $2^r$ event. If you have seen a rank of 5, you have probably seen about $2^5 = 32$ distinct keys. Repeats do not help, and that is the point: the same key gives the same hash and the same rank, so the longest run seen depends only on the distinct keys. The repeats chip shows it directly: every key twice fills the registers exactly as every key once.

One observation is a terrible estimator. A single lucky key with a long run doubles the guess, and ranks only come in powers of two. Flajolet and Martin's fix, kept ever since, is to split the stream into $m = 2^p$ substreams by the hash's top $p$ bits, let each register hold the largest rank its substream has shown, and combine the $m$ guesses. Each register has seen about $n / m$ of the distinct keys, so each guess $2^{M_j}$ is a noisy estimate of $n / m$ , and averaging $m$ of them cuts the noise by about $\sqrt{m}$ .

Why harmonic. LogLog averaged the ranks (a geometric mean of the guesses) and still suffered from outliers; Durand and Flajolet's Super-LogLog threw the largest ranks away before averaging. HyperLogLog averages the guesses $2^{M_j}$ harmonically instead, which tames a single huge guess on its own:

E = \alpha_m \, m^2 \Big/ \sum_{j=0}^{m-1} 2^{-M_j}

A register at 8 contributes $2^{-8}$ to the sum, almost nothing, so it cannot drag the mean up the way it drags an arithmetic mean. The constant $\alpha_m$ corrects the harmonic mean's systematic bias: $0.673$ for 16 registers, $0.697$ for 32, $0.709$ for 64, and $0.7213 / (1 + 1.079 / m)$ beyond. The result has a standard error of about $1.04 / \sqrt{m}$ : a quarter of the truth with 16 registers on this stage, and $0.81\%$ with the $2^{14} = 16384$ registers Redis uses.

Small counts are a different problem. With 24 keys and 16 registers most registers have seen one or two keys, and their ranks are far too coarse to say whether that was one key or two. The default run on the stage ends with 11 registers touched and 5 still at zero, and the raw harmonic estimate is 24.2 for a truth of 24, a lucky landing. The library does not trust it: while the raw estimate is at most $2.5m$ and some registers are empty, it switches to linear counting, which reads the empty registers alone. If $n$ keys fall uniformly into $m$ registers, about $m e^{-n/m}$ stay empty, so $V$ empty registers give $n \approx m \ln(m / V)$ , here $16 \ln(16 / 5) = 18.6$ , 22 percent under. At this scale the error bars of the two estimators overlap; the 2013 paper replaced the hard switch with an empirical bias correction because the seam shows. Push distinct to 48 and the raw estimate crosses $2.5m = 40$ : the method flips to the harmonic mean and lands 20 percent over.

Watch four registers fail. Switch to 4 registers and 48 keys. One register ends at rank 8, a 1-in-256 event, and with only three others to average against, the estimate is 122 for a truth of 48, 155 percent over. With 8 registers the same keys land between 26 percent under and 11 percent over at every count from 24 up, and with 16 between 31 under and 20 over. Nothing about the hash changed; the averaging did. Reseed to see that the error is a distribution: the promise is a standard deviation, not a bound.

Why it is a data structure, not just a formula. Two sketches of the same precision merge by taking the larger register at each position, and the merge is exactly the sketch of the union of the two streams. That is what makes the uniques of a week the elementwise maximum of seven daily sketches rather than a recount, and why distributed systems can count a stream in pieces. The registers need 5 bits each for a 32-bit hash, 6 for a 64-bit one: Redis's 16384 registers at 6 bits are the 12 KB in its documentation.

Where this goes next. The three sketches in this unit answer three questions about a stream the stream is too big to store: a Bloom filter asks whether an item was seen, a count-min sketch how often, and HyperLogLog how many different ones there were. The next lesson leaves the stream and asks a different question of a tree: what if no version of it is ever allowed to change?

Choices worth reading closely in the implementation (the code panel's comments and tracer checkboxes reveal the full published file):

The shift before the count. bucket is hash >>> (32 - p), the top p bits. The rest must be read without them, so rest is (hash << p) >>> 0: the left shift drops the index bits and the unsigned shift keeps JavaScript from reading the result as a negative 32-bit integer, which would make Math.clz32 lie. A rest of all zeros has no first 1, and its rank is 33 - p, one past the longest run the remaining bits can show.
One hash, shared. MixHash is murmur3's finalizer over the key and the seed, the same class the Bloom filter and the count-min sketch use. A sketch is only as good as its hash is uniform; the seed is what Reseed changes, so the same keys land in different registers.
raise or keep, never lower. add compares the rank with the register and writes only when it is higher. The keep branch is the whole idempotence argument in one line: a repeat reaches the same register with the same rank and can never pass the test.
The estimator is private and shared. estimate() computes alpha, the harmonic sum, the raw estimate, and the linear-counting switch once, and both count() and report() call it, so the stage's running curve, which the app recomputes with the same formula after every item, agrees with the final estimate event.
report(distinct) is the scorer. The library never knows the true count; the caller does, because the stage built the stream. run(items) takes it from a Set of the items and emits the verdict, so the error is measured against a truth the sketch itself never stored.
Precision is capped at 6. 64 registers keep every bar readable on a stage; a production sketch uses 12 to 16 bits of index and the same code.

Philippe Flajolet and G. Nigel Martin asked in 1985 how a database could count the distinct values in a column it could read only once, with a hundred words of memory. Their answer was to hash every value and watch its bits: a hash beginning with k zeros is a one-in-2^k event, so the longest run seen hints at how many distinct values passed. Durand and Flajolet shrank the registers to log log bits with LogLog in 2003; in 2007 Flajolet, Fusy, Gandouet and Meunier swapped its geometric mean for a harmonic one and named the result HyperLogLog. Google engineers tuned it for production in 2013.

1985Philippe Flajolet and G. Nigel Martin - 'Probabilistic Counting Algorithms for Data Base Applications' in the Journal of Computer and System Sciences: one pass, a few words of storage, and an estimate that is insensitive to how often each value repeats, aimed at query optimizers.source
2003Marianne Durand and Philippe Flajolet - 'Loglog Counting of Large Cardinalities' at ESA: registers of about log log N bits, 2048 of them counting to 2^27 in about 1.28 KB, with a standard error near 1.05 over the square root of the register count for the Super-LogLog variant.source
2007Flajolet, Fusy, Gandouet and Meunier - 'HyperLogLog: the analysis of a near-optimal cardinality estimation algorithm' at AofA: a harmonic mean in place of LogLog's geometric mean, a standard error of about 1.04 over the square root of m, and LogLog's accuracy in 64 percent of its memory.source
2013Stefan Heule, Marc Nunkesser and Alexander Hall - 'HyperLogLog in Practice' at EDBT, from Google: a 64-bit hash for very large counts, an empirical bias correction for small ones, and a sparse representation that shrinks an almost empty sketch, the variant known as HyperLogLog++.source

Used today

Redis PFCOUNT - PFADD feeds a HyperLogLog and PFCOUNT reads it: up to 12 KB per key for a standard error of 0.81 percent, whatever the count, and PFMERGE unions sketches by taking the larger register.
Unique visitors in analytics - A sketch per page per day counts distinct users without storing their ids, and sketches merge, so a week's uniques are the union of seven days, not a recount.
Cardinality estimation in databases - Approximate distinct counts in query engines and warehouses run a HyperLogLog over a column in one pass, where an exact count would need a hash set the size of the column.

Did you know

The Redis documentation sums the trade up in one line: a HyperLogLog uses up to 12 KB and gives a standard error of 0.81 percent, no matter how many items it has counted.source
Flajolet and Martin wrote in 1985 that their algorithms need only a small additional storage, 'typically less than a hundred binary words', and a few operations per element scanned, and that they are 'by construction totally insensitive to the replicative structure of elements in the file'.source
The 2007 paper's abstract claims that HyperLogLog matches LogLog's accuracy using only 64 percent of the original memory: the whole gain comes from swapping a geometric mean for a harmonic one.source
Durand and Flajolet's LogLog paper received the ESA Test-of-Time Award in 2023, twenty years after it appeared at the same conference.source

precision

distinct24

repeats

seed1

items: 24 of 24
distinct: 24
estimate: 18.61
error: -22%
registers: 11 of 16 touched

hyperloglog.ts

import type { Tracer } from "../trace";import { MixHash } from "./mix-hash";/** The fewest and most index bits a sketch may use: 4 to 64 registers. */export const HLL_MIN_PRECISION = 2;export const HLL_MAX_PRECISION = 6;/** Keys are small non-negative integers so a stage can label them. */export const HLL_MAX_KEY = 999;/** Items one run adds at most, duplicates included, so a stage stays readable. */export const HLL_MAX_ITEMS = 48;export interface HllOptions {  /** Index bits p: the hash's top p bits pick one of m = 2^p registers (default 4). */  readonly precision?: number;  /** Seeds the hash, so the registers follow from the seed and the items alone (default 1). */  readonly seed?: number;}export interface HllReport {  /** The true distinct count of the run's items. */  readonly distinct: number;  /** (estimate - distinct) / distinct, 0 when nothing distinct was added. */  readonly error: number;  readonly estimate: number;  /** The standard error the sketch promises, 1.04 / sqrt(m). */  readonly expectedError: number;  /** Which estimator the count used: linear counting on the empty registers, or the raw harmonic mean. */  readonly method: "linear" | "raw";  readonly precision: number;  /** The registers after the run, bucket order. */  readonly registers: readonly number[];  /** Registers still at 0. */  readonly zeros: number;}/** What one count emits and the report reads. */interface HllEstimate {  readonly alpha: number;  readonly estimate: number;  readonly method: "linear" | "raw";  readonly raw: number;  readonly zeros: number;}/** * A cardinality sketch: m small registers that together estimate how * many distinct keys passed by, without remembering any of them. Each * key is hashed to 32 bits. The top p bits pick a register; the rest is * a run of coin flips, and its rank is the position of the first 1 bit. * A rank of r is a 1-in-2^r event, so the largest rank a register has * seen hints at how many distinct keys fell into it: about 2^rank. * Repeats hash to the same register with the same rank, so they never * move it, which is why duplicates do not inflate the count. The * estimate is a harmonic mean of the registers' 2^rank guesses, scaled * by a constant alpha that corrects the mean's bias. While the sketch is * nearly empty the registers at 0 are the better evidence, and linear * counting (m ln(m / zeros)) takes over. * * Time: O(1) per add, O(m) per count. Space: m registers, each a few * bits, for a count of any size. */export class HyperLogLog {  readonly precision: number;  readonly seed: number;  private readonly m: number;  private readonly registerCount: number;  private readonly mix: MixHash;  private readonly regs: number[];  private readonly registerArray: number[];  constructor(    readonly options: HllOptions = {},    private readonly tracer?: Tracer,  ) {    const precision = options.precision ?? 4;    if (!Number.isInteger(precision) || precision < HLL_MIN_PRECISION || precision > HLL_MAX_PRECISION) {      throw new RangeError(`precision must be an integer in [${HLL_MIN_PRECISION}, ${HLL_MAX_PRECISION}]`);    }    this.precision = precision;    this.seed = options.seed ?? 1;    this.m = 2 ** precision;    this.registerCount = 2 ** precision;    this.mix = new MixHash(this.seed);    this.regs = Array.from({ length: this.m }, () => 0);    this.registerArray = Array.from({ length: this.registerCount }, () => 0);  }  /** Registers still at 0: the evidence linear counting reads. */  get zeros(): number {    return this.regs.filter((register) => register === 0).length;    return this.registerArray.filter((register) => register === 0).length;  }  /** The registers in bucket order, as a copy. */  registers(): number[] {    return [...this.regs];    return [...this.registerArray];  }  /** Hashes a key, picks its register from the top p bits, and raises the register to the rank of the rest if it is higher. */  add(key: number): void {    if (!Number.isInteger(key) || key < 0 || key > HLL_MAX_KEY) {      throw new RangeError(`key must be an integer in [0, ${HLL_MAX_KEY}]`);    }    const p = this.precision;    const indexBits = this.precision;    const hash = this.mix.hash(key);    const bucket = hash >>> (32 - p);    const bucket = hash >>> (32 - indexBits);    // Shift the index bits out so the leading-zero count reads the remaining 32 - p bits only.    const rest = (hash << p) >>> 0;    const rest = (hash << indexBits) >>> 0;    // An all-zero rest is one past the longest run the 32 - p bits can show.    const rank = rest === 0 ? 33 - p : Math.clz32(rest) + 1;    const rank = rest === 0 ? 33 - indexBits : Math.clz32(rest) + 1;    // ▸ hash the item: the top p bits pick a register, the rest is a run of coin flips whose rank is the position of its first 1    this.tracer?.emit("hash", { bucket, hash, key, rank });    const register = this.regs[bucket]!;    const register = this.registerArray[bucket]!;    if (rank > register) {      this.regs[bucket] = rank;      this.registerArray[bucket] = rank;      // ▸ the rank beats what the register holds: the register remembers the new longest run      this.tracer?.emit("raise", { bucket, from: register, key, to: rank });    } else {      // ▸ the rank is no higher than the register: nothing changes, which is why a repeat never inflates the count      this.tracer?.emit("keep", { bucket, key, rank, register });    }  }  /** The distinct-count estimate from the registers as they stand. */  count(): number {    return this.estimate().estimate;  }  /** Adds every item (repeats allowed), counts, and compares the estimate with the true distinct count. */  run(items: readonly number[]): HllReport {    if (items.length > HLL_MAX_ITEMS) throw new RangeError(`a run adds at most ${HLL_MAX_ITEMS} items`);    for (const key of items) this.add(key);    return this.report(new Set(items).size);  }  /** Counts and scores the estimate against a distinct count the caller knows. */  report(distinct: number): HllReport {    if (!Number.isInteger(distinct) || distinct < 0) throw new RangeError("distinct must be a non-negative integer");    const { estimate, method, zeros } = this.estimate();    const error = distinct === 0 ? 0 : (estimate - distinct) / distinct;    // ▸ the estimate beside the true distinct count: the relative error is the sketch's score    this.tracer?.emit("verdict", { distinct, error, estimate });    return {      distinct,      error,      estimate,      expectedError: 1.04 / Math.sqrt(this.m),      expectedError: 1.04 / Math.sqrt(this.registerCount),      method,      precision: this.precision,      registers: this.registers(),      zeros,    };  }  /**   * The estimator both `count` and `report` share. Alpha corrects the   * harmonic mean's bias; the published constants cover 16, 32, and 64   * registers, the closed form the rest. Small counts fall to linear   * counting while registers remain empty.   */  private estimate(): HllEstimate {    const m = this.m;    const registerCount = this.registerCount;    const alpha = m === 16 ? 0.673 : m === 32 ? 0.697 : m === 64 ? 0.709 : 0.7213 / (1 + 1.079 / m);    const alpha = registerCount === 16 ? 0.673 : registerCount === 32 ? 0.697 : registerCount === 64 ? 0.709 : 0.7213 / (1 + 1.079 / registerCount);    let sum = 0;    for (const register of this.regs) sum += 2 ** -register;    for (const register of this.registerArray) sum += 2 ** -register;    const raw = (alpha * m * m) / sum;    const raw = (alpha * registerCount * registerCount) / sum;    const zeros = this.zeros;    const linear = raw <= 2.5 * m && zeros > 0;    const linear = raw <= 2.5 * registerCount && zeros > 0;    const method: "linear" | "raw" = linear ? "linear" : "raw";    const estimate = linear ? m * Math.log(m / zeros) : raw;    const estimate = linear ? registerCount * Math.log(registerCount / zeros) : raw;    // ▸ a harmonic mean of the registers' 2 to the rank guesses, scaled by alpha; while registers remain empty, linear counting reads them instead    this.tracer?.emit("estimate", { alpha, estimate, method, raw, zeros });    return { alpha, estimate, method, raw, zeros };  }}

distinct =: 24
estimate =: 18.61
error =: -22%

24 distinct keys estimated as 18.61 by linear counting, an error of -22%, from registers that remembered no key at all.

import type { Tracer } from "../trace";import { MixHash } from "./mix-hash";/** The fewest and most index bits a sketch may use: 4 to 64 registers. */export const HLL_MIN_PRECISION = 2;export const HLL_MAX_PRECISION = 6;/** Keys are small non-negative integers so a stage can label them. */export const HLL_MAX_KEY = 999;/** Items one run adds at most, duplicates included, so a stage stays readable. */export const HLL_MAX_ITEMS = 48;export interface HllOptions { /** Index bits p: the hash's top p bits pick one of m = 2^p registers (default 4). */ readonly precision?: number; /** Seeds the hash, so the registers follow from the seed and the items alone (default 1). */ readonly seed?: number;}export interface HllReport { /** The true distinct count of the run's items. */ readonly distinct: number; /** (estimate - distinct) / distinct, 0 when nothing distinct was added. */ readonly error: number; readonly estimate: number; /** The standard error the sketch promises, 1.04 / sqrt(m). */ readonly expectedError: number; /** Which estimator the count used: linear counting on the empty registers, or the raw harmonic mean. */ readonly method: "linear" | "raw"; readonly precision: number; /** The registers after the run, bucket order. */ readonly registers: readonly number[]; /** Registers still at 0. */ readonly zeros: number;}/** What one count emits and the report reads. */interface HllEstimate { readonly alpha: number; readonly estimate: number; readonly method: "linear" | "raw"; readonly raw: number; readonly zeros: number;}/** * A cardinality sketch: m small registers that together estimate how * many distinct keys passed by, without remembering any of them. Each * key is hashed to 32 bits. The top p bits pick a register; the rest is * a run of coin flips, and its rank is the position of the first 1 bit. * A rank of r is a 1-in-2^r event, so the largest rank a register has * seen hints at how many distinct keys fell into it: about 2^rank. * Repeats hash to the same register with the same rank, so they never * move it, which is why duplicates do not inflate the count. The * estimate is a harmonic mean of the registers' 2^rank guesses, scaled * by a constant alpha that corrects the mean's bias. While the sketch is * nearly empty the registers at 0 are the better evidence, and linear * counting (m ln(m / zeros)) takes over. * * Time: O(1) per add, O(m) per count. Space: m registers, each a few * bits, for a count of any size. */export class HyperLogLog { readonly precision: number; readonly seed: number; private readonly m: number; private readonly registerCount: number; private readonly mix: MixHash; private readonly regs: number[]; private readonly registerArray: number[]; constructor( readonly options: HllOptions = {}, private readonly tracer?: Tracer, ) { const precision = options.precision ?? 4; if (!Number.isInteger(precision) || precision < HLL_MIN_PRECISION || precision > HLL_MAX_PRECISION) { throw new RangeError(`precision must be an integer in [${HLL_MIN_PRECISION}, ${HLL_MAX_PRECISION}]`); } this.precision = precision; this.seed = options.seed ?? 1; this.m = 2 ** precision; this.registerCount = 2 ** precision; this.mix = new MixHash(this.seed); this.regs = Array.from({ length: this.m }, () => 0); this.registerArray = Array.from({ length: this.registerCount }, () => 0); } /** Registers still at 0: the evidence linear counting reads. */ get zeros(): number { return this.regs.filter((register) => register === 0).length; return this.registerArray.filter((register) => register === 0).length; } /** The registers in bucket order, as a copy. */ registers(): number[] { return [...this.regs]; return [...this.registerArray]; } /** Hashes a key, picks its register from the top p bits, and raises the register to the rank of the rest if it is higher. */ add(key: number): void { if (!Number.isInteger(key) || key < 0 || key > HLL_MAX_KEY) { throw new RangeError(`key must be an integer in [0, ${HLL_MAX_KEY}]`); } const p = this.precision; const indexBits = this.precision; const hash = this.mix.hash(key); const bucket = hash >>> (32 - p); const bucket = hash >>> (32 - indexBits); // Shift the index bits out so the leading-zero count reads the remaining 32 - p bits only. const rest = (hash << p) >>> 0; const rest = (hash << indexBits) >>> 0; // An all-zero rest is one past the longest run the 32 - p bits can show. const rank = rest === 0 ? 33 - p : Math.clz32(rest) + 1; const rank = rest === 0 ? 33 - indexBits : Math.clz32(rest) + 1; // ▸ hash the item: the top p bits pick a register, the rest is a run of coin flips whose rank is the position of its first 1 this.tracer?.emit("hash", { bucket, hash, key, rank }); const register = this.regs[bucket]!; const register = this.registerArray[bucket]!; if (rank > register) { this.regs[bucket] = rank; this.registerArray[bucket] = rank; // ▸ the rank beats what the register holds: the register remembers the new longest run this.tracer?.emit("raise", { bucket, from: register, key, to: rank }); } else { // ▸ the rank is no higher than the register: nothing changes, which is why a repeat never inflates the count this.tracer?.emit("keep", { bucket, key, rank, register }); } } /** The distinct-count estimate from the registers as they stand. */ count(): number { return this.estimate().estimate; } /** Adds every item (repeats allowed), counts, and compares the estimate with the true distinct count. */ run(items: readonly number[]): HllReport { if (items.length > HLL_MAX_ITEMS) throw new RangeError(`a run adds at most ${HLL_MAX_ITEMS} items`); for (const key of items) this.add(key); return this.report(new Set(items).size); } /** Counts and scores the estimate against a distinct count the caller knows. */ report(distinct: number): HllReport { if (!Number.isInteger(distinct) || distinct < 0) throw new RangeError("distinct must be a non-negative integer"); const { estimate, method, zeros } = this.estimate(); const error = distinct === 0 ? 0 : (estimate - distinct) / distinct; // ▸ the estimate beside the true distinct count: the relative error is the sketch's score this.tracer?.emit("verdict", { distinct, error, estimate }); return { distinct, error, estimate, expectedError: 1.04 / Math.sqrt(this.m), expectedError: 1.04 / Math.sqrt(this.registerCount), method, precision: this.precision, registers: this.registers(), zeros, }; } /** * The estimator both `count` and `report` share. Alpha corrects the * harmonic mean's bias; the published constants cover 16, 32, and 64 * registers, the closed form the rest. Small counts fall to linear * counting while registers remain empty. */ private estimate(): HllEstimate { const m = this.m; const registerCount = this.registerCount; const alpha = m === 16 ? 0.673 : m === 32 ? 0.697 : m === 64 ? 0.709 : 0.7213 / (1 + 1.079 / m); const alpha = registerCount === 16 ? 0.673 : registerCount === 32 ? 0.697 : registerCount === 64 ? 0.709 : 0.7213 / (1 + 1.079 / registerCount); let sum = 0; for (const register of this.regs) sum += 2 ** -register; for (const register of this.registerArray) sum += 2 ** -register; const raw = (alpha * m * m) / sum; const raw = (alpha * registerCount * registerCount) / sum; const zeros = this.zeros; const linear = raw <= 2.5 * m && zeros > 0; const linear = raw <= 2.5 * registerCount && zeros > 0; const method: "linear" | "raw" = linear ? "linear" : "raw"; const estimate = linear ? m * Math.log(m / zeros) : raw; const estimate = linear ? registerCount * Math.log(registerCount / zeros) : raw; // ▸ a harmonic mean of the registers' 2 to the rank guesses, scaled by alpha; while registers remain empty, linear counting reads them instead this.tracer?.emit("estimate", { alpha, estimate, method, raw, zeros }); return { alpha, estimate, method, raw, zeros }; }}