Papers for

machine learning system builders

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Follow the regularized leader may fail to find solutions in constrained problems

Follow the Regularized Leader Does Not Converge in Constrained Optimization

Abstract: Follow the regularized leader (FTRL) is a foundational algorithm in online learning whose regret properties have been extensively studied for decades. However, in stark contrast to mirror descent---and gradient descent in particular---the convergence of FTRL to first-order stationary points in constrained nonconvex optimization was not well understood. In this paper, we show that continuous-time FTRL can fail to converge even asymptotically in infinitely smooth constrained optimization problems: its Karush-Kuhn-Tucker (KKT) gap can remain bounded away from zero indefinitely. This is especially surprising in light of the fact that continuous-time FTRL guarantees a monotonic improvement of the objective value. As a result, we establish that non-convergent behavior of no-regret dynamics---which besets general variational inequality problems---can occur even in potential systems. From a technical standpoint, our construction relies on an infinitely differentiable function where the gradient flow dynamics exhibit decelerating oscillations without ever converging pointwise, which we in turn embed into higher-dimensional FTRL dynamics that sustain a perpetually large KKT gap. We complement our negative result by showing that FTRL with Euclidean regularization does converge when the objective function is analytic. This shows that the analytic property plays a more fundamental role for FTRL than for gradient flow: it governs not only pointwise convergence, but convergence to first-order stationarity itself.

Mon 26 OctComputer Science and Game Theory
The gist
The paper finds that a popular algorithm called Follow the Regularized Leader (FTRL), used to make decisions step-by-step, can sometimes get stuck and never settle on a good solution in tricky problems with constraints. This is surprising because the algorithm always seems to improve the goal over time, yet it doesn’t actually reach a proper stopping point. The authors show this happens even in very smooth problems and explain why by studying mathematical examples where the algorithm oscillates endlessly. They also show that if the problem is especially nice (analytic), then FTRL does settle down properly.
Open → 2610.35004v1

Asymmetric sample use improves likelihood-free hypothesis testing efficiency

Asymmetric Likelihood-Free Hypothesis Testing

Abstract: In likelihood-free hypothesis testing (LFHT), given samples from two unknown distributions $P,Q$ on $[n]$ with $\mathrm{d_{TV}}(P,Q)\geq\varepsilon$, and from a third distribution $D\in\{P,Q\}$, the goal is to identify whether $D=P$ or $D=Q$. We study asymmetric likelihood-free hypothesis testing, where the sample budgets $s_P$ and $s_Q$ for $P$ and $Q$ may differ, and characterize the feasible triples $(s_P,s_Q,s_D)$ up to logarithmic factors. We establish that unequal reference budgets can give a polynomial saving. For instance, for constant separation, $n$ samples from $P$ and $n^{3/4}$ from $Q$ allow testing with $\widetilde O(n^{1/4})$ samples from $D$, whereas both existing baselines---symmetric LFHT and unequal-sample closeness testing---require $Ω(\sqrt n)$ samples from $D$. We further apply our results to non-adaptive distribution 2-clustering, where the sample allocation among $k$ distributions must be fixed before observing any data. We obtain matching upper and lower bounds for this problem up to logarithmic factors in terms of the domain size, number of distributions, smaller cluster size, and separation, both with one cluster distribution known and with both unknown. Comparing with known bounds for adaptive sample allocation gives a worst-case adaptivity gap of $\widetildeΘ(k^{1/4})$.

Wed 21 OctMachine LearningData Structures and AlgorithmsInformation Theory
The gist
The paper studies a way to tell apart two unknown groups by only looking at examples from each, even when you can take different numbers of examples from each group. The authors found that using unequal amounts of data from the known groups can make it easier to identify which group a new example belongs to. Their method uses fewer examples in some cases compared to previous approaches. They also show how these findings can help in grouping many unknown distributions when you decide how to divide your samples before seeing any data.
Open → 2610.29798v1

Approximate message passing works under mild entry variability conditions

Universality of approximate message passing under a fourth-moment tail condition

