Bloom: Models, Filters & Applications

• Bloom is a multifaceted topic featuring a multilingual autoregressive language model pretrained on 350B tokens for 46 languages, emphasizing post-pretraining adaptability.
• Bloom filters are space-efficient probabilistic data structures optimized for membership queries, enhanced through deletion mechanisms, scalability improvements, and privacy safeguards.
• Bloom also informs cognitively grounded benchmarks and environmental applications like algal bloom mapping, showcasing its diverse impact across NLP, data structures, and remote sensing.

In contemporary technical literature, Bloom denotes several distinct constructs rather than a single unified concept. In natural language processing, BLOOM is a large publicly available multilingual autoregressive LLM from BigScience, with later work extending it to new languages, instruction following, and sentence-embedding use cases (Yong et al., 2022, Hua et al., 2023). In data systems, Bloom most commonly refers to the Bloom filter family, a class of space-efficient probabilistic data structures for approximate membership and its many extensions for deletion, scalability, indexing, privacy, and adversarial robustness (Luo et al., 2018). The term also appears in benchmark design via Bloom’s Taxonomy, as in bilingual multimodal evaluation of vision-LLMs, and in environmental remote sensing through algal bloom mapping (Abootorabi et al., 4 Jun 2026, Lima et al., 15 Jun 2026).

1. BLOOM as a multilingual LLM

BLOOM is a large, open-access multilingual autoregressive LLM whose sizes in the cited work range from 560M to 7.1B parameters. It uses a decoder-only Transformer architecture with ALiBi positional embeddings, layer normalization after embeddings, and a byte-level BPE tokenizer with a vocabulary of 250,680 tokens. It was pretrained on about 350 billion tokens from the ROOTS corpus, covering 46 natural languages and 13 programming languages (Yong et al., 2022).

The model’s original scope was explicitly multilingual, but its pretraining was limited to those 46 languages. That limitation is operationally important because several languages commonly used in multilingual benchmarks, including relatively high-resource languages such as Korean and Russian, were not part of the original pretraining mixture. The cited work therefore frames BLOOM not only as a pretrained foundation model but also as a platform for post-pretraining language extension (Yong et al., 2022).

Within this line of research, BLOOM is treated as a general-purpose multilingual generator whose capabilities can be adapted after pretraining rather than rederived from scratch. A plausible implication is that BLOOM’s significance lies as much in its extensibility as in its original parameterization and training corpus.

2. Post-pretraining extension, instruction tuning, and embedding adaptation

The paper "BLOOM+1: Adding Language Support to BLOOM for Zero-Shot Prompting" studies whether BLOOM can be adapted after pretraining to support languages not originally seen during training. It adapts BLOOM to eight new languages—German, Russian, Bulgarian, Thai, Turkish, Greek, Korean, and Guarani—under a deliberately resource-constrained setup: up to 100K monolingual sentences from OSCAR per language, 30K sentences from the Jojajovai corpus for Guarani, 25K steps, batch size $= 8$, and sequence length $= 1024$. The study does not retrain the tokenizer, relying instead on the byte-level BPE tokenizer’s ability to represent unseen scripts without unknown tokens; the standard 100K-sample condition uses around 204 million tokens (Yong et al., 2022).

The benchmark compares continued pretraining, MAD-X adapters, and $(\mathrm{IA})^3$, with additional appendix comparisons to BitFit, LoRA, FishMask, and Composable Sparse-Finetuning (C-SFT). Zero-shot prompting is evaluated on XNLI, KLUE-NLI, AmericasNLI, XCOPA, XStoryCloze, XWinograd, and PAWS-X, using translated templates and without prompt engineering. The main findings are scale-dependent: for small BLOOM models, especially 560M, continued pretraining gives the best prompting performance, whereas for larger models, roughly 3B and above, adapter-based methods outperform continued pretraining even though they train fewer parameters. The study also reports that prompting performance is not strongly affected by language family, word order, or whether the script was seen in pretraining; the dominant factor is the amount of language adaptation data, with an estimate that roughly 100 million tokens are needed for effective adaptation. It further reports that lower perplexity does not necessarily imply better prompting accuracy (Yong et al., 2022).

