QArray: a GPU-accelerated constant capacitance model simulator for large quantum dot arrays

TL;DR

QArray tackles the computational bottleneck of simulating large quantum dot arrays under the constant capacitance model by reformulating ground-state charge selection as a two-stage problem: first compute a continuous minimum, then identify the nearest discrete charge states. It introduces two scalable algorithms, default and thresholded, and implements them across Python, Rust, and JAX with OSQP for constrained optimization, achieving GPU-accelerated performance that enables 100×100 pixel diagrams for 16-dot arrays in under a second. The package supports both open and closed regimes, includes realistic features such as charge sensors and thermal broadening, and provides tools for optimal gate voltages and virtual gates. Collectively, QArray enables large-scale dataset generation and potential real-time digital-twin interfacing with quantum dot devices, advancing tuning strategies and machine-learning applications. The work also outlines future directions toward more advanced solvers and community-driven extensions to broaden applicability and performance.

Abstract

Semiconductor quantum dot arrays are a leading architecture for the development of quantum technologies. Over the years, the constant capacitance model has served as a fundamental framework for simulating, understanding, and navigating the charge stability diagrams of small quantum dot arrays. However, while the size of the arrays keeps growing, solving the constant capacitance model becomes computationally prohibitive. This paper presents an open-source software package able to compute a $100 \times 100$ pixels charge stability diagram of a 16-dot array in less than a second. Smaller arrays can be simulated in milliseconds - faster than they could be measured experimentally, enabling the creation of diverse datasets for training machine learning models and the creation of digital twins that can interface with quantum dot devices in real-time. Our software package implements its core functionalities in the systems programming language Rust and the high-performance numerical computing library JAX. The Rust implementation benefits from advanced optimisations and parallelisation, enabling the users to take full advantage of multi-core processors. The JAX implementation allows for GPU acceleration.

Figures (7)

• Figure 1: (a) Schematic of a generic array of quantum dots: The diagram illustrates the representation of a quantum dot device as a system of capacitively coupled electrostatic gates and quantum dots. Solid black lines represent the direct dot-to-gates couplings, while capacitors representing the interdot capacitance are modelled with grey lines respectively. From the choice of the capacitance matrix (stored in the DotArray class), the user can define an array with an arbitrary number of dots and geometry. For given gate voltages, a discrete integer number of charges minimises the system's free energy. (b) The structure of the Qarray package featuring the multiple software implementations, represented as colour-coded boxes denoting Python (blue), Rust (yellow), and JAX (green), of the brute-force, default and thresholded algorithms. The gate voltage composer class generates voltage vectors for native sweeps (e.g., $V_{g1}$ against $V_{g2}$), or it can be used to define arbitrary virtual gate sweeps. DotArray offers methods for computing charge stability diagrams for open or closed regimes with any core choice. Optionally, the charge stability diagram can be coupled with simulated charge sensors to model their response. (c) Charge stability diagrams (computed with our default algorithm implemented in Rust) for a hole-based linear array of four quantum dots in the open regime. The black lines denote transitions separating regions in the charge stability diagram with a fixed dot occupation. (d) Charge stability diagrams (computed with our default algorithm implemented in Rust) for the same linear four-dot array of quantum dots in the closed regime where the total number of charges in the array is fixed to four.
• Figure 2: (a) Diagram depicting the default algorithm applied to an open double dot. The algorithm first finds the continuous minimum (marked with a red cross), which minimises the free energy. The free energy landscape, as a function of the charge on each dot, is shown with contour lines. After computing the continuous minimum, the algorithm evaluates the nearest neighbour discrete charge states (marked as red dots) to determine which is lowest in energy. By comparison, the brute force implementation considers all charge states, leading to it also having to consider the charge states marked as black dots. In this case, (1, 2) is the discrete charge state lowest in energy. (b) Diagram depicting the thresholded algorithm applied to an open double dot. The algorithm computes the continuous minimum (red cross) as in the default algorithm. However, rather than just considering all nearest neighbour discrete charge states, thresholding is used to reduce further the number of charge states needing to be evaluated compared to the default version of the algorithm. As the continuous minimum does not lie within the vertical grey rectangle, for which the width equals the threshold $t = 1/3$, it is unnecessary to consider both the floor and ceiling values for $N_1$. Instead, it can be rounded down. By contrast, the continuous minimum does lie in the horizontal rectangle, so both floor and ceiling values for $N_2$ must be considered. The discrete charge states, considered by the thresholded algorithm, are shown as red dots.
• Figure 3: (a) Adaptation of Fig. 2b from Ref. delbecq2014 showing a stability diagram of a linear quadruple quantum dot array in the open regime. This is measured as a function of the two outermost plunger gates voltages, $V_{\mathrm{P1}}$ and $V_{\mathrm{P4}}$. The colour scale represents the derivative of the sensor signal $V_{\mathrm{rf}}$ with respect to $V_{\mathrm{P1}}$. (b) A recreation of Fig. 2b from Ref. delbecq2014, simulated using QArray. The colour scale represents the derivative of the simulated sensor signal, $V_{\mathrm{sens}}$, with respect to $V_{\mathrm{P1}}$. (c) Adaptation of Fig. 3a from Ref. mortemousque2021 showing the stability diagram of a five-electron configuration corresponding to a five-dot cross-geometry array. The colour scale represents the sum of current changes in all charge sensors ($\sum\nabla i_{\mathrm{qpc}}$) as a function of virtual gates $\delta V_{X}^{-}$ (controlling the left-right detunings) and $\delta V_{Y}^{-}$ (controlling the top-bottom detunings). (d) A recreation of Fig. 3a from mortemousque2021 using QArray. The colour scale represents the derivative of the simulated sensor signal, in this case $V_{\mathrm{qpc}}$, with respect to $\delta V_{Y}^{-}$. To simulate the sensing of a qpc instead of a sensor dot, we considered only a single gate for the sensor dot architecture and replaced the Lorentzian shape response with a linear function.
• Figure 4: (a-b) Average computation time required by each core to generate $100 \times 100$ pixels charge stability diagrams. Simulations are performed for randomly chosen capacitance matrices and gate voltage configurations, and correspond to increasing sizes of both open (top) and closed (bottom) arrays. We ran the JAX and brute force cores on both a CPU and a GPU. For the closed quantum dot arrays, the number of confined electrons/holes matches the number of quantum dots within the array.
• Figure 5: (a-b) Average computation time required by the Rust core to generate a $100 \times 100$ pixels charge stability diagram computed with different threshold values for increasing numbers of quantum dots both for open and closed quantum dot arrays.

Theorems & Definitions (14)

• Theorem B.1
• Proof B.2
• Theorem E.1
• Proof E.2
• Theorem E.3
• Proof E.4
• Theorem E.5
• Proof E.6
• Theorem G.1
• Proof G.2