Abstract: We prove state evolution for approximate message passing (AMP) with rectangular random matrices whose entries are independent, centered, and variance-normalized. The row and column dimensions grow with a ratio that converges to a positive finite limit. The entry laws may differ across coordinates and dimensions, and we assume uniform integrability of the fourth powers of the rescaled entries. For entries sampled independently from a fixed law, a finite fourth moment suffices, with no requirement for higher moments. The nonlinearities are continuously differentiable and globally Lipschitz, with bounded continuous first state derivatives. The signal and noise have independent and identically distributed coordinates with finite moments of all orders, and are independent of each other and of the matrix. At every fixed number of iterations, empirical averages of pseudo-Lipschitz functions of order two converge in probability to the limits specified by Gaussian state evolution. These averages include empirical second moments and products of trajectory coordinates. The proof combines an aggregate bound on third derivatives with randomized Lindeberg replacement and operator-norm truncation, without matching third moments or invoking a non-Gaussian universality theorem. We also show that independence of complementary projected components for every deterministic rank-one constraint pair characterizes Gaussian entries. This identifies the limitation of extending Gaussian conditioning identities to independent non-Gaussian matrices. Finally, a variance-profile example shows that average variance normalization alone does not ensure the homogeneous state evolution limits.

Tue 20 OctInformation Theory
The gist
Approximate message passing (AMP) is a method used to analyze large random matrices common in data science. The paper shows that AMP's performance predictions hold even when matrix entries come from different distributions, as long as their scaled fourth moments are bounded. This broadens the types of data where AMP's predictions remain reliable without needing strong assumptions like identical entry distributions or Gaussianity. The authors also clarify limits on applying Gaussian-based identity methods to non-Gaussian matrices.
Open → 2610.28971v1

Computing information bottleneck values is computationally hard

The Information Bottleneck is NP-hard

Abstract: Given a joint distribution $P_{XY}$ on a finite alphabet, the information bottleneck method seeks a representation $T$ of $X$ that is as informative as possible about $Y$ while compressing $X$, where $T$ and $Y$ are conditionally independent given $X$. We show that computing the optimal value $\mathrm{IB}(P_{XY},R) = \sup_T \{ I(Y;T) : I(X;T) \le R \}$ of the information bottleneck problem, as well as its Lagrangian relaxation $L_β(P_{XY}) = \sup_T \big[I(Y;T) - βI(X;T)\big]$, is NP-hard. Moreover, unless $\mathrm{P} = \mathrm{NP}$, neither $\mathrm{IB}(P_{XY},R)$ nor $L_β(P_{XY})$ can be approximated in polynomial time within an additive error of order $|\mathcal{X}|^{-3/2}$.

Thu 15 OctInformation Theory
The gist
The paper shows that finding the best way to summarize data while keeping important information is very hard for computers to do efficiently. Specifically, the problem, called the information bottleneck, is classified as NP-hard, meaning no quick method is known to solve it exactly for all cases. The authors also prove it is hard to even get close to the best solution within small error in reasonable time. This means efforts to simplify data representation while preserving meaning have fundamental computational barriers.
Open → 2610.22272v1

Constant-depth graph neural networks match 1-WL test with rational weights

Constant-Depth Rational-Weight GNNs and their Connection to Schanuel's Conjecture

Abstract: A landmark result states that the expressive power of graph neural networks (GNNs) is bounded from above by the 1-dimensional Weisfeiler-Leman (1-WL) test. We ask whether a constant-depth GNN can match the expressive power of 1-WL while using only rational weights. We prove that this is the case when Schanuel's conjecture, a famous open problem from transcendental number theory, is taken to be true. Our GNN construction works even with integer weights, and more generally with a broad range of rational weights. As the activation function, it may use logistic sigmoid, hyperbolic tangent, or related functions. It is uniform across all graph sizes. We also prove a partial converse: if a GNN with exponentiation, hyperbolic sine or hyperbolic cosine as activation matches the expressive power of the 1-WL test in a slightly more expressive setting where graphs may contain certain auxiliary vertices, then this implies Schanuel's conjecture restricted to the numbers that arise in computations of the GNN. We also conduct experiments showing that the constructed GNNs indeed match the 1-WL test.

Mon 12 OctMachine LearningLogic in Computer Science
The gist
The paper explores whether certain types of graph neural networks (GNNs) that use only rational numbers as weights can be as powerful as a known graph algorithm called the 1-dimensional Weisfeiler-Leman (1-WL) test. The authors show that this is possible if a famous mathematical hypothesis called Schanuel's conjecture is true. They also prove a partial converse, meaning if such GNNs exist under certain conditions, then Schanuel's conjecture would hold for those cases. Finally, experiments confirm that their GNN construction matches the capabilities of the 1-WL test.
Open → 2610.16993v1

