ULYSSES the Third: An Odyssey Towards a Unified Python Toolkit for Leptogenesis

summary

The gist

ULYSSES is presented as the third release of a Python package for numerically evaluating baryon asymmetry generated through leptogenesis The new version extends the code capabilities to include…

In short

ULYSSES is a third release of a Python package for numerically evaluating baryon asymmetry from leptogenesis. It extends capabilities to handle low-scale scenarios with three quasi-degenerate right-handed neutrinos, complete high-scale leptogenesis phase space evolution, and a new interface for custom model inputs. This unified toolkit allows users to explore different neutrino mass scales and models efficiently.

Key concepts

Low-Scale Leptogenesis
This involves calculating the generation of lepton asymmetry when right-handed neutrinos are relatively light, specifically in scenarios with three quasi-degenerate masses up to 100 TeV. The new version includes advanced density matrix equations to accurately simulate these complex thermal processes.
High-Scale Leptogenesis Phase Space
This refers to the complete numerical evolution of the lepton asymmetry during high-scale leptogenesis, specifically including all $ ext{Delta L}=1$ scattering processes. This goes beyond simpler momentum-averaged approximations to provide a more comprehensive view of how the asymmetry develops.
Extended Parameter Interface
This feature allows users to input custom model parameters outside the standard toolkit structure without changing the core code. This enables researchers to implement unique theoretical models and simultaneously solve leptogenesis alongside dark matter production calculations.
Unified Treatment of Leptogenesis Regimes
The framework is designed to numerically solve coupled Boltzmann and Density Matrix equations that cover thermal, resonant, and low-scale regimes based on the mass scale of the right-handed neutrinos. This ensures a consistent numerical approach across different physical conditions.

Terminology used across episodes

This episode discusses

The paper

ULYSSES the Third: An Odyssey Towards a Unified Python Toolkit for Leptogenesis · Read on arXiv

Alessandro Granelli, Juraj Klarič, Dhruv Pasari, Yuber F. Perez-Gonzalez, Jessica Turner

Instituto de Física Corpuscular (IFIC) · Institute for Theoretical Physics Amsterdam and Delta Institute for Theoretical Physics, University of Amsterdam Science Park 904, The Netherlands · University of Zagreb Faculty of Science Department of Physics, University of Zagreb Croatia · Institute for Particle Physics Phenomenology Department of Physics Durham University UK · Departamento de Física Teórica and Instituto de Física Teórica UAM/CSIC Universidad Autonoma de Madrid Cantoblanco Spain

DOI: 10.1016/j.cpc.2026.110464

Transcript

Introduction to the show: ident: High Energy Physics: Phenomenology. The day in particle phenomenology: models, signatures and constraints.

Kai: I'm Kai.

Mira: And I'm Mira, here with Lev.

Kai: We're looking at the paper: "ULYSSES the Third".

Mira: Here's the gist of the paper. ULYSSES is presented as the third release of a Python package for numerically evaluating baryon asymmetry generated through leptogenesis The new version extends the code capabilities to include low-scale leptogenesis scenarios with three quasi-degenerate right-handed neutrinos, complete Delta L = 1 scattering processes for high-scale leptogenesis, and a new extended parameter interface for custom model inputs This release also includes an alternative parametrization of the Casas–Ibarra matrix and updated default neutrino oscillation parameters.

Kai: Unified Treatment of Leptogenesis Regimes The work addresses the numerical solution of coupled Boltzmann and Density Matrix equations governing thermal, resonant, and low-scale leptogenesis The framework is designed to cover different regimes based on the mass scale and mass hierarchy associated with right-handed neutrinos.

Title and authors: Kai: So we're talking about ULYSSES the Third today. This paper is about a Python package for numerically evaluating baryon asymmetry from leptogenesis. It’s a significant update because it extends what was already there before.

Mira: Exactly. The title itself, "ULYSSES the Third: An Odyssey Towards a Unified Python Toolkit for Leptogenesis," suggests they’re building something more comprehensive than the previous versions of this code. It sounds like they're trying to tie together different ways of studying leptogenesis into one toolkit.

