Optimize AI Code with Advanced Math

mathguard is an escalation skill for math-heavy optimization at scale (n >= 10^6), for use once a classical algorithm is already optimal but mathematics can still give a better bound - usually by accepting bounded approximation, exploiting structure, or moving to a smarter algebraic space. It enforces an Iron Law: no approximate data structure (Bloom filter, HyperLogLog, Count-Min Sketch, MinHash/LSH, t-digest, JL projection, floating FFT) may be proposed without a written error parameter (epsilon/delta) and explicit caller acceptance that they tolerate that kind of wrong answer.

Before proposing any math-level technique, the skill requires a fixed pre-proposal protocol in order: the classical floor and its Big-O, why classical is not enough, the named technique, exact-or-approximate mode with epsilon if approximate, the new bound with a one-line derivation, the trade (what it buys vs costs), at least one disqualifier for when NOT to use it, and the code or pseudocode. It ships a large playbook mapping problem to classical approach to math technique to win to caveat, across six categories: probabilistic sketches (Bloom filter, HyperLogLog, Count-Min Sketch, MinHash+LSH, reservoir sampling, Boyer-Moore majority, t-digest/GK quantiles), fast arithmetic and transforms (FFT/NTT/Karatsuba, fast exponentiation, Euclidean algorithm, Strassen, conjugate gradient), dimensionality reduction (Johnson-Lindenstrauss projection, truncated SVD, randomized SVD), spatial geometry (kd-tree/R-tree/BVH, sweep line, Graham scan, divide-and-conquer closest pair), graph/algebraic tricks (union-find with path compression, Fenwick tree, segment tree, binary lifting, Floyd's cycle detection, monoid parallel reduction), and amortized/online algorithms (doubling, two-heap streaming median, monotonic deque).

import { createHLL } from 'hyperloglog-lite';
const hll = createHLL({ precision: 14 });
for await (const event of stream) {
  hll.add(event.userId);
}
return hll.estimate(); // 49.6M ± 0.4M; dashboard reads ~50M

Use it for large-scale data (n >= 10^6) - similarity search, deduplication, top-K/heavy-hitters, streaming analytics, cardinality estimation, embeddings, recommender systems - or for signal/image processing, polynomial or big-integer arithmetic, convolution, graph distance, and computational geometry, once a gateway skill (lemmaly) has already confirmed the classical answer is not enough. Do NOT use it when the caller needs exact answers (auth, billing, dedup-for-correctness, primary keys), when n is small (under 10^4) on a non-hot path, or when the bottleneck is I/O rather than CPU/memory - the worked example in the skill itself warns that plugging a HyperLogLog estimate into a billing pipeline silently undercounts and skips charges.

Output discipline requires that any code using a math-level technique include: a comment naming the technique with a citation, the exact error parameters chosen and why, a measured or asymptotic justification, and an exact-mode fallback path if the caller might need one. A verification checklist gates shipping: technique named, epsilon/delta documented, caller tolerance confirmed, bound derivation present, at least one disqualifier documented, fallback or exactness-impossibility noted, seed strategy documented if randomized, and downstream exact-consumers audited.

Works alongside two related skills in the same family: lemmaly, the gateway that picks the classical algorithm first, loaded before mathguard; and invariant-guard, for stating epsilon-bounds as part of the postcondition of an approximate algorithm once the technique is chosen. A third related skill, complexity-cuts, applies instead when the bottleneck is CPU/memory on existing baseline code rather than needing an approximation.

Developers and AI coding assistants working on large-scale data systems - streaming analytics, recommenders, similarity search, numeric/combinatorial computation - who need a disciplined, auditable process for introducing probabilistic or approximate algorithms instead of silently degrading correctness or cargo-culting a technique nobody can justify.