Projection-Optimized Pipelines

• Projection-Optimized Pipelines are workflows that use projection steps to transform data into simpler representations, enhancing optimization and computational efficiency.
• They employ diverse projection techniques—from metric and graph projections to output filters and bit-space mappings—to tackle challenges in scheduling, join processing, and neural compression.
• This systematic approach enables pipeline-wide performance gains and scalability improvements across domains like optimization algorithms, machine learning, databases, and radio imaging.

Projection-Optimized Pipelines denote a broad class of workflows in which a projection step is used to move computation into a representation that is easier to optimize, schedule, evaluate, or solve. In the surveyed literature, the relevant “projection” can be a metric projection onto a convex set, a directed-graph projection into a DAG, a projection-redistribution operator on classifier outputs, a randomized bit projection for compact inference, a projection from pilot-estimated variance components to an evaluation design, a relational projection in join processing, or an optimized projection-function parameterization in Wannierization. This diversity suggests a unifying theme: projections are used not merely as local operators, but as organizing devices for entire pipelines (Censor et al., 2014, Haeupler et al., 6 Apr 2026, Peng et al., 30 Oct 2025, Zhao et al., 2024).

1. Foundational meaning of projection

In the classical optimization literature, projection methods are iterative algorithms that use projections onto sets while relying on the principle that projections onto individual sets are easier to perform than projections onto intersections or other derived sets. For a nonempty closed convex set $C \subset \mathbb{R}^n$, the metric projection is

$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$

The surveyed properties include firm nonexpansiveness, nonexpansiveness, and Fejér monotonicity with respect to the solution set. Inexact projections are also part of the framework: a projection may be replaced by $\tilde P_C(x_k)=P_C(x_k)+e_k)$ under summable or relative-error conditions, while preserving convergence under standard assumptions (Censor et al., 2014).

This foundation supports several canonical algorithmic skeletons. Alternating projections and cyclic POCS compose projectors onto multiple sets; Dykstra’s algorithm augments cyclic projection with per-set residuals to recover the best approximation to an intersection of closed convex sets; Douglas–Rachford splitting uses reflectors $R_C=2P_C-I$ and is especially important for inconsistent feasibility and for links to ADMM; simultaneous, block-iterative, and string-averaging schemes expose parallel structure. The same survey emphasizes that some of these structures are particularly suitable for parallel computing, which is a recurrent theme in later pipeline-oriented work (Censor et al., 2014).

The foundational literature also broadens the meaning of projection beyond Euclidean nearest-point maps. Proximal operators coincide with projections when the objective is an indicator function, and Bregman projections replace Euclidean distance with a divergence

$$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$

This matters for later domains because modern “projection-optimized” workflows often preserve the pipeline logic of classical projection methods—move into a simpler space, solve there, then map back—even when the projection itself is no longer a Euclidean projector in the strict Hilbert-space sense (Censor et al., 2014).

2. Graph projections as algorithmic reductions

A particularly explicit pipeline formulation appears in directed-graph algorithms. A DAG projection of a directed graph $G=(V,E)$ with edge lengths is a DAG $D=(V',E')$ together with a projection map $\pi:V'\to V$ that is a weight-preserving graph homomorphism: for every $(x,y)\in E'$, one has $(\pi(x),\pi(y))\in E$ and $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$0. In the flow setting, a partial projection allows $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$1, where $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$2 denotes dummy vertices used to route capacity and preserve congestion. The central result is that every directed graph with $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$3 vertices and $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$4 edges admits a DAG projection with $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$5 edges that either $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$6-approximates all-pairs distances or $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$7-approximates all-pairs-subset maximum flow, with almost-linear sequential and almost-optimal parallel constructions (Haeupler et al., 6 Apr 2026).

The distance guarantee is one-sided and homomorphism-compatible:

$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$8

for $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$9, width $\tilde P_C(x_k)=P_C(x_k)+e_k)$0, and size $\tilde P_C(x_k)=P_C(x_k)+e_k)$1. The flow guarantee is

