SIEVE: A Multidisciplinary Filtering Paradigm

• SIEVE is a polysemous concept referring to methods that filter, approximate, or select information through structured exclusion, with applications across number theory, statistics, and computing.
• In number theory, sieve methods estimate the size of integer sets by systematically removing integers with prescribed prime factors using combinatorial, analytical, and semidefinite techniques.
• In econometrics and computer science, SIEVE approximates infinite-dimensional objects and manages resources via finite, scalable models, delivering tangible performance and accuracy improvements.

SIEVE is a polysemous term in contemporary research. In analytic number theory, it denotes families of procedures that estimate the size of sets after removing integers with prescribed prime divisors, ranging from Selberg’s lower bound constructions to combinatorial, large, and larger sieves (Franze, 2010). In statistics and econometrics, “sieve” denotes the approximation of an infinite-dimensional object by a finite-dimensional family whose dimension grows with sample size (Luo et al., 4 May 2026). In computer systems and machine learning, “SIEVE” is also used as a system name for workload-aware filtered vector search, microservice metric reduction and dependency extraction, parser-free security-log querying, and dynamic expert-aware scheduling for MoE inference (Li et al., 16 Jul 2025). Across these settings, the term consistently refers to structured elimination, approximation, or selection, although the formal objects being filtered differ substantially.

1. Number-theoretic foundations

In the classical sieve framework, one starts from a finite sequence of integers or weighted integers $A$ with total mass $X$, a set of primes $P$, and the sifted sum

$$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$

The objective is to bound $S(A,P,z)$ in terms of $X$, $z$, and the distribution of $A$ across residue classes. A multiplicative model writes $|A_d|=X/f(d)+R_d$, with sieve dimension $\kappa$ defined by

$X$0

For the $X$1 sieve, Franze computes explicit sifting limits for integral dimensions $X$2 and reports that for integral $X$3 the $X$4 sieve gives strictly smaller $X$5 than the Diamond–Halberstam–Richert combinatorial sieve, hence stronger sifting at the threshold $X$6 (Franze, 2010).

The continuous sieve function $X$7 entering this analysis is defined by the differential–difference equation

$X$8

with

$X$9

The lower bound ultimately takes the form

$P$0

and positivity of the associated integral functional yields a positive lower bound of size $P$1 (Franze, 2010).

A distinct but related development is the semidefinite formulation of sifting problems. “A Semidefinite Framework for the Sieve” recasts upper-bound sieve arguments as an SDP over cones of feasible Gram matrices and dual cones of matrices whose relevant submatrices are positive semidefinite. In that framework, the Large Sieve appears as a special case, and, with an additional nonnegative-entry matrix, the Larger Sieve also fits the same template; the paper explicitly states that no new sieve-theoretic bounds are proved (Brady, 2021). This reformulation replaces scalar sieve weights by matrix certificates and emphasizes mechanically checkable PSD constraints rather than co-NP-hard sieve-weight inequalities.

The term also extends to classification problems about when a sieve behaves as predicted. “When the sieve works” studies sets of primes $P$2 for which sieving by $P$3 leaves roughly the expected number of integers, with the decisive condition expressed through reciprocal-prime mass in intervals such as $P$4. Theorem 1 there gives a lower bound of the expected order even when the sieving set includes primes in $P$5, a regime beyond the reach of classical lower-bound sieve theory (Granville et al., 2012). This suggests that additive-combinatorial structure can substitute for traditional “level of distribution” hypotheses when the sieving primes extend above $P$6.

2. Prime sieves and explicit arithmetic algorithms

The sieve of Eratosthenes remains the canonical example of a prime sieve, but several papers develop highly optimized or structurally modified variants. “An improved sieve of Eratosthenes” gives a method to sieve up to $P$7 in space $P$8 bits and time $P$9, and to factor all integers up to $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$0 in space $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$1 bits and time $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$2 (Helfgott, 2017). Its key device is a short working interval of length $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$3 together with Diophantine approximation and local linearization of $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$4, so that only those divisors $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$5 capable of having a multiple in the current interval are scheduled.