Privileged context design shapes language model policy changes

Privileged Context as Drift in On-Policy Self-Distillation

Abstract: On-policy self-distillation (OPSD) trains a language model to match a copy of itself conditioned on privileged context. Existing work varies what privileged context contains and how it is produced while also changing models, data, and training setups, making the effects of privileged context design difficult to isolate. Motivated by efforts in continual learning to reduce catastrophic forgetting, we study how the choice of privileged context affects policy drift. Specifically, we vary two axes: content (a demonstration, feedback, or rephrase) and source (external, self-generated with a verifier, or self-generated without a verifier). We train Qwen2.5-7B with OPSD across these nine combinations and three datasets, measuring target-task accuracy, prior-task retention, reverse KL from the base policy, and parameter-update geometry. Holding source fixed, changing content spans a wider median KL range than holding content fixed and changing source. The ratio between these ranges is $5.1\times$ for per-token KL and $2.2\times$ for per-sequence KL. Parameter-update geometry shows the same pattern: updates from adapters that share content are more closely aligned (mean cosine $0.571$) than updates from adapters that share source ($0.255$). For continual learning, these findings suggest that privileged context should be treated as part of OPSD's stability design because it is associated with how far and in what direction the policy moves.

Tue 6 OctMachine Learning
The gist
When training language models to improve themselves, researchers use extra helpful information called privileged context. This paper studies how different types of this extra information affect how much the model's behavior changes during training. The authors found that the kind of information given (like examples or feedback) impacts the model's changes more than where that information comes from. This helps guide how to design training to keep models stable and learn better.
Open → 2610.07842v1

Post-training method improves diffusion language model accuracy and speed

Representation-Space MMD for Diffusion Language Models

Abstract: We introduce a post-training method for diffusion language models (DLMs) that minimizes Maximum Mean Discrepancy (MMD) between generated and reference distributions in the feature space of a frozen pretrained DLM. To estimate MMD, we retain contextual features at individual token positions, obtaining multiple observations per sequence from a single extractor pass. We optimize this objective using policy gradients for discrete models and direct differentiation through generated latents for continuous models. In both cases, computing the loss directly from these features enables efficient post-training without full sampling trajectories or jointly trained auxiliary models. Experiments show lower generative perplexity at comparable entropy on OpenWebText and better accuracy-computation trade-offs on GSM8K. On 16B DMax-LLaDA2.0 models with hybrid masked-uniform diffusion, we increase decoding parallelism with similar or higher accuracy on math and code benchmarks.

Mon 5 OctComputation and LanguageMachine Learning
The gist
Diffusion language models generate text differently from standard models, but improving them after training has been tricky. The authors introduce a new way to fine-tune these models by comparing features of generated and real text to better match the two. Their method works efficiently and improves model accuracy and speed without needing complex extra steps. Tests show better results on general text and math problems, making decoding faster with no loss in quality.
Open → 2610.06648v1

Minkowski attractor networks speed up hyperbolic visual representations

Minkowski Attractor Networks: Closed-Form Hyperbolic Flows for Visual Representations

Abstract: Geometric representation learning predominantly scaffolds representations onto flat Euclidean subspaces or compact product tori ($\mathbb{T}^K$). However, flat manifolds possess vanishing curvature and polynomial volume growth, inherently suffering from metric distortion when embedding multi-scale, tree-like visual hierarchies. While hyperbolic spaces ($\mathbb{H}^m$) circumvent this via constant negative curvature ($K<0$) and exponential volume expansion, prior hyperbolic deep architectures are hindered by computationally cumbersome Riemannian optimization, non-linear gyrovector calculus, and floating-point instabilities. In this work, we introduce \textbf{Minkowski Attractor Networks (MAN)}, an operator-splitting-inspired framework that embeds representations within pseudo-Riemannian Minkowski spacetime ($\mathbb{R}^{1,m}$). By framing hyperbolic manifolds as quadric level sets, MAN resolves hyperbolic geometry by combining linear Lorentz group transport with non-linear cone lifting and closed-form radial rescaling, evaluating in a single forward pass without numerical ODE solvers or iterative retractions. We establish \textbf{MAN-2D} ($\mathbb{R}^{1,1} \to \mathbb{H}^1$) as our primary, high-throughput visual backbone, which maximizes channel factorization granularity into $D/2$ independent two-dimensional Minkowski blocks. We further formulate \textbf{MAN-4D} ($\mathbb{R}^{1,3} \to \mathbb{H}^3$) as a spacetime extension, leveraging a commuting Cartan-subalgebra parameterization of $\mathrm{SO}^+(1,3)$ to evaluate 4D Lorentz isometries via two commuting 2D planar maps without matrix-exponential overhead.