$\tilde P_C(x_k)=P_C(x_k)+e_k)$2

The lower bound for flow is obtained by routing flows from $\tilde P_C(x_k)=P_C(x_k)+e_k)$3 through $\tilde P_C(x_k)=P_C(x_k)+e_k)$4, while the upper bound is certified by an explicit projection algorithm that maps flows and cuts from $\tilde P_C(x_k)=P_C(x_k)+e_k)$5 back to $\tilde P_C(x_k)=P_C(x_k)+e_k)$6 with only $\tilde P_C(x_k)=P_C(x_k)+e_k)$7 congestion blow-up (Haeupler et al., 6 Apr 2026).

The construction itself is pipeline-oriented. In the distance case, the paper uses low-diameter decomposition, shortest-path trees, reversed shortest-path trees, induced concatenation of projections, and multi-copy concatenation to absorb reversed edges. In the flow case, it uses a directed expander hierarchy, weak expander decomposition, a cut-matching game for directed graphs, concatenation with dummy nodes, and multi-copy slack scaling. These are not merely proofs of existence: they yield a three-stage computational pattern of projection construction, DAG oracle execution, and projection back to the original graph (Haeupler et al., 6 Apr 2026).

The resulting transfer principle is strong. A general directed-graph pipeline can be rewritten as: construct $\tilde P_C(x_k)=P_C(x_k)+e_k)$8, run the simpler DAG algorithm, then map answers back via $\tilde P_C(x_k)=P_C(x_k)+e_k)$9. The paper uses this to improve $R_C=2P_C-I$0-approximate distance preservers to size $R_C=2P_C-I$1, simplify $R_C=2P_C-I$2-hop-set construction, obtain a randomized $R_C=2P_C-I$3-approximation algorithm for single-source $R_C=2P_C-I$4-bounded max-flow to all $R_C=2P_C-I$5 in time $R_C=2P_C-I$6, and lift simple push-relabel style DAG max-flow algorithms to general directed graphs with only an $R_C=2P_C-I$7 loss. It also reframes open problems by reducing exact directed SSSP to exact undirected SSSP, and exact directed maximum flow to $R_C=2P_C-I$8-approximate maximum flow on DAGs (Haeupler et al., 6 Apr 2026).

3. Output-space and bit-space projections in learned models

In machine unlearning, projection is used as an output-space filter rather than as a retraining primitive. The Modular Projection–Redistribution Unlearning layer views classification training as a sequential process over classes and interprets class unlearning as reversing the last inductive extension. Let $R_C=2P_C-I$9, let $$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$0 be the set of classes to forget, and let $$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$1 be the retained classes. For single-class unlearning, the forget-class direction is estimated from the average confidence vector over forget examples, normalized, and used to define a hyperplane projection

$$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$2

A minimal model-agnostic filter is then

$$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$3

with removed classes zeroed and their mass redistributed over $$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$4. The fuller formulation adds projection, retained-mass rescaling, and normalization so that $$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$5 and $$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$6 (Peng et al., 30 Oct 2025).

This pipeline is explicitly modular. It requires only output access, not retraining, not parameter access, and not full access to the original dataset. The per-sample cost is $$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$7, while the one-time cost of computing the projection operator is $$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$8–$$D_f(y,x)=f(y)-f(x)-\langle \nabla f(x), y-x\rangle.$$9 depending on the size of $G=(V,E)$0. Empirically, the paper reports retraining versus MPRU runtimes of $G=(V,E)$1 versus $G=(V,E)$2 on CIFAR-10, $G=(V,E)$3 versus $G=(V,E)$4 on CIFAR-100, and $G=(V,E)$5 versus $G=(V,E)$6 on Covertype, while maintaining similar outputs to a fully retrained model according to retain accuracy, KL divergence, and MSE analyses (Peng et al., 30 Oct 2025).

ProjectionNet uses projection at a different layer of the pipeline: compact representation learning for on-device inference. It jointly trains a full trainer network and a smaller projection network. The latter applies $G=(V,E)$7 fixed random projection functions, each producing $G=(V,E)$8 bits, so that an example is represented by $G=(V,E)$9 “neural bits.” The projection aggregation and projection-network output are