“Two Compact Incremental Prime Sieves” studies compactness and incrementality simultaneously. It introduces the rolling sieve, which uses $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$6 bits and runs in $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$7 time, and it shows how to modify the Atkin–Bernstein sieve to obtain a sieve that is compact and $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$8-incremental, thereby solving an open problem of Pritchard from 1994 (Sorenson, 2015). The rolling sieve maintains a circular array of stacks indexed by a moving window; when the stack at the current position is empty, the corresponding integer is either prime or a prime square, and square detection triggers the insertion of a newly discovered prime into future positions.

At the implementation level, “Cache optimized linear sieve” addresses the loss of locality caused by large primes. Its central idea is to process the sieve table in cache-sized segments and to organize large primes into cyclic “circles” and “buckets,” so that only those primes that actually hit the current segment are touched (Járai et al., 2011). The arithmetic complexity remains that of Eratosthenes, but the memory behavior becomes much more robust on slow memory systems because the segment is streamed once and prime metadata are handled by in-place bucket-sort.

For prime-gap computation, “Combined Sieve Algorithm for Prime Gaps” exploits massive concurrency across regularly spaced intervals $$S(A,P,z)=\sum_{n\in A,\ (n,P(z))=1} a_n,\qquad P(z)=\prod_{p\in P,\ p<z} p.$$9. It precomputes $S(A,P,z)$0, uses 64-bit arithmetic for small $S(A,P,z)$1, and for large $S(A,P,z)$2 solves a modular inequality that enumerates exactly those $S(A,P,z)$3 for which the interval contains a multiple of $S(A,P,z)$4. The paper states that the cost is proportional to the number of enumerated factors, that the new sieve “regularly runs 10,000x faster” when handling many intervals concurrently, and that the higher sieve limits accelerate large-prime-gap search by $S(A,P,z)$5–$S(A,P,z)$6; two top-10 record merit prime gaps were found during development (Troisi, 2020).

A more conceptual line treats Eratosthenes’ sieve itself as a discrete dynamical system. “Eratosthenes sieve supports the $S(A,P,z)$7-tuple conjecture” studies the cycles of gaps $S(A,P,z)$8 among generators modulo the primorial $S(A,P,z)$9, proves that every admissible instance of every admissible constellation of gaps arises and persists in the sieve, and shows that the population dynamics are consistent with the Hardy–Littlewood estimates for admissible constellations (Holt, 27 Feb 2025). The paper introduces primorial coordinates as a compact notation for tracking admissible instances.

3. Specialized sieves in group theory, random structures, and sparse sensing

The language of sieving also extends far beyond ordinary prime sieves. In finitely generated groups, Lubotzky and Meiri formulate a general sieve based on random walks on Cayley graphs and families of finite quotients. A subset $X$0 is called exponentially small when

$X$1

for the simple random walk $X$2 on any admissible generating multiset. Their principal application shows that if $X$3 is a finitely generated non virtually-solvable linear group of characteristic zero, then the set of proper powers is exponentially small (Lubotzky et al., 2011). The mechanism combines property $X$4, strong approximation, and a group large sieve inequality across congruence quotients.

In random graph theory, sieve terminology appears in a probabilistic-incidence form. “Sieve Methods in Random Graph Theory” applies the simple sieve and the Turán sieve to bound the probability that $X$5 has diameter $X$6, and similarly for diameter $X$7 in bipartite graphs. For a fixed pair $X$8 in $X$9, the “bad” event is that $z$0 is absent and $z$1 have no common neighbor, which has probability

$z$2

From this, the simple sieve yields a lower bound

$z$3

while the Turán sieve yields a complementary upper bound based on pairwise overlaps (Liu et al., 2018). The paper emphasizes that the two bounds “almost completely” complement each other.

