Papers for

simulation software developers

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.

Farms builds a trustworthy knowledge base for automated computing science

FARMS: A Verifiable Foundation for Automated Computational Science

Abstract: Automated computational science could accelerate discovery by selecting, adapting and developing numerical methods. This prospect requires mathematical knowledge that AI systems can interpret and reuse with explicit guarantees. Here we present FARMS, a faithful and efficient foundation that transforms computational mathematics into AI-ready computing knowledge. FARMS connects formal statements to source context, algorithmic meaning and quantitative guarantees through source preparation, reusable representations and semantic review. Across 171 targets in randomized numerical linear algebra and numerical partial differential equations, 157 were accepted by the pipeline, with mean estimated costs of US \$0.85-2.29 per target across sources. Lean-checked implications from explicit source premises connect selected statements to computational skills, illustrated by a heat-flow solve and wave-response compression. FARMS therefore supports an affordable, reusable knowledge foundation for trustworthy automated computational science.

Thu 29 OctArtificial IntelligenceLogic in Computer Science
The gist
Scientists want to use AI to help pick and improve math methods for computers to solve scientific problems faster. The authors created a tool called FARMS that turns complex math statements into a form AI can understand and trust, linking these statements back to their original sources and proofs. FARMS was tested on many math problems related to linear algebra and differential equations, and it successfully verified most of them efficiently and cheaply. This helps make automated problem-solving in science more reliable and easier to reuse. The authors show examples where their system connects math knowledge with real computational tasks like heat flow and wave response.
Open → 2610.40560v1

New kernel method improves solving complex partial differential equations

CFKS: Continuum-Feature Kernel PDE Solvers

Abstract: Neural-network-based PDE solvers require architectural choices, particularly the number of layers and neurons per layer. Fixing a single Gaussian radial basis function (RBF) feature layer and taking the number of features to the continuum limit removes the need to prescribe a finite feature count or select individual feature centers, thereby reducing representation arbitrariness. Motivated by this principle, we introduce Continuum-Feature Kernel Solver (CFKS), a deterministic framework for PDEs obtained by analytically marginalizing a bounded continuum of Gaussian RBF features. CFKS works directly with the resulting continuum-feature mean kernel and its operator-applied counterparts, parameterized by prescribed Gaussian widths and bounded center distributions. For linear PDEs, CFKS leads to symmetric operator-kernel collocation systems with null-space enforcement of physical constraints. Nonlinear PDEs are addressed through linearized initialization and nonlinear least-squares residual minimization using analytical kernel derivatives and Jacobians. Residual-guided collocation enrichment and sequential space--time-slab marching provide additional resolution strategies, while prescribed multiscale kernel refinement helps resolve localized nonlinear structures. Finite-feature experiments confirm convergence of empirical value and operator Gram matrices toward their continuum counterparts. Numerical studies include oscillatory and multiscale ODEs, irregular-domain Poisson and biharmonic problems, singular perturbations, transient transport equations, and viscous Burgers' equation. The results establish CFKS as a direct computational connection between finite Gaussian-RBF representations and continuum-feature kernel PDE solvers. Codes: https://github.com/vikas-dwivedi-2022/CFKS_Codes

Wed 28 OctMachine Learning
The gist
Solving partial differential equations (PDEs) with neural networks often requires guessing how many features or layers to use, which can be tricky. The authors developed a method called CFKS that removes this guesswork by using an infinite, continuous set of simple building blocks called Gaussian features. This approach turns the problem into working with smooth kernels, making it easier to enforce physical rules and solve both linear and nonlinear PDEs. Their tests show CFKS can handle a range of challenging problems with oscillations, sharp changes, and unusual shapes.
Open → 2610.38644v1

Simulation gaps challenge testing accuracy for automated driving systems

The Reality Gap in Automated Driving Systems Testing: Landscape, Challenges, and Research Directions

Abstract: Simulation is essential for testing automated driving systems (ADS), but discrepancies between simulation and reality can undermine testing conclusions. It remains unclear which discrepancies the literature addresses and what evidence supports correspondence claims. We present a systematic mapping of 235 primary studies that measure or mitigate the reality gap in ADS testing, selected from 4,195 publications. We characterise objectives, targets, approaches, experimental setups, and evaluation evidence. Our classification distinguishes simulated and real-world execution across six ADS test components, separately for each approach and its evaluation reference. This distinguishes real-world information used to construct an approach from evidence used to evaluate its claims. Of the included studies, 76% address mitigation, primarily targeting scenario and actor realism and perception, while 94% report validation or measurement procedures. Only 61 studies report metrics from multiple families covering sensor/perception correspondence, ADS behaviour, vehicle dynamics, or safety outcomes; this coverage does not establish causal links between discrepancies and test verdicts. The synthesis highlights that real-world content and physical execution must be interpreted against the claim evaluated. The findings motivate claim-specific evaluation and component-level reporting to establish which discrepancies affect testing conclusions and when simulation evidence supports conclusions about real-world ADS behaviour.

Wed 28 OctSoftware EngineeringRobotics
The gist
Testing self-driving cars often uses computer simulations because testing in the real world can be difficult or unsafe. But simulations don't always match reality, which can lead to incorrect conclusions about how well these systems work. The authors looked at over 200 studies to see how researchers measure and fix the differences between simulation and reality. They found most work focuses on making scenarios and perceptions more realistic but that many studies lack clear evidence linking simulation problems to actual safety impacts. Their analysis suggests tests should clearly state which real-world differences matter and report on specific parts of the self-driving system.
Open → 2610.38628v1

Self-evolving vision language models improve physical reasoning accuracy

PhysEvolve: Verifier-grounded Self-evolution for Physical Reasoning with Executable Worlds

Abstract: Physical reasoning underpins how embodied systems understand and act in the physical world, yet vision-language models (VLMs) remain unreliable on questions about dynamics and physical causality. Progress is critically constrained by the scarcity of grounded counterfactual training data, as observational videos capture only the factual trajectory that occurred. The self-evolving paradigm offers a route beyond fixed datasets by enabling models to construct their own training problems. Extending this paradigm to physics, however, requires an external source of truth that can both validate model-proposed environments and verify alternative physical outcomes under intervention. We introduce \physevolve{}, a verifier-grounded self-evolving framework that trains VLMs for causal physical reasoning from model-proposed executable worlds and simulation-authored tasks. At each round, a shared VLM proposes executable world programs and evidence schemas; a deterministic physics engine freezes each valid world, simulates matched baseline and body-elided counterfactual branches, and synthesizes discrete, answer-bound visual tasks. Exact verifier feedback from task solving updates both the shared policy via GRPO and an adaptive curriculum over physical intents. Starting from Qwen3-VL-8B-Instruct, \physevolve{} achieves targeted gains across PhysBench, CausalPhys, and ContPhy without human intervention data, improving PhysBench Throwing by $8.8$ points and ContPhy Counterfactual Removal and Goal-Pit by $7.4$ and $24.4$ points. These gains concentrate on interaction-sensitive and altered-world questions, demonstrating zero-shot transfer of causal principles to unseen complex dynamics (cloth, fluid, soft bodies) and real-world video.