Lev: From what I can tell, it’s moving toward handling more complex scenarios and giving users a better way to plug in their own physics models. It suggests a push for broader applicability beyond just the most basic setups.

Kai: Right, so what’s the actual substance of this third release? It seems they are tackling different mass scales and neutrino hierarchies, which is crucial because that dictates how you calculate things.

Mira: They’re unifying the treatment across thermal leptogenesis, resonant leptogenesis, and low-scale scenarios. This means they're trying to build a framework that covers those different regimes cohesively rather than having separate code for each case.

Lev: That unification is key for me because running complex simulations on real hardware often requires specific approximations, so a unified treatment should make it easier to test if the physics holds up across those transitions.

Kai: One of the big wins they highlight is handling low-scale leptogenesis with three quasi-degenerate right-handed neutrinos up to one hundred teraelectronvolts. That’s a big numerical challenge because those masses are very close together, and capturing that requires specific math.

Mira: They specifically mention implementing "state of the art density matrix equations for low-scale leptogenesis with three quasidegenerate in mass RHNs," which they've extended to the non-relativistic limit. That extension means they’re including contributions from both lepton number conserving and lepton number violating processes in the Hamiltonian and rates, making it valid up to those one hundred teraelectronvolt scales.

Lev: If that works up to one hundred teraelectronvolts, that’s a lot of computational work. The overhead for running those full density matrix calculations on real hardware would be substantial, but if the solver is efficient, it might be manageable within certain constraints.

Title and authors: Kai: Then there’s the high-scale stuff too. They've added complete phase-space evolution for high-scale vanilla leptogenesis by incorporating routines that implement delta L equals one scattering processes in that scenario with just one decaying right-handed neutrino.

Mira: That completes the modules they introduced in the second version, enabling a more comprehensive phase space evolution of both the right-handed neutrino and the lepton asymmetry beyond just using a momentum-averaged approximation. It’s about getting a better picture of how things evolve over time.

Lev: I wonder if that complete phase space evolution is practical when you think about running it on hardware where we have to manage very tight tolerances for those scattering terms.

Kai: They also focused on making the code more flexible for users. They introduced an extended parameter interface, which lets people pass model-specific parameters beyond just the standard leptogenesis runcard without having to change the core infrastructure of the package itself.

Mira: That’s a big usability boost for me because it means custom model implementations are much easier now, and you can solve standard leptogenesis equations alongside freeze in dark matter production at the same time, which is a very useful coupling.

Lev: Coupling it to dark matter production is interesting; that adds another layer of complexity to the coupled system we have to evolve simultaneously on hardware.

Kai: They also added a new alternative parametrization for the Casas–Ibarra matrix and updated default neutrino oscillation parameters, which are fundamental inputs for any leptogenesis calculation.

Mira: That’s good because parameter choices really matter; having alternatives lets researchers test if their final asymmetry result is sensitive to the initial setup assumptions.

Lev: From an engineering standpoint, having alternative parametrizations means we have more benchmarks to test the stability of the solvers when changing those inputs.

Kai: On efficiency, they used a bespoke numba compatible wrapper around cquadpack for fast numerical quadrature within numba compiled routines. They claim this is an order of magnitude faster than in version two and allows for the use of an analytic Jacobian matrix in the solve ordinary differential equation function.

Title and authors: Mira: That speed improvement is significant because solving stiff differential equations like these usually takes a long time, so making it faster with numba and that analytic Jacobian makes a huge difference for the runtime.

Lev: If we can get that order of magnitude speedup, then running the more complex scenarios they describe becomes much more accessible for people trying to prototype things on real hardware.

Kai: They also included a feature to allow systematic cross comparison across independent research groups by checking results against benchmarks from published works, such as reproducing benchmarks from references thirty-one and thirty-two and checking with the public C++ code amiqs <ref:2605.16540#pg3>.