The same paper extends BLOOMZ, the multilingual multitask-finetuned version of BLOOM built on xP3, and finds that the best way to teach BLOOMZ a new language is to include that language in the multitask fine-tuning mixture. By contrast, training language adapters on unlabeled monolingual text and applying them to BLOOMZ can hurt instruction-following ability and, on some tasks, degrade performance to near-random. This suggests an important distinction between adding language modeling competence and preserving instruction-following behavior (Yong et al., 2022).

A separate line of work, "LACoS-BLOOM: Low-rank Adaptation with Contrastive objective on 8 bits Siamese-BLOOM," repurposes BLOOM for multilingual sentence embeddings. It combines 8-bit block-wise quantization, LoRA, a Siamese architecture, and a multiple negative ranking (MNR) loss trained on entailment pairs from SNLI, MNLI, and multilingual NLI. The paper reports that BLOOM 7.1B can be run end-to-end on a single 32GB GPU, with the frozen model stored in 8-bit form and less than 1% of parameters trained. It reports STS-Avg. values of 43.62, 59.02, 60.50, and 62.38 for LACoS-BLOOM-560m, 1.1b, 3.1b, and 7.1b respectively, compared with 58.42 for SBERT, and reports strong gains on xSTS, especially under multilingual training (Hua et al., 2023).

3. Bloom filters as approximate membership structures

A Bloom filter is a space-efficient probabilistic data structure for membership queries. In its standard form, it represents a set $S \subseteq U$ using a bit vector of length $m$, initially all zeros, together with $k$ independent hash functions. To insert an element $x$, the filter sets the $k$ positions $\{h_1(x), \ldots, h_k(x)\}$ to 1; to query membership, it checks those same positions. If any queried bit is 0, the element is definitely not present; if all are 1, the element is possibly present. The structure therefore has one-sided error: in the standard form it has no false negatives, but it may produce false positives (Luo et al., 2018, Ke et al., 2 Feb 2025).

The standard false-positive rate is given as

$$f_r = \left[1-\left(1-\frac{1}{m}\right)^{nk}\right]^k \approx \left(1-e^{-kn/m}\right)^k,$$

where $= 1024$0 is the number of inserted elements. The optimal number of hash functions is

$= 1024$1

and with this choice the false-positive rate becomes approximately $= 1024$2. These formulas capture the central Bloom-filter tradeoff: reducing false positives requires memory that grows linearly with $= 1024$3, and practical systems tune $= 1024$4, $= 1024$5, and $= 1024$6 rather than treating them independently (Luo et al., 2018).

The survey literature organizes Bloom-filter design around four recurrent challenges: false positives, implementation cost, elasticity, and functionality. The corresponding optimization directions are to reduce false positives, optimize implementation, represent diverse sets, and enrich functionality. This framing is useful because it shows that Bloom filters are best understood ոչ as a single fixed structure, but as a design family whose members trade off space, speed, functionality, and error guarantees differently (Luo et al., 2018).

4. Optimization, scalability, and extended functionality in the Bloom family

One major line of extension adds functionality to the standard set-membership primitive. The Deletable Bloom filter (DlBF) reserves $= 1024$7 bits for a region bitmap and uses the remaining $= 1024$8 bits as the membership array. Regions marked collision-free are deletable; regions marked as having seen a collision are non-deletable. Deletion clears only bits that lie in collision-free regions, yielding false-negative-free deletions at the cost of reserving part of the bit budget for collision encoding and accepting that some elements may become non-deletable (Rothenberg et al., 2010).