$D=(V',E')$0

The projections are LSH-based and fixed rather than learned; gradients update only the small head above the bit layer. The joint objective combines label loss for the trainer, a distillation term aligning the projection network to the trainer, and label loss for the projection network, with $D=(V',E')$1, $D=(V',E')$2, and $D=(V',E')$3 (Ravi, 2017).

The computational consequences are concrete. Inference complexity is $D=(V',E')$4, where $D=(V',E')$5 is the observed feature size, and the bit-layer storage is $D=(V',E')$6 plus the classifier parameters. On MNIST, a projection network with $D=(V',E')$7 and $D=(V',E')$8 uses $D=(V',E')$9 neural bits, achieves compression $\pi:V'\to V$0, and reaches $\pi:V'\to V$1 Precision@1; adding a small fully connected layer raises Precision@1 to $\pi:V'\to V$2 at $\pi:V'\to V$3 compression. On a 20-intent semantic classification dataset, an LSTM-ProjectionNet with $\pi:V'\to V$4 bits attains $\pi:V'\to V$5 Precision@1 against $\pi:V'\to V$6 for the full LSTM. The paper frames these results in terms of how many bits are required to capture a trainer’s predictive capacity (Ravi, 2017).

Taken together, these two systems illustrate distinct projection roles within learned pipelines. MPRU is a post hoc output filter that modifies a deployed classifier’s output simplex; ProjectionNet is a training-time and deployment-time student architecture whose internal representation is already projected into bit space. The difference is operational rather than merely mathematical: one pipeline preserves a base model and edits outputs, while the other trains a separate compact inference path (Peng et al., 30 Oct 2025, Ravi, 2017).

4. Pipeline optimization through reordering, variance projection, and schedule feasibility

In machine-learning input systems, projection-optimized design often means pushing size-reducing transformations early and delaying size-increasing work. The cedar framework represents an input pipeline as a DAG of stateless Pipes—maps, filters, batching, decoding, augmentation, normalization, tokenization, and related operators—with explicit dependency and randomness annotations. Its optimizer applies reordering, caching, prefetching, fusion, offloading, and sharding through pass-based graph rewrites. The size model is explicit:

$\pi:V'\to V$7

This makes “projection pushdown” literal for dataflow graphs: filters, grayscale, cropping, and truncation are favored early, while size-expanding transforms such as int8-to-fp32 conversion are deferred. Across six pipelines, cedar outperformed tf.data, Ray Data, and PyTorch DataLoader by $\pi:V'\to V$8, $\pi:V'\to V$9, and $(x,y)\in E'$0 on average locally, and outperformed Ray Data and tf.data service by $(x,y)\in E'$1 and $(x,y)\in E'$2 on average in distributed settings (Zhao et al., 2024).

In LLM evaluation, the same phrase has a statistical meaning. Under the Total Evaluation Error framework, a projection-optimized pipeline is an evaluation design selected to minimize projected total measurement error from a small factorial pilot to a larger fixed-cost study. The design vector is

$(x,y)\in E'$3

for items, prompt variants, judges, temperatures, and replications, and the projection operator is

$(x,y)\in E'$4

The variance model is a crossed mixed-effects decomposition over items, prompts, temperatures, judges, their two-way interactions, and residual noise. Corrected confidence intervals use the full D-study variance rather than naive item-only noise estimates. Empirically, optimized pipelines outperform $(x,y)\in E'$5 of possible naive pipelines against a human baseline, and on MMLU the optimized budget allocation halves estimation error relative to standard single-prompt evaluation at equivalent cost (Messing, 13 Apr 2026).

OptPipe applies constrained optimization to pipeline parallelism for LLM training. It formulates scheduling, activation reuse, offload, and reload decisions as a MILP that minimizes makespan $(x,y)\in E'$6 under per-device memory budgets, compute precedence, and bandwidth constraints. Throughput is expressed as

$(x,y)\in E'$7

