⚛️ quantum physics

Towards Quantum Software for Quantum Simulation

This paper identifies critical gaps in the current quantum simulation software stack, such as the lack of general-purpose frameworks and hardware-aware mappings, and advocates for a modular, model-driven engineering approach to enable scalable, cross-platform, and automated quantum simulation workflows.

Original authors: Maja Franz, Lukas Schmidbauer, Joshua Ammermann, Ina Schaefer, Wolfgang Mauerer

Published 2026-01-23

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Maja Franz, Lukas Schmidbauer, Joshua Ammermann, Ina Schaefer, Wolfgang Mauerer

Original paper licensed under CC BY 4.0 (http://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

The Big Idea: Building a "Quantum Wind Tunnel"

Imagine you want to test how a new airplane design handles turbulence. You have two choices:

The Old Way (Classical Computing): You write a massive, complex computer program to mathematically calculate every drop of air and every force on the plane. It's like trying to solve a billion-piece puzzle in your head.
The Quantum Way (Quantum Simulation): Instead of calculating the math, you build a tiny, physical model of the plane and put it in a real wind tunnel. You let the wind blow on the model, and the model physically shows you what happens.

This paper argues that Quantum Simulation is the "wind tunnel" of the future. It uses actual quantum computers to mimic complex physical systems (like chemical molecules or subatomic particles) rather than just calculating them. The authors believe this is the most promising way to show that quantum computers are truly useful.

The Problem: We Are Still "Hand-Crafting" Everything

Currently, using a quantum computer for this is like building a custom wind tunnel for every single airplane design you want to test.

No Standard Tools: There is no "off-the-shelf" software that lets you say, "Here is the physics of a molecule; please simulate it."
Manual Labor: Scientists have to manually translate their physics theories into code that fits specific, quirky quantum machines. It's like having to hand-carve a new set of keys for every single door you want to open.
Hardware Lock-in: If you want to switch from one type of quantum computer to another, you often have to start from scratch because the software isn't built to be flexible.

The paper says we are missing the "infrastructure" that software engineers usually provide for other types of computing. We lack the blueprints, the translators, and the standard tools.

The Proposed Solution: A "Model-Driven" Factory

The authors propose a new way of working called Model-Driven Engineering (MDE). Think of this as moving from hand-carving keys to a factory assembly line.

Here is how their vision works, using the example of simulating a theory from high-energy physics (like how particles interact):

The Blueprint (The Model): A scientist writes down the physics rules (the "Theoretical Model") in a high-level language that describes the system, not the computer.
The Translator (The Framework): A new software framework takes that blueprint and automatically figures out how to build it.
- It can choose to build it as a Digital Simulation (breaking the physics down into tiny, discrete steps like a video game).
- Or, it can choose an Analogue Simulation (building a physical system that naturally behaves like the target, like a water model for fluid dynamics).
The Assembly (The Hardware): The software automatically converts the blueprint into the specific instructions (pulses or gates) needed for the specific quantum machine available, whether it's a neutral atom simulator or a trapped ion machine.

Why This Matters (According to the Paper)

The paper highlights three main gaps that need to be filled to make this factory work:

Missing Abstractions: We need a way to describe physics that doesn't get bogged down in the details of the computer hardware. It's like needing a language that describes "flight" without needing to know the specific engine model of the plane.
The "Middleman" Problem: We need a universal "intermediate language" that sits between the physics theory and the hardware. This allows the same physics model to be run on different types of quantum computers without rewriting the code.
No Benchmarking: Right now, it's hard to tell if a quantum simulation is actually better than a classical one because we lack the tools to measure and compare them fairly. We need a "scoreboard" to see which method works best.

The Bottom Line

The authors are calling for the software engineering community to step in and build the operating system for quantum simulations.

Instead of scientists spending years manually translating their physics into code for a specific machine, they want a modular, automated framework. This would allow them to focus on the science (the "wind tunnel" physics) while the software handles the messy work of translating that science into instructions for the quantum hardware.

In short: We have the quantum hardware (the wind tunnel), but we are still trying to build the airplane models by hand. This paper wants to build the machine that automatically builds those models for us.

Technical Summary: Towards Quantum Software for Quantum Simulation

Problem Statement
Quantum simulation is recognized as a leading candidate for demonstrating practical quantum advantage, offering the potential to study complex physical systems (e.g., chemical molecules, high-energy physics) with exponentially greater efficiency than classical high-performance computing. However, the current state of the field is hindered by a lack of robust software infrastructure. Unlike quantum optimization or machine learning, which benefit from established algebraic modeling techniques and domain-specific modeling languages (DSMLs) for automated transformation, quantum simulation remains largely manual, problem-specific, and hardware-dependent.

The existing approach relies on model-based workflows where a subject Hamiltonian is manually mapped to quantum computers. This ad hoc methodology creates several critical gaps:

Lack of General-Purpose Frameworks: There are no standard frameworks for model specification, Hamiltonian construction, or hardware-aware mappings.
Limited Reusability and Scalability: Implementations are difficult to generalize, making it hard to benchmark against classical methods or quantify trade-offs between alternative mappings.
Hardware Intricacies: The need for substantial customization for specific quantum hardware exacerbates the difficulty of systematic development.
Absence of Tooling: Robust simulation and benchmarking tooling is missing, hindering performance analysis and empirical validation.

Methodology and Vision
The authors advocate for a shift from isolated demonstrations to a systematic, modular approach grounded in Model-Driven Engineering (MDE). The proposed methodology envisions a quantum simulation software stack that facilitates automation, performance evaluation, and reusability across different types of simulation (digital and analogue).

The paper outlines a conceptual framework illustrated through a high-energy physics example: simulating a one-dimensional lattice gauge theory (specifically, a toy model of quantum electrodynamics) using an array of neutral atoms. The proposed stack consists of the following layers:

Physical System & Theoretical Model: The starting point is the physical system described by a Hamiltonian ( $\hat{H}_{sys}$ ) containing matter field operators and gauge fields.
Domain-Specific Models (Application): High-level abstractions that capture the underlying physical theories (e.g., Hamiltonian dynamics) without being tied to computer science constructs.
Intermediate Representations: Hardware-independent representations that decouple simulation logic from specific architectures. These must be expressive enough to encode complex operations while remaining amenable to optimization.
Domain-Specific Models (Hardware): Mappings to specific hardware models (e.g., the Bose-Hubbard model for neutral atoms).
Executable Code/Pulses: The final transpilation into control parameters and pulses for execution.

The framework supports both Digital Quantum Simulation (using Trotterisation to approximate time evolution via gate sequences) and Analogue Quantum Simulation (directly mapping the system Hamiltonian to a simulator Hamiltonian $\hat{H}_{sim}$ ). The authors suggest a mixed approach where analogue blocks provide scalability by reducing gate counts, while digital steps expand operational variety.

Key Contributions
The paper does not present a fully implemented software suite but rather identifies critical gaps and outlines a vision for a future framework. Its primary contributions include:

Identification of Gaps: A systematic analysis of the missing infrastructure in the quantum simulation software stack, specifically the absence of general-purpose frameworks for model specification and hardware-aware mappings.
MDE Proposal: The advocacy for a Model-Driven Engineering approach to bridge the gap between physical theories and executable quantum programs.
Framework Architecture: A detailed outline of a layered software stack (from theoretical models to pulse-level execution) using a lattice gauge theory example to demonstrate the necessary transformations.
Research Questions: The formulation of specific open challenges regarding the selection of intermediate representations, the integration of noise models, and the development of benchmarking tools to evaluate strategies across the digital-analogue spectrum.

Results and Claims
The paper does not report experimental results or performance benchmarks, as it is a position and vision paper. Instead, it claims that:

Current manual processes severely limit the ability to explore the space of quantum simulation strategies.
The lack of standardised workflows prevents the generalisation of implementations and the quantification of trade-offs between mappings.
A software stack including domain-specific abstractions, modeling languages, and tooling for mapping and optimization is critical for unlocking the full potential of physics-driven quantum approaches.
The field requires formal abstractions and intermediate representations that can support automatic transformations, optimizations, and scheduling for specific hardware constraints.

Significance
The authors position this work as an initial step toward developing a comprehensive quantum simulation software framework, an area that has received limited attention compared to other quantum computing domains. By highlighting the deficiencies in current tooling and proposing an MDE-based architecture, the paper aims to guide the community toward scalable, cross-platform simulation workflows. The significance lies in the call to move beyond problem-specific, manual mappings toward a systematic engineering discipline that can handle the complexities of both digital and analogue quantum simulations, ultimately enabling the field to tackle classically intractable problems with greater efficiency and reliability.