Another line addresses scalability. The survey literature notes that classical Bloom filters are naturally static, while later work introduces scalable and dynamic variants. The paper "scaleBF: A High Scalable Membership Filter using 3D Bloom Filter" proposes scaleBF, which uses multiple 3D Bloom Filters (3DBFs) arranged through a chaining hash structure. The paper states average insertion and average lookup of $= 1024$9, with worst-case $(\mathrm{IA})^3$0 if many keys collide into one chain. Related engineering work also proposes robustBF, a 2D Bloom Filter built from modified Murmur hashing and prime-sized dimensions; that paper reports nearly zero false positive probability with more than $(\mathrm{IA})^3$1 and $(\mathrm{IA})^3$2 lower memory consumption than standard and counting Bloom filters respectively (Patgiri et al., 2019, Nayak et al., 2021).

A further class of extensions generalizes the output of Bloom-style structures. Bloom maps lift approximate membership to approximate static key–value dictionaries. For a static $(\mathrm{IA})^3$3-map, the paper derives a lower bound of

$(\mathrm{IA})^3$4

bits per key in the false-positive-only setting and introduces Bloom maps whose simple construction uses

$(\mathrm{IA})^3$5

bits per key. The entropy term $(\mathrm{IA})^3$6 formalizes that approximate map storage depends not only on the target error rate but also on the value distribution over keys (0710.3246).

When the problem is not a single set but many Bloom filters, the indexing problem becomes multidimensional. Bloofi organizes many Bloom filters in a hierarchical structure akin to a B+ tree, with internal nodes storing the bitwise OR of children; Flat-Bloofi instead packs Bloom filters to exploit bit-level parallelism. Both address the problem of determining which indexed sets may contain a queried element, not merely whether any set does (Crainiceanu et al., 2015). For multiple-set matching with explicit set identifiers, Bloom Matrix and Bloom Vector return sets of item identifiers rather than booleans; the cited work shows that Bloom Matrix is faster for basic ADD and LOOKUP, while Bloom Vector is more space efficient under Zipf-distributed data, motivating Bloom Test as a pre-filter for choosing the appropriate structure (Concas et al., 2019).

Bloom filters also serve as compact control summaries in network protocols. In epidemic forwarding for DTNs, they encode a node’s buffer content so that encountering nodes can avoid redundant packet transmissions. The cited ns-3 study reports that management strategy matters: Strategy B reduces overhead substantially relative to Strategy A, while Strategy C, which adds a second Bloom filter for delivered packets, has the best overall performance and improves congestion relief (Marandi et al., 2012).

5. Verifiable, private, and adversary-aware Bloom structures

Several papers reinterpret Bloom-style structures through cryptographic and privacy-theoretic lenses. The Bloom tree combines Bloom filters with Merkle trees by hashing Bloom-filter chunks into Merkle-tree leaves. This yields probabilistic presence proofs and non-probabilistic absence proofs: when all queried bits are 1, the prover returns the relevant chunks plus a Merkle multiproof; when any queried bit is 0, a single authenticated chunk gives a definitive absence proof. The resulting structure turns a local probabilistic data structure into a remotely verifiable authenticated data structure (Ramabaja et al., 2020).

Privacy-preserving membership is treated explicitly in DPBloomfilter, which applies Random Response independently to every bit of the Bloom filter after insertion. The paper proves $(\mathrm{IA})^3$7-differential privacy by calibrating the per-bit privacy level as $(\mathrm{IA})^3$8, where $(\mathrm{IA})^3$9 is a high-probability bound on the number of bits affected by a neighboring change. Query complexity remains $S \subseteq U$0 and initialization remains $S \subseteq U$1, so the mechanism preserves the standard asymptotic order apart from an additional linear pass over the bit array. The paper also notes the unavoidable tradeoff: as $S \subseteq U$2, the mechanism approaches random guessing (Ke et al., 2 Feb 2025).

Cost-sensitive and adversarial settings motivate more adaptive designs. Hash Adaptive Bloom Filter (HABF) assumes that some negative keys are known in advance and that false positives have unequal costs. It customizes hash functions for selected positive keys, stores those customizations in HashExpressor, and uses a two-round query process that preserves zero false negatives while reducing cost-weighted false positives. The paper formalizes a weighted false-positive objective over negative keys and reports improvements over standard Bloom filters and learned variants in weighted FPR, especially under skewed cost distributions (Xie et al., 2021).