Mon 26 OctArtificial Intelligence
The gist
Physical reasoning helps machines understand how things move and interact, but current vision-language models struggle with answers about cause and effect in the physical world. The authors created PhysEvolve, a system where the model generates its own physics problems, checks them through simulations, and learns from the exact answers. This approach improves the model's ability to solve tricky questions about movement and changed scenarios, even for things it hasn’t seen before like cloth and fluids. It does all this without needing hand-labeled training data.
Open → 2610.34921v1

Polynomial features improve low dimensional data models with stability control

Greedy Orthogonal Polynomial Manifolds with Lipschitz Control for Dimensionality Reduction and Reduced Modeling

Abstract: Polynomial manifolds provide nonlinear low-dimensional representations through polynomial decoders. We propose to represent the polynomial terms of the decoder using features that are orthonormal on the training data. This empirical orthogonality enables a greedy algorithm, Greedy-OPM, which jointly selects encoder modes and polynomial features while minimizing the reconstruction error under a prescribed bound on the decoder's Lipschitz constant. Numerical experiments show that this Lipschitz constraint improves generalization away from the training data while retaining high reconstruction accuracy.

Sat 24 OctMachine Learning
The gist
When creating simpler versions of complex data, it helps to ensure the simplified model remains accurate even when looking at new data. The authors suggest a new way to pick parts of a polynomial-based model that are both easy to work with and keep the model from changing too wildly. They show their method can build models that are both precise and reliable beyond just the initial training data. This approach helps make better predictions and understandings outside the examples the model learned from.
Open → 2610.33784v1

New learning method improves prediction of coherent futures in changing worlds

Operator-Mismatch Contrastive Learning for World-Relative Trajectory Coherence

Abstract: World models are increasingly judged by how well they rank plausible futures, yet plausibility alone is the wrong target. The same scene can evolve under many latent rules, and a future that is smooth and physically valid under one rule can be incoherent under the rule actually in force. We formalize the resulting failure, operator-blindness, and show that it is systematically hidden by standard evaluation: a scorer can attain near-perfect generic ranking while separating current-world from other-world futures no better than chance. We introduce Operator-Mismatch Contrastive (OMC) learning, whose semantic hard negatives are valid-but-wrong-operator trajectories, and a matching protocol that measures world-relative coherence directly. On a controlled synthetic benchmark with in- and out-of-distribution operator parameters, across two trajectory-scoring backbones, and on feature-level external validation with CoPhy ballsCF, OMC raises operator-sensitive scoring far above a chance baseline that nonetheless achieves 0.99 generic top-1. We prove that the wrong-operator negative is necessary both for the protocol to detect the failure and for the objective to fix it, and position OMC as an auxiliary coherence signal (a trajectory-coherence scorer, not a generative model, planner, or control agent) that can be attached to existing world-model representations.

Sun 18 OctMachine Learning
The gist
Predicting possible future paths in a world is tricky because the rules that govern how things change might be different each time. The authors find that existing methods often can tell if a future looks believable, but can't tell if it fits the actual rules in effect. They propose a new way to train models by showing them examples of futures that are valid but use the wrong rules, helping them learn to spot which futures truly match the current world. Their approach improves the ability to score predictions in a way that respects the true dynamics of the situation.
Open → 2610.25360v1

Triple overlap boosts multi-GPU Krylov solver performance at scale

Triple Overlap in Pipelined Krylov Methods on Multi-GPU Systems

Abstract: We introduce a novel triple-overlap implementation of the pipelined preconditioned conjugate gradient (Pipe-PCG) and pipelined stabilized biconjugate gradient (Pipe-BiCGStab) solvers, methods widely used in scientific applications. By leveraging a collective communication library, our approach extends conventional computation-communication overlap to concurrently execute collective operations, irregular P2P communication, and compute kernels, enabling computation-communication-communication overlap across multiple GPUs. We evaluate the design on the MareNostrum 5 (H100) and Leonardo (A100) supercomputers, comparing against PETSc and the state-of-the-art two-stream NCCL implementation using SuiteSparse matrices and three massive instances scaled up to 512 GPUs. The three-stream design outperforms the two-stream baseline on every instance, with the margin widening from 2-6% at 4 GPUs to 18-47% at 64 GPUs. At 64 GPUs, the geometric-mean speedup over the two-stream baseline is 1.33x on MareNostrum 5 and 1.23x on Leonardo for Pipe-PCG, and reaches 1.30x for Pipe-BiCGStab. In large-scale experiments, we observed a speedup up to 35% in Pipe-PCG and up to 33% in Pipe-BiCGStab compared to the two-stream design. For PETSc, the margin is even wider, up to 3.27x speedup in both Pipe-PCG and Pipe-BiCGStab. Related code for the proposed method is available online: https://github.com/ParCoreLab/aCG

Sun 18 OctDistributed, Parallel, and Cluster Computing
The gist
Solving large scientific problems on many GPUs can be slowed down by communication delays. The authors show that overlapping three key tasks—computation, collective communication, and point-to-point communication—at the same time speeds up well-known Krylov solvers. They tested their approach on powerful supercomputers and found it performs better than existing methods, especially as the number of GPUs increases. This advance helps run important scientific simulations faster.
Open → 2610.25058v1

Physically accurate video repair improves realistic video generation

Agentic Physics-Grounded Video Generation via Memory-Augmented In-Context Reasoning

