fix(precompute): restore HLL delta-vs-full invariant under sparse representation

[zzylol]

Summary

TestHLLWrapper_DeltaNeverLargerThanFull (in asap-precompute-go/sketches/) began failing on a pristine origin/main tree after the sketchlib-go dependency was bumped to the merged in-memory sparse HLL commit (fff038b, sketchlib-go PR #66, "in-memory sparse representation with dense promotion"). Consumed via the local replace => ../../sketchlib-go directive.

Verdict: (B) — the test's assumption is stale. This is a test-only fix. The production delta/serialization path is correct: the min(full, delta) clamp in HLLWrapper.ComputeDeltaAgainst is intact and the real bandwidth invariant holds in every regime.

Evidence (byte numbers across cardinalities)

The failure is not the size invariant (len(payload) > len(full)) — that never triggers. It is the second sub-case's stale expectation that near-empty-base (base=1, +400) must clamp to a FULL frame (isFull == true).

Measured HLLWrapper.ComputeDeltaAgainst payload vs the actual same-state full snapshot:

case	base	extra	same-state full	delta payload	isFull	delta > full?
large-base	20000	+50	16532	88	false	no
near-empty-base	1	+400	957	805	false	no
from0 +1	0	1	153	5	false	no
from0 +100	0	100	398	248	false	no
from0 +4096	0	4096	7445	7295	false	no
from0 +6000	0	6000	10249	10099	false	no
from0 +50000	0	50000	16532	16532	true	no

Before #66 the "full" frame for a low-cardinality sketch was effectively the dense ~16KB register array, and for the base=1, +400 case the register delta exceeded the serialized full frame, so the clamp fired (isFull=true). After #66 the full snapshot is representation-adaptive: that same state now serializes to a 957-byte wire-sparse frame, while the register delta is 805 bytes — genuinely smaller. So ComputeDeltaAgainst correctly keeps the delta (isFull=false) instead of clamping. The test's hardcoded expectation that this specific input forces a full is what broke; the production invariant did not.

The genuine invariant — "the delta path never ships more bytes than the same-state full snapshot" — holds everywhere (delta > full? is always no). The clamp still fires correctly at high cardinality (0, +50000: the delta reaches the dense full size and emits full).

Fix

Rewrote TestHLLWrapper_DeltaNeverLargerThanFull (test only) to:

• assert the size invariant directly against the ACTUAL same-state full snapshot (never a hardcoded dense constant), so it stays correct whether the full frame is sparse or dense;
• pin BOTH clamp regimes without assuming which fixed input lands in which: a small/medium increment must keep a strictly-smaller delta, and a high-cardinality-from-empty delta must grow until it reaches the dense full size and clamp to full.

The original intent (the delta path is never a pessimization vs sending full) is preserved, not loosened.

• Files changed: asap-precompute-go/sketches/hll_test.go (test only; no production code).

Results

• go test ./sketches/ -run HLL — PASS (all 9 HLL tests)
• go test ./sketches/ — ok
• go vet ./sketches/ — clean
• gofmt -l sketches/hll_test.go — clean

Provenance / stacking

• Surfaced from the sketchlib-go benchmark delta transmission with accuracy, bandwidth, memory, cpu usage #66 sparse-HLL merge (fff038b).
• Independent of / stackable with PRs feat(precompute): dual-mode aggregation (per-series vs whole-stream) unified under Mode #471 and feat(precompute): opt-in sparse in-memory HLL for warm aggregators #472.

🤖 Generated with Claude Code