Learned Bloom filters introduce a separate attack surface because an adaptive adversary can probe both the backup filter and the learned model. "Adversary Resilient Learned Bloom Filters" defines learned resilient and learned reveal resilient notions, extends adversarial models such as Always-Bet and Bet-or-Pass to the learned setting, and gives secure PRP-based constructions. Its main theorem states that if pseudo-random permutations exist, then an $S \subseteq U$3-sandwiched learned Bloom filter using $S \subseteq U$4 bits can be transformed into an $S \subseteq U$5-adversarial reveal resilient learned Bloom filter using

$S \subseteq U$6

bits. This closes an open problem identified for adaptive security of learned Bloom filters (Almashaqbeh et al., 2024).

Distribution-aware design provides another axis of adaptation. Daisy Bloom filters treat the input set as drawn from a distribution $S \subseteq U$7 and queries from a distribution $S \subseteq U$8, and assign a different number of hash functions per element, $S \subseteq U$9, depending on $m$0 and $m$1. The paper derives a distributional lower bound and shows an asymptotically tight construction with worst-case constant-time insertions and queries, while also noting that the scheme collapses back to the standard Bloom-filter regime when $m$2 (Bercea et al., 2022).

6. Bloom in cognitively informed benchmarks and algal bloom mapping

Outside language modeling and approximate membership, the term appears in benchmark construction through Bloom’s Taxonomy. BloomBench is described as the first cognitively human-grounded, bilingual English–Arabic multimodal benchmark for vision-LLMs. It contains 7,747 bilingual image–question–answer pairs over 106 task leaf nodes and operationalizes six cognitive levels: Remember, Understand, Apply, Analyze, Evaluate, and Create. The dataset uses a semi-automated pipeline with scenario ideation, VQA generation, multiple-choice conversion, Arabic translation, and a hybrid validation protocol; the reported quality rate on a stratified audit of 969 samples is 98.45% (Abootorabi et al., 4 Jun 2026).

BloomBench’s evaluation methodology uses zero-shot prompting, Regex-based Answer Extraction (RAE), and Likelihood-based Scoring (LBS). The paper reports strong RAE performance ceilings for several models, with Gemma4-31B reaching 89.8% in English and 87.6% in Arabic, but also highlights a pronounced RAE–LBS divergence for some models and a persistent English–Arabic performance gap. Its central conclusion is a cognitive asymmetry: current VLMs are strongest on Understand and Evaluate, but weaker on Remember, Apply, and Create, with the Arabic deficit especially visible in higher-order cognition (Abootorabi et al., 4 Jun 2026).

The environmental sense of the term appears in algal bloom monitoring. The paper "Landsat-Sentinel-2 Algal Bloom Mapping Using Vision Transformers" presents a global coastal bloom patch dataset and compares ResUNet, Vanilla Vision Transformer, Swin Transformer, SegFormer, and Prithvi for fine-scale bloom detection. Training data were built from 225 high-algal-occurrence coastal regions, with 15,421 images initially screened and 660 bloom scenes retained; the final dataset contains 24,265 training patches and 12,255 validation patches, each 256 × 256 pixels. In the main benchmark, ResUNet achieves the highest F1 at 0.58, and Swin Transformer is the best transformer-based model at 0.57. The paper further reports that under cloud and sunglint stress, the Swin Transformer avoids the widespread false positives produced by NDVI and FAI, and that the 30 m Landsat-Sentinel product resolves fragmented bloom structures not captured by 1 km MODIS-derived products (Lima et al., 15 Jun 2026).

Taken together, these research usages show that Bloom functions as a technically dense label across multiple subfields: as a multilingual foundation model and its adaptations, as a mature and rapidly diversifying family of probabilistic data structures, and as an organizing principle or application term in multimodal benchmarking and environmental sensing. The commonality is not a shared mechanism but a shared role as a compact name for well-developed research programs with distinct formal objects and evaluation regimes.