and the paper explicitly defines binary offload decisions, continuous start and end times, and serialization variables for compute, offload, and reload channels. Although the core method is MILP rather than gradient projection, the paper gives a “projection view” in which the feasible region is a polyhedron and an infeasible schedule is conceptually projected back into that region by the solver. The empirical result is up to $(x,y)\in E'$8 reduction in idle pipeline time under the same per-device memory limit, with memory-limited examples showing large runtime reductions relative to PipeOffload (Li et al., 6 Oct 2025).

These three cases differ in substrate—data DAGs, evaluation designs, and training schedules—but they share a common pipeline logic. cedar projects a logical graph into a low-cost execution plan; the TEE framework projects pilot-estimated variance components into a budget-constrained experimental design; OptPipe projects candidate schedules into a memory- and dependency-feasible region. In each case, projection is part of global orchestration rather than an isolated operator (Zhao et al., 2024, Messing, 13 Apr 2026, Li et al., 6 Oct 2025).

5. Projection pipelines in databases, electronic structure, and radio imaging

In database systems, projection-optimized design concerns join-project queries, where the final result retains only a subset of the variables in the query body and many witnesses may collapse onto the same projected tuple. The paper on fast join-project evaluation studies queries such as

$(x,y)\in E'$9

and shows that simple projection pushdown in a binary join tree is insufficient. Its algorithm uses a hybrid pipeline: low-degree components are processed with worst-case optimal join algorithms and projected early, while high-degree “heavy” subproblems are rewritten as Boolean matrix multiplications that implicitly deduplicate the projected output. For the two-path query, when the matrix-multiplication exponent is $(\pi(x),\pi(y))\in E$0, the runtime becomes $(\pi(x),\pi(y))\in E$1 if $(\pi(x),\pi(y))\in E$2 and $(\pi(x),\pi(y))\in E$3 if $(\pi(x),\pi(y))\in E$4. The implementation reports improvements of as much as $(\pi(x),\pi(y))\in E$5 over state-of-the-art techniques on dense datasets (Deep et al., 2020).

In electronic-structure theory, optimized projection functions parameterize the Wannierization pipeline. The relevant object is a semi-unitary matrix $(\pi(x),\pi(y))\in E$6, with

$(\pi(x),\pi(y))\in E$7

which defines trial projection functions over a larger orbital pool. The paper derives an exact Euclidean gradient of the Wannier spread functional $(\pi(x),\pi(y))\in E$8 with respect to $(\pi(x),\pi(y))\in E$9, without the standard OPF approximations, by differentiating the SVD of $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$00 and then optimizing on the Stiefel manifold with L-BFGS and retractions. It further augments the trial space with self-projections built from reasonably localized intermediate Wannier functions. Empirically, self-projections yield $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$01–$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$02 extra reduction of $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$03 over OPF-only in challenging entangled cases, and OPF alone already produces spreads within $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$04–$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$05 of fully minimized MLWFs for isolated bands in systems such as c-Si, GaAs, SiO$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$06, Cr$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$07O$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$08, BaSnO$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$09, NaCl, and Si-20 (Tillack et al., 5 Feb 2025).

In radio interferometric imaging, the relevant projection is the $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$10-projection correction for wide-field non-coplanar baselines. The measured visibility satisfies

$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$11

and the $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$12-term is corrected by convolving visibilities with a $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$13-dependent kernel in the $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$14 plane before gridding. The pipeline stages are data loading, preprocessing and $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$15-binning, kernel generation, kernel selection, gridding, FFT, deapodization, and output. The dominant computational cost is gridding at $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$16, with $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$17 the convolution-kernel support. Parallel MPI+OpenMP and MPI+CUDA implementations reduce the runtime of a 15 GB JVLA dataset from $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$18 for single-thread processing to $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$19 and $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$20, respectively, on 10 nodes. The study also reports sharp gridding-time increases when support exceeds about $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$21–$P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$22 pixels and when image size exceeds $P_C(x) = \arg\min_{y \in C} \|y-x\|_2.$23 pixels, and observes that single-precision GPU processing is markedly faster than double precision (Lao et al., 2019).

