A TU Munich team has built a formal system to automatically find quantum gates whose logic has a classical equivalent and remove them. Accepted at IEEE QSW 2026 with an open source implementation, the paper is a narrow but real step toward cheaper near term quantum execution.
Every quantum program carries hidden classical slack. Quantum computers are celebrated for what they can do that classical machines cannot, but the programs that run on them are not purely quantum. There is almost always a classical layer handling setup, control logic, mid-circuit measurements, and readout. The question the Munich Quantum Toolkit group asks in a new paper is: how much of the quantum part is actually doing quantum work?
The answer, it turns out, depends on what the compiler can prove.
Lian Remme, Alexander Weinert, Andre Waschk, Lukas Burgholzer, and Robert Wille at the Technical University of Munich have published a method called hybrid quantum-classical constant propagation. Their system tracks what the quantum and classical parts of a circuit are doing at each execution step. Wherever the classical side already knows the outcome, the quantum side does not need to compute it. The result gets replaced with a fast, reliable classical instruction. The paper appears at IEEE QSW 2026 and the code is in MQT Core, the group's open-source quantum software library.
Constant propagation is not new to compilers. Classical compilers have used some version of it for decades to eliminate dead code, fold constants, and simplify expressions before code runs. The intellectual move here is applying that same logic to hybrid programs that mix quantum and classical operations, and being precise about when the quantum part can be safely trimmed.
This is worth a moment because it is also a quiet admission. If classical compiler techniques are still being adapted for quantum programs in 2026, quantum compilation tooling is not mature. It is an active research area where foundational passes are still being invented and formalized rather than inherited from decades of established practice. That is not an insult, it is a description of where the field is. The MQT group, which has published consistently in this space including a broader MQT Compiler Collection paper in April 2026, is one of the groups doing the formal work to change that.
The paper's own framing is careful: the optimization reduces costly multi-qubit operations, making quantum programs more practical and robust for near-term devices. It does not claim to reduce the number of qubits required, change the asymptotic complexity of any quantum algorithm, or make quantum computers unnecessary for any class of problem. The authors are explicit that this only works where a classical equivalent exists, where the classical side of the program already knows what the quantum side would compute. For programs that are genuinely quantum throughout, the technique does nothing. This is not a cure for quantum circuit bloat. It is a partial solution to a specific and well-defined slice of it.
The paper extends an earlier effort called Quantum Constant Propagation, or QCP, published via Springer, which used gate-level information to remove superfluous controls and gates. The new work formalizes and generalizes that direction via a hybrid state model. That is a typical move in academic quantum software research, where a working tool often precedes the full mathematical account of why it works.
What makes this one traceable is the open-source implementation. MQT Core is on GitHub. A developer, a technical evaluator, or a researcher can look at exactly which gates the optimization eliminates and under what conditions. That is not nothing. In a field where many quantum software claims are in press releases or behind NDA, a paper with a working implementation and a peer-reviewed conference acceptance is as solid as it gets at this stage of the story.
The gap that remains unverified is whether this approach shows up in commercial quantum compilers. Qiskit and CQG's tket have their own circuit optimization passes. Whether they implement something equivalent, or could adopt this approach, is not addressed in the paper. That is the more interesting question for anyone building a quantum software stack.
The broader point is structural. The quantum-classical boundary in a hybrid program is increasingly a compiler design question, not just a physics constraint. As the toolchains mature, more of that boundary will be decided automatically, by the compiler's ability to prove equivalence. This paper is one formal step in that direction. Whether commercial compilers follow the MQT Core path is the story after the paper.