Mira: That bridge between different numerical implementations is important for building confidence in the results coming out of these simulations, because if we can reproduce known results, it validates the underlying physics being modeled.

Lev: Having a check against established benchmarks is crucial for error estimation; it helps you know how much systematic uncertainty you might have when applying your own model parameters.

Kai: So to wrap up this section on improvements, they’ve focused on handling more physical regimes, increasing user flexibility, speeding up the math substantially, and providing a way to compare results against existing literature.

Mira: It seems like the main theme is making the toolkit robust enough for people to use it across a wider variety of theoretical inputs and physical scales.

Lev: For real hardware implementation, I’d focus on how those custom model interfaces translate into efficient kernel calls, but the numerical speedup they claim is something we can test immediately.

Kai: So, this paper is about making ULYSSES the Third a much more powerful and versatile tool for exploring leptogenesis physics. This whole package has evolved significantly since its beginning.

Mira: It’s about providing a unified way to tackle the complexity of low-scale, high-scale, and resonant scenarios while keeping the user in control of their model inputs.

Lev: For us working on error correction, it means we have a better standardized way to generate those initial conditions for our simulations.

Kai: So that's where we are with ULYSSES the Third. It’s a substantial numerical tool that makes complex leptogenesis scenarios more accessible through better math and better interfaces.

The paper's summary: Kai: So, ULYSSES the Third is basically this new Python package for checking how much matter we have in the universe coming from something called leptogenesis, and they're trying to make it a one-stop shop for different kinds of physics scenarios.

Mira: It’s about unifying the code so you can switch between thermal, resonant, and low-scale scenarios easily without rewriting everything.

Lev: So they’re aiming for a single toolkit that handles those different mass scales and neutrino hierarchies we talked about earlier.

Kai: Right, it sounds like the big goal is making it easier for people to test if their specific model fits into any of these frameworks. They’re trying to bridge the gap between different ways people calculate this asymmetry.

Mira: Exactly, and one of the things they do is include a way to check your results against stuff from other research groups, like reproducing benchmarks they've seen before.

Lev: That cross-checking feature is important for building confidence in the numbers; you need to know if your simulation method is sound or if it’s just giving you noise.

Kai: They also built in a way for users to plug in their own custom parameters without touching the core code, which means they can couple leptogenesis calculations with things like dark matter production right inside the package.

Mira: That coupling capability is pretty neat because it lets you look at how all these different physical processes interact simultaneously in one run.

Lev: From an engineering side, that means we have to make sure the interface handles those custom inputs cleanly so we don't introduce instability when someone plugs in something weird.

Kai: They also made big numerical improvements, like using a faster wrapper around cquadpack and getting a much quicker solve time for those stiff differential equations.

Mira: So, they’re not just changing the physics setup; they’re making the actual computation of it much more practical to run on real hardware.

Lev: If you get that speed up, then running simulations with those complex low-scale scenarios becomes something you can actually do in a reasonable timeframe.

Kai: It seems like they’ve focused on making the whole process—from setting up the model to getting a fast answer—much more streamlined and reliable.

Mira: The implication is that people who are building new models won't have to reinvent the wheel for every single calculation; they can just use this framework.

Lev: It gives us a standardized way to run these tests, which helps when we try to figure out what kind of computational resources we actually need for future experiments.

Kai: So, ULYSSES the Third is about taking the whole process of calculating baryon asymmetry and making it more accessible and computationally efficient for everyone working in this area.

Mira: And now that they have this unified toolkit, the next step is seeing what kinds of new physics scenarios people will test with it.

The paper's improvements: Tom: So we're looking at what ULYSSES the Third actually adds to the toolkit, and it’s not just about making things faster, but how they've fixed some of those tricky numerical problems.

Kai: They tackled that low-scale leptogenesis problem by adding these state-of-the-art density matrix equations for three quasi-degenerate right handed neutrinos up to one hundred teraelectronvolts.

