Papers for

financial modeling teams

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.

Efficient quantum circuits improve flow model simulation with neural networks

An Efficient Quantum Circuit for Flow Model Execution Using Quantum Neural Networks

Abstract: Flow models generate trajectories from an initial distribution to a target distribution by solving an ordinary differential equation defined by a velocity field. Flow matching learns this velocity field by modeling the transport dynamics between the two distributions. Wavefunction flow establishes a formal connection between flow models and quantum dynamics by introducing a continuity Hamiltonian, which drives the Schrödinger evolution of quantum states. In this paper, we investigate accurate and efficient quantum simulation of the wavefunction flow, thereby realizing the efficient implementation of flow models on quantum computers. We first leverage a quantum read-only memory (QROM)-based phase kickback framework for the wavefunction flow simulation, generating probability densities that closely match those produced by the corresponding conventional flow model. To address the high circuit-resource cost, we further incorporate a trained quantum neural network (QNN) into the phase kickback framework, replacing QROM for data encoding. Numerical experiments demonstrate that our proposed method implements flow models on quantum computers more efficiently, since it maintains the accuracy of wavefunction flow simulation compared with the QROM-based framework, and significantly reduces the circuit resources.

Thu 8 OctMachine Learning
The gist
Flow models help transform one set of data into another by following certain paths. This paper shows how to use quantum computers to run these models more efficiently by simulating quantum states that behave like the flow paths. To do this, the authors combine existing quantum memory techniques with a trained quantum neural network to reduce the complexity of the circuit needed. Their experiments show this new method keeps accuracy while using fewer computational resources.
Open → 2610.11537v1

Gaussian flow dynamics improve learning of time-dependent stochastic models

Gaussian Flow Dynamics: Simulation-Free Neural SDE Learning Beyond One-Time Marginals

Abstract: Simulation-free training of latent Stochastic Differential Equations (SDEs) relies on a variational posterior process whose one-time marginals are tractable, typically Gaussian. Such marginals, however, do not determine the underlying dynamics: many processes share the same marginals while differing in their temporal structure, and existing parameterizations fix this structure implicitly, which restricts the posterior family and biases the learned model. We introduce Gaussian flow dynamics, which construct stochastic processes directly from smoothly evolving Gaussian marginals while making the marginal-preserving, or gauge, degrees of freedom explicit and parameterizable. The construction admits state-dependent diffusion coefficients and recovers every linear SDE with additive noise and a non-degenerate Gaussian initial distribution. Building on it, we propose Gauge Matching, a simulation-free method for latent SDE learning that combines Gaussian flow dynamics with the SDE Matching objective. Gauge Matching costs at most quadratically in the latent dimension per step, like SDE Matching, but learns the temporal structure of the posterior beyond its one-time marginals. It comes within a nat of Helmholtz-SDE, which computes the gauge from the prior Jacobian at cubic cost, on the linear benchmark where the exact posterior is known, matches it on nonlinear systems, and applies where Helmholtz-SDE does not, to state-dependent noise.

Sat 3 OctMachine Learning
The gist
Learning how systems change over time with randomness is tricky when you only know snapshots of their states at single moments. The authors show that just knowing these snapshots doesn't tell you the full story of how the system evolves. They introduce a new way to model these systems that explicitly accounts for the paths they take, not just the points they hit. This results in better learning of the underlying dynamics without needing to simulate many possible paths, saving time and computational effort.
Open → 2610.04390v1

Time series models improve by routing on raw inputs before normalization

Raw-Routed Mixture of Adapters: A Causal Intervention for Routing Collapse in Time Series Foundation Models

Abstract: Time series foundation models (TSFMs) commonly adapt to new data by attaching a single trainable head to a frozen backbone, a one-size-fits-all setup that underfits heterogeneous regimes. Replacing the head with a mixture of experts is the standard upgrade, but on instance-normalized backbones (the dominant TSFM design class) it fails: routing entropy collapses to zero and one expert absorbs every input, a failure we call normalization-induced routing collapse. Standard MoE rescue mechanisms do not repair it, because the cause is in the router's input, not its optimization. Pre-encoder normalization strips the statistics a router would need to tell regimes apart. A mutual-information decomposition makes this precise and yields a signal-ratio that, computed before training, predicts dataset vulnerability (Spearman $ρ= -0.88$). Eight causal controls, including a vision-modality replication, isolate instance normalization as the cause. The prescription is a minimal causal intervention: Raw-Routed Mixture of Adapters (RR-MoA), which routes on the raw, pre-normalization input. Under a strictly frozen backbone, RR-MoA wins 54/54 comparisons against the strongest fixed adapter and significantly outperforms LoRA, TRACE, AdaMix, and full fine-tuning. The effect generalizes across six backbones and an imputation task. Frozen RR-MoA also beats full fine-tuning by 12-79% (the Frozen Paradox); two architecturally distinct variants confirm the principle generalizes beyond this specific router.