Tue 29 SeptComputer Vision and Pattern Recognition
The gist
Visual data like images often have complex, tree-like structures that are hard to represent using ordinary flat spaces. The authors introduce Minkowski Attractor Networks, a new way to embed these visual patterns into a space with constant negative curvature called hyperbolic space. Their method avoids difficult calculations used before and can be computed efficiently in one step. This makes it easier and faster to model complicated visual relationships in machine learning systems.
Open → 2609.37817v1

Task scope shapes information needs more than receiver type

On Task Scope and Information Retention in Source Coding

Abstract: We argue that dividing codec design into Coding for Machines (CfM) and Coding for Humans (CfH) is a misleading distinction for deciding what information a codec may discard. Receiver identity does not determine admissible information loss. The required rate depends on task scope, including the predictions to support, their losses and tolerated risks, the encoder observation, and the permitted decoding procedures. Notably, a machine task may have a higher minimum rate than a restricted human decision. Rate savings on selected machine tasks apply only to the stated requirements, not to an intrinsic ordering by receiver type. We extend source and feature coding to finite task families, derive when restricting the encoder observation preserves the minimum rate, and show that equality between source and split-feature coding rates can no longer hold as the task scope expands.

Tue 29 SeptInformation TheoryMachine Learning
The gist
Deciding what information to keep or throw away when compressing data depends on the task you want the data to help with, not just who will receive it. The paper shows that whether a computer or a human uses the data doesn’t alone say how much detail must be saved. Instead, the kinds of predictions and decisions the data supports, and their accuracy requirements, really determine how much information is needed. The authors explain this by extending classic data compression ideas to handle multiple tasks and their demands.
Open → 2609.37575v1

Sharp privacy budget limit for protecting training data revealed

A Sharp Transition in Data Reconstruction under Differential Privacy

Abstract: Data reconstruction attacks have empirically been successful in recovering training samples from learned models, raising privacy concerns and motivating defenses with guarantees that remain valid against future threats. While differential privacy (DP) provides formal protection, choosing the privacy budget remains a challenge: small budgets severely reduce utility, but it is hard to quantify how large the budget can be without allowing accurate reconstruction. In this work, we study informed attackers who aim to reconstruct a single $d$-dimensional training sample from a $ρ$-zero-concentrated DP model, knowing all other training data. Our main contribution is to establish a sharp transition at $ρ\asymp d$ for data reconstruction: on the one hand, we derive entropy-based lower bounds for any private mechanism and any attack, characterizing a set of target priors for which reconstruction is information-theoretically impossible for $ρ\ll d$; on the other hand, we analyze a simple attack on private linear regression with output perturbation, showing that reconstruction is practically feasible for $ρ\gg d$. Remarkably, the transition moves to $ρ\asymp s$ for data lying in an $s$-dimensional subspace, demonstrating that the privacy budget guaranteeing adequate protection must be assessed in terms of the effective dimension of the data. We validate our findings via experiments on synthetic data and natural images (CIFAR-10, ImageNet).

Tue 29 SeptMachine LearningArtificial Intelligence
The gist
This paper looks at how much privacy protection is needed to stop attackers from uncovering individual training data used to build a model. The authors found a clear tipping point in privacy settings: too weak, and attackers can reconstruct data; strong enough, and it becomes practically impossible. They also discovered this tipping point depends on the data's effective dimensionality, not just the raw size. Their experiments with synthetic and real images confirm these findings.
Open → 2609.37344v1

Neural solver uses math to improve partial differential equation accuracy

Theory Guided and Interpretable Neural Operator Design for Partial Differential Equation Learning

Abstract: Accurate numerical solutions of partial differential equations (PDEs) are crucial in numerous science and engineering applications. In this work, we introduce a novel neural PDE solver named AFDONet, which incorporates neural operator learning and adaptive Fourier decomposition (AFD) theory for the first time into a specifically designed variational autoencoder (VAE) structure, to solve a general class of nonlinear PDEs on smooth manifolds. AFDONet is the first neural PDE solver whose architectural and component design is fully guided by an established mathematical framework (in this case, AFD theory), turning neural operator design from an art to a science. Thus, AFDONet also exhibits exceptional mathematical explainability and groundness, and enjoys several desired properties. Furthermore, AFDONet achieves outstanding solution accuracy and competitive computational efficiency in several benchmark problems. In particular, thanks to its deep connections with AFD theory, AFDONet shows superior performance in solving PDEs on i) arbitrary (Riemannian) manifolds, and ii) datasets with sharp gradients. Overall, this work presents a new paradigm for designing explainable neural operator frameworks.

