# Algorithms

Algorithms are clearly specified processes for computation that produce prescribed results when their rules are followed.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Optimal algorithmic complexity of inference in quantum kernel methods

DevFeed: [Optimal algorithmic complexity of inference in quantum kernel methods](<https://devfeed.tech/articles/optimal-algorithmic-complexity-of-inference-in-quantum-kernel-methods-144886.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2604.15214>)

Author: Elies Gil-Fuster, Seongwook Shin, Sofiene Jerbi, Jens Eisert, Maximilian J. Kramer

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Inference](<https://devfeed.tech/topics/inference.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Combinatorial optimization](<https://devfeed.tech/topics/combinatorial-optimization.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [amplitude](<https://devfeed.tech/tags/amplitude.md>), [bottleneck](<https://devfeed.tech/tags/bottleneck.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [gate](<https://devfeed.tech/tags/gate.md>), [inference](<https://devfeed.tech/tags/inference.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [quant-ph](<https://devfeed.tech/tags/quant-ph.md>), [quantum](<https://devfeed.tech/tags/quantum.md>), [quantum-advantage](<https://devfeed.tech/tags/quantum-advantage.md>), [query](<https://devfeed.tech/tags/query.md>), [sampling](<https://devfeed.tech/tags/sampling.md>), [supervised-learning](<https://devfeed.tech/tags/supervised-learning.md>)

### AI overview

Quantum kernel inference estimates a weighted sum of kernel values, and independently sampling each term has query complexity O(N‖α‖₂²/ε²). The abstract identifies two choices--sampling or quantum amplitude estimation for kernel values, and term-by-term estimation or encoding the full sum as one observable. Combining the single-observable encoding with amplitude estimation achieves O(‖α‖₁/ε) queries, with a matching lower bound up to logarithmic factors. This removes N from the query count and improves dependence on ‖α‖₁ and ε. The paper also analyzes gate costs: the query-optimal method is not always best in gate complexity, so the practical strategy depends on hardware. All described algorithms use amplitude estimation as a subroutine.

### Source excerpt

arXiv:2604.15214v3 Announce Type: replace-cross Abstract: Quantum kernel methods are among the leading candidates for achieving quantum advantage in supervised learning. A key bottleneck is the cost of inference: evaluating a trained model on new data requires estimating a weighted sum $\sum_{i=1}^N \alpha_i k(x,x_i)$ of $N$ kernel values to additive precision $\varepsilon$, where $\alpha$ is the vector of trained coefficients. The standard approach estimates each term independently via sampling, yielding a query complexity of $O(N\lVert\alpha\rVert_2^2/\varepsilon^2)$. In this work, we identify two independent axes for improvement: (1) How individual kernel values are estimated (sampling versus quantum amplitude estimation), and (2) how the sum is approximated (term-by-term versus via a single observable), and systematically analyze all combinations thereof. The query-optimal combination, encoding the full inference sum as the expectation value of a single observable and applying quantum amplitude estimation, achieves a query complexity of $O(\lVert\alpha\rVert_1/\varepsilon)$, removing the dependence on $N$ from the query count and yielding a quadratic improvement in both $\lVert\alpha\rVert_1$ and $\varepsilon$. We prove a matching lower bound of $\Omega(\lVert\alpha\rVert_1/\varepsilon)$, establishing query-optimality of our approach up to logarithmic factors. Beyond query complexity, we also analyze how these improvements translate into gate costs and show that the query-optimal strategy is not always optimal in practice from the perspective of gate complexity. Our results provide both a query-optimal algorithm and a practically optimal choice of strategy depending on hardware capabilities, along with a complete landscape of intermediate methods to guide practitioners. All algorithms require only amplitude estimation as a subroutine and are thus natural candidates for early-fault-tolerant implementations.

## Beyond 4: Improved Competitive Traveling Repairperson

DevFeed: [Beyond 4: Improved Competitive Traveling Repairperson](<https://devfeed.tech/articles/beyond-4-improved-competitive-traveling-repairperson-146120.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.21943>)

Author: Bibek Maharjan, Gokarna Sharma

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Combinatorial optimization](<https://devfeed.tech/topics/combinatorial-optimization.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [class](<https://devfeed.tech/tags/class.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-dm](<https://devfeed.tech/tags/cs-dm.md>), [cs-ds](<https://devfeed.tech/tags/cs-ds.md>), [cs-ma](<https://devfeed.tech/tags/cs-ma.md>), [data-structures-and-algorithms](<https://devfeed.tech/tags/data-structures-and-algorithms.md>), [metric](<https://devfeed.tech/tags/metric.md>), [online](<https://devfeed.tech/tags/online.md>), [problems](<https://devfeed.tech/tags/problems.md>), [ratio](<https://devfeed.tech/tags/ratio.md>), [residual](<https://devfeed.tech/tags/residual.md>), [state](<https://devfeed.tech/tags/state.md>), [zero](<https://devfeed.tech/tags/zero.md>)

### AI overview

For the online traveling repairperson problem on arbitrary metrics, the paper reports a deterministic algorithm with competitive ratio 3.877, improving on the stated 4-competitive state of the art. For zero-residual instances, it reports a ratio of 3+ε for every ε>0. The abstract also says these results extend to some variants of online dial-a-ride; it does not specify which variants or give further algorithmic details.

### Source excerpt

arXiv:2611.21943v1 Announce Type: cross Abstract: With $k\geq 1$ repairpersons starting initially from a depot, we present a 3.877-competitive deterministic algorithm for the fundamental online traveling repairperson problem on an arbitrary metric. For the special class of zero-residual instances, we improve the ratio to $3+\epsilon$ for every $\epsilon>0$. We also extend these results to some variants of the related so-called online dial-a-ride problem. The state-of-the-art is the 4-competitive deterministic algorithm for both problems.

## Sequential Probability Assignment against Smoothed Adversaries with Unknown Base Measure

DevFeed: [Sequential Probability Assignment against Smoothed Adversaries with Unknown Base Measure](<https://devfeed.tech/articles/sequential-probability-assignment-against-smoothed-adversaries-with-unknown-base-measure-145064.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25514>)

Author: Ziyi Liu, Daniel M. Roy

Published: 2026-11-20T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [concept-learning](<https://devfeed.tech/topics/concept-learning.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [adversarial](<https://devfeed.tech/tags/adversarial.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [entropy](<https://devfeed.tech/tags/entropy.md>), [learning](<https://devfeed.tech/tags/learning.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [probability](<https://devfeed.tech/tags/probability.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>)

### AI overview

The paper studies sequential probability assignment with smooth, well-specified data when the adversary's reference base measure is unknown, without the Lipschitz condition used in earlier work. It gives regret upper bounds for both adaptive and oblivious smoothed adversaries: the adaptive bound depends on empirical ℓ∞ Hellinger entropy, while the oblivious bound uses empirical ℓ2 Hellinger entropy. Both algorithms are based on truncated empirical Hellinger covers. A general lower bound shows the bounds are essentially tight for some natural classes and indicates that learning can be harder when the base measure is unknown than when it is known.

### Source excerpt

arXiv:2611.25514v1 Announce Type: new Abstract: Smoothed online learning has recently been studied as a way to bypass hardness results for the fully adversarial setting, which can be overly pessimistic. In this framework, the adversary is constrained to generate contexts from distributions having a bounded density with respect to some fixed base measure $\mu$. Prior work makes the strong assumption that $\mu$ is known to the learner, with notable exceptions including Block et al. (2024) and Blanchard (2025). In this paper, we study sequential probability assignment (a.k.a., online learning with log loss) with smooth, well-specified data in the more general setting where $\mu$ is \emph{unknown}, without the Lipschitz condition imposed in the work of Block et al. (2024) and Blanchard (2025). We prove regret upper bounds against both adaptive and oblivious smoothed adversaries: the adaptive bound is controlled by empirical $\ell_\infty$ Hellinger entropy, while the oblivious bound improves this dependence to empirical $\ell_2$ Hellinger entropy, the notion that has been shown to characterize the complexity of learning with i.i.d. data (Bilodeau et al., 2023). Both bounds are obtained through algorithms based on truncated empirical Hellinger covers. We complement these results with a general lower bound, showing that our upper bounds are essentially tight for some natural classes, which implies a separation in the difficulty of smoothed online learning between regimes where $\mu$ is known and where it is unknown.

## Silver Rate Is (Almost) Optimal for Gradient Descent

DevFeed: [Silver Rate Is (Almost) Optimal for Gradient Descent](<https://devfeed.tech/articles/silver-rate-is-almost-optimal-for-gradient-descent-144923.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.09152>)

Author: Yuhan Ye, Kaizhao Liu

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Combinatorial optimization](<https://devfeed.tech/topics/combinatorial-optimization.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [checkpoint](<https://devfeed.tech/tags/checkpoint.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [convex](<https://devfeed.tech/tags/convex.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [gradient-descent](<https://devfeed.tech/tags/gradient-descent.md>), [local](<https://devfeed.tech/tags/local.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [optimization](<https://devfeed.tech/tags/optimization.md>)

### AI overview

For smooth convex objectives, the recursive silver stepsize schedule's convergence exponent, p_sil = log₂(1+√2) ~= 1.2716, is optimal among predetermined nonnegative gradient descent step schedules: the paper proves a matching Ω(n^(−p_sil−o(1))) lower bound. It also proves an anytime lower bound matching the known upper-bound exponent of about 1.1195. The proof selects iterations where the trajectory explores new coordinates, links them with local functions, and introduces a hard function that bends the trajectory between checkpoints. A recursive maximization over admissible checkpoint sets yields the lower bound for every prescribed schedule.

### Source excerpt

arXiv:2609.09152v3 Announce Type: replace-cross Abstract: Gradient descent (GD) is one of the most fundamental algorithms in optimization. Yet even for smooth convex objectives, the optimal rate among predetermined nonnegative stepsize schedules has remained unresolved. Altschuler and Parrilo [Mathematical Programming, 2025] showed that their recursive silver stepsize schedule achieves an $O(n^{-p_{\mathrm{sil}}})$ rate, where $p_{\mathrm{sil}}=\log_2(1+\sqrt2)\approx1.2716$, improving upon the classical $O(n^{-1})$ rate of constant-step GD. Although the optimality of $p_{\mathrm{sil}}$ has been well supported by numerical evidence for small $n$, a matching lower bound has remained missing. In this paper, we prove an $\Omega(n^{-p_{\mathrm{sil}}-o(1)})$ lower bound for GD, showing that $p_{\mathrm{sil}}$ is the optimal convergence exponent. Additionally, we prove an anytime lower bound that matches the exponent $2p_{\mathrm{sil}}/(1+p_{\mathrm{sil}})\approx1.1195$ of the known upper bound [Zhang, Lee, Du, and Chen, COLT 2025]. Building on the approaches of [Ma and Chen, 2026; Jung, Cho, and Yun, 2026], we select specific iterations as checkpoints at which the GD trajectory explores a new coordinate, and we couple these coordinates using a chain of local functions. Our main technical contribution is a local hard function that bends the GD trajectory between successive checkpoints, resulting in a sharpened lower bound. For each prescribed stepsize schedule, we maximize this bound over admissible checkpoint sets. A recursive analysis of this maximum then yields a lower bound matching the silver exponent for every such schedule.

## Variance-Adaptive Upper Confidence Bounds for Multi-Armed Bandits with Kaplan--Meier Survival Estimation

DevFeed: [Variance-Adaptive Upper Confidence Bounds for Multi-Armed Bandits with Kaplan--Meier Survival Estimation](<https://devfeed.tech/articles/variance-adaptive-upper-confidence-bounds-for-multi-armed-bandits-with-kaplan-meier-survival-estimation-144997.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24988>)

Author: Yangfan Cui, Andrew Papanicolaou

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Simulation](<https://devfeed.tech/topics/simulation.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [bandits](<https://devfeed.tech/tags/bandits.md>), [cancer](<https://devfeed.tech/tags/cancer.md>), [confidence-bounds](<https://devfeed.tech/tags/confidence-bounds.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [exploration](<https://devfeed.tech/tags/exploration.md>), [greenwood](<https://devfeed.tech/tags/greenwood.md>), [kaplan](<https://devfeed.tech/tags/kaplan.md>), [math-pr](<https://devfeed.tech/tags/math-pr.md>), [multi-armed-bandit](<https://devfeed.tech/tags/multi-armed-bandit.md>), [policy](<https://devfeed.tech/tags/policy.md>), [probability](<https://devfeed.tech/tags/probability.md>), [realtime](<https://devfeed.tech/tags/realtime.md>), [sequential-decision](<https://devfeed.tech/tags/sequential-decision.md>), [simulation](<https://devfeed.tech/tags/simulation.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>), [survival](<https://devfeed.tech/tags/survival.md>), [variance](<https://devfeed.tech/tags/variance.md>)

### AI overview

KM-UCB adapts upper confidence bounds to bandit decisions where rewards are survival probabilities at a fixed horizon and outcomes are right-censored event times. It uses a fixed-cohort empirical Bernstein bound parameterized by Greenwood's variance, addressing variation that Hoeffding-type bounds ignore. For real-time allocation, it retains the Greenwood index and reviews the recommended arm using a survival bound from completed records. Under catch-up reporting, the policy has logarithmic expected regret with an arm-specific variance term in the exploration bound. The abstract reports evaluation of the original policy in a delayed simulation and retrospective replay of breast cancer trial data, and a separate paired simulation for a correction.

### Source excerpt

arXiv:2611.24988v1 Announce Type: cross Abstract: We study the stochastic multi-armed bandit problem in which the reward associated with each arm is the survival probability at a pre-specified time horizon, and the observed outcome is a right-censored time-to-event variable. Standard bandit algorithms face delayed and partial observations in this setting. Prior adaptations for the Kaplan--Meier (KM) estimator rely on Hoeffding-type bounds that ignore the inherent heteroscedasticity of continuous survival processes. To bridge this gap, we propose KM-UCB, a variance-adaptive policy that unites continuous-time survival analysis with discrete sequential decision-making. By leveraging martingale theory and continuous influence functions, we derive a fixed-cohort empirical Bernstein bound parameterized by Greenwood's variance formula. For realtime allocation, we retain the Greenwood index and use a survival bound from completed records to review the recommended arm. Under catch-up reporting, the policy has logarithmic expected regret with an arm-specific variance term in the exploration bound. We evaluate the original policy in a dual-layer delayed simulation and a retrospective replay of breast cancer trial data, and evaluate the correction in a separate paired simulation.

## StarMPI-SVD: Distributed-Memory Parallel Star-M Tensor SVD

DevFeed: [StarMPI-SVD: Distributed-Memory Parallel Star-M Tensor SVD](<https://devfeed.tech/articles/starmpi-svd-distributed-memory-parallel-star-m-tensor-svd-146136.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.26451>)

Author: Naman Pesricha, Grey Ballard, Srinivas Eswar, Md Taufique Hussain, Vishwas Rao, Phani Motamarri

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Compression](<https://devfeed.tech/topics/compression.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [communication](<https://devfeed.tech/tags/communication.md>), [compression](<https://devfeed.tech/tags/compression.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [data](<https://devfeed.tech/tags/data.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [nodes](<https://devfeed.tech/tags/nodes.md>), [order](<https://devfeed.tech/tags/order.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [singular-value-decomposition](<https://devfeed.tech/tags/singular-value-decomposition.md>), [size](<https://devfeed.tech/tags/size.md>), [star](<https://devfeed.tech/tags/star.md>), [svd](<https://devfeed.tech/tags/svd.md>)

### AI overview

The work presents the first distributed-memory implementations of t-SVDM-I and adaptive t-SVDM-II for N-way tensors, extending star-M compression beyond shared-memory settings. t-SVDM-I uses invertible transformations and slice-wise truncated SVDs at a prescribed rank; t-SVDM-II selects slice-wise ranks to meet an error tolerance. Asynchronous, non-blocking communication is used for data redistribution to address computational and communication bottlenecks. Strong-scaling experiments report at least 70% parallel efficiency on up to 128 nodes (6,144 cores); the methods are applied to datasets up to 768 GB.

### Source excerpt

arXiv:2611.26451v1 Announce Type: new Abstract: The star-M tensor algebra generalizes the optimal compression guarantees of the matrix singular value decomposition (SVD) to higher-order tensors. The t-SVDM-I decomposition is computed using a set of invertible transformations and slice-wise truncated SVDs with a prescribed rank, and its adaptive, multirank variant t-SVDM-II can determine slice-wise ranks to satisfy a prescribed error tolerance. Existing implementations of these algorithms are limited to shared-memory environments, restricting their applicability to modern large-scale datasets. In this work, we present the first distributed-memory implementations of t-SVDM-I and t-SVDM-II, which are generalized to N-way tensors. To address computational and communication bottlenecks, we design asynchronous, non-blocking communication strategies for efficient data redistribution to obtain highly efficient key computational kernels. Strong-scaling experiments demonstrate the efficiency and scalability of our approach (at least 70% parallel efficiency on up to 128 nodes, or 6144 cores), and we apply the star-M compression techniques to a set of application datasets of size up to 768 GB.

## Extensions of Robbins-Siegmund Theorem with Applications in Reinforcement Learning

DevFeed: [Extensions of Robbins-Siegmund Theorem with Applications in Reinforcement Learning](<https://devfeed.tech/articles/extensions-of-robbins-siegmund-theorem-with-applications-in-reinforcement-learning-144860.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2509.26442>)

Author: Xinyu Liu, Zixuan Xie, Shangtong Zhang

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Reinforcement learning](<https://devfeed.tech/topics/reinforcement-learning.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [function-approximation](<https://devfeed.tech/tags/function-approximation.md>), [linear](<https://devfeed.tech/tags/linear.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [probability](<https://devfeed.tech/tags/probability.md>), [reinforcement-learning](<https://devfeed.tech/tags/reinforcement-learning.md>), [stochastic-processes](<https://devfeed.tech/tags/stochastic-processes.md>)

### AI overview

The paper extends the Robbins-Siegmund theorem to cases where the zero-order term is square-summable rather than summable, adding an assumption on process increments to establish almost sure convergence to a bounded set. It also states almost sure convergence rates, high-probability concentration bounds, and L^p convergence rates. Applied to stochastic approximation and reinforcement learning, the results include claimed first rates and bounds of these kinds for Q-learning with linear function approximation. The supplied text is an abstract, so it does not specify the increment assumption or technical conditions.

### Source excerpt

arXiv:2509.26442v3 Announce Type: replace Abstract: The Robbins-Siegmund theorem establishes the convergence of stochastic processes that are almost supermartingales and is one of the most commonly used approaches for analyzing stochastic iterative algorithms in stochastic approximation and reinforcement learning (RL). However, its original form has a significant limitation as it requires the zero-order term to be summable. In many important RL applications, this summable condition, however, cannot be met. This limitation motivates us to extend the Robbins-Siegmund theorem for almost supermartingales where the zero-order term is not summable, but only square-summable. In particular, we introduce a novel and mild assumption on the increments of the stochastic processes. This together with the square-summable condition enables an almost sure convergence to a bounded set. Additionally, we further provide almost sure convergence rates, high probability concentration bounds, and $L^p$ convergence rates. We then apply the new results to stochastic approximation and RL. Notably, we obtain the first almost sure convergence rate, the first high probability concentration bound, and the first $L^p$ convergence rate for $Q$-learning with linear function approximation.

## UniReFP: Robust Unified Fingerprinting for Vision Models against Cross-Task Repurposing Attacks

DevFeed: [UniReFP: Robust Unified Fingerprinting for Vision Models against Cross-Task Repurposing Attacks](<https://devfeed.tech/articles/unirefp-robust-unified-fingerprinting-for-vision-models-against-cross-task-repurposing-attacks-146035.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25555>)

Author: Ziye Geng, Guang Yang, Yihang Chen, Lingfeng Yao, Xing Shi, Miao Pan, Xin Fu, Changqing Luo

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [object-detection](<https://devfeed.tech/topics/object-detection.md>), [Model Development](<https://devfeed.tech/topics/model-development.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [attacks](<https://devfeed.tech/tags/attacks.md>), [classifier](<https://devfeed.tech/tags/classifier.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-cv](<https://devfeed.tech/tags/cs-cv.md>), [formats](<https://devfeed.tech/tags/formats.md>), [framework](<https://devfeed.tech/tags/framework.md>), [intermediate-representations](<https://devfeed.tech/tags/intermediate-representations.md>), [models](<https://devfeed.tech/tags/models.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [robust](<https://devfeed.tech/tags/robust.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [space](<https://devfeed.tech/tags/space.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [verification](<https://devfeed.tech/tags/verification.md>), [vision](<https://devfeed.tech/tags/vision.md>)

### AI overview

The abstract identifies cross-task repurposing--changing a vision model's task and output format--as an attack that can make existing fingerprints inapplicable. UniReFP generates grouped fingerprints using a repurposed surrogate classifier, encoding ownership evidence in a shared class-level semantic space. At verification, task-aware projection maps suspect outputs to semantic-presence vectors; ownership is assessed by consistency within fingerprint groups. The abstract reports superior performance under cross-task repurposing, other commonly studied model modifications, and combinations of these attacks. It provides no experimental details or quantitative results.

### Source excerpt

arXiv:2611.25555v1 Announce Type: cross Abstract: We identify, for the first time, a new model modification attack--the cross-task model repurposing attack--that can render fingerprints generated by existing model fingerprinting approaches inapplicable. To address this challenge, we propose UniReFP--a novel unified model fingerprinting framework applicable to diverse vision models across different tasks--that utilizes ownership evidence in a shared class-level semantic space rather than original task-specific output space, enabling effective ownership verification when a protected model is repurposed across tasks with heterogeneous output formats. Specifically, UniReFP constructs a surrogate classifier by repurposing the protected model, enabling fingerprints to be generated independently of the original task-dependent output space of the protected model. Moreover, it optimizes grouped fingerprints to encode ownership evidence: fingerprints within the same group are encouraged to induce consistent semantic responses and intermediate representations on the surrogate classifier, while producing dispersed responses on independently trained reference classifiers. During verification, UniReFP uses a task-aware semantic projection mechanism to map heterogeneous suspect-model outputs into unified semantic-presence vectors, and determines ownership by measuring inner-group consistency. Extensive experimental results validate the effectiveness of UniReFP, consistently showing superior performance under cross-task repurposing attacks, commonly studied model modification attacks, and even their combinations.

## On the trajectories of the ID algorithm

DevFeed: [On the trajectories of the ID algorithm](<https://devfeed.tech/articles/on-the-trajectories-of-the-id-algorithm-145598.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25877>)

Author: Ivano Lodato, Simran Hiranandani, Aditya Varna Iyer

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [graph](<https://devfeed.tech/tags/graph.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [math-pr](<https://devfeed.tech/tags/math-pr.md>), [nested](<https://devfeed.tech/tags/nested.md>), [nesting](<https://devfeed.tech/tags/nesting.md>), [ratio](<https://devfeed.tech/tags/ratio.md>), [stat-me](<https://devfeed.tech/tags/stat-me.md>)

### AI overview

The paper analyzes how the ID algorithm constructs interventional formulas by tracing its recursive call trajectories. It reports that line 4 and the exit lines determine the formula's single outer summation, while repeated tail steps build the inner summations and ratios. A denominator retains a summation only when a repetition of the tail is entangled; an ancestry test in the original graph can determine in advance whether a topological ordering avoids that case. The authors also derive a bound on nesting depth and a dimensional counting constraint for every output, intended to guide implementation and simplification.

### Source excerpt

arXiv:2611.25877v1 Announce Type: cross Abstract: The ID algorithm decides whether an interventional distribution can be computed from observational data and, when it can, returns a formula in which products, ratios and summations of conditional probabilities are nested inside one another. We study these formulas by following the trajectories of the calls of the algorithm, each of which ends with a tail (an alternation of lines 7 and 2) and an exit, and we derive two main results. First, line~4 and the exit lines fix the single outer summation of the output, while the tail forms everything inside it, both the inner summations and the ratios. Second, a ratio keeps a summation in its denominator only when a repetition of the tail is entangled, and a test of ancestry in the original graph decides, before any formula is computed, whether a topological order can be chosen so as to avoid it. We also derive a bound on the nesting depth of the output, and show a simple ``dimensional'' count that every output has to satisfy. Together, these results constrain the form of an ID output and guide its implementation and simplification.

## Fast Computation of Lowest Common Ancestor in Version Control Commit Graph

DevFeed: [Fast Computation of Lowest Common Ancestor in Version Control Commit Graph](<https://devfeed.tech/articles/fast-computation-of-lowest-common-ancestor-in-version-control-commit-graph-145782.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25912>)

Author: Stepan Polokhin, Ruslan Savchenko, Yuriy Chernyshov

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Graphs](<https://devfeed.tech/topics/graphs.md>), [version-control](<https://devfeed.tech/topics/version-control.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [branch](<https://devfeed.tech/tags/branch.md>), [commit](<https://devfeed.tech/tags/commit.md>), [cs-ds](<https://devfeed.tech/tags/cs-ds.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data-structures-and-algorithms](<https://devfeed.tech/tags/data-structures-and-algorithms.md>), [fast](<https://devfeed.tech/tags/fast.md>), [version-control](<https://devfeed.tech/tags/version-control.md>)

### AI overview

Finding a merge base in a version control commit graph is difficult because the graph is an arbitrary acyclic graph, and searches can traverse millions of commits when no common ancestor exists. The proposed method identifies "supporting branches," preprocesses the graph around them, and uses this structure to accelerate lowest-common-ancestor queries. When removing those branches leaves connected components of bounded size, a query can take time comparable to searching within one component. The stated running time is O(δ_G m_c + n_s log² n_s + m_s log n_s), with O(d) preprocessed data per vertex; the abstract defines these parameters in terms of component size, supporting-branch reachability, and branch adjacency. The supplied text gives no benchmark results.

### Source excerpt

arXiv:2611.25912v1 Announce Type: cross Abstract: The problem of finding the lowest common ancestor in the commit graph arises when a user wants to merge two (or more) development branches: for example, to add their own development into a common branch. At that moment, the version control system must determine the merge base - the common ancestor of the latest commits of the branches, in order to show the mutual difference between the branches. The problem is complicated by the fact that the commit graph is not a tree but an arbitrary acyclic graph. Moreover, if there is no common ancestor, searching for one may require traversing the entire graph. Traversing a graph with several million vertices takes tens of seconds, which becomes noticeable to users. We show that the commit graph has additional structure - supporting branches - and that this can be used to speed up the algorithm. By extracting supporting branches, the graph can be preprocessed and the search for the lowest common ancestor can be significantly accelerated. Moreover, if removing the supporting branches decomposes the graph into connected components of bounded size, the lowest common ancestor query can be answered in time comparable to searching for a common ancestor within a single component only. We present an algorithm running in time $O(\delta_Gm_c + n_s\log^2 n_s + m_s\log n_s)$ and requiring $O(d)$ preprocessed data per vertex, where $\delta_G$ is the maximum out-degree of a vertex in $G$, $n_c$ and $m_c$ are the maximum numbers of vertices and edges in a connected component formed after removing the supporting branches, $n_s$ is the number of supporting branches, $m_s$ is the number of edges in the reachability graph between the supporting branches, and $d$ is the maximum number of supporting branches adjacent to any single component.

## Study and Improvement of Search Algorithms in Stochastic Perfect-Information

DevFeed: [Study and Improvement of Search Algorithms in Stochastic Perfect-Information](<https://devfeed.tech/articles/study-and-improvement-of-search-algorithms-in-stochastic-perfect-information-142800.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24486>)

Author: Quentin Cohen-Solal, Tristan Cazenave

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Electrical engineering and computer science (EECS)](<https://devfeed.tech/topics/electrical-engineering-and-computer-science-eecs.md>), [monte carlo tree search](<https://devfeed.tech/topics/monte-carlo-tree-search.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [games](<https://devfeed.tech/tags/games.md>), [minimax](<https://devfeed.tech/tags/minimax.md>), [performance](<https://devfeed.tech/tags/performance.md>), [search](<https://devfeed.tech/tags/search.md>)

### AI overview

The article generalizes Unbounded Minimax, a search algorithm for deterministic zero-sum two-player games with perfect information, to stochastic games in the same setting. Its abstract reports experiments showing better performance than the main stochastic search algorithms, but the excerpt gives no details about the methods, benchmarks, or measured results.

### Source excerpt

arXiv:2611.24486v1 Announce Type: new Abstract: In this article, we generalize Unbounded Minimax, the state- of-the-art search algorithm for deterministic zero-sum two- player games with perfect information to the framework of stochastic zero-sum two-player games with perfect informa- tion. We experimentally show that this generalized algorithm achieves better performance than the main stochastic search algorithms.

## Games played by Exponential Weights Algorithms

DevFeed: [Games played by Exponential Weights Algorithms](<https://devfeed.tech/articles/games-played-by-exponential-weights-algorithms-142488.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2407.06676>)

Author: Maurizio d'Andrea (TSE-R), Fabien Gensbittel (TSE-R), J\\'er\\^ome Renault (TSE-R)

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [games](<https://devfeed.tech/tags/games.md>), [interaction](<https://devfeed.tech/tags/interaction.md>), [learning](<https://devfeed.tech/tags/learning.md>), [markov-chain](<https://devfeed.tech/tags/markov-chain.md>), [math-pr](<https://devfeed.tech/tags/math-pr.md>), [probability](<https://devfeed.tech/tags/probability.md>)

### AI overview

The paper studies last-iterate behavior when players repeatedly use exponential weights with fixed learning rates: their mixed-action profile forms a homogeneous Markov chain. It reports that, when a strict Nash equilibrium exists, the probability of playing one at the next stage converges almost surely to either 0 or 1. Any limit of the mixed-action profile, if it exists, is a Nash equilibrium with equalizing payoffs. In strong coordination games, where payoffs are positive on the diagonal and zero elsewhere, the profile converges almost surely to a strict Nash equilibrium. The excerpt does not provide proofs or resolve the open questions it mentions.

### Source excerpt

arXiv:2407.06676v2 Announce Type: replace Abstract: This paper studies the last-iterate convergence properties of the exponential weights algorithm with constant learning rates. We consider a repeated interaction in discrete time, where each player uses an exponential weights algorithm characterized by an initial mixed action and a fixed learning rate, so that the mixed action profile $p^t$ played at stage $t$ follows an homogeneous Markov chain. At first, we show that whenever a strict Nash equilibrium exists, the probability to play a strict Nash equilibrium at the next stage converges almost surely to 0 or 1. Secondly, we show that the limit of $p^t$, whenever it exists, belongs to the set of ``Nash Equilibria with Equalizing Payoffs''. Thirdly, we show that in strong coordination games, where the payoff of a player is positive on the diagonal and 0 elsewhere, $p^t$ converges almost surely to one of the strict Nash equilibria. We conclude with open questions.

## Budgeted Proper Loss Design for Uncertain Decision Thresholds

DevFeed: [Budgeted Proper Loss Design for Uncertain Decision Thresholds](<https://devfeed.tech/articles/budgeted-proper-loss-design-for-uncertain-decision-thresholds-143371.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23247>)

Author: Ankit Sharma (International Institute of Information Technology Bangalore)

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [budget](<https://devfeed.tech/tags/budget.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [case](<https://devfeed.tech/tags/case.md>), [choice](<https://devfeed.tech/tags/choice.md>), [construction](<https://devfeed.tech/tags/construction.md>), [costs](<https://devfeed.tech/tags/costs.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [decision](<https://devfeed.tech/tags/decision.md>), [design](<https://devfeed.tech/tags/design.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [error](<https://devfeed.tech/tags/error.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [family](<https://devfeed.tech/tags/family.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [found](<https://devfeed.tech/tags/found.md>), [free](<https://devfeed.tech/tags/free.md>), [general](<https://devfeed.tech/tags/general.md>)

### AI overview

The paper designs proper losses for binary probability estimates used by decision makers with thresholds drawn from a specified finite family. Under a fixed total weight budget and a positive pointwise floor, its optimal loss weight clips a rescaled upper envelope of the threshold densities at that floor; a one-dimensional root search sets the normalization. The authors prove the multiplier's sharpness and optimality, analyze stability to density misspecification, and identify a limitation for atomic threshold laws. An exact histogram implementation and two synthetic experiments over 20 seeds show a better regret multiplier than uniform or average-density weights, but fitted-model performance does not improve uniformly. The guarantee concerns loss design under the stated budget, not general predictive superiority.

### Source excerpt

arXiv:2611.23247v1 Announce Type: new Abstract: A binary probability estimate may be used by several decision makers with different error costs. Proper scoring rules can emphasize selected probability thresholds, but a single average threshold distribution need not give a good worst-case regret guarantee. We study the choice of a proper loss when the threshold distribution belongs to a finite specified family. Among integrable loss weights with a positive pointwise floor and a fixed total mass, we derive the weight that minimizes the sharp, distribution-free multiplier from surrogate regret to threshold-averaged decision regret. The solution clips a rescaled upper envelope of the threshold densities at the prescribed floor; its normalization is found by a one-dimensional root search. We give proofs of sharpness, optimality, and stability under density misspecification, as well as a limitation for atomic threshold laws. An exact histogram implementation and two synthetic experiments across 20 seeds verify the construction. The optimized multiplier improves over uniform and average-density weights, while fitted-model performance does not improve uniformly. The result is a loss-design guarantee under an explicit budget, rather than a general claim of predictive superiority.

## Diffusion Models are Provably Efficient Priors for Sparse Recovery

DevFeed: [Diffusion Models are Provably Efficient Priors for Sparse Recovery](<https://devfeed.tech/articles/diffusion-models-are-provably-efficient-priors-for-sparse-recovery-143536.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24602>)

Author: Ivan Lee, Xingyu Xu, Yuejie Chi

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [AI Models](<https://devfeed.tech/topics/ai-models.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [cs-it](<https://devfeed.tech/tags/cs-it.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [diffusion](<https://devfeed.tech/tags/diffusion.md>), [diffusion-models](<https://devfeed.tech/tags/diffusion-models.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [math-it](<https://devfeed.tech/tags/math-it.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [sampling](<https://devfeed.tech/tags/sampling.md>), [sensing](<https://devfeed.tech/tags/sensing.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>), [theoretical](<https://devfeed.tech/tags/theoretical.md>)

### AI overview

Given an accurate diffusion model of a sparsity-promoting Bernoulli-Gaussian prior, a likelihood-guided annealed Langevin sampler recovers sparse signals from few linear measurements in polynomial time, with near-optimal sample complexity across a broad family of random and deterministic sensing matrices. If the signal is drawn from the assumed prior, the paper also proves total variation guarantees for posterior sampling after a final denoising step.

### Source excerpt

arXiv:2611.24602v1 Announce Type: cross Abstract: Diffusion models have transformed generative modeling through their ability to capture and generate samples from complex data distributions. This success has spurred substantial interest in using pretrained diffusion models as expressive priors for highly ill-posed inverse problems in imaging and sensing. Despite strong empirical performance, theoretical understanding of this approach remains limited: existing guarantees are often asymptotic or entail prohibitive computational costs in the worst case. In this paper, we address this gap by studying sparse recovery from a small number of linear measurements, a classical problem in compressed sensing. We show that, given an accurate diffusion model capturing a sparsity-promoting Bernoulli-Gaussian prior, a likelihood-guided annealed Langevin sampler provably recovers the sparse signal in polynomial time with near-optimal sample complexity for a broad family of random and deterministic sensing matrices. When the signal is indeed drawn from the postulated prior, we further establish total variation guarantees for posterior sampling after a final denoising step. These results lay a theoretical foundation for statistically and computationally efficient inverse solvers with diffusion priors.

## How Hough Transforms Enable Computers to See

DevFeed: [How Hough Transforms Enable Computers to See](<https://devfeed.tech/articles/how-hough-transforms-enable-computers-to-see-141981.md>)

Original publisher: [Read original article](<https://hackaday.com/2026/11/18/how-hough-transforms-enable-computers-to-see/>)

Author: Maya Posch

Published: 2026-11-19T03:00:48Z

Content type: article

Language: en

Sources: [Hackaday](<https://devfeed.tech/sources/hackaday.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Computer science](<https://devfeed.tech/topics/computer-science.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [cognition](<https://devfeed.tech/tags/cognition.md>), [computer-vision](<https://devfeed.tech/tags/computer-vision.md>), [detection](<https://devfeed.tech/tags/detection.md>), [hough-transform](<https://devfeed.tech/tags/hough-transform.md>), [lidar](<https://devfeed.tech/tags/lidar.md>), [noise](<https://devfeed.tech/tags/noise.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [radar](<https://devfeed.tech/tags/radar.md>)

### AI overview

The Hough Transform helps computers detect lines and object borders in images by finding scene points that may form them, relying on edge detection. Paul Hough developed the original method in the 1960s to analyze bubble-chamber photographs. Checking every possible line is too slow for complex real-world scenes, so later optimizations reduce processing time and improve tolerance to pixel noise. Detection alone does not identify what an object means or what action to take; the excerpt notes that sensors such as radar or Lidar can provide additional scene information for systems such as cars.

### Source excerpt

Although identifying what we can see with our eyes feels like the most natural thing in the world, the responsible cognitive processes running on our brain's wetware are quite a ...read more

## GPU architecture, clearly explained

DevFeed: [GPU architecture, clearly explained](<https://devfeed.tech/articles/gpu-architecture-clearly-explained-141433.md>)

Original publisher: [Read original article](<https://blog.dailydoseofds.com/p/gpu-architecture-clearly-explained>)

Author: Avi Chawla

Published: 2026-11-19T00:13:29Z

Content type: article

Language: en

Sources: [Daily Dose of Data Science](<https://devfeed.tech/sources/daily-dose-of-data-science.md>)

Topics: [Multi-GPU](<https://devfeed.tech/topics/multi-gpu.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [quantization](<https://devfeed.tech/topics/quantization.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [addition](<https://devfeed.tech/tags/addition.md>), [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [attention](<https://devfeed.tech/tags/attention.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [block](<https://devfeed.tech/tags/block.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [cache](<https://devfeed.tech/tags/cache.md>), [compute](<https://devfeed.tech/tags/compute.md>), [data](<https://devfeed.tech/tags/data.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gpu-architecture](<https://devfeed.tech/tags/gpu-architecture.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-bandwidth](<https://devfeed.tech/tags/memory-bandwidth.md>), [token](<https://devfeed.tech/tags/token.md>)

### AI overview

For single-response LLM generation, memory bandwidth can limit token rate because each 16-bit weight read transfers two bytes for only two arithmetic operations. Batching requests improves reuse by applying each loaded weight across several requests. GPU execution is organized as threads grouped into 32-thread warps, blocks of cooperating warps, and SMs that run blocks. Registers, shared memory and L1, and the shared L2 cache keep data closer to compute; model weights and large arrays reside in HBM, which takes longer to access. Algorithms can reduce HBM traffic by reusing local data: FlashAttention processes smaller pieces and keeps intermediate results near compute instead of writing and rereading a full attention-score table. Thus compute ratings alone do not predict token speed; data movement and reuse also matter.

### Source excerpt

...and why memory bandwidth, not compute, sets your token rate.

## How to Estimate Dose-Response Curves When DoubleML Falls Short

DevFeed: [How to Estimate Dose-Response Curves When DoubleML Falls Short](<https://devfeed.tech/articles/how-to-estimate-dose-response-curves-when-doubleml-falls-short-140793.md>)

Original publisher: [Read original article](<https://towardsdatascience.com/how-to-estimate-dose-response-curves-when-doubleml-falls-short/>)

Author: Ryan OSullivan

Published: 2026-11-18T12:00:00Z

Content type: article

Language: en

Sources: [Towards Data Science](<https://devfeed.tech/sources/towards-data-science.md>)

Topics: [doubleml](<https://devfeed.tech/topics/doubleml.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [2-2](<https://devfeed.tech/tags/2-2.md>), [2014](<https://devfeed.tech/tags/2014.md>), [2017](<https://devfeed.tech/tags/2017.md>), [2018](<https://devfeed.tech/tags/2018.md>), [2020](<https://devfeed.tech/tags/2020.md>), [2021](<https://devfeed.tech/tags/2021.md>), [2022](<https://devfeed.tech/tags/2022.md>), [2025](<https://devfeed.tech/tags/2025.md>), [aggregate](<https://devfeed.tech/tags/aggregate.md>), [aipw](<https://devfeed.tech/tags/aipw.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [app](<https://devfeed.tech/tags/app.md>), [causal-inference](<https://devfeed.tech/tags/causal-inference.md>), [data](<https://devfeed.tech/tags/data.md>), [data-science](<https://devfeed.tech/tags/data-science.md>), [doubleml](<https://devfeed.tech/tags/doubleml.md>), [editor-s-picks](<https://devfeed.tech/tags/editor-s-picks.md>), [estimator](<https://devfeed.tech/tags/estimator.md>), [hidden](<https://devfeed.tech/tags/hidden.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [response](<https://devfeed.tech/tags/response.md>), [robust](<https://devfeed.tech/tags/robust.md>), [simulations](<https://devfeed.tech/tags/simulations.md>), [statistics](<https://devfeed.tech/tags/statistics.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

For continuous treatments, DoubleML's usual partially linear model estimates one linear slope; it can miss nonlinear effects and becomes noisy when fitted separately to small groups. The article presents a doubly robust dose-response curve: cross-fit outcome and dose models, combine them into a pseudo-outcome, then smooth it with partial pooling across nested groups. In simulations, this method captured inverted-U and saturating effects, corrected much of the error when one nuisance model was misspecified, and improved estimates for small groups. Learner choice mattered: density weights could fail with boosting alone, while balancing weights performed better in that setting; a stack combining boosting and splines worked well on smooth data, though no learner won everywhere. For hidden confounding, difference-in-differences helped when the unmeasured trait was stable, subject to a stronger parallel-trends assumption. The author cautions that simulated confidence bands often undercovered and identifies poor dose overlap, group-level treatment, zero-dose spikes, and crossed groups as limitations.

### Source excerpt

Simulations test DoubleML against Kennedy's doubly robust estimator, with partial pooling across 200 stores and a DiD fix for hidden confounders. The post How to Estimate Dose-Response Curves When DoubleML Falls Short appeared first on Towards Data Science.

## Tight Lower Bounds for Differentially Private Continual Counting

DevFeed: [Tight Lower Bounds for Differentially Private Continual Counting](<https://devfeed.tech/articles/tight-lower-bounds-for-differentially-private-continual-counting-141452.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.17650>)

Author: Charlie Harrison, Ethan Leeman

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Differential Privacy](<https://devfeed.tech/topics/differential-privacy.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [binary-tree](<https://devfeed.tech/tags/binary-tree.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-ds](<https://devfeed.tech/tags/cs-ds.md>), [differential-privacy](<https://devfeed.tech/tags/differential-privacy.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [error](<https://devfeed.tech/tags/error.md>), [gaussian](<https://devfeed.tech/tags/gaussian.md>), [lower-bounds](<https://devfeed.tech/tags/lower-bounds.md>), [mechanism](<https://devfeed.tech/tags/mechanism.md>), [noise](<https://devfeed.tech/tags/noise.md>), [stream](<https://devfeed.tech/tags/stream.md>)

### AI overview

For differential privacy with 0 ≤ ε ≤ 1 and 0 ≤ δ ≤ 1/4, the paper proves asymptotically tight lower bounds for ℓ∞ error, mean squared error, and maximum per-coordinate expected squared error in continual counting. The bounds apply to arbitrary mechanisms, including ones given the full stream in advance, and match the blocked Binary Tree Mechanism using whichever of Laplace or Gaussian noise performs better. This establishes asymptotic optimality across the stated error measures and privacy regimes. The proof uses one hard distribution that tags possible target flipped elements with a score evaluated down a tree; a simple score modification handles all three error measures.

### Source excerpt

arXiv:2609.17650v3 Announce Type: replace-cross Abstract: The Binary Tree Mechanism is a standard algorithm for differentially private continual counting, but its complete asymptotic optimality under differential privacy has remained unresolved since its introduction. We resolve this question. For $0 \leq \varepsilon \leq 1$, we prove asymptotically tight lower bounds for $\ell_\infty$, mean squared, and maximum per-coordinate expected squared error simultaneously under all regimes of $0 \leq \delta \leq 1/4$. These bounds hold for arbitrary mechanisms, even when the entire stream is available in advance. Our lower bounds match the (blocked) Binary Tree Mechanism instantiated with the best of Laplace or Gaussian noise, establishing its asymptotic optimality. Our proof uses a single hard distribution where elements are ``tagged'' as potentially being the target flipped element via a score evaluated down a tree. A simple modification of the score allows the same framework to establish tight lower bounds for all three error measures.

## Colombo: A Frontier-to-Frontier Autoresearch System for Oracle-Based Optimization

DevFeed: [Colombo: A Frontier-to-Frontier Autoresearch System for Oracle-Based Optimization](<https://devfeed.tech/articles/colombo-a-frontier-to-frontier-autoresearch-system-for-oracle-based-optimization-140116.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23080>)

Author: Haihan Zhang, Wendao Wu, Chenheng Zhang, Chunyuan Zheng, Yanyi Li, Cong Fang, Haoxuan Li, Zhouchen Lin

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Combinatorial optimization](<https://devfeed.tech/topics/combinatorial-optimization.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [AI for science](<https://devfeed.tech/topics/ai-for-science.md>), [Operations research and optimization](<https://devfeed.tech/topics/operations-research-and-optimization.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [adversarial](<https://devfeed.tech/tags/adversarial.md>), [ai](<https://devfeed.tech/tags/ai.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [atlas](<https://devfeed.tech/tags/atlas.md>), [autoresearch](<https://devfeed.tech/tags/autoresearch.md>), [certification](<https://devfeed.tech/tags/certification.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [formal](<https://devfeed.tech/tags/formal.md>), [frontier](<https://devfeed.tech/tags/frontier.md>), [independent](<https://devfeed.tech/tags/independent.md>), [lean](<https://devfeed.tech/tags/lean.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [memory](<https://devfeed.tech/tags/memory.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [research](<https://devfeed.tech/tags/research.md>), [science](<https://devfeed.tech/tags/science.md>), [system](<https://devfeed.tech/tags/system.md>)

### AI overview

Colombo is a self-organizing AI research system instantiated in oracle-based optimization. It maps gaps between achievable guarantees and unavoidable costs in a Complexity Atlas, then turns unresolved gaps into adaptive research programmes. Its Adversarial Co-Ascent develops algorithms alongside hard problem families to test information use and expose unavoidable costs. Independent review and Lean-based certification check claims, while long-term memory carries supported findings across settings. The abstract reports optimal or near-optimal rates for more than fifty Atlas settings; it does not provide details of those settings or the underlying proofs.

### Source excerpt

arXiv:2611.23080v1 Announce Type: new Abstract: Science advances from frontier to frontier as discoveries reshape what is known and create the basis for further discovery. We present Colombo, a self-organizing AI researcher that drives this renewal, first instantiated in oracle-based optimization. Here, the central question is how efficiently a problem class can be solved through a prescribed information interface and what costs no admissible algorithm can avoid. The gap between achievable guarantees and unavoidable limits defines the frontier recorded in its Complexity Atlas, a living map of frontier settings and the current state of knowledge. Self-Organization turns unresolved gaps into adaptive research programmes, coordinating conjecture formation, mathematical investigation, and replanning as evidence accumulates. Adversarial Co-Ascent develops algorithms and hard families through reciprocal challenge, exposing mechanisms of information use and concealment that guide stronger methods and proofs of unavoidable costs. Independent review and Lean-based formal certification check mathematical claims, while the Long-Term Memory carries supported findings and research experience across settings. To date, Colombo has established optimal or near-optimal rates for more than fifty settings in the Atlas. Colombo thus takes a concrete step toward Autopoietic Science: a scientific process whose validated advances regenerate the conditions of its own progress, continually reshaping how inquiry is organized and what it can discover.

## A Transformer-Derived Iterative Preconditioner

DevFeed: [A Transformer-Derived Iterative Preconditioner](<https://devfeed.tech/articles/a-transformer-derived-iterative-preconditioner-141821.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22941>)

Author: Patrick Lutz, Themistoklis Haris, Aditya Gangrade, Venkatesh Saligrama

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Transformer](<https://devfeed.tech/topics/transformer.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [attention](<https://devfeed.tech/tags/attention.md>), [condition-number](<https://devfeed.tech/tags/condition-number.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [gradient-descent](<https://devfeed.tech/tags/gradient-descent.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [linear](<https://devfeed.tech/tags/linear.md>), [local](<https://devfeed.tech/tags/local.md>), [mixing](<https://devfeed.tech/tags/mixing.md>), [prediction](<https://devfeed.tech/tags/prediction.md>), [problems](<https://devfeed.tech/tags/problems.md>), [proof-of-concept](<https://devfeed.tech/tags/proof-of-concept.md>), [rapid](<https://devfeed.tech/tags/rapid.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [reduce](<https://devfeed.tech/tags/reduce.md>), [softmax](<https://devfeed.tech/tags/softmax.md>), [solve](<https://devfeed.tech/tags/solve.md>), [transformer](<https://devfeed.tech/tags/transformer.md>)

### AI overview

A transformer trained to solve linear systems implicitly performs conditioning improvements; tracing its computations led to RAPID, a standalone iterative preconditioner with no learned components. For symmetric positive definite matrices, RAPID combines randomized mixing with sparse local corrections and can be applied incrementally. Proof-of-concept tests on synthetic and real-world problems report improved conditioning and fewer conjugate-gradient iterations to reach a target accuracy. Under a Haar-mixing idealization, the authors prove convergence to any fixed target condition number regardless of the matrix's spectral distribution, with logarithmic dependence on initial conditioning.

### Source excerpt

arXiv:2611.22941v1 Announce Type: new Abstract: Transformers trained on in-context prediction problems can learn known numerical algorithms, e.g., gradient descent. We go further, showing that their internal computations can reveal new algorithms with provable guarantees. A softmax-attention transformer trained to solve linear systems $Xw=y$ implicitly improves matrix conditioning. Tracing $XX^\top$ reveals an iterative preconditioning primitive, which we develop into RAPID, a standalone algorithm requiring no learned components. RAPID is an anytime preconditioner for symmetric positive definite (SPD) matrices, using randomized mixing and sparse local corrections to improve conditioning. Proof-of-concept experiments on synthetic and real-world problems consistently improve conditioning and reduce conjugate gradient iterations needed to reach a target accuracy. For a Haar-mixing idealization, we prove convergence to any fixed target condition number regardless of spectral distribution, with only logarithmic dependence on initial conditioning. Together, these results show how a transformer can discover a broadly applicable numerical algorithm.

## Values Shape What Self-Improving Coding Agents Build

DevFeed: [Values Shape What Self-Improving Coding Agents Build](<https://devfeed.tech/articles/values-shape-what-self-improving-coding-agents-build-140113.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23067>)

Author: Jason Liang, Dylan Waldner, Risto Miikkulainen

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [ai alignment](<https://devfeed.tech/topics/ai-alignment.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ma](<https://devfeed.tech/tags/cs-ma.md>), [human-oversight](<https://devfeed.tech/tags/human-oversight.md>), [improvement](<https://devfeed.tech/tags/improvement.md>), [performance](<https://devfeed.tech/tags/performance.md>), [self-improvement](<https://devfeed.tech/tags/self-improvement.md>), [self-improving-agents](<https://devfeed.tech/tags/self-improving-agents.md>), [values](<https://devfeed.tech/tags/values.md>)

### AI overview

Across diverse coding tasks, short value statements in a self-improving agent's persistent instructions affected both performance and the solutions it built. In the study, openness to change improved held-out performance, while conservation scored below an agent given no values. Value types also led to algorithms differing in size, complexity, and approach. The researchers report that oversight matters: letting agents revise their values narrowed differences between value sets, and values distilled from AI literature showed no detectable gain over having none. These findings concern the tasks and conditions described in the abstract.

### Source excerpt

arXiv:2611.23067v1 Announce Type: new Abstract: Self-improving agents are typically optimized for the results they produce, with less attention to how they produce them. Their instructions give designers limited ways to shape how they work, especially when the task is open-ended. This paper studies whether a short value statement in an agent's persistent instruction file changes not only how well the agent performs but also what it builds. Four higher-order value types in Schwartz's theory of basic human values were evaluated: openness to change, conservation, self-enhancement, and self-transcendence. Across diverse coding tasks, the values were held fixed within each run over multiple iterations of self-improvement. Three findings emerged: (1) Values matter for performance across a diverse set of tasks. The openness values increase performance on held-out data, whereas the opposite conservation values result in scores below those of an agent given no values. (2) Values change what agents build, producing solution algorithms that differ in size, complexity and approach. (3) Human oversight is still needed for designing values. Allowing the agent to revise its own values narrows the differences between sets of values, and values distilled from the AI literature provide no detectable gain over having no values. Properly designed values can thus influence what a self-improving coding agent builds and, where the task permits, how well it performs.

## Deal With It: On Better Schedules for Listwise Reranking

DevFeed: [Deal With It: On Better Schedules for Listwise Reranking](<https://devfeed.tech/articles/deal-with-it-on-better-schedules-for-listwise-reranking-140023.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22392>)

Author: Benjamin Clavi\\'e, Herumb Shandilya, Hanna Lichtenberg, Aamir Shakir, Makoto P. Kato

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [search-engines](<https://devfeed.tech/topics/search-engines.md>), [round robin](<https://devfeed.tech/topics/round-robin.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ir](<https://devfeed.tech/tags/cs-ir.md>), [quota](<https://devfeed.tech/tags/quota.md>), [random](<https://devfeed.tech/tags/random.md>), [rank](<https://devfeed.tech/tags/rank.md>), [repair](<https://devfeed.tech/tags/repair.md>), [reranking](<https://devfeed.tech/tags/reranking.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [schedules](<https://devfeed.tech/tags/schedules.md>), [split](<https://devfeed.tech/tags/split.md>)

### AI overview

Listwise LLM rerankers can lose top passages when a parallel schedule advances a fixed quota from each candidate group, triggering costly repair calls. The abstract reports that dealing candidates round-robin by retriever rank minimizes expected cuts under a simple retriever model; contiguous chunks cut more as the retriever improves. DealRank is within 0.1 nDCG@10 points of the best schedules on average across six LLMs, and is 1.1-1.4 times faster than BlitzRank with concurrent first calls up to 1,000 candidates. In existing schedules such as BlitzRank, dealing reduces queries requiring repair from 59% to 14% with no significant quality change. Random partitioning appears equivalent at quota four, but depends on the seed and trails by 1.3 nDCG@10 points at quota one over a dense retriever. These are abstract-level claims; the supplied text does not include the full paper.

### Source excerpt

arXiv:2611.22392v1 Announce Type: cross Abstract: Listwise LLM rerankers cannot reliably rank hundreds of documents in a single call, and rely on schedules to orchestrate their calls. Parallel schedules split candidates into groups and advance a fixed quota from each. When a group holds more of the top passages than its quota, some are cut, and expensive repair calls become required. We show that the way candidates are split matters where such a quota can bind, and that, in expected cuts, the best split there deals them round-robin by retriever rank, like cards. Although not conceptually new, dealing has remained unanalyzed. We prove that, under a simple retriever model, no split with equal quotas cuts fewer of the true top ten on average, and that contiguous chunks cut more as the retriever improves. DealRank, the simplest schedule our analysis allows, is on average within 0.1 nDCG@10 points of the best schedules over six LLMs, in two rounds. It is consistently 1.1 to 1.4 times faster than BlitzRank with concurrent first calls up to a thousand candidates. There, it needs three rounds and is eleven times faster than the sliding window. In existing schedules such as BlitzRank, dealing reduces repair calls from 59% of queries to 14%, improving latency with no significant change in quality. Random partitioning appears equivalent at a quota of four, as predicted, but ties results to the seed and trails by 1.3 nDCG@10 points at a quota of one over a dense retriever.

## On Minimal Observation Time for Recovering Latent Hawkes Networks

DevFeed: [On Minimal Observation Time for Recovering Latent Hawkes Networks](<https://devfeed.tech/articles/on-minimal-observation-time-for-recovering-latent-hawkes-networks-141552.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2605.08400>)

Author: Jonas Linkerh\\"agner, Michele Bortolasi, Lorenzo Baldassari, Maarten V. de Hoop, Ivan Dokmani\\'c

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [arxiv](<https://devfeed.tech/tags/arxiv.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [cs-it](<https://devfeed.tech/tags/cs-it.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [data](<https://devfeed.tech/tags/data.md>), [estimator](<https://devfeed.tech/tags/estimator.md>), [event](<https://devfeed.tech/tags/event.md>), [finance](<https://devfeed.tech/tags/finance.md>), [inequality](<https://devfeed.tech/tags/inequality.md>), [log](<https://devfeed.tech/tags/log.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [math-it](<https://devfeed.tech/tags/math-it.md>), [math-st](<https://devfeed.tech/tags/math-st.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [minimal](<https://devfeed.tech/tags/minimal.md>), [networks](<https://devfeed.tech/tags/networks.md>), [neuroscience](<https://devfeed.tech/tags/neuroscience.md>), [point](<https://devfeed.tech/tags/point.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>), [stat-th](<https://devfeed.tech/tags/stat-th.md>), [systems](<https://devfeed.tech/tags/systems.md>), [theoretical](<https://devfeed.tech/tags/theoretical.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

For stationary Hawkes processes with sparse, weak interactions, exact recovery of a latent network requires observation time of order log d, and the paper proves this rate is both sufficient and necessary. Its upper-bound method screens with clipped, binned event data, then refines estimates by least squares, using concentration bounds from the Poisson cluster representation. For the lower bound, it combines Fano's inequality with Jacod's Girsanov formula on a suitable subclass of networks.

### Source excerpt

arXiv:2605.08400v2 Announce Type: replace-cross Abstract: Dynamics of interacting systems in engineering, society, and nature often evolve over latent networks that govern which entities can interact. We study the problem of inferring these networks from event-based observations, which arise naturally in finance, seismology, and neuroscience. While there is substantial algorithmic work addressing this important problem, theoretical results are scarce. In this paper we ask the following fundamental question: what is the minimum time that one must observe the dynamics in order to exactly recover the underlying network, as a function of the number $d$ of interacting entities? For a class of stationary Hawkes processes with sparse, weak interactions, we prove that an observation time of order $\log d$ is sufficient and necessary. For the upper bound we construct a two-stage estimator that uses clipped and binned event data for screening, followed by a least-squares refinement, and apply concentration bounds derived from the Poisson cluster representation. For the lower bound we combine Fano's inequality with Jacod's Girsanov formula for point processes on a suitable subclass of networks.

## Tight Bounds for Non-Monotone Submodular Maximization under a Cardinality Constraint with Constant Recourse

DevFeed: [Tight Bounds for Non-Monotone Submodular Maximization under a Cardinality Constraint with Constant Recourse](<https://devfeed.tech/articles/tight-bounds-for-non-monotone-submodular-maximization-under-a-cardinality-constraint-with-constant-recourse-139013.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.20257>)

Author: Vaneet Aggarwal

Published: 2026-11-17T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Combinatorial optimization](<https://devfeed.tech/topics/combinatorial-optimization.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [polynomials](<https://devfeed.tech/topics/polynomials.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [after](<https://devfeed.tech/tags/after.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [also](<https://devfeed.tech/tags/also.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [best](<https://devfeed.tech/tags/best.md>), [budget](<https://devfeed.tech/tags/budget.md>), [cardinality](<https://devfeed.tech/tags/cardinality.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [cs-ds](<https://devfeed.tech/tags/cs-ds.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [elements](<https://devfeed.tech/tags/elements.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [function](<https://devfeed.tech/tags/function.md>), [graph](<https://devfeed.tech/tags/graph.md>), [groups](<https://devfeed.tech/tags/groups.md>), [half](<https://devfeed.tech/tags/half.md>), [inequality](<https://devfeed.tech/tags/inequality.md>), [under](<https://devfeed.tech/tags/under.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

For online maximization of a nonnegative, non-monotone submodular function under a cardinality constraint, the paper gives an algorithm with recourse O(ε⁻²) and expected value at least (1/4−ε) times the best feasible set of arrived elements at every step. It makes polynomially many function evaluations, only on sets of arrived elements. The authors prove 1/4 is the optimal limiting ratio for constant recourse, even with advance knowledge of the function and arrival order and unlimited computation; any fixed ratio above 1/4 requires recourse growing as a positive power of the cardinality budget. The method caps selection probabilities at one half, maintains a bound relating feasible-set values to the expected value of a random set, and gradually replaces elements to round those probabilities. The excerpt reports an improvement over the previous constant-recourse ratio of about 0.172.

### Source excerpt

arXiv:2611.20257v1 Announce Type: cross Abstract: We study the maximization of a nonnegative submodular function under a cardinality constraint when elements arrive one at a time and an algorithm must report a feasible set after every arrival. The recourse of an algorithm is the largest number of insertions and deletions that it makes to the reported set at a single arrival. For every $\epsilon>0$, we give an algorithm with recourse $O(\epsilon^{-2})$ whose reported set has, at every time, expected value at least $1/4-\epsilon$ times the largest value of a feasible set of arrived elements. The algorithm evaluates the function polynomially often, and only on sets of arrived elements. We also show that no algorithm with constant recourse achieves a ratio above $1/4$, even if it knows the function and the arrival order in advance and has unlimited computation, and that any fixed ratio above $1/4$ requires recourse that grows as a positive power of the cardinality budget. Thus $1/4$ is the optimal limiting ratio with constant recourse. The previous best ratio with constant recourse was $3-2\sqrt2\approx0.172$. Our algorithm assigns selection probabilities of at most one half and maintains, as elements arrive, an inequality bounding the value of every feasible set by a multiple of the expected value of a random set drawn with these probabilities; the reported set moves to a rounding of these probabilities through gradual replacements. The upper bound uses a weighted directed graph whose vertices arrive in groups of decreasing sizes.

[Next page](<https://devfeed.tech/topics/algorithms.md?cursor=WyIyMDI2LTExLTE3VDA1OjAwOjAwKzAwOjAwIiwgImZmODZjZWQ1LWZlZTctNDNmZi04YjdmLTE2MzhlZGU3Y2E3YyJd>)