Wed 30 SeptMachine Learning
The gist
Time series models often struggle to adapt to new patterns because they use a single adjustable part on top of a fixed main model. A common solution is to add multiple specialized parts and decide which to use for each input, but this fails when the model normalizes data beforehand, causing the decision process to collapse to always choosing the same part. The authors identify that the normalization step removes important differences needed for routing. They propose a fix that routes decisions based on the raw input before normalization, which consistently improves model performance across various tests.
Open → 2609.39445v1

Charm++ runtime enables fast no-restart resizing for cloud HPC

No-Restart Elasticity in an Adaptive Runtime System for Cloud-Native HPC

Abstract: Exploiting discounted spot instances for HPC requires an application to change its resource allocation at runtime, shrinking ahead of an interruption and expanding onto replacement capacity. Existing elasticity mechanisms implement rescaling as a full process teardown followed by a cold restart at the new processor count, and the restart stage accounts for up to 95% of the total overhead, growing with node count and increasing substantially on GPUs due to CUDA context initialization. In this paper, we present a no-restart rescaling mechanism for the Charm++ runtime system in which surviving processes never exit: a rescaling operation consists of a membership negotiation with a lightweight external coordinator, reconciliation of the UCX communication endpoints with the new cluster view, and a return to the top of the runtime initialization path that preserves live application state. This reduces the cost of a rescaling operation, excluding the load balancing step that any rescaling model requires, from multiple seconds to 8--15ms on CPUs and 7--11ms on GPUs, at 4 to 32 instances. Because processes survive, GPU device state persists in place, eliminating the checkpointing daemons previously required for GPU elasticity, and a launcher-independent bootstrap mechanism removes the dependence on supervised process managers, which are incompatible with spot instance interruptions. Integrated with an existing spot instance management framework, the mechanism cuts the end-to-end overhead of eight simultaneous interruptions to 0.2% of runtime on CPUs and 0.6% on GPUs, and raises the rate at which a job can be rescaled below 1% overhead by a factor of seven.

Sat 26 SeptDistributed, Parallel, and Cluster Computing
The gist
Running big computing jobs in the cloud often means using cheap but unreliable machines that can disappear suddenly. The authors present a way for these jobs to shrink or grow without the usual long pause to restart everything. Their method keeps all running processes alive and just updates connections and states quickly, saving seconds down to milliseconds. This helps programs using GPUs too, avoiding slow restarts related to GPU setup. Overall, their approach cuts downtime drastically, making cloud computing with spot machines smoother and cheaper.
Open → 2609.32217v1

Llms improve math optimization models with evolving skill memory

OptiSkill: A Hierarchical and Evolving SkillBank for LLM-Based Optimization Modeling

Abstract: Automated operations research (OR) modeling requires LLMs to translate natural-language decision problems into correct mathematical programs. Existing methods can improve individual formulations, but they often solve problems in isolation, retaining little reusable experience and repeating similar formulation errors. Prior memory-based approaches store examples, thoughts, or insights as references, while OR modeling requires reusable formulation skills that transfer across problem narratives and guide concrete modeling decisions. We propose OptiSkill, a skill-augmented framework that builds a hierarchical and evolving SkillBank for LLM-based OR modeling. SkillBank stores solver-verified experience as reusable skills, with Global Strategies for problem-level formulation skeletons and Step Experiences for local error-prevention rules. It is further refined through stable batch-level test-time evolution, where candidate skills are incorporated only after validation. Experiments on eight OR modeling benchmarks show that OptiSkill improves formulation accuracy across LLM backbones, outperforms strong agentic baselines, and gains further by expanding SkillBank coverage and reliability. Code and data are available at https://github.com/rachhhhing/OptiSkill

Sat 19 SeptArtificial Intelligence
The gist
Turning word problems into math formulas for decision-making can be tricky and prone to repeated mistakes. The authors created OptiSkill, a system that helps large language models remember and reuse proven math-building skills and error fixes when doing this translation. OptiSkill organizes these skills in a hierarchy and updates them only when they work well, improving the accuracy of math models across different tasks. This approach helps computers learn how to better write optimization problems by building on past successes.
Open → 2609.22987v1