HS3: A Descriptive, Interoperable Serialization Standardfor Statistical Models in High-Energy Physics
This paper introduces HS3, a new implementation-agnostic, human-readable, and extensible serialization standard for statistical models in high-energy physics designed to overcome the limitations of existing formats by enabling machine-readable interoperability, long-term preservation, and FAIR data principles across diverse software frameworks.
Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you're trying to explain a incredibly complex recipe to a friend. But here's the catch: your friend only speaks "French," you only speak "German," and the original recipe was written in a secret code that only makes sense if you have a specific, expensive kitchen appliance from 2015. If you try to translate it, the measurements might get mixed up, the ingredients might change, and if that old appliance breaks in ten years, the recipe is lost forever.
This is exactly the problem scientists in High-Energy Physics (HEP) have been facing with their "recipes" for understanding the universe. These recipes are called statistical models (or likelihoods), and they are the mathematical blueprints that tell us how data from giant particle smashers like the Large Hadron Collider (LHC) connects to the laws of physics.
For a long time, these blueprints were locked in ROOT workspaces. Think of these as binary files—like a secret code that only a specific, old computer program (ROOT) can read. They were powerful, but if that program changed or disappeared, the recipe was gone. Then, a new format called pyhf JSON showed up. It was like writing the recipe in plain English on a sticky note. It was easy to read and share, but it was a bit too simple; it couldn't handle the super-complex, multi-layered dishes that some physicists needed to cook up.
The result? A messy kitchen. Some teams used the secret code, others used the sticky notes, and trying to combine their work was a nightmare. You couldn't easily check if two different teams were actually cooking the same dish, and preserving these recipes for future generations was risky.
Enter HS3 (High-Energy Physics Statistics Serialization Standard).
The authors of this paper introduce HS3 as a new, universal language for these statistical models. It's not a specific software program or a new kitchen appliance; it's a descriptive standard. Think of it as a "Universal Recipe Card" system.
Here is how it works, using the paper's own logic:
1. It's a "Descriptive" Language, Not a "Do-This" List
Old formats often told the computer how to calculate the answer step-by-step (procedural). HS3 just describes what the answer is made of (declarative). It's like saying, "This cake is made of flour, eggs, and sugar mixed in a specific ratio," rather than "First, beat the eggs for 3 minutes, then add flour slowly."
- The Analogy: Imagine a LEGO set. The old way was a video showing exactly which hand to use and how fast to snap the bricks together. HS3 is just the instruction manual showing the final picture and listing the exact bricks needed. It doesn't care if you build it with your left hand, your right hand, or a robot arm. As long as you use the right bricks (distributions, functions, datasets), the final model is the same.
2. It's Built for Humans and Machines
HS3 uses JSON, a format that looks like text. This means a human can open the file in a simple text editor and actually understand the structure. It's readable, just like the pyhf sticky notes, but it's powerful enough to handle the complex "secret code" models from ROOT.
- The Analogy: It's like a map that is both a detailed GPS route for a robot and a clear, drawn picture for a hiker. You can see the path, but you can also read the names of the streets.
3. It's a "Computational Graph"
The paper describes HS3 models as computational graphs. Imagine a flowchart where every box is a piece of the puzzle (a number, a formula, a data point) and the lines show how they connect.
- The Analogy: Think of a family tree. You have the "Ancestors" (the raw data and basic math rules) and the "Descendants" (the final result). HS3 draws the whole tree. It doesn't matter if you are using a C++ computer, a Python script, or a Julia program; they can all look at the same family tree and understand the relationships.
What HS3 is NOT (and what the paper rules out):
The paper is very clear about what HS3 is not. It is not a new algorithm for solving math problems. It doesn't tell you how to find the best answer (like a specific way to minimize errors). It leaves that job to the software that reads the HS3 file.
- The Rule: If you think HS3 is a magic calculator that solves the problem for you, you're wrong. It's just the blueprint. The paper explicitly states that the "inference procedures and implementation-specific execution details" are the responsibility of the tools that use HS3, not the standard itself.
How Sure Are They?
The authors are very confident that this design works for what they need, but they are careful not to claim it's a finished, perfect product for every single scenario yet.
- Proven/Measured: They have built working prototypes in C++ (ROOT), Python (pyhs3), and Julia (HS3.jl). They have successfully taken real models from the ATLAS and CMS experiments, converted them to HS3, and then converted them back.
- The Evidence: In their tests (specifically looking at a measurement of from ATLAS data), they showed that the results from the C++ version and the Python version matched almost perfectly. The difference was so tiny (around ) that it was basically zero. This proves that the "Universal Recipe Card" works across different languages.
- The Caveat: They admit that while they can convert most things, some very specific, custom tools used by CMS (like certain DataCard features) might need a little extra work or future updates to be fully compatible. It's not a "one-click fix" for every single weird edge case in existence yet, but the path is clear.
Why Does This Matter?
The paper argues that as the LHC moves from "finding new particles" to "measuring them with extreme precision," we need to be able to share these recipes easily.
- The "FAIR" Goal: The authors want these models to be FAIR: Findable, Accessible, Interoperable, and Reusable.
- The Future: They are already seeing HS3 being used on HEPData (a public archive) with a special "badge" to show a model is ready to go. They are even testing it with the DEMOS project, which wants to use this same "Universal Recipe Card" for other fields like astrophysics and nuclear physics, not just particle physics.
The Bottom Line
The paper suggests that HS3 is the missing link that can finally let physicists from different labs, using different computers, speak the same language. It's not a new way to do the math; it's a new way to write down the math so that anyone, anywhere, and in the future, can read it and understand exactly what was done. It turns a locked, secret code into a clear, open book.
As the paper puts it, HS3 aims to become for statistical models what .root files were for data: a durable, portable, and universally exchangeable representation. But unlike the old files, this one is written in a language that humans can actually read.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.