Sun 27 SeptMachine LearningComputational Engineering, Finance, and Science
The gist
Solving partial differential equations (PDEs) accurately is important for many science and engineering tasks. The authors created a new neural network called AFDONet that uses a special math theory, adaptive Fourier decomposition, to design its structure. This math-guided design helps the network solve complex PDEs more precisely and makes its inner workings easier to understand. It works well on curved spaces and problems with sharp changes. Overall, the authors show a better way to build neural solvers with clear mathematical foundations.
Open → 2609.33715v1

Transformers can generate two text streams at once by mixing inputs

Your Transformer Can Hold Two Thoughts at Once: Evidence of Linear Superposition in LLMs

Abstract: While Large Language Models (LLMs) rely on highly non-linear components, in this work we demonstrate that they exhibit fundamental linearity: when inputs from distinct text streams are linearly combined, the model outputs a superposition of the individual next-token distributions. We term this the \textit{Superposition Linearity Hypothesis}. We provide evidence that superposition is an intrinsic property of the Transformer architecture rather than an emergent consequence of training; in fact, we observe that it tends to diminish as pretraining progresses. However, we demonstrate that linearity can be substantially restored through lightweight fine-tuning, significantly reducing the divergence between the predicted next-token distribution and the average of the individual next-token distributions. Finally, we introduce a guided decoding procedure that disentangles superposed outputs, enabling the simultaneous generation of two coherent continuations from a single forward pass.

Thu 24 SeptComputation and LanguageArtificial Intelligence
The gist
Large Language Models like transformers use complex math, but this paper shows they have a simple kind of ‘linearity’ when combining two different text inputs. The researchers found that mixing inputs causes the model to mix its outputs in a predictable way, like holding two thoughts at once. This behavior is built into the model’s design and can even be improved with some fine-tuning. They also created a method to separate these mixed outputs so the model can produce two coherent text continuations at the same time.
Open → 2609.29845v1

Residual additive networks improve speech recognition with exact data routing

Task-Directed Residual AddUNet:Perfect-Reconstruction Routing for Full-Rate Representations

Abstract: This paper establishes a perfect-reconstruction (PR) interpretation of AddUNet and its full-rate realization, and introduces a Residual Full-Rate PR architecture for task-directed representation learning. The survivor--skip structure of a constrained additive U-Net is shown to be exactly equivalent to a critically sampled multirate PR filter bank. The full-rate formulation removes the complementary-subband restrictions of the critically sampled system while preserving PR. A Residual Full-Rate PR architecture is then proposed to progressively route task-irrelevant, nuisance, or redundant structure away from the task-facing survivor while retaining the routed information explicitly. Exact reconstruction is guaranteed for arbitrary shape-compatible linear or nonlinear routing operators, without requiring invertibility, a matched synthesis bank, reconstruction loss, or learned decoder. The resulting architecture decouples representation design from reconstruction design: conservation is structural, while learning is devoted to task-directed routing. The same formulation identifies an identity-shortcut ResNet with its residual output retained as a full-rate PR system. Experiments verify exact single-channel routing of linearly separable factors to machine precision. On TIMIT, the proposed front-end improves test PER from $28.60\pm2.09\%$ to $25.76\pm0.41\%$ with the recognizer and training protocol held fixed, while maintaining exact reconstruction. Speaker probing further shows that structural conservation does not itself imply task-specific invariance.

Mon 14 SeptMachine Learning
The gist
High-quality machine learning often needs ways to break down and combine data exactly without losing information. The paper shows that a special kind of neural network called AddUNet can perfectly reconstruct its input even as it filters and routes parts of data for tasks like speech recognition. The authors introduce a more flexible version that keeps all data perfectly intact while learning to send irrelevant parts away from the main processing path. This helps improve speech recognition accuracy without sacrificing data quality or needing extra reconstruction steps.
Open → 2609.15857v1

New method improves recognition of unseen image compositions