A specialized arithmetic construction is Weber’s twin-prime sieve. Here the sieve variable is not the prime itself but the twin rank $z$4 in a candidate pair $z$5. For each odd prime $z$6, there are exactly two non-rank residue classes modulo $z$7, equivalently two arithmetic progressions $z$8 and $z$9, and the positive integers are partitioned into twin ranks and non-ranks (Weber, 2012). The paper states that the sieve “has no parity problem” because it excludes exact congruence classes corresponding to divisibility of $A$0, rather than relying on weighted cancellations sensitive to the parity of the number of prime factors.

In compressed sensing, the Reed–Muller Sieve is a deterministic sensing matrix whose columns are obtained by exponentiating codewords in the quaternary second-order Reed–Muller code. For $A$1 rows and $A$2 columns, the column indexed by a symmetric matrix $A$3 has entries

$A$4

with arithmetic modulo $A$5. The paper states that for $A$6 the Reed–Muller Sieve removes the need for independence among signal entries in support identification, enables local detection with complexity $A$7, and yields average-case $A$8 error bounds tighter than the $A$9 and $|A_d|=X/f(d)+R_d$0 bounds associated with random and expander-based ensembles (Calderbank et al., 2010).

4. Sieve estimation in statistics and econometrics

In nonparametric statistics, a sieve is a sequence of finite-dimensional approximation spaces used to estimate an infinite-dimensional target. “Simultaneous Inference for Nonlinear Time Series, a Sieve M-regression Approach” formulates this explicitly as

$|A_d|=X/f(d)+R_d$1

with basis dimension $|A_d|=X/f(d)+R_d$2. The paper develops a uniform Bahadur representation for sieve M-estimators under temporal dependence, a convex Gaussian approximation for convex events, and a self-convolved bootstrap for simultaneous confidence regions over the predictor domain (Luo et al., 4 May 2026). Under the stated assumptions, it permits $|A_d|=X/f(d)+R_d$3 to grow at polynomial rates and derives loss-specific Bahadur remainders such as $|A_d|=X/f(d)+R_d$4 for quantile loss and $|A_d|=X/f(d)+R_d$5 for Huber, least-squares, and expectile losses.

The same paper treats a broad class of convex losses, including quantile, Huber, $|A_d|=X/f(d)+R_d$6, and expectile losses, and states that for $|A_d|=X/f(d)+R_d$7 the simultaneous critical value satisfies $|A_d|=X/f(d)+R_d$8 (Luo et al., 4 May 2026). A plausible implication is that the sieve formulation is being used not merely for consistency or pointwise asymptotics, but as an organizing device for global inference under dependence.

In structural econometrics, “A Sieve-SMM Estimator for Dynamic Models” uses a sieve to approximate an unknown shock density by a Gaussian-and-tails mixture family. The estimated dynamic model matches sample and simulated empirical characteristic functions, while the sieve dimension $|A_d|=X/f(d)+R_d$9 grows with sample size under the restriction

$\kappa$0

The construction is explicitly semiparametric: the finite-dimensional structural parameter $\kappa$1 is estimated jointly with the infinite-dimensional shock distribution represented by the sieve (Forneron, 2019). The paper argues that this matters empirically because welfare and asset-pricing quantities depend on the full shock distribution rather than only on low-order moments.

The econometric application reports that allowing non-Gaussian shocks through the sieve can reduce estimated relative risk aversion in a production economy from approximately $\kappa$2 to approximately $\kappa$3, with a reported $\kappa$4 confidence interval of $\kappa$5 in the abstract (Forneron, 2019). This suggests that, in this literature, “sieve” is inseparable from robustness to misspecification rather than merely from approximation theory.

5. Systems named SIEVE in computing and machine learning

A prominent recent use of the name is “SIEVE: Effective Filtered Vector Search with Collection of Indexes.” The system addresses filtered vector search under hard predicates by building many predicate-specialized ANN indexes rather than constraining traversal inside a single HNSW-like graph. It uses a three-dimensional analytical model over index memory size, search latency, and recall; a workload-aware greedy packing algorithm chooses which indexes to materialize under memory and build-time budgets; and at query time the model selects the fastest index meeting the target recall (Li et al., 16 Jul 2025). The paper reports up to $\kappa$6 speedup, build-time overhead as low as $\kappa$7 relative to a single global HNSW build, and total memory at most $\kappa$8 that of a standard HNSW graph.