Mira: So, they’ve extended the math to include both lepton number conserving and lepton number violating processes in the rates, which makes it valid up to that scale.

Lev: That extension is huge because those mass scales are really close together, and getting those contributions right requires careful handling of the Hamiltonian.

Kai: Then for high-scale vanilla leptogenesis, they added complete phase-space evolution by including routines for delta L equals one scattering processes with just one decaying right handed neutrino.

Mira: That means they’re moving beyond just averaging the momentum to get a more complete picture of how things evolve in space and time.

Lev: It’s about getting the full trajectory, not just some rough estimate of the final asymmetry.

Kai: They also made it much easier for users with custom physics by introducing an extended parameter interface so they can plug in model specific parameters without messing up the core code.

Mira: That’s smart because it lets people do more than just standard tests; they can solve leptogenesis and dark matter freeze in at the same time.

Lev: From a hardware standpoint, that flexibility is good, but we need to make sure those custom inputs don't cause numerical instability when we try to run the simulation on real systems.

Kai: For efficiency, they used a bespoke numba compatible wrapper around cquadpack which they say is an order of magnitude faster than the second version and allows for an analytic Jacobian matrix in the solve function.

Mira: That speed boost is significant because solving those stiff differential equations usually takes a long time, so making it that much faster really makes these simulations more accessible.

Lev: If you get that speed up, then running the more complex scenarios they describe becomes something you can actually do in a reasonable timeframe on hardware.

Kai: They also added this feature for systematic cross comparison, letting people check their results against benchmarks from published papers or even that public C++ code amiqs.

Mira: That’s a nice touch because it gives researchers a way to validate their own work against what others have already done in these numerical simulations.

Lev: A benchmark check is vital for error estimation; it helps you understand the systematic uncertainty you’re dealing with when you run your own model.

Kai: So, the improvements are all about making the tool more powerful physically, easier to use for custom models, and much faster computationally.

Mira: It seems like they’ve focused on giving people a much more robust way to explore the whole landscape of leptogenesis scenarios.

Lev: It gives us a standardized way to run these tests, which helps when we try to figure out what kind of computational resources we actually need for future experiments.

Kai: So, ULYSSES the Third is about taking the whole process of calculating baryon asymmetry and making it more accessible and computationally efficient for everyone working in this area.

Mira: And now that they have this unified toolkit, the next step is seeing what kinds of new physics scenarios people will test with it.

Conclusion: Tom: So we’re wrapping up our look at ULYSSES the Third by summarizing what all this work actually means for the field, and getting ready to move on to something new.

Kai: Basically, this paper shows how they unified a lot of different ways of calculating baryon asymmetry from leptogenesis into one Python toolkit.

Mira: They’ve taken everything from thermal scenarios to low-scale physics and made it easier for people to plug in their own custom models.

Lev: It means researchers have a standardized way to run these kinds of complex simulations, which helps when we try to figure out what kind of computational resources we need for future experiments.

Kai: So, the implication is that anyone working on leptogenesis doesn't have to start from scratch every time they want to test a new idea.

Mira: It’s about making the whole process more accessible by providing a unified framework that covers different mass scales and neutrino hierarchies.

Lev: For me, it means when I think about running this on real hardware, I have a clearer picture of the numerical demands involved upfront.

Kai: So ULYSSES the Third is a really solid piece of software that makes complex physics simulations more streamlined and reliable for everyone.

Mira: It’s a big step toward making these calculations practical tools rather than just theoretical exercises on paper.

Lev: Having that unified approach should help us all get better at estimating the error margins when we are pushing the limits of what we can compute on a computer.

Kai: Alright, that’s our time on ULYSSES the Third. It's a substantial update to this package for numerically evaluating baryon asymmetry from leptogenesis.

Mira: We’re excited to see how the community uses this unified interface to push the boundaries of what we can simulate next.

Lev: Next up, we have a paper on new methods for error correction in quantum computing that I think is going to be really interesting.

More episodes

← Home