Abstract: Physical plausibility is essential for realistic video generation. Existing methods impose physical guidance before synthesis via simulations or refined prompts, but this can limit dynamic diversity, miss errors that emerge only after generation, and require repeated regeneration when inconsistencies remain. We therefore study a generate-diagnose-repair paradigm that preserves the original generation capability and selectively repairs physical inconsistencies afterward, raising two key questions: what to repair and how to repair? To address them, we introduce PhysRepair, an agentic video generation framework that combines causal reasoning over the observed physical failure with prior repair experience to enable localized and adaptive correction. Specifically, Spatiotemporal Causal Constraints identify the first invalid physical state and its causally affected states, producing a repair specification that guides physically plausible local regeneration while preserving unaffected content. Experience-augmented In-context Learning combines the ongoing repair context with relevant experience from previous repairs, allowing the agent to adapt its repair decisions across diverse physical failures and accumulate completed trajectories for future cases. Experiments on Physics-IQ Verified across solid mechanics, fluid dynamics, optics, thermodynamics, and magnetism demonstrate that PhysRepair consistently improves the physical plausibility of generated videos over existing methods. Our project page is available at https://xxkkxxx.github.io/PhysRepair-Website/.

Fri 16 OctComputer Vision and Pattern Recognition
The gist
Making videos that show realistic physical actions is hard because mistakes can only appear after the video is made. The authors created a method called PhysRepair that finds where the physical errors start and fixes only those parts without redoing the whole video. It learns from past fixes to improve over time and makes videos that follow the rules of physics better than before. This helps in creating videos that look and behave more realistically in different areas like fluids, heat, and light.
Open → 2610.23677v1

Elastic axis position changes flutter speed and shock behavior in aerofoils

How the elastic axis folds the transonic flutter boundary: shock energy transfer and conformally calibrated active learning

Abstract: Isogai's case A, a pitch-plunge aerofoil whose elastic axis lies half a chord ahead of the leading edge, has a folded transonic flutter boundary in inviscid flow: near the bottom of the transonic dip several flutter speeds coexist at one Mach number. We map this boundary, and the family obtained by moving the elastic axis, with coupled unsteady Euler simulations, a Gaussian-process surrogate of the damping coefficient trained by batch active learning, and split conformal prediction on independent random simulations, which turns the surrogate into stability calls with a distribution-free error rate. Three failure modes of time-domain damping labels that leave no trace in the residuals are documented, and the half-degree mean incidence left by the common one-degree start is shown to raise the flutter speed at the dip by 2.8%, more than any numerical setting. With 80 simulations the learned case A boundary labels 64 of 65 independent runs correctly, and calibrated calls are wrong in at most 1.6% of cases. Over Mach number, elastic axis and flutter speed index, 193 simulations and 40 calibration runs show that the fold exists only for elastic axes more than about 0.4 chord ahead of the leading edge; it closes between 0.39 and 0.33 chord ahead, on two meshes. Chordwise energy budgets, closed against the solver loads and the growth rate within a few per cent, explain the boundary. The lower branch is crossed through the reduced frequency at unchanged shock phase. On the upper branch the shock is pinned at the trailing edge, and moving the elastic axis aft brings the pivot of the flutter mode towards the section, so that the damping of the supersonic surface falls faster than the residual shock input and the fold closes.

Fri 16 OctMachine Learning
The gist
Flutter is a dangerous vibration that aircraft wings can experience at certain speeds. This paper studies how shifting the elastic axis of a wing changes when flutter starts, especially in conditions near the speed of sound. The authors combined detailed simulations with smart machine learning to map how flutter speeds vary for different elastic axis positions. They found that moving the elastic axis affects the shockwave patterns on the wing and changes the flutter behavior in complex ways. Their approach also helps reliably predict stability from simulation data with very few errors.
Open → 2610.23298v1

Physics foundation models improve control of fluid flows efficiently

Physics Foundation Models for Efficient Control of Fluid Flows

Abstract: We investigate whether a physics foundation model (PFM) pretrained for PDE forecasting can be repurposed for closed-loop fluid-flow control. We construct a PFM-based controller by attaching lightweight Gaussian actor and critic heads to frozen pretrained representations and train the policy using proximal policy optimization (PPO). We evaluate the approach on HydroGym's two-dimensional Kolmogorov-flow environment using vorticity observations at \(64\times64\) and \(128\times128\) resolutions and Reynolds numbers \(\mathrm{Re}=100\) and \(200\). Across these settings, we compare the frozen PFM controller against a baseline MLP policy trained with the same PPO framework. The PFM controller achieves consistently higher reward while requiring smaller executed action magnitudes over training, indicating improved control performance with reduced control effort. These results provide initial evidence that representations learned through self-supervised next-frame prediction can be transferred directly to closed-loop fluid flow control. Project page: https://mahindrautela.github.io/morph.

Sat 10 OctMachine Learning
The gist
Controlling how fluids move can be very complicated and needs smart methods. The authors study if a special type of computer model, trained to predict fluid patterns, can also be used to control fluids in real time. They show their model works better and uses less effort than a typical approach. This suggests that these physics-based models can learn useful ways to control fluids without extra training from scratch.
Open → 2610.15173v1

Simulation data selection improves robot training for real tasks

TUCO: Curating Simulation Demonstrations for Sim-to-Real Robot Policy Co-Training

Abstract: Simulation demonstrations can supplement scarce real-world data for robot policy co-training. However, the value of using data curation to actively select these demonstrations for sim-to-real co-training remains underexplored. Existing curation methods also lack a unified criterion for measuring trajectory-level utility and set-level coverage from closed-loop target behavior. To address these gaps, we present the first systematic study of data curation for sim-to-real robot policy co-training and propose Trajectory-level Utility and set-level Coverage Optimization (TUCO). TUCO uses influence functions to trace how each source demonstration affects target-domain scoring rollouts. Our key insight is that these effects can be decomposed into an overall contribution to target return and variation across rollouts, providing a common closed-loop basis for measuring trajectory utility and set coverage. We further propose a performance-aligned subset optimizer that combines these measures in a unified curation objective to reduce redundancy and select complementary demonstrations. Extensive experiments on RoboMimic and OmniReset establish the value of active simulation data curation for sim-to-real policy co-training and show that TUCO achieves state-of-the-art performance across single-simulator, sim-to-sim, and sim-to-real settings.

Sun 4 OctRobotics
The gist
Robots need lots of practice data to learn how to do tasks well, but real-world data is often scarce and expensive. The authors show that carefully choosing which simulated practice runs to include helps robots learn more effectively when combining simulated and real data. Their new method, called TUCO, picks useful and diverse simulation examples to improve robot learning. Tests show that this approach boosts performance in different robot training scenarios.
Open → 2610.05407v1

Diffusion sampling method improves sparse data recovery in pdes

