Optimize AI Code with Advanced Math

mathguard is the acceleration skill in the algorithm-discipline suite alongside lemmaly (which picks the right classical algorithm first): it kicks in when the classical algorithm is already asymptotically optimal but a math-heavy technique - probabilistic data structures, randomized projections, or algebraic tricks - can beat that floor by accepting bounded approximation or exploiting structure. Use it for large-scale data (n >= 10^6): similarity search, deduplication, top-K/heavy-hitters, streaming analytics, cardinality estimation, embeddings, signal/image processing, polynomial or big-integer arithmetic, graph distance, or computational geometry - loaded only after lemmaly has confirmed the classical answer isn't enough. Do not use it when exact answers are required (auth, billing, dedup-for-correctness, primary keys), n is small (<10^4) on a non-hot path, or the bottleneck is I/O rather than CPU/memory.

The Iron Law: no approximate structure without a written error parameter (ε/δ or false-positive rate) and explicit confirmation the caller can tolerate that kind of wrong answer. Before proposing a technique, the skill requires: declaring exact vs. approximate mode up front; naming the technique precisely (Bloom filter, HyperLogLog, Count-Min Sketch, MinHash+LSH, Johnson-Lindenstrauss projection, FFT/NTT, Karatsuba, Strassen, sweep line, kd-tree/BVH, union-find with path compression, Floyd's cycle detection, Boyer-Moore majority, reservoir sampling, Aho-Corasick, segment tree with lazy propagation, Fenwick tree) rather than describing it vaguely as "a smart approximation"; stating the trade (what it buys - space/time/parallelism - versus what it costs - accuracy, code complexity, dependency, non-determinism); and justifying the asymptotic win with a one-line bound (e.g. "HyperLogLog: count uniques in O(log log n) bits at standard error 1.04/sqrt(m)").

Pre-proposal protocol (all 7 required before code):
1. Classical floor (best non-mathy algorithm + Big-O)
2. Why classical isn't enough
3. Named math technique
4. Exact or approximate (with ε if approximate)
5. New bound with one-line derivation
6. The trade (buys/costs)
7. At least one disqualifier (when NOT to use this)

A playbook table maps problems to techniques: membership testing at scale -> Bloom filter (false positives only, cannot remove); counting distinct stream values -> HyperLogLog (~1% relative error, cannot list elements); top-K/heavy-hitters -> Count-Min Sketch plus a heap.

Use it once a classical algorithm has already hit its lower bound and the problem is large enough (n >= 10^6) or math-heavy enough (signal processing, big-integer arithmetic, geometry) that an approximate or algebraic technique gives a real asymptotic win. Never use it to silently degrade an exact-answer requirement (authentication, billing, primary keys, correctness-critical deduplication) to an approximate one - if no exact win exists and the caller needs exact answers, the rule is to say so and stop, not propose a probabilistic structure anyway. Also disqualified: small n on a non-hot path, I/O-bound bottlenecks, or a team that won't maintain the added complexity.

Input is a computational problem already known to be at its classical algorithmic floor, with its scale (n) and correctness requirements (exact vs. approximate-tolerant). Output is either a named math-heavy technique with its exact error parameter, asymptotic-win derivation, and buy/cost trade-off stated explicitly, or an explicit refusal to propose an approximate technique when the caller needs exact answers.

Works alongside the lemmaly algorithm-discipline suite (lemmaly for classical algorithm selection, complexity-cuts for refactoring slow code, invariant-guard for correctness proofs), applicable to any language or codebase where large-scale or math-heavy computation is being optimized.

Developers and engineers optimizing large-scale or math-heavy computations who need a disciplined way to introduce probabilistic or algebraic techniques (Bloom filters, HyperLogLog, FFT, LSH) without silently trading away correctness guarantees callers depend on.