From Model Patterns to Abstract Semantics in Compositional Zero-Shot Learning

Abstract: Compositional Zero Shot Learning aims to recognize unseen compositions by recombining learned primitives. Recent methods rely on vision language models and attempt to explicitly model contextual variations of primitives through multiple representations. However, such approaches are limited by fixed variant capacity and competition between abstract and concrete semantics. In this work, we present a new perspective that views primitive variations as the context-driven activation of concrete visual cues rather than independent entities. Based on it, we propose CLEAR, a CLoze-style rEAsoning-based Re-ranking framework inspired by human perceptual processes. CLEAR extracts conditional variants from the primitive candidate set in a coarse-to-fine manner, performs cloze-style reasoning to infer high-level semantics, and re-ranks predictions to correct biases toward salient concrete primitives. Extensive experiments demonstrate that CLEAR consistently improves the Base Model and outperforms state-of-the-art methods on the challenging C-GQA and MIT-States datasets. Code is available at https://github.com/buptLwz/CLEAR.

Mon 14 SeptComputer Vision and Pattern Recognition
The gist
Recognizing new combinations of objects and their features in images is hard because models usually learn fixed examples. This paper introduces a method called CLEAR that treats parts of images as clues activated by context, similar to how humans perceive things. CLEAR uses a step-by-step reasoning process to better understand and rank possible interpretations of images, reducing errors from obvious visuals. Tests show CLEAR consistently enhances existing models and beats other methods on tough image datasets.
Open → 2609.15649v1

Gpu utilization for large language model inference breaks down efficiency factors

Dissecting GPU Utilization for LLM Inference on Nvidia Hopper

Abstract: A single SM utilization percentage can make an LLM inference workload look compute-saturated while hiding how much useful work is being done. The problem is not that the counter is wrong, but that it collapses several different mechanisms into one number. This is most severe during decode, where each request contributes only one new token and dense projection GEMMs become small-row matrix multiplications. On Hopper, the bfloat16 GMMA path executes these operations in fixed 64-row matrix fragments, so small-batch decode can fill only a small fraction of each fragment with real token rows. In this paper, we profile vLLM with FlashAttention-3 and cuBLASLt on an H100 NVL across cold prefill, warm prefill, and decode, sweeping sequence length and batch size. We replace the usual single utilization number with eight counter-validated views derived from raw Nsight Compute reports, each pinned to an NCU counter or explicit formula. Together, these views map utilization gaps to concrete mechanisms - fragment fill, occupancy limits, stall signatures, wave quantization, and kernel selection - across four production models and six per-layer kernel roles.

Fri 11 SeptPerformanceHardware ArchitectureDistributed, Parallel, and Cluster Computing
The gist
Measuring how busy a GPU is during large language model (LLM) use can be misleading because a single percentage doesn't show all the details. The authors explain that during tasks like generating text (decoding), GPU operations handle small pieces inefficiently, leading to underused GPU power. They studied Nvidia's Hopper GPU running models with different settings and used detailed counters to explain why the GPU isn't fully efficient. This helps reveal what exactly limits GPU performance during these tasks.
Open → 2609.12923v1

Digital communication codes functions directly into wireless signals

The Computing Channel: How Modulation Programs the Airwaves

Abstract: Distributed computing and distributed artificial intelligence require frequent exchanges of intermediate results, although many applications need only an aggregate rather than messages from individual devices. Conventional systems recover each message before computing the aggregate, whereas over-the-air computation (OAC) exploits simultaneous transmission to obtain it directly. However, dominant OAC implementations rely on analog signaling, creating a mismatch with finite-precision data and digital communication procedures. This article presents digital function-oriented communication, in which finite-alphabet symbol representations and receiver decisions are jointly designed so that multiple-access superposition encodes the desired function without recovering individual inputs. We introduce its computational-constellation principle, main design approaches, extensions, and implementation challenges. Federated edge learning illustrates how the framework can reduce user-dependent data-bearing resources while operating directly on quantized model updates.

Thu 10 SeptDistributed, Parallel, and Cluster Computing
The gist
Sending messages between many computers or devices usually means sending each message separately, which is slow. The authors point out a new way to send data by letting devices transmit at the same time so the receiver can directly get answers to questions like sums or averages, without reading everything first. Their method works with digital signals, which are easier to handle in computers, by designing symbols and decoding rules together. This could help in applications like teaching AI models across many devices more efficiently.
Open → 2609.11145v1