Backward-Consistent Diffusion Sampling for Sparsely Observed PDE Inverse Problems

Abstract: Recovering Partial Differential Equation (PDE) coefficient fields from extremely sparse observations is a severely ill-posed inverse problem for which generative machine learning methods (e.g., diffusion models) have become a leading way to encode the prior. Recent state-of-the-art diffusion solvers lift these priors to function spaces, finding a physics-consistent reconstruction in the output space of the diffusion denoiser. We prove that, in a discontinuous PDE setting, output space methods can result in failure to appropriately minimize the unobserved error with the correct coefficient field. Consequently, we propose Function space Backward-Consistent Sampling (FunBCS), an input space optimization approach for solving PDE problems which aims to find the best input such that the denoiser reconstruction is physics-consistent. We then prove that FunBCS appropriately minimizes the unobserved error, unlike output space optimization methods. Per our theoretical analysis, we also provide insights on how to dynamically allocate the number of input space optimization steps used throughout the sampling process. Our evaluations, across four PDE inverse problems (including the discontinuous Darcy flow), demonstrate that FunBCS reduces the reconstruction error by $27$-$64\%$ while running $1.4$-$2.1\times$ faster when compared to the current state-of-the-art.

Sat 3 OctMachine Learning
The gist
Recovering tricky physical properties from very limited data is hard. The authors show that existing methods can fail when dealing with sudden changes in these properties. They propose a new technique, FunBCS, that works backward on the original inputs to better match the physical rules. Their method reduces errors significantly and runs faster in tests on several problems.
Open → 2610.04624v1

Physics constrained generative models speed up physical field simulation

PMosFM: Preconditioned Manifold Matching for One-Step Physics-Constrained Generation

Abstract: Physics-constrained generative models aim to generate physical fields that match a target distribution and satisfy prescribed constraints. However, enforcing these constraints often increases sampling costs through iterative corrections or training costs through residual optimization and trajectory unrolling. To address this issue, we introduce \textbf{P}reconditioned \textbf{M}anifold \textbf{o}ne-\textbf{s}tep \textbf{F}low \textbf{M}atching (\textbf{PMosFM}), a preconditioned manifold matching framework for one-step physics-constrained generation. By encoding constraints in a manifold decoder, PMosFM learns transport in intrinsic coordinates without separate residual losses or terminal residual unrolling. A geometric preconditioner rescales coordinates using the decoder-induced metric, while a regularized covariance transform approximately whitens the interpolation-state inputs. A finite-interval objective couples velocity supervision with consistency between decoded endpoints in physical space. We show that exact parameterization removes residual-induced Gauss--Newton curvature, that geometric and covariance effects separate in a local conditioning bound, and that physical flow-map error bounds endpoint distributional error. Controlled ablations examine conditioning, and experiments evaluate optimizer-update time and memory footprint. At inference, PMosFM uses one neural transport evaluation followed by physical decoding. Experiments across benchmarks show lower training and sampling time than the multi-step baselines at comparable physical and distributional fidelity. Code and datasets will be released publicly.

Wed 30 SeptMachine Learning
The gist
Generating physical fields, like fluid flows or temperature maps, usually requires slow methods to ensure they follow real-world physics. The authors introduce a new approach called PMosFM that learns in a way that respects physical constraints without many slow correction steps. This approach uses geometry and math tricks to make the generation faster and just as accurate. They show that it trains and runs quicker than older methods while keeping high-quality results.
Open → 2609.40287v1

Flapping wing aerodynamics improved by controlled spectral correction method

Bounded Channel-Adaptive Spectral Learning for Forward-Consistent Inverse Flapping-Wing Aerodynamics

Abstract: Flapping-wing vehicles regulate aerodynamic forces and moments through coordinated variations in stroke, deviation, and pitch motion. Because the resulting loads depend on both the instantaneous wing configuration and its preceding motion history, recovering suitable wing kinematics from a desired aerodynamic trajectory is a challenging inverse problem. Existing sequence models capture temporal dependencies, while spectral methods can exploit the periodic structure of flapping motion. However, unrestricted frequency-domain augmentation may interfere with temporal representations and produce inconsistent corrections across kinematic variables and prediction horizons. We propose the Bounded Channel-Adaptive Spectral Residual Gated Recurrent Unit (BCS-GRU), which retains recurrent temporal prediction as its primary representation and restricts spectral information to a controlled output-specific correction. We further introduce a causally aligned forward-consistency objective that evaluates predicted kinematics through a separately trained and frozen aerodynamic surrogate. Experiments under a unified episode-level protocol show that BCS-GRU improves inverse prediction over recurrent and adaptive-spectral baselines, with greater benefits at longer prediction horizons. Forward-consistent fine-tuning further improves surrogate-based aerodynamic consistency while maintaining mean kinematic accuracy. These results demonstrate that controlled spectral correction and forward-consistent learning provide an effective framework for history-aware inverse modelling of flapping-wing aerodynamics.

Wed 30 SeptRobotics
The gist
Flapping-wing flying vehicles move their wings in complex patterns to control how they fly. Figuring out the right wing motions from a desired flying force is difficult because the forces depend on both current and past wing movements. The authors created a new model called BCS-GRU that mostly uses time-based predictions but adds limited frequency-based corrections to better guess wing motions. Their approach also checks predictions against a separate flight simulator to improve accuracy and consistency. Tests showed this method predicts wing movements more accurately, especially for longer flight sequences.
Open → 2609.38730v1

Symmetry aware reinforcement learning cuts training data needs

Sample Complexity of Equivariant Reinforcement Learning

Abstract: Reinforcement learning (RL) is a powerful framework for robotic control, yet its practical application is often hindered by high sample complexity. This is particularly restrictive in physical domains where interaction data is costly. While the world often exhibits geometric and physical symmetries, standard RL algorithms typically fail to exploit this structure. In this paper, we demonstrate that exploiting group symmetries significantly reduces the sample complexity of RL. Focusing on finite-horizon Markov decision processes, we find that leveraging homomorphisms induced by group symmetries significantly reduces the theoretical upper and lower bounds on the number of environment interactions required to reach an optimal return. We further extend these bounds to continuous state and action spaces, providing corresponding sample-complexity guarantees under appropriate regularity assumptions. Beyond theory, we validate our findings through controlled experiments and demonstrate the advantages of symmetry-aware policy learning on high-dimensional continuous robotic simulations. Our results show that integrating symmetry into the learning pipeline yields substantial gains in sample efficiency and performance, offering a principled path toward more data-efficient robotics.