These examples show that “projection-optimized” can refer to quite different operators: relational projection plus heavy-light decomposition, projection-function parameterization plus self-projections in a variational functional, or a Fourier-domain convolution correcting a geometric phase term. What is constant is the pipeline role of the projection step: it reduces witness multiplicity, improves localization, or restructures the dominant compute kernel (Deep et al., 2020, Tillack et al., 5 Feb 2025, Lao et al., 2019).

6. Common structure, misconceptions, and open directions

A frequent misconception is that projection-optimized pipelines must involve Euclidean nearest-point operators. The surveyed work shows a wider taxonomy. Classical projection methods do use metric, approximate, and Bregman projections onto sets; DAG projections are weight-preserving graph homomorphisms or partial projections with dummy vertices; MPRU uses orthogonal projection onto a hyperplane in output space; ProjectionNet uses fixed randomized LSH projections into bit vectors; join-project evaluation uses relational projection; and the TEE framework uses a projection operator from estimated variance components to a cost-constrained evaluation design (Censor et al., 2014, Haeupler et al., 6 Apr 2026, Peng et al., 30 Oct 2025, Ravi, 2017, Deep et al., 2020, Messing, 13 Apr 2026).

The literature also clarifies that projection does not automatically guarantee end-to-end optimality. DAG projections are randomized and rely on directed low-diameter decompositions or expander hierarchies; deterministic alternatives remain nontrivial, and the strongest exact problems are only reduced to easier settings rather than solved outright (Haeupler et al., 6 Apr 2026). MPRU is explicitly a class-level output filter and offers weaker internal deletion guarantees than full retraining, especially when class representations are entangled (Peng et al., 30 Oct 2025). ProjectionNet compresses aggressively, but performance degrades on tasks with large output spaces and complex visual structure, and the approach does not report hardware latency or energy measurements (Ravi, 2017).

On the systems side, optimizer quality depends on modeling assumptions. cedar’s reordering model assumes per-Pipe latency scales linearly with input size and currently limits reordering to linear subgraphs; OptPipe inherits MILP overhead and sensitivity to inaccurate runtime or bandwidth profiles; in LLM evaluation, corrected confidence intervals depend on mixed-model assumptions, exchangeability of prompts and replications, and a pilot of at least moderate factorial richness (Zhao et al., 2024, Li et al., 6 Oct 2025, Messing, 13 Apr 2026). In database and imaging pipelines, matrix multiplication and GPU acceleration are not universally beneficial: sparse join-project instances often revert to pure worst-case optimal joins, and wide-field gridding becomes sharply more expensive once kernel support or image size crosses empirical thresholds (Deep et al., 2020, Lao et al., 2019).

Open directions are correspondingly domain-specific. DAG projections convert exact directed SSSP and exact directed maximum flow into problems on DAGs or undirected graphs, sharpening where further algorithmic progress is needed (Haeupler et al., 6 Apr 2026). Join-project evaluation currently targets two-path and star queries, and broader acyclic or cyclic query classes require better projection-size estimators and decompositions (Deep et al., 2020). Automatic MLWF generation still depends on the quality of the projector pool, and adaptive projector selection, symmetry exploitation, and spin–orbit coupling remain active extensions (Tillack et al., 5 Feb 2025). The TEE framework notes that multi-turn and multi-agent evaluations are outlined but not fully validated (Messing, 13 Apr 2026).

Across these domains, the common structure is not a single algebra but a recurrent systems principle: select a projected representation in which the dominant subproblem is cheaper, better conditioned, or more parallelizable; perform the main computation there; and preserve enough structure to map guarantees or outputs back to the original task. That principle explains why the same phrase can legitimately describe convex-feasibility algorithms, directed-graph reductions, output filters, compact student networks, experimental-design optimization, database plans, Wannierization, and radio-imaging kernels (Censor et al., 2014, Haeupler et al., 6 Apr 2026, Zhao et al., 2024).