Another system called Sieve operates in observability for microservices. “Sieve: Actionable Insights from Monitored Metrics in Microservices” first reduces metrics within each service by clustering time series with k-Shape after variance filtering, then extracts directed metric dependencies across communicating services using Granger causality. It reports metric reduction by at least an order of magnitude, specifically $\kappa$9–$X$00, while preserving “statistical equivalence,” and monitoring-overhead reductions of CPU $X$01, storage $X$02, and network $X$03 (Thalheim et al., 2017). The learned reduced metric set and dependency graph are then used for autoscaling orchestration and root-cause analysis.

In security operations, “Parser-Free Querying of Security Logs” presents Sieve as a system that generates executable query code from natural-language security questions using one LLM call plus deterministic execution over raw logs. The system grounds the model with lightweight context extracted from templates or sampled lines, then executes the generated Python or Bash under a sandbox and retry loop (Luo et al., 21 May 2026). Evaluated on $X$04 security queries across $X$05 log types, it achieves “over a $X$06 reduction in error rate on complex temporal and cross-event queries” relative to manual analyst scripting.

For mixture-of-experts inference, “Sieve: Dynamic Expert-Aware PIM Acceleration for Evolving Mixture-of-Experts Models” uses runtime token-to-expert distributions to partition experts between GPUs and attached HBM-PIM stacks. Its scheduler minimizes

$X$07

thereby jointly accounting for communication, GPU execution, and PIM execution (Kim et al., 11 May 2026). On a cycle-accurate simulator, the framework improves both throughput and interactivity by $X$08, $X$09, and $X$10 on Qwen3.5-397B-A17B, GPT-OSS-120B, and Qwen3-30B-A3B, respectively.

6. Cross-cutting interpretation and disciplinary divergence

Despite the diversity of objects involved, the term “sieve” is used with notable consistency. In number theory it filters integers or residue classes by divisibility constraints; in group theory it filters random-walk trajectories through finite quotients; in random graphs it filters objects by forbidden local configurations; in compressed sensing it filters support locations through structured measurements; in nonparametric estimation it filters an infinite-dimensional parameter space through finite-dimensional approximants; and in systems papers named SIEVE it filters indexes, metrics, log formats, or experts under resource constraints (Lubotzky et al., 2011). This suggests a shared conceptual core: a sieve is a mechanism that imposes structured exclusion while preserving enough combinatorial or statistical information to count, reconstruct, or optimize what remains.

The same word, however, marks fundamentally different proof techniques and guarantees. Selberg’s $X$11 sieve, the semidefinite large-sieve framework, and Weber’s twin-rank sieve are exact arithmetic constructions with explicit multiplicative factors and inclusion–exclusion structure (Franze, 2010). Sieve M-regression and sieve-SMM are approximation schemes whose guarantees are asymptotic and depend on basis growth, empirical process control, and bias–variance tradeoffs (Luo et al., 4 May 2026). By contrast, systems named SIEVE in computer science use analytical cost models, template extraction, or runtime scheduling; their evaluation criteria are latency, recall, monitoring overhead, error rate, or throughput rather than asymptotic counting functions (Li et al., 16 Jul 2025).

A common misconception is that all sieves are variants of the sieve of Eratosthenes. The research record does not support that reduction. Eratosthenes remains central for prime generation and its optimized descendants, but the term now covers lower-bound and upper-bound analytic sieves, semidefinite relaxations, probabilistic large-sieve principles in groups, deterministic sensing matrices, nonparametric estimation architectures, and several unrelated systems acronyms (Helfgott, 2017). The encyclopedia meaning of SIEVE is therefore not a single method but a family of filtering paradigms whose exact semantics are discipline-specific.