Tue 29 SeptComputational ComplexityMachine Learning
The gist
Teaching robots to perform tasks takes a lot of practice, which can be expensive and slow. This paper shows that when robots know about the symmetries in their environment—like how rotating or flipping something doesn't change its properties—they can learn much faster. By using ideas from math about these symmetries, the authors found ways to reduce how many tries a robot needs to get good at a task. They also tested their ideas on robot simulations and saw real improvements in learning speed.
Open → 2609.36421v1

Stride enables automated checks of text and crowd movements matching

STRIDE: Automated Evaluation of Text-to-Trajectory Alignment across Diverse Contexts

Abstract: Language-conditioned trajectory generation is here, but its evaluation has not kept pace. Existing pedestrian trajectory metrics compare trajectories with real-world human data. This does not scale to text-to-trajectory generation across diverse contexts, as collecting human trajectories for every scenario is costly and infeasible. Moreover, pedestrian behavior is heterogeneous and context-dependent, with no single metric as the correct answer, and current evaluation frameworks are not transferable to this domain. These challenges make scalable, reliable evaluation difficult. We introduce STRIDE, the first framework for evaluating context alignment between scenario descriptions and pedestrian trajectories. STRIDE addresses these challenges through three design choices. First, we derive our VRDST evaluation protocol from sociological theories to define a complete evaluation space. Second, it decomposes high-level context into scenario-adaptive behavioral questions. Third, every question is resolved against a deterministic measurement tool library that yields reproducible answers. Together, STRIDE enables complete, verifiable, automated, and scalable evaluation across diverse contexts without requiring human trajectory data. We instantiate STRIDE in the crowd domain as STRIDE-Bench, comprising 1K scenarios, 6K behavioral questions, and 11K measurements with calibrated expected answers across 30 real-world maps. Comprehensive human validations show that STRIDE-Bench is consistent with human behavior and judgment, achieving 80% human agreement. We further evaluate several text-to-trajectory models, finding limited context-alignment capability and persistent challenges in fine-grained context conditioning. We believe that the STRIDE framework provides a first step toward principled evaluation of context-aligned pedestrian trajectory generation.

Mon 28 SeptArtificial IntelligenceComputers and Society
The gist
It is hard to evaluate how well text instructions match with predicted paths people take in crowds, because collecting real human movement for every scenario is costly. The authors created STRIDE, a new system that uses sociological ideas to break down complex scenarios into measurable questions, answered by tools rather than humans. This lets them check if pedestrian paths fit their text descriptions across many different settings without needing real human data. They tested STRIDE and found it agrees with human judgments about 80% of the time and revealed current models struggle with detailed context. This work takes an initial step toward fair and automated evaluation of how well text instructions align with pedestrian movement predictions.
Open → 2609.34799v1

MultiEcho framework measures response laws of learned worlds

MultiEcho: An Experimental Science of Learned Worlds

Abstract: World models can be studied as experimental systems with response laws of their own. We introduce MultiEcho, a framework for estimating these laws through controlled counterfactual interventions, delimiting their applicability, and separately testing their physical correspondence. Across nine simulated physical systems and seven frozen model configurations, three-reference estimators predict complete intervention responses and recover intervention parameters. Estimator selection uses discovery data only; frozen fits are evaluated on validation and confirmation contexts. The experiments distinguish response predictability, intervention readability and physical accuracy. Responses can be locally describable yet poorly match physical effects in the same target coordinates. Event-window, visibility and camera interventions reveal conditional applicability, and paired generator configurations show reduced readability under a scene prompt with stronger guidance. Magnitude sweeps expose small image errors alongside large relative effect errors. An exact-reset material experiment separates registered visible-response success from fixed-readout failure on material-dependent futures at matched positions and velocities. Exact finite-scale identities resolve odd and even response errors; first-order remainder bounds specify when refined calibration converges. MultiEcho provides an experimental basis for studying learned-world laws independently of, and in relation to, physical laws.

Sun 27 SeptMachine Learning
The gist
Understanding how AI models imagine or simulate physical worlds requires studying the rules they seem to follow. The authors introduce MultiEcho, a method to test how well AI models respond to changes or interventions like in experiments. By comparing different AI models across several simulated worlds, they reveal how these internal rules match or differ from real physical laws. This helps to figure out where and when the AI’s imagined worlds behave reliably or unpredictably.
Open → 2609.33347v1

OneWorld improves consistent physics understanding across actions in video prediction

OneWorld: Learning Consistent Physics Across Actions in World Models

Abstract: Action-conditioned video world models aim to predict scene evolution under different actions, a capability that is essential for reliable planning, decision-making, and interaction in dynamic environments. However, futures generated independently from the same initial scene may each appear plausible while implying incompatible physical properties, such as friction or mass. This inconsistency can lead to contradictory predictions across interventions, making it difficult for the model to maintain a coherent understanding of the underlying world and limiting its reliability for planning and decision-making. To address these issues, we propose OneWorld, a shared-mechanism counterfactual generation framework that jointly models multiple action-conditioned futures under a common latent physical mechanism. A physical mechanism interpreter first infers a distribution over latent mechanisms from each action-outcome branch. These distributions are then aggregated into shared-world evidence, which captures whether the branches admit a common physical explanation while accounting for uncertainty in less informative branches. This evidence constrains flow training and guides sampling, encouraging consistency in the underlying physical mechanism while preserving the distinct outcomes induced by different actions. We further introduce a multi-intervention evaluation protocol in controlled environments, following the interaction settings of ACWM-Phys, to assess whether generated futures can be jointly explained by the same physical parameters, alongside standard measures of single-rollout prediction quality. Experiments in these environments show that OneWorld improves cross-intervention physical consistency while maintaining competitive single-rollout prediction quality.

Fri 25 SeptComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Predicting how a scene changes after different actions is hard because each prediction might assume different physical rules, making it confusing. The authors propose OneWorld, a method that learns a shared physical explanation behind various possible outcomes for different actions. This makes predictions agree on basic physics like friction or mass, helping the model better understand and plan in dynamic environments. They also create a way to test if the predictions use consistent physics across multiple actions. Experiments show that OneWorld keeps good prediction quality while improving physical consistency across scenarios.
Open → 2609.30946v1

Neural solver uses less memory and works on any shape

MENO: Memory-Efficient Neural Operator

