⚛️ quantum physics

Geometric heat pumping on a quantum processor

This paper demonstrates the implementation of geometric heat pumping on a superconducting quantum processor using a collision model, where a driven qubit exchanges energy with thermal ancilla reservoirs to verify that the resulting heat transfer depends solely on the driving contour in parameter space and converges to the geometric limit in the slow-driving regime.

Original authors: Gerónimo J. Caselli, Luis O. Manuel, Liliana Arrachea, Pablo S. Cornaglia

Published 2026-10-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Gerónimo J. Caselli, Luis O. Manuel, Liliana Arrachea, Pablo S. Cornaglia

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

In the microscopic world of quantum computing, heat is not just a nuisance; it is a fundamental barrier. Quantum bits, or qubits, are the fragile engines of these machines, capable of performing calculations that classical computers cannot touch. However, to function correctly, these qubits must be kept incredibly cold and isolated from their surroundings. If they absorb even a tiny amount of thermal energy from their environment, their delicate quantum states collapse, and the calculation fails. For years, scientists have sought ways to actively cool these systems, not just by shielding them, but by using the laws of physics to pump heat away from the qubits and dump it elsewhere, much like a refrigerator moves heat from its interior to the outside air. This process, known as heat pumping, relies on cycling a system through a series of changes. When these changes are performed slowly and in a specific geometric pattern, the amount of heat moved depends only on the shape of the path taken, not on how fast the machine runs. This "geometric" property offers a promising route to efficient cooling, but until now, it had remained a theoretical concept, never demonstrated on a real, programmable quantum chip.

A team of researchers has now brought this concept to life, successfully implementing geometric heat pumping on a superconducting quantum processor. They treated a single qubit as a working engine, connecting it to two simulated heat reservoirs. In the real world, a reservoir might be a large block of metal or a cloud of atoms, but here, the researchers used two other qubits, prepared in specific thermal states, to act as these reservoirs. The process works like a microscopic collision: the working qubit repeatedly bumps into these reservoir qubits, exchanging energy with them. By carefully modulating the energy levels of the working qubit and the strength of its connection to each reservoir, the team created a cycle where heat flows from one reservoir to the other. The key to their success was the geometry of the control. They varied two parameters of the qubit—the energy difference between its states and the angle of its connection to the reservoirs—tracing a closed loop in a mathematical space. Just as a hiker might walk a loop around a mountain and end up at a different elevation than where they started, the qubit, after completing its cycle, had moved a net amount of heat from one side to the other, even though both reservoirs were at the same temperature.

The experiment was conducted on an IBM quantum processor, where the researchers programmed the chip to execute a sequence of operations representing this collision model. They prepared the system, ran the cycle, and then measured the energy of the reservoir qubits before and after each interaction. This allowed them to calculate exactly how much heat was exchanged. To isolate the specific "pumping" effect from the background noise and inevitable energy loss that occurs in any real machine, the team ran the cycle in two directions: clockwise and counter-clockwise. They found that the heat pumped due to the geometric shape of the cycle flipped its sign when the direction was reversed, while the unwanted background heating remained the same. By comparing these two runs, they could mathematically subtract the noise and reveal the pure geometric heat pumping. The results matched theoretical predictions with remarkable precision, confirming that the amount of heat moved depended on the area enclosed by the loop in the control space, exactly as the theory of geometric phases predicts.

The researchers observed that the efficiency of this pumping depended on how slowly they ran the cycle. When the cycle was performed slowly, the heat transfer approached the ideal geometric limit, where the process is determined solely by the shape of the path. However, when the cycle was run faster, the system generated more heat than it moved, a result of friction-like dissipation that overwhelmed the pumping effect. This finding highlights a critical trade-off: while the geometric mechanism is robust, the current generation of quantum hardware is still too noisy to achieve net cooling. In this specific implementation, the heat generated by the machine's own imperfections, particularly during the waiting times between operations, was larger than the heat the machine managed to pump, precluding net cooling. Despite this, the experiment serves as a vital proof of concept. It demonstrates that programmable quantum processors can be used to simulate and control complex thermodynamic processes with high fidelity.

This work does not yet solve the problem of cooling quantum computers, but it establishes a new method for doing so. The team showed that by using a collision model—where the system interacts with a sequence of fresh, prepared qubits—they could create a consistent and measurable record of heat flow. This approach allows for a detailed, microscopic view of how energy moves in open quantum systems. The success of the experiment suggests that as quantum hardware improves, with faster gates and longer coherence times, these geometric protocols could become a practical tool for active cooling. The ability to control heat flow with such precision opens the door to designing quantum thermal machines that can operate efficiently, potentially enabling the next generation of quantum computers to run at lower temperatures and with greater stability. The path forward is clear: refine the hardware to reduce the background noise, and the geometric heat pump could become a standard component in the toolkit of quantum engineering.