Abstract: We propose the Memory-Efficient Neural Operator (MENO) as a high-performance PDE neural solver based on the Manifold Function Encoder (MFE). MENO features three primary advantages: (1) MENO has a significantly smaller memory footprint and much faster training speed than other popular architectures, with the memory footprint being independent of the data resolution, and therefore holds the potential for scaling up to large-scale models. (2) MENO can accept PDE inputs of arbitrary form, including arbitrary geometric domains and arbitrary discretizations. In particular, it is capable of handling cross-geometry scenarios, i.e., where the input functions and the output solutions are defined on different manifolds. (3) MENO exhibits strong generalization capability, and achieves the best accuracy on most of the benchmarks we tested, compared with the results reported in the literature. The code is available on GitHub at https://github.com/jpzxshi/MENO, and all numerical examples in this paper can be run with a single command to reproduce the reported results.

Wed 23 SeptMachine Learning
The gist
Solving partial differential equations (PDEs) is important in many fields like engineering and physics, but often requires lots of computer memory and limited data formats. The authors introduce MENO, a neural network method that uses much less memory and runs faster than previous methods. It can handle PDE problems on any kind of shape or grid, even when inputs and outputs differ in shape. MENO also performs very accurately across many test problems compared to other methods.
Open → 2609.27739v1

Dual AI models improve testing for safer autonomous driving simulations

Teach-to-Crash: A Closed-Loop Student-Teacher LLM Framework for Collision-Inducing Test Scenario Generation

Abstract: Validating Autonomous Driving Systems (ADS) in simulation requires testing architectures that can discover rare, safety-critical failures while generating scenarios that are executable, diverse, and useful for downstream failure analysis. We introduce Teach-to-Crash, a closed-loop testing framework that combines a constrained ego-centric scenario representation, stagnation-aware search control, and a dual-LLM architecture for adaptive failure discovery. A high-reasoning Teacher LLM acts as an adaptive search controller, while a low-reasoning Student LLM emits simulator-executable scenarios in a strict JSON schema. The Teacher intervenes only when rolling collision rate and time-to-collision metrics stagnate, providing strategic guidance to redirect the search. In a CARLA case study with two experimental setups that vary the ego vehicle's speed policy, Teach-to-Crash achieves the highest Collision Hit Rate (90.79%), the shortest mean Time-to-Collision (18.31 s), and a competitive Collision Discovery Rate (136.21). PAFOT attains a higher mean CDR (179.44), but with substantially larger variance. Teach-to-Crash also yields the highest diversity (0.547) and, averaged across both setups on the CARLA Traffic Manager controller, the highest avoidability-based usefulness proxy (60.04%) among the compared methods. These results, within the evaluated CARLA scope, provide evidence that closed-loop dual-LLM reasoning can steer adversarial simulation-based testing over a constrained executable program space, generating failures that are frequent, structurally diverse, and assessed as more frequently avoidable.

Wed 23 SeptSoftware EngineeringArtificial IntelligenceMultiagent Systems
The gist
Testing self-driving cars in simulation is hard because dangerous crashes are rare but important to find. The authors created a system called Teach-to-Crash that uses two AI language models working together: one guides the search for crash scenarios, and the other creates detailed driving scenarios. This teamwork leads to more frequent, varied, and useful crash examples. Their tests showed it finds crashes faster and more reliably than other methods.
Open → 2609.27296v1

Tiga compiler speeds up graph learning on memory-limited devices

Tiga: Compiling Graph Message Passing at Scale

Abstract: Graph message passing offers a common way to express learning algorithms, physical simulations, and numerical solvers. Efficient execution depends on interaction structure and data movement, which can be obscured when a program is expressed as a sequence of tensor operations. On memory-constrained systems such as laptops, materializing connectivity and intermediate messages can also exhaust device memory. We present Tiga, a just-in-time compiler that separates the definition of a message-passing program from how its interactions are traversed, computed, and stored. Tiga preserves graph relations and reducer algebra in a multi-level intermediate representation, enabling traversal specialization, fusion of relation generation with aggregation, and reverse-mode automatic differentiation. Backend-specific lowering targets CPUs and GPUs. Its runtime extends execution beyond device-memory capacity by streaming graph partitions from disk through host memory with page-sized device staging buffers; partition ownership and halo exchange extend the same programming model to distributed execution. A Python interface interoperates with ordinary PyTorch tensors and autograd for forward and backward computation. Numerical checks validate outputs and gradients for differentiable workloads. A differentiated geometric workload characterizes the memory--time tradeoff of fused forward and backward execution. Evaluation against matched Torch and PyTorch Geometric baselines demonstrates reduced runtime and device-memory use for generated-relation workloads, while offloaded forward execution processes billion-edge graphs on a single memory-limited GPU. Measurements on heterogeneous devices further characterize the communication and load-balance costs of distributed execution.

Mon 21 SeptDistributed, Parallel, and Cluster Computing
The gist
Graph message passing is a way to handle complex data relationships, but running these programs can be slow and use too much memory, especially on smaller devices like laptops. This paper introduces Tiga, a tool that separates the program’s logic from how it actually processes data, allowing it to run more efficiently on CPUs and GPUs. Tiga can handle huge graphs by streaming data from disk and can work across multiple machines, all while integrating smoothly with Python and PyTorch. The authors show that Tiga reduces runtime and memory use compared to existing tools and can process huge graphs on limited hardware.
Open → 2609.24802v1

Driving policy behaviors reveal risks under new conditions

Beyond the Leaderboard: Counterfactual Diagnosis of End-to-End and VLA Driving Policies Under Domain Shift

Abstract: End-to-end and vision-language-action (VLA) driving policies are compared by leaderboard rank, but a rank reports an outcome, not the behaviour behind it, so it predicts poorly how a policy will behave at a new site. On six released policies, rank on nuScenes open-loop error or on NAVSIM's leaderboard does not carry over to scenes with a pedestrian near the ego corridor at a new site. We propose a counterfactual check-up: a few hundred real frames, each edited two ways (pedestrian removed, or re-lit by a night-style perturbation), every edit verified by an independent detector, and the change in the planned trajectory read as a diagnosis rather than a score. From these edits two causal axes are read, and five exams built on them separate what a score merges: how far the policy plans to drive, whether seeing the pedestrian buys safety, whether that response scales with danger, whether the plan moves when nothing requires it, and how much an irrelevant lighting change moves it. On 246 NAVSIM near-pedestrian scenes, in the cells where the pedestrian lies on the planned path only 1.9% of responses are genuine avoidance, and under our open-loop protocol the median clearance change is at most 0.03 m and the median change in planned distance at most 0.08 m for every policy. In a pre-registered test from left- to right-hand drive, the exposure and specificity orderings, the lighting verdict and the collision outcome transfer, while point values and the hazard-sensitivity verdict do not. Read as a selection report, the profiles say which policy is safe because it plans short, which covers a human-like distance without yielding, and which is unsteady under a change that requires no reaction, and they price each verdict: most settle within a few dozen frames, hazard sensitivity needs hundreds. Code and edited frames will be released.

Fri 18 SeptComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Current driving AI systems are ranked by how well they perform overall, but these rankings don't explain how or why they behave the way they do, especially in new situations like unfamiliar roads. The authors tested six driving policies by changing real video frames to see if the AI would react correctly—for example, by avoiding a pedestrian or adjusting to nighttime lighting. They found that most systems barely react to pedestrians on their path. Their method reveals how each AI plans, reacts to danger, or overreacts to harmless changes. This new way of testing can help pick safer and more reliable driving systems.
Open → 2609.22582v1

End-to-end autonomous driving models improve trajectory stability and safety

Stabilizing Trajectory Outputs in End-to-End Autonomous Driving via SC-IMM Based Teacher Signals

Abstract: End-to-End autonomous driving models commonly predict future waypoints from sensor inputs and convert them into vehicle control commands through a downstream controller. However, conventional waypoint-based imitation learning mainly minimizes coordinate-level errors, making it difficult to capture scene-dependent path-speed changes and temporal instability across waypoint outputs. In this paper, we propose an offline teacher-signal generation and learning method for trajectory-output stabilization based on a Scene-Conditioned Interacting Multiple Model (SC-IMM) to mitigate this issue. The proposed method converts expert trajectories into path-speed states and performs IMM updates conditioned on scene cues to generate path-speed teacher labels and mode posterior probabilities. The generated signals are added to the original trajectory loss as auxiliary supervision during training, while the inference structure and waypoint controller remain unchanged. In closed-loop evaluation on 100 short routes in CARLA Town12, the proposed method improved the driving score by 28.0% and reduced Collision/km by 62.3% compared with the baseline, while also improving jerk and trajectory-variation metrics. These results demonstrate that offline teacher signals embedding scene-conditioned motion-model cues can guide trajectory-output driving models toward more stable closed-loop behavior.

Fri 18 SeptRobotics
The gist
Self-driving cars often predict where to go next by showing the car a set of points it should follow. But just making these points close to the expert’s path can make the car drive unevenly or too fast sometimes. The authors propose a new way to teach the car by turning expert driving paths into detailed signals that include not just where to go but also how fast. They use these signals as extra guidance during training without changing the final driving process. This helps the car drive smoother and safer in simulated tests.
Open → 2609.21404v1

Rigid-body dynamics derivatives improve modeling of closed-chain systems

Adapting Rigid-Body Dynamics Derivatives for Constraint Embedding Closed-Chain Models

Abstract: This paper extends an existing algorithm for the first-order derivatives of rigid-body dynamics to the case of closed-chain kinematic systems modeled using constraint embed- ding. Many standard dynamics algorithms apply to both open- chain and constraint-embedded models, but existing efficient derivative methods assume joint velocity effects are locally config- uration invariant. We remove this assumption and derive adapted algorithms that extend dynamics derivatives to more general joint types, including those arising in constraint-embedded closed- chain models. Our results compare conventional pin-joint robot models with more complete actuation models that capture local closed chains. We show that the additional terms introduced by these generalizations have low computational impact when mod- eling actuation kinematics alone, but can incur higher cost when additional rigid bodies, such as motor rotors, are included in the actuation chain, or when considering non-local loops. Overall, these results enable more accurate dynamics computations for constraint-embedded actuation submechanisms to be adopted in model-predictive control and differentiable simulation.

Thu 17 SeptRobotics
The gist
Calculating how robots move and respond often involves understanding their joints and how they connect. The authors worked on improving methods that calculate changes in robot movement, especially for robots with loops in their joints (closed chains). They extended earlier methods to handle more complex joint types that appear when these loops are modeled with certain constraints. Their improvements allow for more accurate and efficient simulation and control of these robots, especially when motors and extra moving parts are included.
Open → 2609.21024v1

Graph hypernetworks improve adaptation of neural solvers for related physics problems

Amortizing Physics-Informed Neural Solvers via Graph Hypernetworks

Abstract: Amortizing physics-informed neural networks (PINNs) across related PDEs requires describing each equation to a reusable solver. Coefficient vectors encode numerical parameters in predefined slots, leaving operator and cross-field assignments implicit. We make these relationships explicit in an operator graph, with nodes for fields, derivatives, terms, and residuals and coefficients retained as term attributes. A graph hypernetwork generates diagonal codes that initialize a meta-trained factorized PINN for each target equation. Meta-training and target-specific adaptation use governing equations and prescribed conditions without solution labels. We compare coefficient-vector, DeepSets-based term-set, and graph conditioning by solution accuracy within a fixed adaptation budget. In scalar convection-diffusion-reaction problems, both term-based descriptors improve high-reaction accuracy, with similar performance. In two-field Fisher-KPP, meta-training sees uncoupled and one-way systems; after 3,000 adaptation steps on unseen two-way coupling, the graph's mean final error is 35.7% below the term set and 67.7% below the coefficient vector. In a fixed-structure capacitively coupled plasma model, the coefficient vector performs best. These results support extending coefficient conditioning with explicit equation relationships for physics-based solver adaptation.

Thu 17 SeptMachine Learning
The gist
Solving physics problems with math equations called partial differential equations (PDEs) can be slow when done many times for similar problems. The authors improved neural networks designed to solve these equations by representing the math in a graph that clearly shows how parts of the equation relate. This lets their system learn from many related equations and quickly adapt to new ones, improving accuracy without needing example solutions. They tested this idea on different physics problems and found the graph-based approach often worked better than simpler ways to describe the equations.
Open → 2609.19915v1

Autonomous vehicles learn safer parking in complex urban spaces

Learning Reliable Parking Policies via Offline Reinforcement Learning with Quantized Action Representations