Technical Summary: Geometric Heat Pumping on a Quantum Processor

Problem Statement
Geometric heat pumping is a mechanism where energy is transferred between reservoirs at equal temperatures via an adiabatic cyclic driving of a system's parameters. In this regime, the exchanged heat depends solely on the geometry of the driving contour in parameter space, analogous to a Berry phase, rather than the speed of traversal. While theoretically well-established in electronic systems and cold-atom platforms, and extensively studied in driven-qubit models, an experimental realization of this phenomenon within controllable quantum hardware has remained outstanding. A primary motivation for this research is the potential application to quantum processors, where efficient qubit cooling is essential for accurate operation, yet remains a central challenge in quantum thermodynamics.

Methodology
The authors implement geometric heat pumping on a programmable superconducting quantum processor (IBM's Heron r2, specifically the ibm_kingston device) using a quantum collision model. The experimental setup involves:

Physical Model: A working qubit is driven by two periodic field components, $B_x(t)$ and $B_z(t)$ , which modulate both the qubit's energy splitting and its relative coupling to two thermal reservoirs (Left and Right). The reservoirs are simulated at equal temperature $T$ .
Collision Model Implementation: The thermal reservoirs are emulated by sequences of ancilla qubits prepared in thermal states. The continuous interaction is discretized into $N$ time cells. In each cell, the working qubit interacts sequentially with two ancillas (one for each reservoir) via partial-swap gates. The interaction strength is determined by the instantaneous coupling rates, which depend on the angle of the qubit's state on the Bloch sphere relative to the reservoir coupling axes.
Circuit Design: The protocol uses three physical qubits: one working qubit and two ancillas. The circuit executes a symmetric sequence of collisions ( $L-R-R-L$ ) per time cell to minimize discretization errors and reservoir-order bias. Before each collision, the ancilla is reset and rotated to prepare a thermal state; projective energy measurements are performed before and after the interaction to record the stochastic heat exchange.
Data Analysis: To isolate the geometric pumping component from the dominant dissipative background (noise and orientation-even heat), the authors execute the protocol with two opposite traversal directions (clockwise and counter-clockwise) along the same contour. The geometric heat is identified as the orientation-odd component, calculated as the half-difference between the heat exchanged in the two directions.

Key Contributions

Experimental Realization: This work provides the first experimental demonstration of geometric heat pumping on a quantum processor, successfully emulating thermal reservoirs and measuring heat flow using a collision model.
Validation of Theory: The experimental results show excellent agreement with exact simulations of the collision model and the corresponding Lindblad dynamics without adjustable parameters.
Geometric Characterization: The study confirms that the pumped heat depends on the area enclosed by the driving contour in parameter space and vanishes when the area is zero, consistent with the geometric nature of the phenomenon.
Noise Analysis: The authors demonstrate that while hardware noise (gate errors, relaxation, dephasing) produces a significant orientation-even heating background that currently precludes net cooling, the orientation-odd pumping signal can be extracted by reversing the driving protocol.

Results

Adiabatic Limit: For slow driving (long periods $\mathcal{T}$ ), the measured pumped heat converges to the theoretical geometric limit ( $Q_{\text{geo}}$ ). The data follows the expansion $Q_\alpha = Q_{\text{geo}, \alpha} + \mathcal{C}_\alpha/\mathcal{T}$ , where the second term represents dissipative corrections.
Contour Dependence: The pumped heat scales with the area of the driving loop in the $(B_x, B_z)$ plane. When the loop width $\delta B$ is zero (enclosing no area), the pumped heat vanishes within error bars.
Fast Driving: For faster cycles, the heat exhibits non-monotonic behavior near the qubit precession timescale. In this regime, the dissipated heat exceeds the pumped component, resulting in a net heating of the reservoirs ( $Q_\alpha > 0$ for both).
Noise Impact: The measured heat includes a substantial orientation-even background (1–5 $k_B T$ per cycle) arising from hardware noise, which is significantly larger than the pumped signal (~0.34 $k_B T$ ). However, the orientation-odd component (the pumping signal) remains robust, with noise contributions to this component being less than 10% of the even background.

Significance
The paper establishes a proof of concept for controlling heat flow and potentially cooling qubits through programmable driving protocols on quantum hardware. It demonstrates that quantum processors can serve as testbeds for quantum thermodynamics, specifically for validating collision models and Lindblad dynamics. While the current implementation is limited by hardware noise which prevents net cooling, the successful extraction of the geometric pumping signal validates the underlying physical mechanism. The authors suggest that reducing waiting times, improving gate fidelities, and increasing coherence times are necessary steps toward achieving net heat extraction. Additionally, the work highlights the utility of the collision model for digital simulations of open quantum systems and thermodynamic bookkeeping on quantum processors.

More like this