Abstract: Parking is a routine yet safety-critical task for autonomous vehicles operating in urban environments. However, cluttered and weakly structured parking spaces, compounded by the interactive uncertainty from surrounding vehicles, hinder reliable maneuver generation. To address these challenges, we develop a waypoint-level offline reinforcement learning framework for interaction-aware autonomous parking. Specifically, a dedicated parking dataset is constructed from hierarchical expert rollouts with rotational waypoint augmentation, covering both non-interactive scenarios and interactive ones. The policy is then conditioned on a compact state representation, in which LiDAR-based obstacle features are adapted to the target pose via feature-wise linear modulation. A state-conditioned tokenizer further quantizes continuous waypoint sequences into discrete action tokens, over which conservative Q-learning is performed to suppress value overestimation on poorly supported actions. Extensive closed-loop experiments are conducted in the high-fidelity CARLA simulator. The proposed framework attains the highest parking success rate among all baselines and transfers reliably to unseen parking slots.

Thu 17 SeptRobotics
The gist
Parking is a tricky but important task for self-driving cars, especially in crowded and messy city parking lots. The authors created a way for these cars to learn reliable parking moves by studying many expert examples and using a clever method to simplify the possible actions into small parts. Their approach helps the car plan and park safely even around other cars that might move unpredictably. Tests in a detailed driving simulator showed this new method worked better than others and handled new parking spots well.
Open → 2609.19894v1

Hybrid method couples neural networks with classical models for fluid flow

Hybrid coupling with numerics-informed neural networks and the overlapping Schwarz alternating method

Abstract: We develop a hybrid modeling framework for coupling pre-trained numerics-informed neural networks (NINNs) with classical full order models (FOMs) using the overlapping Schwarz alternating method. We consider the two-dimensional advection-diffusion equation in the advection-dominated, Peclet-number 10^6 regime. We first demonstrate that, unlike the corresponding physics-informed neural network (PINN), a monolithic NINN can be accurately trained on our model problem without domain decomposition. We then employ overlapping multiplicative Schwarz as a deployment mechanism for coupling a pre-trained, subdomain-local NINN with a neighboring FOM, with the NINN weights held fixed throughout the Schwarz iteration. We consider two training approaches for the subdomain-local NINNs: a top-down approach, in which boundary data are obtained from a coupled Schwarz solve on the full domain with a FOM on each subdomain (FOM-FOM Schwarz), and a bottom-up approach, in which boundary traces are generated synthetically on the NINN subdomain without requiring any full-domain solves. The resulting hybrid NINN-FOM solutions agree closely with the corresponding FOM-FOM Schwarz solutions, with the top-down and bottom-up training approaches yielding comparable accuracy.

Tue 15 SeptMachine Learning
The gist
This paper addresses how to combine two types of computer models to solve a complex physics problem involving fluid flow and heat transfer. The authors show that special neural networks trained with numerical data can work accurately on their own for this problem. They then develop a way to link these neural networks with traditional physics-based models using a mathematical method called Schwarz iteration. This hybrid approach produces results very close to using only traditional models, but with more flexibility in training and deploying parts of the model.
Open → 2609.17841v1

Adaptive neural operators improve computation and interaction for solving PDEs

Where to Compute and How to Interact: Operator-Readable Adaptation with Gauge-Aware Transport

Abstract: Adaptive meshes enable neural operators for partial differential equations (PDEs) to allocate spatial samples and computation according to local physical structures. Existing approaches, however, mainly address where to compute, with less attention to how information should interact after node relocation. Mesh adaptation changes local sampling scales, neighborhood structures, and geometric contexts, so representations formed at different nodes may not be directly comparable. Direct aggregation can therefore entangle physical variation with discretization-induced representation variation. Because allocation and interaction are jointly optimized through the same output objective, their individual roles are also difficult to distinguish from final errors alone. We introduce operator readability, requiring an adaptive operator to account for and test why computation is allocated to particular locations and how representations interact under the resulting nonuniform discretization. Based on this principle, we propose the Gauge-Aware Adaptive Mesh Neural Operator (GA-AMNO). Physics-informed adaptive allocation answers where to compute, while geometry-conditioned low-rank Gauge transport maps source features into target representation contexts before aggregation, answering how to interact. This makes mesh-to-solver information exchange inspectable and intervenable. We establish sufficient conditions for representation-consistent aggregation and analyze approximate transport errors and continuity under topology-preserving mesh deformations. Experiments on five PDE benchmarks demonstrate improved predictive accuracy, while controlled interventions and geometric-mismatch analyses verify the roles of allocation and interaction and show that Gauge transport improves cross-discretization representation compatibility under strong geometric mismatch.

Mon 14 SeptMachine Learning
The gist
Partial differential equations (PDEs) model many physical systems, but solving them efficiently is hard. The authors study adaptive methods that decide where to focus computation on a mesh and how to combine information from different parts. They show that simply changing where computation happens can cause confusion between physical changes and changes from the mesh itself. Their new method, called GA-AMNO, not only picks where to compute but also carefully adjusts how information interacts across the mesh, making the whole process clearer and more accurate. Tests on various PDEs show better results and the ability to check how each part contributes.
Open → 2609.15620v1

Zeroth-order optimization improves using adaptive directional hints

Adaptively Incorporating Directional Hints into Zeroth-Order Optimization

Abstract: We study zeroth-order optimization of non-convex functions with the aid of directional hints, which are cheap but potentially inaccurate approximations of the true gradient direction, given by linear subspaces at each iteration. To leverage these hints adaptively while maintaining robustness to their quality, we introduce Control-Variate Zeroth-Order Descent (CV-ZOD), a new framework that refines the classical zeroth-order gradient estimator with a control variate that can be set based on the directional hints. We first show that the oracle algorithm that optimally sets the reference vector and step size at each iteration achieves a convergence rate that interpolates between the first-order $O(1/T)$ rate and the zeroth-order $O(d/T)$ rate, depending on the quality of the hints along the trajectory. We then develop a practical variant of CV-ZOD that achieves the same oracle guarantee up to logarithmic factors, without any prior knowledge of the hint quality. We validate the method empirically on simulation-based scientific optimization tasks, demonstrating sustained progress on non-convex landscapes where zeroth-order descent is slower and existing guided methods stall as guidance deteriorates.

Tue 8 SeptMachine Learning
The gist
Optimizing complicated functions without direct information about their slope is hard and slow. The authors study a way to speed this up by using approximate directional hints that suggest good directions to move. They develop a method called CV-ZOD that combines these hints with existing techniques, adjusting how much it trusts the hints based on their quality. Their approach works well in practice, maintaining steady progress even when the hints get worse, unlike previous methods that struggle when guidance is inaccurate.
Open → 2609.08277v1