WorksPhysics and Astronomy
QCap: a physics-corrected graph neural network for the capacitance matrix of any planar superconducting device layout
Abstract
Electromagnetic simulations of device layouts to extract capacitance are computationally intensive, a major obstacle to accurate design of circuit devices. Machine learning models can bypass these simulations, but previous approaches have been restricted to layouts using only particular components, and require thousands of simulations of those same components as training data. We present QCap, a model that accurately predicts the Maxwell capacitance matrix of an arbitrary superconducting device layout in seconds, compared to minutes to hours of Ansys Q3D simulations. We develop a novel design-embedding algorithm that converts the layout into a universal graph format, allowing the model to work with any layout created with any tool. To achieve high accuracy, we obtain a coarse physics prior from a fast method of moments simulation of capacitance, then train the model to correct this prior. On 4,009 test designs withheld from training data the model outputs agree with Q3D simulations to a median error of 0.177%, and on never-seen component families it stays below 1% error. We demonstrate the model's scaling by obtaining the capacitance matrix of a 9-superconducting-qubit device in 12 seconds on a laptop (compared to 19.9 h and 228 GB of memory in Ansys) with sub-percent error, and capacitance of a (too large to simulate) 100-qubit, 781-conductor device in 3.4 min on a laptop. We provide the open-source models and data on SQuADDS and Hugging Face. Our results provide a powerful tool for large-scale accurate circuit design and guide the development of models to bypass other physical simulations.
Introduction
Electromagnetic (EM) simulations to predict analog circuit device behavior are essential for accurate design. As an example, we focus on superconducting quantum circuits, which are among the most mature platforms for fault-tolerant quantum computing. They have been operated below the threshold of the surface code [1, 2] and are fabricated with lithographic processes that scale to large chips [3, 4, 5]. Progress on this platform runs in learning cycles of design, fabrication and measurement [6]. Faster, more accurate predictions of device behavior can make these cycles shorter and more effective, allowing faster progress towards utility-scale quantum processors.
EM simulations of capacitance are particularly important for superconducting device design. The shunt capacitance of a transmon, the most common superconducting qubit, sets its charging energy , and with it the anharmonicity and the transition frequency [7] (where is the energy of a Josephson element). Capacitances couple qubits to readout resonators, buses, drive lines and tunable couplers, and every parasitic capacitance causes unwanted interactions [3, 8]. The capacitances of an -conductor device are described in its Maxwell capacitance matrix [5, 9].
Typically capacitance is computed with a quasi-static field solver such as Ansys Q3D [10] or Palace [11, 12]. Open layout tools [13, 14, 15] and design databases [16] make candidate layouts cheap to draw, and quantization methods turn a capacitance matrix or an eigenmode solution into a circuit Hamiltonian [9, 17, 18, 19], including for circuits with distributed resonators [20]. Repeating capacitance simulations as a design is iteratively refined can be extremely computationally costly. Each simulation takes minutes for a two-conductor capacitor, 1-2 hours for a qubit with several coupling capacitors, about half a day for a qubit embedded with four tunable couplers in a grid (Fig. 2(c)), and becomes infeasible for large devices.
Several approaches are possible to bypass these computationally intensive simulations, but each has its limitations. Physical models such as conformal-mapping formulas for coplanar structures [21, 22, 23] assume a closed form for the geometry at hand, reducing accuracy. Fast integral-equation solvers and the multipole and hierarchical-matrix methods that speed them up [24, 25, 26, 27] still mesh and solve every layout from scratch, while a mesh-free random-walk solver guided by a network [28] still solves each layout anew. Machine-learned surrogates [29, 30, 31] map between the design parameters of one component and its Hamiltonian parameters, forward or inverse. However, their input is the parameter string of a particular layout generation tool, so such a model cannot be evaluated on another component, on a layout drawn by another tool, or on a chip with many compponents, and each new component requires thousands of new training simulations. Graph neural networks have been trained to predict capacitance of a conventional integrated circuit directly from a layout [32, 33, 34], for predicting the parasitics from a circuit schematic before the layout is drawn [35], and to choose the gate frequencies of large superconducting processors [36]. In every case the network maps its input straight to the answer, so all the physics must be reflected in and learned from the training data, requiring large training data and limiting accuracy
on prediction of never-before-seen devices. In contrast, training a model once and reusing it across tasks [37, 38, 39] can be far more accurate and efficient, but has not yet been demonstrated for EM simulation.
In this paper we present QCap, a machine-learned model that computes the full Maxwell capacitance matrix of any planar layout with any number of conductors from the layout .gds file alone. Our model matches EM solver results in seconds per component. The model is based on two advancements. First, we develop a geometry ric embedding of the layout, a richer representation than a parameter string that uses a small number of parameters to capture the geometry of an arbitrary device in a graph whose nodes are the conductors and whose edges are conductor pairs. The same functions act on every node and every edge, so the same network can serve any layout with any number of conductors from any drawing tool, including components it has never seen. The second advance is our use of a cheap physics prior to quickly get a rough physical prediction of capacitance. The neural network then learns only a bounded residual on the prior. Learning a map that fully encodes Maxwell’s equations would be a hard training problem, but the prior turns it into a small local correction, making the model accurate enough to substitute for the field solver despite limited training data (about 35,000 Q3D solutions). The model gives capacitance predictions on in-family test designs that differ from Q3D solves by a median relative error of 0.177%, a median absolute error (MAE) of 0.016 fF, and a root mean square error (RMSE) of 0.025 fF, and are within 0.408% on a whole component family held out of training (MAE 0.0413 fF, RMSE 0.0591 fF). We show that the model can achieve percent-level accuracy on large devices and can predict device capacitances far beyond the scale that Q3D can handle. Despite all training data having the same substrate thickness and dielectric constant, the model maintains percent-level accuracy predicting other thicknesses and dielectrics when a small correction factor is incorporated.
In Section II we explain the embedding protocol. § 2 introduces QCap as well as two variants (Figure 2(b)) and their training. Sec. IV contains the main results. Details of the methods and secondary results are in the appendices.
Figure 2. (a) Agreement between QCap and Q3D simulations for capacitances of the nine-qubit grid device (Sec. IV C 2). (b) Layout-mean median error against the number of conductors on all test datasets of Table II. The legend gives the MAE and RMSE of each predictor over these layouts. (c) Wall time against of QCap on different hardware and of Q3D per design on eight cores. Q3D takes 6.8 h in median at –, and a power-law fit to its 595 designs with , , extrapolates to 41 days for the 100-qubit chip (), which QCap predicts in 2.6 min to 66 min depending on the hardware.
Embedding protocol
Consider a family of components with design space parameters —for instance, two rectangular capacitor pads with parameters length, width, height, and spacing. A surrogate trained on of one component family learns a map that cannot be evaluated on a second family, or even on the same family parametrized in a different way (i.e., made with a different design tool). What current ML approaches to chip design lack is an embedding, a map that takes layouts (objects with any number of conductors, drawn with any tool) into a space a learning algorithm can operate on [40, 41, 42]. Learning a complicated physics map from scratch may require large amounts of training data, and a good embedding needs to be able to work at any scale. We therefore require to be universal (defined for any planar layout independent of the design tool used), geometric (describing each conductor and each coupling in physical units), local and size-invariant (a qubit inside a grid looks like the same qubit on its own chip), physical (carrying a physics block from which the network learns), and fast at every system size.
The eventual goal is to replace the results of capacitance simulations. To train, validate, and test our approach, we use a data set of Ansys Q3D simulations of various components. Simulation details are given in Appendix C. The simulations’ own noise, from the convergence of the pass sequence and the mirror asymmetry of symmetric designs, is below 0.02% (0.005 fF). An independent finite-element solver, Palace [11], on meshes from meshswell [43], agrees with Q3D to within 1.7% in median over the mutual entries (MAE at most 2.2 fF, RMSE at most 1.9 fF) on the one-, five- and nine-qubit grids and on 14 component designs of six families. OverTABLE I. The dataset in five groups, with the splits for training, validation, and testing, the number of conductors including ground, and representative layouts. Figure 10 shows layouts of every family in each group, and Table III of Appendix B lists every family and test set.
Figure 10. Representative layouts of every design family and test set, grouped as in Table I with the splits of each group. Each family shows four layouts, chosen by a fixed sampling rule rather than by hand, with its number of layouts on the right in gray text. Table III lists every family.
all, we have simulated results on 39,962 layouts that we split into 35,354 for training and 4,608 for validation, and a further 5,902 layouts form the test sets (Table I). Figure 10 shows some representative layouts from our dataset.
| Group | Training | Validation | Test | Rep. Layouts | |
| Capacitor families | 3–7 | 32,073 | 4,071 | 4,009 | |
| Qubit families | 3–5 | 735 | 93 | 926 | |
| Generated layouts | 2–68 | 2,546 | 295 | 364 | |
| Held-out sets | 2–18 | 0 | 149 | 600 | |
| Multi-qubit grids | 15–67 | 0 | 0 | 3 | |
| Total | 35,354 | 4,608 | 5,902 |
Table I. The dataset in five groups, with the splits for training, validation, and testing, the number of conductors including ground, and representative layouts.
Bipartite embedding structure
The embedding has a geometric part and a physics part,
i.e., a set of fixed-length vectors on a graph whose nodes are the conductors of the layout and whose edges are their pairs, together with some global information and the outputs of a cheap physics solve and (defined in Sec. II C). Note that a single vector of fixed length could not do this job, because the number of conductors varies from layout to layout and the matrix to be predicted has entries. Figure 3 follows the construction of the geometric part on one layout.
Figure 3. Walkthrough of the geometric embedding. (a) A TransmonPocket read from its .gds file as six conductors: the ground (gray), the two pads A (red) and B (yellow) and the three couplers C, R and D, drawn thicker than in the actual design for visibility. (b) The same layout as a graph, with a node for every conductor and an edge for every pair; edge width indicates the physics prior . (c) The 60 entries of a node vector are 11 shape scalars, 33 Fourier magnitudes of the outer contour, and 16 width spectra. The top row shows coupler C rebuilt from , 4 and 16 of its Fourier harmonics. The 42 entries of a pair vector are the separation spectrum with the minimum gap, three coupling moments, a conformal coupling, two shielding shares, a ground flag, and the local context. The bottom row shows for the pair of A and C the local context within 50, 150 and 400 m (dashed), with each boundary sample colored by its distance to the other conductor. On bottom right is the separation spectrum, how much boundary of one conductor faces the other at each distance. (d) A pad and its bus line (circled) have the same node local vectors alone on a chip and inside a 3 3 grid of 67 conductors, and, once standardized, the same pair vectors except for the two shielding shares. The whole embedding takes under 0.1 s on one laptop core.
Geometric embedding
The idea of the geometric embedding algorithm is to provide the network maximum geometric information in a form that means the same thing for every component. From the input .gds file we unite all polygons of the ground layer into one ground net and take each galvanically connected body of the signal layer as one conductor, so is read directly from the file (Figure 3(a)). Every pair of conductors, the ground included, is joined by an edge, forming a complete graph with edges. A network fed this graph (Figure 3(b)) applies the same functions to every node and edge, so its parameter count does not depend on and relabeling the conductors only permutes the output (§ 2 A).
The conductor vector describes the shape of each conductor, ground included, by shape scalars, the Fourier magnitudes of its outer contour [44], and a width spectrum. An edge holds the pair vector , which says how much metal of faces how much metal of , at what distance, and what surrounds them (Figure 3(c)). It holds a separation spectrum of the facing boundary, i.e., how much boundary faces the other conductor in each of ten distance bins, coupling moments that weight this spectrum as a coupling would, a conformal coupling from the coplanar-strip formula [23], two shielding shares, which are the fraction of each conductor’s total coupling that this pair carries, and the local context: the fractions of ground, other metal and etched substrate within 50, 150 and 400 μm. Importantly, almost nothing in a pair vector refers to the chip size, the pocket size or the total number of conductors. Only the two shielding shares, normalized by each conductor’s total coupling, see the rest of the chip, and in a reference device they move by 0.1 interquartile range between a qubit alone on its chip and the same qubit inside a 3 × 3 grid of 67 conductors, with every other entry identical (Figure 3(d)). This is what lets a correction learned on components act on a chip. Lastly, a global vector holds the logarithms of the chip area, the pocket area, the substrate thickness and the effective permittivity. Performing the embedding takes ∼ 0.1 s for a component and a few seconds for a 68-conductor layout (see Appendix § 2.1.4 for a detailed overview).
An ML system can be trained on this embedding to learn any layout-level target (e.g. capacitance), and can generalize to layouts outside its training families. In practice, however, its effectiveness depends strongly on the diversity and size of the training data (Sec. IV A, Appendix § 1). Unfortunately, large data sets of superconducting device EM simulations are not available. We therefore use a physics prior to reduce training requirements.
Fast physics prior
Learning the physics of electrostatics with a network is a challenging task. It is far easier for a network to correct an inaccurate physics result to match the reference Q3D result. This lets the model learn from little data and act on components it has never seen, because the correction is only a function of local geometry that reads the same on every layout. Importantly, the prior is also where we can put what we know about the physics of the problem, and the network learns the rest. Physics that the data cannot teach enters the model here, and it is here that a physical expectation can be written in to steer the model (an example of this is how we calibrate for the substrate properties as explained in Sec. IV C1). While we use this approach to train models for predicting capacitance matrices, it is a completely general physics-informed learning method that can be adapted for any use case where we want to train models but where reference data is scarce.
Let the physics prior be the Maxwell capacitance matrix of a cheap but physically complete solve of the same layout (described below) and be a reference training capacitance matrix. The off-diagonal elements are the negatives of the capacitances between conductors, and the on-diagonal elements are the total capacitance of a conductor to all other conductors and ground. Entry by entry, we define the residual as the difference between the logarithms of the prior and the reference,
The network learns this residual , as in -learning and multifidelity modeling [45, 46]. The prior need not be accurate, it need only encode the basic physics so that the network’s correction is bounded. This bound parameter needs to be measured from the dataset and depends on how the prior was defined. The network of § 2 therefore predicts only within that bound, so where the data runs out the prediction stays close to the physics. The residual is also the same function for every component that presents the same local situations, which is why a correction learned on three-conductor capacitors can act on a many-conductor chip (Table VIII).
| Predictor | All Entries | fF | Within 100 µm | Beyond 100 µm | Xeon 2 Threads | GH200 32 CPUs | Peak (GB) | |
| 15 | QCap, windows | 0.370 (0.00074 / 0.1769) | 0.648 (0.0156 / 0.2702) | 0.612 (0.0532 / 0.3487) | (0.00027 / 0.0034) | 17.2 s (15.8) | 3.1 s (2.4) | 2.19 |
| QCap, global solve | 0.520 (0.0010 / 0.2021) | 0.760 (0.0127 / 0.3087) | 0.761 (0.2558 / 0.3985) | (0.00046 / 0.0029) | 41.1 s (39.8) | 10.2 s (9.5) | 1.18 | |
| QCap, half-space | 0.370 (0.00075 / 0.1769) | 0.648 (0.0156 / 0.2702) | 0.612 (0.0532 / 0.3487) | (0.00028 / 0.0034) | as windows | |||
| solver-free | 2.271 (0.0033 / 3.2116) | 12.071 (1.3688 / 4.9058) | 11.424 (1.9526 / 6.3312) | (0.0016 / 0.0988) | 0.67 s* | – | – | |
| QCap-Fast | 1.549 (0.0023 / 1.6488) | 7.259 (0.3936 / 2.5186) | 4.627 (1.3285 / 3.2490) | (0.0011 / 0.0752) | 0.68 s* | – | – | |
| 35 | QCap, windows | 0.209 (0.00025 / 0.1448) | 0.952 (0.0159 / 0.3185) | 0.975 (0.2420 / 0.4315) | (0.00016 / 0.0031) | 32.7 s (29.9) | 6.6 s (5.7) | 3.32 |
| QCap, global solve | 0.249 (0.00027 / 0.1825) | 1.208 (0.0238 / 0.4013) | 1.609 (0.2969 / 0.5437) | (0.00016 / 0.0031) | 134.0 s (131.2) | 48.2 s (47.3) | 1.68 | |
| QCap, half-space | 1.009 (0.0015 / 0.1449) | 0.952 (0.0159 / 0.3185) | 0.975 (0.2420 / 0.4315) | (0.0012 / 0.0053) | as windows | |||
| solver-free | 1.948 (0.0022 / 2.7358) | 15.738 (0.4090 / 6.0170) | 13.217 (1.4570 / 8.1511) | (0.0015 / 0.0573) | 2.17 s* | – | – | |
| QCap-Fast | 2.471 (0.0026 / 0.7508) | 10.393 (0.6734 / 1.6512) | 6.498 (1.1664 / 2.2322) | (0.0021 / 0.0539) | 2.20 s* | – | – | |
| 67 | QCap, windows | 0.105 (0.00011 / 0.1041) | 0.872 (0.0183 / 0.3053) | 1.186 (0.2940 / 0.4211) | (0.000089 / 0.0022) | 138.6 s (130.3) | 14.7 s (12.9) | 3.31 |
| QCap, global solve | 0.113 (0.00012 / 0.1191) | 1.119 (0.0219 / 0.3494) | 1.294 (0.2802 / 0.4820) | (0.000097 / 0.0025) | 631.6 s (623.3) | 265.0 s (263.2) | 3.68 | |
| QCap, half-space | 0.960 (0.0012 / 0.1042) | 0.872 (0.0183 / 0.3053) | 1.186 (0.2940 / 0.4211) | (0.0010 / 0.0046) | as windows | |||
| solver-free | 1.304 (0.0013 / 2.8477) | 18.403 (0.4320 / 8.3526) | 16.595 (1.9905 / 11.5230) | (0.0012 / 0.0471) | 5.47 s* | – | – | |
| QCap-Fast | 1.408 (0.0014 / 0.9404) | 14.875 (0.5690 / 2.7583) | 6.048 (1.1617 / 3.7966) | (0.0012 / 0.0676) | 5.54 s* | – | – |
Table VIII.
The physics prior we use in our work has been carefully chosen to optimize for fast computation speed with just enough accuracy to make training our networks effective. We use a method of moments on the metal alone [24, 47] (Appendix E1) where the conductors are treated as sheets of zero thickness on a substrate of permittivity and thickness , with vacuum above and below it. In contrast, the reference Ansys Q3D solve meshes the entire chip, its substrate, and the box around it and refines that mesh pass after pass until the matrix converges. To compute the prior fast we only discretize the metal coarsely and account for the substrate through a Green’s function kernel.
We treat the substrate as an image series in the substrate thickness and dielectric constant [48], as the closed-form Green’s functions of layered media do in microwave and capacitance extraction [49, 50] (Eq. (11)). This allows us to reduce the problem to a uniform medium of effective permittivity for distances well below and to the vacuum kernel far beyond it, because the field lines between distant conductors mostly leave the substrate. This series also makes the substrate thickness and permittivity explicit inputs of the prior, allowing the model to work on unseen substrates (see Section IV C1). The charge on the metal is expanded in flat panels, Eq. (12), which makes the solving very fast: a fraction of a second for a component (0.075 s in median on two CPUs of an EPYC node, Table IV) compared to the minutes to hours required when accurately solved via Q3D (Table II).
| Sample Layout | Dataset Family (Test Layouts) | Q3D Median (min) | QCap % Error (MAE / RMSE, fF) | Physics Prior % Error (MAE / RMSE, fF) | EPYC 2 CPUs (s) | Laptop (M5 Pro) 18 Threads (s) | GH200 32 CPUs (s) |
| interdigital (1,904) | 21.1‡ | 0.157 (0.0134 / 0.0164) | 9.332 (0.9270 / 0.8942) | 1.13 | 0.23 | 0.38 | |
| paddle (1,533) | 23.9‡ | 0.222 (0.0127 / 0.0182) | 9.642 (0.7753 / 0.8709) | 0.539 | 0.11 | 0.18 | |
| concentric (194) | 34.2‡ | 0.171 (0.0862 / 0.1646) | 2.134 (0.957 / 1.306) | 13.0 | 2.67 | 4.34 | |
| star (188) | 19.6‡ | 0.083 (0.0165 / 0.0274) | 3.475 (0.8978 / 0.9776) | 4.28 | 0.88 | 1.43 | |
| multipad star (190) | 27.5‡ | 0.121 (0.0047 / 0.0210) | 3.101 (0.1862 / 0.4297) | 8.42 | 1.47 | 2.21 | |
| Xmon (578) | 16.7¶ | 0.325 (0.0985 / 0.2110) | 8.662 (5.422 / 7.432) | 1.09 | 0.22 | 0.34 | |
| TransmonPocket (171) | 5.2¶ | 0.167 (0.0281 / 0.0545) | 2.405 (0.4213 / 0.7196) | 5.39 | 0.99 | 1.53 | |
| shielded concentric (177) | 11.0¶ | 0.157 (0.0615 / 0.1251) | 1.577 (0.631 / 1.431) | 21.4 | 4.18 | 6.63 | |
| single conductor in a ground cut (147) | 7.0 | 0.594 (2.387 / 2.387) | 13.72 (57.85 / 57.85) | 1.55 | 0.35 | 0.60 | |
| random shape placements (110) | 13.7 | 0.567 (0.0655 / 0.1225) | 11.90 (1.562 / 3.626) | 0.536 | 0.10 | 0.16 | |
| mixed-shape layouts (107) | 15.1 | 0.652 (0.0092 / 0.1584) | 3.957 (0.0753 / 0.7731) | 5.48 | 0.69 | 0.91 | |
| freeform geometries (60) | 20.0 | 0.570 (0.1651 / 0.2873) | 9.112 (2.444 / 4.200) | 1.01 | 0.20 | 0.32 | |
| all quantum-metal QComponents (348) | 52.0§ | 0.993 (6.615 / 6.631) | 10.77 (84.08 / 84.22) | 8.18 | 1.87 | 3.18 | |
| large (40) | 27.1 | 0.657 (0.0036 / 0.1522) | 1.491 (0.0086 / 0.5106) | 16.1 | 2.45 | 3.45 | |
| unseen qubits and couplers (116) | 22.5 | 0.672 (0.0936 / 0.3522) | 9.009 (1.875 / 3.654) | 1.32 | 0.23 | 0.35 | |
| held-out TransmonPockets (36) | 27.2 | 0.326 (0.0189 / 0.1152) | 2.256 (0.0933 / 0.5727) | 7.00 | 1.20 | 1.80 |
Table II. Zero-shot accuracy and inference times of QCap and the physics prior on every test set of Table III. Errors are the median relative error in % (MAE / RMSE in fF). The mean end-to-end wall time is in seconds (colored from green to red), measured on different hardware, and the median Q3D wall time per layout is from our solver records. The marks ‡, ¶, and § indicate details of the timing that are explained in Appendix G.
To maximize the accuracy of our prior, we make use of the fact that the error of a coarse solve is mainly set by its mesh resolution. The charge on a thin film piles up at its edges as with the distance to the edge. Flat panels of size cannot follow that, so every solve misses some edge charge, and the error is first order in . In our data the error is always the same sign, with the prior coming out too low (Appendix E 2). Luckily, one Richardson step [51] removes this first-order error:
From two solves at panel sizes and , we expect the coarser solve to make roughly twice the error of the finer one. We thus project the refined answer as
applied entry by entry in . On the validation layout dataset, we find that this halves the prior’s error for the finer solve alone and at less than twice the cost of that solve (Appendix E 2). This optimized prior, , is what we use for the physics embedding. The mesh step is kept with every entry as the one physics-derived input of the pair vector.
This prior’s compute time is proportional to the size of the chip ( in memory and in time). We therefore make one further optimization to speed things up even more for larger devices. For layouts of more than nine conductors we solve the prior in windows (Figure 11(a)). Groups of at most eight conductors are excited one at a time inside a window that leaves nearby features unchanged and merges everything farther away into the ground, so the size of a window is set by the metal around its core and not by the chip (Appendix E 3). For pairs far apart that cannot be contained in the same window, we use the closed form of a far-field coupling through a grounded plane [52],
Figure 11. The two constructions of the prior for layouts of more than nine conductors. (a) One of the nine windows of the nine-qubit grid. Conductors are colored by circuit role as in Figure 8. Its core conductors (filled), at most eight, are those whose centers fall in one cell of a recursive bisection of the chip (dotted), and they are excited one at a time. The halo, every conductor within 100 smallest gaps of the core (dash-dotted), is held at 0 V. The metal outside the halo but within 100 gaps of the halo conductors is merged into the ground (hatched), and the rest of the metal and gaps are merged into a single filled ground plane. The rest of the chip is left out. (b) The substrate factor of Eq. (14) for 350 of silicon against the measured ratio of Q3D to the half-space dipole on far pairs across ground pockets, as the median and interquartile range per distance bin. Up to 2 mm the validation pairs lie at 0.86–1.11 times the curve and the grid pairs at about 0.73 times it. Beyond 2 mm (shaded) Q3D is below its own noise.
i.e., the field of a dipole through an opening of effective area collected by a second opening at distance . The effective area is the area of conductor plus a share of its perimeter times its mean gap to the nearest other metal, i.e., the conductor together with part of the gap around it, with fitted once on training layouts. Eq. (4) as written holds for two conductors in the same ground pocket. Across ground pockets the field below the plane sees a substrate of finite thickness, and is replaced by a distance-dependent as shown in Figure 11(b) (Appendix E 3). The cost of the optimized prior now grows with the number of conductors, about on the grids of Sec. IV C 2, and not with the chip area.
The learning problem
The input of QCap is a .gds layout file and its output is the full Maxwell matrix of its conductors, with read from the layout file. Section II showed how we
Figure 4. The cumulative distribution of (the correction the network must learn) over the mutual entries of at least 0.1 fF of the validation layouts. Here is the physics prior (Eq. (3)), or with no physics prior the training median of the pair kind (signal-signal or signal-ground). The choice of prior determines the bound of the correction.
go from the layout to its embedding and in this section we explain how we go from the embedding to the output of the capacitance matrix (illustrated in Figure 1(b)).
Figure 1. Workflow for capacitance extraction from a layout, by using a traditional field solver (top) and by using QCap, the model presented in this work. (a) The input is a GDS file, here the nine-qubit grid of Sec. IV C 2. A solver such as Q3D meshes the layout, solves it, and refines the mesh until the convergence criterion is met. QCap instead embeds the geometry and a physics prior and corrects the prior with a message-passing network. (b) A detailed depiction of QCap. The geometric embedding gives a vector for every conductor, for every pair of conductors and for the whole layout. The physics embedding solves the layout on a coarse and a finer mesh, in local windows when it has more than nine conductors, and extrapolates the two solves to the physics prior. The message-passing correction updates the state of every conductor in two rounds. Its two heads then give a correction to the prior for every pair, within a correction limit, and a positive row sum for every conductor, which together give the pair capacitances and the self-capacitances of the Maxwell matrix.
Model architecture
Let be the encoding of conductor and the symmetric output of the pair head of the network (described below). QCap predicts
Here is a node head and is the median over all training data conductors of the same role (ground or signal) of the log of the sum of the corresponding matrix row. The residual of Eq. (2) is parametrized as , so every mutual entry lies within a factor of the extrapolated physics, and the error of a prediction can never exceed the error of the physics by more than ,
The parameter is the size of the correction the network is allowed. From our datasets, we find that the optimized prior is off by up to about 20% on all but a few training entries, so we set , a factor of (Appendix § 2.11), which allows our model to accurately correct every entry whose prior is already that close to the reference. The mutual entries are positive and the matrix is symmetric because , and each row sum is positive, which makes the matrix strictly diagonally dominant and therefore positive definite. We use the learned for the self capacitance rather than the prior’s because the prior’s prediction builds up the error of each term in a row; the learned term reduces this error.
The network comprises two-layer perceptrons of width 64 that encode the conductor vector together with the global vector into , and the pair vector together with the mesh step into a pair state . Two message-passing rounds form a message on every pair from its two conductors and the pair state, and update every conductor from the mean of the messages of its pairs [53, 54]. After the last round the pair head returns and the node head reads (Eq. (15)). In physical terms, one round is one sweep of a self-consistent relaxation with the update rule fitted to the data rather than derived, and two rounds let the pair head see, beyond the pair itself, what else each of its two conductors faces. The graph is complete, so the message passing costs , a few milliseconds on the layouts of this paper.
Models and training
The model described so far is the flagship model we release, : a three-seed ensemble of networks acting on the optimized prior , whose outputs we average into a single capacitance matrix. This is our most accurate model. We also report two more models:
The solver-free network is the same network as but without the physics prior. Its base is the training median of each pair kind (signal-signal or signal-ground) and its pair head is unbounded, since there is no prior for it to stay close to. This model helps us understand how well the model can perform when harnessing only the richer geometrical representation.
The fast model, -Fast, asks whether the physics prior itself can be learned instead of being computed. For this model, we add a second network, trained on an additional 346,993 generated layouts solved by the physics prior only with no Q3D reference (the training part of the 385,593-layout surrogate set of Appendix B), to predict the optimized prior from the geometric embedding. ’s frozen networks are applied unchanged to its output, so this model only affects the physics prior (Appendix § 2.11).
We also show the optimized physics prior alone as our baseline reference. All three models share the geometric embedding, the encoders, the message passing, and the closure head, and differ only in the physics they compute at inference: a small correction (), a full solve (solver-free), or a learned stand-in plus a small correction (-Fast) (Figure 5).
Figure 5. The three models of this paper. Each seed of the network has 89858 parameters (1.08 MB for the three-seed ensemble). QCap-Fast’s surrogate adds 1023362 parameters (4.09 MB), trained on the 346,993 training layouts of the surrogate set, labeled by the prior alone (Appendix B). Note that the physics enters as the base to which the heads add the residual (Eq. (5)), not as a network input. Only the geometric data is fed to the network.
The reference for training is the Q3D matrix of each training layout whose entries are and . We use a Huber loss [55] on the logarithmic error of every mutual entry, plus down-weighted terms on the self terms (Eq. (16)). Care must be taken in how minibatches are drawn, so that no family is drowned out by the two largest. The parameters are optimized with AdamW [56] for a fixed 18,000 steps (Appendix § 2.11). Each seed has 89,858 parameters and trains in 239 s on two threads of a GH200 node’s CPU. The network accounts for less than 0.2 s of any prediction, the remainder being the time needed to compute the prior.
Results
We score the prediction of the model using the following three metrics over its mutual entries (finite positive reference values):
in % and fF, averaged over the layouts of the dataset (the layout mean), with a 0.1 fF floor that keeps attofarad entries at the solver’s own noise from dominating a relative error. We call one predictor better than another only when the difference between them is statistically clear, otherwise we call them tied (Appendix G). Every time we quote is a wall time from the input of a layout file to the output of a complete matrix, named with its machine and thread count, i.e., a laptop (Apple M5 Pro), cluster nodes with AMD EPYC 7513 or 7542 CPUs (EPYC nodes) or Intel Xeon E5-2640 v4 CPUs (Xeon nodes), or the Grace CPU of a GH200 node. The test sets of tbl:I were excluded from training, validation, coefficient fitting and selection, and all networks were frozen before any test set was scored.
Performance compared to published models
To our knowledge three models predicting capacitance of superconducting quantum devices based on layout have been published: the forward MLP of Seidel et al. [29] and the forward MLP and the invertible network (INN) of Nugraha and Shao [30]. We emphasize that these approaches are only able to predict capacitance of the component family they are trained on. We compare performance of models using our and -Fast approaches, but trained only on a single family, against those found in literature. We test on each of the design families in our dataset that have at least 1000 entries, i.e., the five capacitor families of Table III. We re-implemented the three published surrogates and trained them on our data, one network per family (Appendix G). Every predictor was trained from scratch on designs of
a family, with swept from 3 to 1000 designs. The predictions were evaluated on the family’s test designs with the results shown in Figure 6 and Table IV.
Figure 6. Performance of our three models and three literature models when each is trained only on designs in a single device family, and tested on that family. The physics prior (dashed line) is shown for reference. Up arrows indicate INN RMSE off scale, 3469 fF () and 3273 fF ().
| Family (Training Designs) | Seidel et al. MLP | Nugraha & Shao MLP | Nugraha & Shao INN | Physics Prior | QCap |
| interdigital (15,548) | 2.898 (0.215 / 0.308) | 0.147 (0.011 / 0.013) | 0.091 (0.0061 / 0.008) | 9.332 (0.927 / 0.894) | 0.157 (0.013 / 0.016) |
| paddle (11,875) | 1.215 (0.068 / 0.098) | 0.183 (0.010 / 0.015) | 0.154 (0.0084 / 0.014) | 9.642 (0.775 / 0.871) | 0.222 (0.013 / 0.018) |
| concentric (1,617) | 3.025 (1.326 / 3.305) | 1.805 (0.843 / 1.894) | 1.130 (0.562 / 1.335) | 2.134 (0.957 / 1.306) | 0.171 (0.086 / 0.165) |
| star (1,569) | 1.831 (0.253 / 0.514) | 2.431 (0.334 / 0.652) | 2.255 (0.331 / 0.626) | 3.475 (0.898 / 0.978) | 0.083 (0.017 / 0.027) |
| multipad star (1,464) | 2.920 (0.109 / 0.420) | 2.846 (0.099 / 0.380) | 1.995 (0.072 / 0.294) | 3.101 (0.186 / 0.430) | 0.121 (0.0047 / 0.021) |
| time per design | 0.21 ms | 0.02 ms | 0.27 ms | 0.075 s | 0.755 s |
Table IV. In-family comparison of the published parameter-based surrogates, the physics prior and QCap, per family at the full training set. Errors are the median relative error in % (MAE / RMSE in fF). Median time per design is for the parameter networks on one thread and, end to end, for the physics prior and QCap on two CPUs of an EPYC node.
When only three training designs are used, QCap is 40-170 times more accurate than the published models, and they reach its three-design error only with 700-4100 designs on interdigital and paddle capacitors and never on the other three families. They catch up only on the two families with more than 10,000 training designs, where the Nugraha & Shao networks trained on the full family are comparable to QCap (Table IV).
Most of the advantage at few designs comes from the inclusion of the physics prior part of our architecture, as demonstrated by lower errors for QCap and QCap-Fast, which include it. QCap-Fast does not improve much with additional training because its floor is mostly the error of its learned prior and not the learned correction. The solver-free network learns faster than QCap in every family but is still 5.5-14.5 times its median error at on four families, and nearly catches up only on paddle capacitors. QCap is the only model far below the 2–10% error of the optimized physics prior at every .
Generalization at zero shot
The main purpose of QCap is to bypass the simulator. To demonstrate this, we train the model on the full 35,354 simulations of Table III. We then run inference using the trained QCap model on all the test datasets in Table III with the results shown in Table II. This test set includes device designs and families that the model has never seen in training (i.e. the held-out sets of Table III, except for the grids which we discuss in Sec. IV C 2).
On the families it trained on, scored on test designs it never saw, QCap is within 0.08-0.65% of Q3D (MAE 0.0047-2.39 fF, RMSE 0.016-2.39 fF). On the families it never saw at all, it stays below 1%, at 0.33-0.99% (MAE 0.0036-6.62 fF, RMSE 0.115-6.63 fF). It is better than the physics prior on every family and every metric except the MAE of the large- layouts, where the two are tied: from 2.3 times in median on the large- layouts (1.49 against 0.657%; MAE 0.0086 against 0.0036 fF, RMSE 0.511 against 0.152 fF) to 16 times on the freeform geometries (9.11 against 0.570%; MAE 2.44 against 0.165 fF, RMSE 4.20 against 0.287 fF) among the families it never saw.
Our model is also orders of magnitude faster than the simulator. Q3D takes a median of 5.2-52 min per layout, while QCap takes 0.54-21 s on average on two CPUs of an EPYC node (31-2700 times faster), 0.10-42.8 s on a Macbook laptop (160-13000 times faster) and 0.16-6.6 s on 32 CPUs of a GH200 node (100-8000 times faster). We timed every test layout on the EPYC nodes and only 12 layouts on all three machines, so the laptop and GH200 times are the EPYC times scaled by the machine ratio fitted on those 12 layouts (Appendix G).
Scaling beyond the trained domains
The training data have two constraints: every simulation has the same substrate (350 m thick silicon), and the devices are small. Half of the training layouts are under 0.11 (about 0.33 0.33 mm) and 99% under 5.4 with only 244 (0.7%) of the designs with more than two conductors exceeding 2 2 mm and 15 exceeding 4 4 mm (the largest being a 67-conductor layout on 6.0 6.6 mm). No training layout has more than 68 conductors, and only 137 (0.39%) have more than 18.
Given these constraints in the training data we cannot expect the model to be highly accurate in these unseen domains. However, since the prior carries the physics of both, we can use that to address the shortcomings of the training datasets.
Different Substrates
To test how well the physics prior corrects for substrate differences, we simulated five designs from each of the three families — interdigital, shielded concentric and Xmon — in Q3D at silicon substrate thicknesses from 10 to 1000 m () and at 350 m thick substrate permittivities from 3.8 to 24 (Table VI). We compare to a naive approach where the physics prior uses the same 350 m silicon substrate for all designs. Figure 7 shows the result for one held-out Xmon against thickness (a, b) and for the 15 designs against permittivity (c). As expected, the naive model returns its 350 m answer no matter what the substrate is, so its error grows as the stack moves away from the training one. After including substrate information, the model stays within a few times its training-stack error on every stack tested, while the naive model’s error blows up except in cases where the target substrate stack is close to the one seen in training. We also expect the regime at which the naive model fails to depend on the ratio of the substrate thickness to the layout’s lateral size, and Figure 12 shows this dependency, with the naive model’s error falling as for and the substrate-aware model staying flat throughout (Appendix H2).
Figure 7. Predictions for substrates differing from the training data, which is all on 350 m of silicon with (vertical gray lines). The released model computes its physics prior for the substrate the user sets (substrate aware). Without this step (naive), the same networks give their 350 m answer on every substrate. (a) For an Xmon that is not in the training data, the coupling between its cross and bus claw, , and its cross-to-ground capacitance, , against silicon thickness. (b) Median error of this Xmon over its mutual entries versus substrate thickness (Table VI gives the means over all 15 designs of this test). (c) Mean median error of the 15 designs at 350 m against permittivity.
Figure 12. Error on the silicon solves of the substrate study (Sec. IV C1) against , the substrate thickness over the lateral size of the layout. Each point is the median error of one solve. For the naive error (filled circles) follows how far the Q3D matrix itself moves from its 350 m solution (open squares, power-law fits), while the substrate-aware released model, shown as layout means in four bins of , stays flat. The dotted line is the error on the training substrate.
| Substrate | Naive | Substrate Aware (Released) | Q3D Change from 350 µm Si |
| Si 10 µm | 76.64 (8.566 / 18.789) | 0.69 (0.077 / 0.164) | 76.46 (8.545 / 18.742) |
| Si 25 µm | 14.58 (4.157 / 9.132) | 0.93 (0.174 / 0.290) | 14.59 (4.149 / 9.093) |
| Si 50 µm | 5.88 (2.038 / 4.298) | 1.02 (0.187 / 0.353) | 5.72 (2.042 / 4.265) |
| Si 100 µm | 2.88 (0.960 / 1.660) | 0.92 (0.189 / 0.351) | 3.02 (0.970 / 1.636) |
| Si 200 µm | 0.70 (0.232 / 0.359) | 0.58 (0.141 / 0.261) | 0.69 (0.222 / 0.311) |
| Si 350 µm (training) | 0.23 (0.053 / 0.111) | = naive | 0 |
| Si 1000 µm | 0.50 (0.134 / 0.245) | 0.65 (0.217 / 0.451) | 0.36 (0.080 / 0.183) |
| fused silica, | 162.9 (20.47 / 30.50) | 0.64 (0.058 / 0.093) | 1.31 (0.136 / 0.290) |
| sapphire, 10.34 | 10.0 (3.00 / 4.48) | 0.26 (0.050 / 0.106) | 0.10 (0.022 / 0.047) |
| Si, room temperature, 11.7 | 1.89 (0.630 / 0.942) | 0.23 (0.054 / 0.113) | 0.02 (0.0049 / 0.011) |
| GaAs, 12.9 | 10.4 (3.84 / 5.72) | 0.21 (0.057 / 0.120) | 0.11 (0.030 / 0.064) |
| Ge, 16.0 | 26.9 (12.17 / 18.09) | 0.22 (0.081 / 0.158) | 0.30 (0.120 / 0.218) |
| LaAlO, 24 | 50.4 (33.61 / 50.01) | 0.23 (0.115 / 0.219) | 0.56 (0.318 / 0.603) |
Table VI. QCap on substrates other than its training stack, over the 15 designs of Sec. IV C 1. Errors are the median relative error in % (MAE / RMSE in fF). Naive and substrate aware are as in Figure 7, and the last column is how far Q3D itself moves from its 350 µm silicon solution. For the other materials that solution is first rescaled by the change of , so the column is the change beyond a plain permittivity rescaling.
Large Devices
By construction nothing limits the system size our network can be applied to, since more conductors are just more vectors and the same functions. The method of moments dense solve, however, does not scale, and very few training layouts exist to teach the correction what a large chip looks like. The windowed solve described in Sec. II C ensures that the prior is scalable. On a large chip whose ground plane covers everything between the components, the field of the excited conductor is confined by the grounded metal around it. It is a near field across its local gaps and, outside its local neighborhood, approximately the field of a dipole normal to the plane falling as . A solve that keeps the neighborhood exactly and simplifies the rest therefore reproduces a global solve to within the mesh error (Appendix E3).
We test the model’s accuracy at large scale using three devices with multi-qubit grids of two-pad transmons, bus lines, and tunable couplers as shown in Figure 8(a). The devices are one qubit with its four couplers ( conductors including ground and floating stubs), a five-qubit cluster (), and a nine-qubit grid (), solved in Q3D in 12.5, 16.1 and 19.9 h at 26, 56 and 228 GB of peak memory (Table VII). The inference times on these three grids from our model was 12.1, 30.3 and 96.5 s end to end on two CPUs of an EPYC node (3700, 1900 and 740 times faster), 3.4, 6.7 and 11.7 s on a macbook laptop (13000, 8700 and 6100 times faster) and 2.8, 4.6 and 18.8 s on 32 CPUs of a GH200 node (16000, 13000 and 3800 times faster), with a peak memory of 2.2-3.3 GB on two threads of a Xeon node.
Figure 8. QCap on multi-qubit grids, one grid per row in (a)–(c). (a) The one-, five- and nine-qubit grids (, 35 and 67), with conductors colored by circuit role. (b) The signed error of every mutual entry, grouped by role. The seven entries beyond fF are ground capacitances of bus lines and couplers (103–124 fF), each about 1% low. (c) Relative error of every mutual entry (0.1 fF floor) against the pair separation. (d) The 100-qubit chip (), for which no field-solver reference exists, with one 1.8 mm qubit cell enlarged beside it. Its predicted is drawn with the ground row and column nine cells wide, next to its 304590 mutual entries against the pair separation, with ground pairs as gray circles. (e) Wall time of QCap on the 100-qubit chip by stage, end to end on different hardware.
| Predictor | All Entries | fF | Within 100 µm | Beyond 100 µm | EPYC 2 CPUs | Laptop (M5 Pro) 18 Threads | GH200 32 CPUs | |
| 15 | Q3D | 105 entries | 45 entries | 27 entries | 8 entries | 12.5 h on 1 core | ||
| QCap | 0.370 (0.00074 / 0.1769) | 0.648 (0.0156 / 0.2702) | 0.612 (0.0532 / 0.3487) | 0.00027 / 0.0034 | 12.1 s | 3.37 s | 2.78 s | |
| global solve‡ | 0.520 (0.0010 / 0.2021) | 0.760 (0.0127 / 0.3087) | 0.761 (0.2558 / 0.3985) | 0.00046 / 0.0029 | — | — | — | |
| physics prior | 0.871 (0.0016 / 3.168) | 7.094 (0.088 / 4.839) | 7.805 (1.541 / 6.247) | 0.00024 / 0.0301 | 11.5 s | — | — | |
| solver-free | 2.271 (0.0039 / 3.212) | 12.07 (1.369 / 4.906) | 11.42 (1.953 / 6.331) | 0.0016 / 0.0988 | 0.67 s | — | — | |
| 35 | Q3D | 595 entries | 123 entries | 67 entries | 528 entries | 16.1 h on 16 cores | ||
| QCap | 0.209 (0.00025 / 0.1448) | 0.952 (0.0159 / 0.3185) | 0.975 (0.2420 / 0.4315) | 0.00016 / 0.0031 | 30.3 s | 6.65 s | 4.61 s | |
| global solve‡ | 0.249 (0.00027 / 0.1825) | 1.208 (0.0238 / 0.4013) | 1.609 (0.2969 / 0.5437) | 0.00016 / 0.0031 | — | — | — | |
| physics prior | 0.340 (0.00035 / 1.627) | 4.992 (0.085 / 3.577) | 6.668 (1.162 / 4.847) | 0.00027 / 0.0104 | 28.1 s | — | — | |
| solver-free | 1.948 (0.0022 / 2.736) | 15.74 (0.409 / 6.017) | 13.22 (1.457 / 8.151) | 0.0015 / 0.0573 | 2.17 s | — | — | |
| 67 | Q3D | 2,211 entries | 257 entries | 135 entries | 2,076 entries | 19.9 h on 32 cores | ||
| QCap | 0.105 (0.00013 / 0.1041) | 0.872 (0.0183 / 0.3053) | 1.186 (0.2940 / 0.4211) | 0.000089 / 0.0022 | 96.5 s | 11.7 s | 18.8 s | |
| global solve‡ | 0.113 (0.00012 / 0.1191) | 1.119 (0.0219 / 0.3494) | 1.294 (0.2802 / 0.4820) | 0.000097 / 0.0025 | — | — | — | |
| physics prior | 0.170 (0.00017 / 1.267) | 4.125 (0.070 / 3.716) | 7.918 (1.077 / 5.128) | 0.00015 / 0.0036 | 91.1 s | — | — | |
| solver-free | 1.304 (0.0013 / 2.848) | 18.40 (0.432 / 8.353) | 16.60 (1.990 / 11.52) | 0.0012 / 0.0471 | 5.47 s | — | — |
Table VII. Errors and inference times of our models against Q3D on the multi-qubit grids. Errors are the median relative error in % (MAE / RMSE in fF). The last three columns are wall times on the hardware named in their headings, end to end for QCap and the solver-free network, while the physics-prior time is the time of its two solves within QCap’s run. The Q3D times are on the number of cores of one cluster node given in their row. †Timed only in the paired runs of Table VIII. ‡Converged to 0.062% instead of 0.05% because of out-of-memory errors.
On the near pairs QCap is within 0.61, 0.98 and 1.19% of Q3D on the one-, five- and nine-qubit grids (MAE 0.053, 0.24 and 0.29 fF; RMSE 0.35, 0.43 and 0.42 fF) while on the far pairs beyond 1 mm its couplings are 0.86-1.13 times Q3D’s in median (MAE 0.054-0.10 aF). For these tiny capacitances we do not put the 0.1 fF floor on the relative error denominator. The larger relative error is due both to the very small overall capacitance and to the fact that on these pairs the prior itself sits 1.34-1.47 times above Q3D on the five- and nine-qubit grids (Appendix E3). This is more than the factor the network is allowed to remove, so on the far pairs the network applies its maximum correction and the accuracy is limited by the prior. All in all, 2904 of the 2911 mutual entries of the three grids are within 1 fF of Q3D. The other seven are the largest ground capacitances of bus lines and couplers (103-124 fF) and are within 1.5 fF (about 1%), which is excellent agreement for systems of this size.
Lastly, we tested a design extending the same grid design to 10 10 qubits, giving 100 two-pad transmons at 1.6 mm pitch and 180 tunable couplers on a 30 30 mm ground plane, conductors. Extrapolating the meshes of the three smaller grids with their length of metal edge, a converged Q3D solution of this chip needs about 48-63 million surface triangles and 2-4 TB of memory in one shared-memory machine, which is more than the 1.5 TB of the largest node on our university’s clusters, and even on such a machine it would take one week to two months of adaptive passes at 16 cores, with no guarantee of convergence (Appendix H3). QCap predicts the full matrix (Figure 8(d)) in 3.4 min on a laptop (Apple M5 Pro, 18 threads), 2.6 min on 32 CPUs of a GH200 node and 66 min on two CPUs of a Xeon node, with a peak resident memory of 2.6-4.4 GB per process. Most of that time is the windowed physics prior, 79-98% of the run across these machines (Figure 8(e)). Although we make no claims of absolute accuracy here as there is no reference to compare against, this result demonstrates the capability of our approach, allowing us in just a few minutes on a laptop to extract the full capacitance matrix for a 100-qubit chip — a feat beyond the reach of any field solver currently available to us.
Practical workflows
A common workflow is to start with a set of device performance targets and attempt to realize a design to meet those targets. Ideally, we want to use some inverse design [57, 58] flows to optimize our layout for our target; however, no publicly known generalized surrogates exist to drive them. Identifying likely parameter relationships and sampling strategies is a major challenge that scales poorly. Since our model can provide accurate results very fast without having to run full simulations, it allows us to bypass this problem by simply running exhaustive screening searches and then confirming the target device behavior with an expensive Q3D solve.
For the first case we attempt to design Xmons at three targets of charging energy and “claw” capacitor coupling, and . We used our design tool to generate 5000 layouts, random within sensible parameter bounds, and ran QCap on all of them. Generating the layouts took about a minute on a laptop and the inference took a few minutes of wall time over 64 parallel processes. The same sweep in Q3D would take hours to days. For each target, we then chose the design candidate that the model predicted would best match and simulated it in Q3D as shown in Figure 9(a) (the per-target outcomes are in Appendix H4). The relatively higher errors for the last two targets are a consequence of the layout sampling not producing a design near the target. Every Xmon point sits on the diagonal of Figure 9(b), i.e., prediction is within 0.3% of the Q3D result on every Xmon quantity (at most 0.41 MHz discrepancy on and 0.011 fF on , the latter on the 4 fF target).
Figure 9. (a) 5000 random candidates in the model’s (, ) plane, the three targets (crosses) and, for each target, the candidate the model ranks best as predicted (open red marker) and as solved by Q3D (small black marker). Each target keeps its marker shape in all three panels. (b) Comparison of QCap and Q3D errors versus target for and of the three Xmons. A point on the dashed diagonal is a design whose model prediction agrees with a Q3D simulation, and its distance from the origin along the diagonal is how far the screened design itself is from the target. is filled and open. (c) QCap prediction for the best pick of each target, relative to the target. From the random screen alone (open), the picks miss by up to 2.4% ( fF) for the Xmons and 21% ( fF) for the TransmonPocket, set by how densely the screen samples each target. Refining the TransmonPocket (filled) brings every quantity within 0.7%.
Next, we consider a six-conductor TransmonPocket with three couplers and four simultaneous targets, MHz and effective couplings of 10, 1 and 0.1 fF to the readout, bus and drive (both defined in Appendix H4). This is a problem where it is fairly tough to a priori come up with any parameter space bound. In a similar fashion to before, we again screen 5000 candidates, but this time we follow up with four refinement rounds, doing additional parameter sweeps around the best picks (Appendix H4). Solving the final candidate we found in Q3D gives and the readout and bus couplings within 0.5% of the target (+0.97 MHz, −0.006 fF and −0.0017 fF errors) and the drive coupling 1.86% above it (+0.0019 fF
error) (Figure 9(c)). The whole search took about an hour of wall time, 38 min on 32–64 CPUs of our cluster and 21 min on a laptop. In contrast, Q3D simulations of such layouts on 16 cores took a median of 4.8 min each.
Conclusion
We have developed a model which predicts the capacitance matrix of a superconducting circuit device. The model uses a geometric embedding that lets one network serve any layout and a cheap physics prior on which the network learns only a bounded residual — the physics the network would otherwise have to learn from data is computed instead. We achieve percent-level agreement with Ansys Q3D simulations in orders of magnitude less compute time, and are able to predict the capacitance matrix of a (too large to simulate) 100-qubit, 781-conductor chip in 3.4 min on a laptop.
The model’s accuracy on unseen designs comes from computing the physics at inference rather than during training. This is shown by the alternative solver-free model, which falls well behind its in-family accuracy on out-of-family designs. Likewise, on a family held out of training QCap-Fast fails to capture the physics distilled in its surrogate, while QCap with its computed prior remains accurate. Having more (quantity and variation) data especially helps improve the solver-free model (Appendix § 1) and would improve all models, which is why we strongly request community contributions of such design and simulation datasets to SQuADDS [16]. An obvious future direction is to extend to flip-chip and multilayer devices, which will be the subject of future work [59]. The approach we demonstrate is not specific to capacitance or even electromagnetism. It can be adapted to other domains where design loops exist with an expensive physics solver step. The goal is to create an embedding graph to make sure that the ML model can remain scalable and to add a physics prior that is cheap, contains the physics you want to add, and leaves the network a bounded correction so that the model can also generalize. Future work could develop models for capacitance of non-superconducting circuits, for other electromagnetic quantities, and for other physics simulations such as thermal conductance.
Acknowledgments
The authors gratefully acknowledge Firas Abouzahr, Simon Bilodeau, Peter Chen, Eneçtali Figueroa-Feliciano, Helge Gehring, Madison Howard, Can Knaut, Lionel Martinez, Nicola Pancotti, Taylor Patti, Armin Razavi, Olivia Seidel, Andrew W Senior, Sara Sussman, and Yingheng Tang for useful discussions. The authors gratefully acknowledge NVIDIA for providing the GH200 system used in this work and the National Energy Research Scientific Computing Center (NERSC) for providing compute for benchmarking simulations. Funding was provided by the Army Research Office and the Laboratory for Physical Sciences under grant W911NF-25-1-0255, the National Science Foundation under grant 2612093, and the Avasant Foundation via the SPARQ-AI program.
Statement of AI use
Generative AI tools (Claude Opus 5.5 and Claude Fable 5.1) were used during the preparation of this manuscript to assist with copyediting and text polishing, and to assist with portions of the analytical derivations and calculations presented in this work. All AI-assisted derivations and calculations were independently verified by the authors; all scientific claims, conclusions, and content of this manuscript remain the sole responsibility of the authors.
Data and code availability
All data, code and models in this work are publicly available on Hugging Face and SQuADDS. Details of access are given in Appendices A and B.
ML Model Usage
The models run without installation on a browser as a Hugging Face Space (https://huggingface.co/spaces/SQuADDS/planar-capacitance). A prediction takes four steps. The user uploads a GDSII file or picks a bundled example. Next, the user verifies that their ground and conductors are identified correctly (we use the convention of layer/datatype 1/0 for ground and 1/10 for all other conductors) and optionally crops the ground or selects a subset of conductors, previewing the prepared layout before solving. The user then chooses the model and the substrate (the silicon stack of the training data by default). Finally, the Space returns the full Maxwell matrix in fF, ground first and with one row per conductor found in the layout, as a table and as CSV and JSON downloads. For batch screening, users can use the gradio_client. The Space is a demo that follows standard practice for public tools — uploads need a sign-in, use and input size are capped per user, and uploaded layouts are not stored.
For heavy/everyday use, we recommend running the models locally through SQuADDS (version 0.5) as the optional squadds[ml] extra. The model weights are on Hugging Face (https://huggingface.co/SQuADDS/QCap). To use the models, users can call the object CapacitancePredictor and specify the model they want. It takes a GDS path, a gdstk cell or library, or a list of them, and returns the full Maxwell matrix in fF, ground first (res.names, res.matrix_fF), together with the checks for the Maxwell matrix (res.checks) and the wall time (res.timing_s). We also ship a shell command squadds-ml predict that does the same without any Python.
For readers who already design with SQuADDS, the model inference is plug-and-play into their present workflows. MLSimulator has the call and result format of SQuADDS’s Q3D simulator, so the ML inference simply replaces the electrostatic solve and Analyzer.predict_capacitance rebuilds the closest database designs as Quantum Metal components and predicts them. Every prediction converts to the SQuADDS simulation-result format (res.to_sim_results()), so the Hamiltonian calculators (transmon, XMmon, floating transmon, coupled transmons and resonators) remain compatible. The released datasets can be accessed via the PlanarCapacitanceDB object. Users can retrain the networks on their own Q3D data and contribute data or models back to SQuADDS. The following code snippet shows how to run inference and do a dataset query using the new API. We have also added detailed tutorials (https://lfl-lab.github.io/SQuADDS/qcap/#tutorials) to the docsite to go over new workflows that this work enables and how users can train their own models and contribute them back to SQuADDS.
Dataset Availability
All data generated for this paper are available on HuggingFace as two datasets under CC-BY-4.0. The primary dataset, SQuADDS_PlanarCapacitance (https://huggingface.co/datasets/SQuADDS/SQuADDS_PlanarCapacitance), contains both the raw data, i.e. every Q3D-solved layout as a GDSII file with its full Maxwell matrix, and the embeddings. The embedding store is structured so that users can query the geometric embedding and the physics prior independently and train their own models. The SQuADDS_PlanarCapacitance-Synthetic (https://huggingface.co/datasets/SQuADDS/SQuADDS_PlanarCapacitance-Synthetic) dataset holds generated layouts with no Q3D solution, solved only by the thin-film prior of Appendix E, in two parts, the surrogate set of 385,593 layouts, 346,993 for training and 38,600 for validation, on which QCap-Fast’s surrogate physics prior was trained (Appendix F) and a generic set of 286,134 layouts, of which 48,075 carry the optimized physics prior of QCap. All of these datasets can be accessed programmatically via the SQuADDS API.
Q3D Simulation Details
Every reference matrix in this work is an Ansys Q3D (2025 R2) solution with one set-up: a 350 m silicon substrate () on a finite chip in a 1000 m vacuum box, zero-thickness conductors and mixed-order basis functions of first and second order, solved for capacitance only at 13 GHz. Q3D refines its mesh adaptively
| Design Family | Training | Validation | Test | Rep. Layout | |
| interdigital | 3 | 15,548 | 1,931 | 1,904 | |
| paddle | 3 | 11,875 | 1,592 | 1,533 | |
| concentric | 3 | 1,617 | 170 | 194 | |
| star | 3 | 1,569 | 202 | 188 | |
| multipad star | 4–7 | 1,464 | 176 | 190 | |
| Xmon | 3–4 | 179 | 18 | 578 | |
| TransmonPocket | 4–5 | 361 | 48 | 171 | |
| shielded concentric | 3–5 | 195 | 27 | 177 | |
| single conductor in a ground cut | 2 | 729 | 98 | 147 | |
| random shape placements | 3–5 | 796 | 94 | 110 | |
| mixed-shape layouts | 2–68 | 751 | 103 | 107 | |
| local edge effects | 3–4 | 120 | 0 | 0 | |
| third-body couplings | 4–6 | 150 | 0 | 0 | |
| crowded pockets | 6–18 | 0 | 149 | 0 | |
| freeform geometries | 3–5 | 0 | 0 | 60 | |
| all quantum-metal QComponents | 2–3 | 0 | 0 | 348 | |
| large | 8–12 | 0 | 0 | 40 | |
| unseen qubits and couplers | 3–7 | 0 | 0 | 116 | |
| held-out TransmonPockets | 6 | 0 | 0 | 36 | |
| one-qubit grid | 15 | 0 | 0 | 1 | |
| five-qubit grid | 35 | 0 | 0 | 1 | |
| nine-qubit grid | 67 | 0 | 0 | 1 | |
| Total | 35,354 | 4,608 | 5,902 |
Table 3. Every design family used in this work, with its splits for training, validation and testing, the number of conductors including ground, and a representative layout.
until every matrix entry changes by less than a target per pass, 0.05% for three consecutive passes for most families. Before any model was trained, every matrix was also checked against the solver’s own integrated surface charge.
Geometric embedding algorithm
Section II motivated the need for a geometric embedding , stated the requirements it must satisfy, and introduced our embedding algorithm. Here we provide all the details so that one can recompute them exactly. The full list of the 60 conductor, 42 pair and 4 global columns, with their values for every layout of Table I, is in the three geometric-embedding tables of the published dataset (https://huggingface.co/datasets/SQuADDS/SQuADDS_PlanarCapacitance), which is also
the full list of embedding inputs as the network reads them.
The algorithm reads the metal layers of the GDS file and nothing else, so elements like Josephson junctions, ports, and labels are ignored. Every conductor is a region of the plane and its boundary is a closed contour. The ground is the one exception. Wherever the ground needs a region, for its shape scalars and its width spectrum, we use its etched pocket (the complement of the ground within its own bounding box) so the chip outline never enters a conductor vector. All lengths and areas enter the vectors as logarithms in micrometers.
The conductor vector has three blocks. The first is 11 shape scalars: a ground flag, log area, log perimeter, compactness, solidity, the radius of the largest inscribed disk, aspect, elongation, the normalized major moment of the area, the number of holes and the mean width. The second block is 33 Fourier magnitudes of the outer contour [44] (Figure 3(c)). We take the outer contour of the largest part of the region, resample it at points of equal arc length, write the points as complex numbers and compute
with . The magnitudes are normalized so that they do not depend on position, size, orientation or starting point and describe the shape alone. The fundamental is a circle, the odd harmonics are the corners of a rectangle, and the higher orders are the notches and interdigital teeth. The descriptor is rotation-invariant but not reflection-invariant, because a reflection exchanges and , so a mirrored coupler is a different point of the embedding and that invariance has to come from the data. The third block is the width spectrum, the fraction of the area that survives erosion by a disk of radius , at sixteen radii from 0.25 to 100 m. It separates thin strips from compact pads and sets the scale of the fringing field.
The pair vector (Figure 3(c)) is built from the boundary of conductor that faces conductor and vice versa. The separation spectrum is the minimum gap and the length of boundary of one conductor that faces the other in each of ten logarithmic distance bins with edges at 0.5, 1.15, 2.63, 6.0, 13.8, 31.6, 72.5, 166, 381, 873 and 2000 m, stored as with the facing length in bin . The three coupling moments weight the facing boundary as a coupling would, along the facing boundary for , with the distance floored at 0.05 m. The conformal coupling applies the capacitance per unit length of two infinite coplanar strips on a half-space [23] at every boundary sample. With the distance from sample of conductor to the nearest sample of conductor ,
plus the same sum from to , in units of . Here is the complete elliptic integral of the first kind, , is the strip width of conductor with area and perimeter , and is the boundary sampling step. The distance is floored at as for the moments, and for the ground and . The two shielding shares are the fraction of each conductor’s total conformal coupling that this pair carries. The local context is the fractions of ground metal, other metal and etched substrate in rings of , and around the conductors. A ground block repeats the separation block against the ground edge within of the conductor only, and a ground flag completes the vector. Every quantity is the mean of the two directions, so the vector is symmetric.
The global vector holds the four logarithms listed in Sec. II B: chip area, pocket area, substrate thickness, and effective permittivity. Every entry of the three vectors is in physical units and is standardized by the median and interquartile range of the training data, and these constants are frozen with the model. Laplace’s equation has no length scale, so a dilation of the layout shifts every logarithmic length by a constant, which the network can read. The pocket rule for the ground and the ground block are what keep the vectors local.
Optimized Physics Prior Implementation
Section II C introduced the optimized physics prior and what it does for the model. Here we elaborate on the key concepts for its implementation. Throughout, is the mesh resolution in panels per smallest gap, with the smallest gap of the layout and the finest panel size, so that the resolution of a solve is one number, and is one Richardson step, Eq. (3), from the solves at and . QCap uses .
Integral equation, kernel, panels and solver
Each entry of the Maxwell matrix is the solution of a boundary-value problem, in which the potential obeys Laplace’s equation in the dielectric and takes prescribed values on every conductor, and by Gauss’s law the entry is the surface integral of the induced charge, . With every conductor a sheet of zero thickness, the surface charge that puts conductor at and all others at obeys the first-kind integral equation [24, 47]
Here is the potential at of a unit point charge at on the substrate surface, and the integral runs over the metal of every conductor. Solving Eq. (10) once per conductor and integrating the charge gives a valid Maxwell capacitance matrix for any planar layout.
The kernel is where we encode the substrate information (which is not included in the layout GDS file). For an infinitely thick substrate it is the kernel of a uniform medium of permittivity , . For a substrate of thickness with vacuum on both sides, which is what the prior assumes everywhere, it is the image series [48]
Here is the in-plane distance between the two points and is the reflection coefficient of the dielectric interface. The image at depth is the -th reflection between the two faces of the substrate, and the image weights sum to , which makes the far limit exact. Multiplied by , the kernel goes from at to at and reaches the midpoint of the two at , about for of silicon. The transition is this slow because each image pair is weaker than the one before by only , with for silicon. We keep the images until , pairs for silicon, and add the rest of the weight as one image at that depth. The images are smooth on the scale of a panel and are tabulated once per design, so only the term needs exact integrals over the panels, for a panel’s own potential and for neighbors closer than panel sides.
The substrate kernel is what sets the far couplings of a larger device. On the one-qubit grid of Sec. IV C 2, a solve with the half-space kernel puts the couplings beyond at times the Q3D-simulated values in median, and the substrate kernel at times. The kernel covers a single dielectric layer. A multilayer stack would add more interfaces and so more families of images [50], which we have not implemented but is the natural extension of this work.
We discretize Eq. (10) with flat panels. Expanding in panels of constant charge and enforcing the equation at the panel centers gives a dense linear system and, from it, the Maxwell matrix of the discretized problem,
Here is the panel-to-panel potential matrix, , is the panel-to-conductor membership matrix with if panel lies on conductor , and is the vector of conductor potentials. Neighboring panels of different sizes make slightly asymmetric, so we store its near entries as . is then symmetric and, in every case we recorded, positive definite, so is symmetric and positive definite. Up to 12000 panels we factorize by Cholesky decomposition, and above that a conjugate-gradient solve with a hierarchical-matrix preconditioner takes one right-hand side per conductor. This scheme gives no bound on the energy, so the sign of the mesh error has to be measured rather than derived (Appendix E2).
The panels are fine at metal edges and narrow gaps and coarser elsewhere, and each region of the mesh is refined only as much as its own geometry needs. They lie on a quadtree attached to the signal conductors, and the finest panel of a cell is . Here is the distance from the cell’s metal to the nearest other metal and is the smallest gap of the layout wider than . A sub-micrometer slit therefore refines only its own neighborhood, and the prior of a component does not change when the chip around it grows.
Panels of size line every metal edge and are cut along the exact polygon boundary; they double in size away from the edges, and up to 16 collinear panels along a straight edge merge into one strip. The solves at and 3 run in a canonical frame, with rotation, origin and conductor order fixed by the geometry, and are averaged over the frames of a symmetric layout, so the mesh does not depend on how the layout was drawn.
Mesh error and Richardson step
Here we give the measurements behind the mesh error of Sec. II C and the reason for the pair and 3. On the validation designs the prior lies below the reference on 98% of mutual entries at every resolution we solved. We solve , 1.5 and 3, extracting an error dependence that is roughly linear in —the first five families of Table II have median estimated exponents ranging from 0.84 to 1.18.
We apply the Richardson step of Eq. (3) in the logarithm because that keeps the result positive and makes the correction multiplicative, like the network’s own. The mesh step of the pair vector is the difference of the same two solves,
The choice of the pair is a trade-off between its time and accuracy. On the validation layouts, roughly halves the error of the single solve at , in median, MAE, and RMSE alike, and takes 1.7 times as long. Finer pairs reduce the error further, but slowly and at several times the cost. A coarser pair halves the time, but we found the networks trained on it to be less accurate. The residual of Eq. (2) is then a small remaining mesh part plus the difference between a thin sheet and
the full three-dimensional solve with a finite chip and enclosure.
Windows and the far field
In large devices we solve the prior in windows. First, the device is bisected into two regions, then each region is bisected, etc., until each region forms a core of at most eight conductors. Each core gets its own solve window (Figure 11(a)). Each conductor in the core is excited to 1 V while the others are held at 0 V. A halo bounded by a contour at a distance of 100 smallest gaps from each core conductor defines another region in the window. Conductors which fall inside the halo but not inside the core are always kept at 0 V. All metal that is outside the halo but within 100 gaps of any core or halo conductor is treated as part of the ground plane. Metal which is farther away but inside the window is treated as part of the ground plane, and for this reason all gaps less than 250 are filled with metal. After making these modifications, each window is solved at both mesh levels and Eq. (3) is applied entry by entry. Two conductors that share no window are always at least 100 gaps apart and take the far field of Eq. (4). The cost of the prior is then a sum over windows plus the far fill, which takes milliseconds.
We checked the locality behind the windows on the 67-conductor grid, against the global solve on the same mesh. The windows reproduce the entries between signal conductors to 0.3–0.6% (MAE at most 0.014 fF, RMSE at most 0.040 fF) and the ground entries to 1.1% (0.76 / 1.4 fF). The ground is the least local, because its charge spreads over the whole plane. On the same grid the windows are 4.6 times faster than the global solve on two threads of a Xeon node and 18 times faster on 32 CPUs of a GH200 node, where they run in parallel (Table VIII). More important than the speed, they bound the memory and time of every solve, which large designs like the 781-conductor chip depend on.
The prior behind every result of this paper, and the one released with the models, was modified from the prior the networks were trained on. There are three modifications, each of which fixes a defect we found on validation layouts of more than nine conductors. First, a conductor too small to hold a single panel used to drop out of its window’s solve, leaving its pairs to a rough closed-form estimate; it now gets panels. Second, far pairs inside one ground pocket used a two-dimensional coplanar-strip formula that does not fall off with distance as a real three-dimensional field does; they now take the half-space dipole of Eq. (4). Third, a window’s ground plane could be clipped too close to a core conductor that sits far from the ground edge; its margin now widens to reach the ground. None of the three modifications acts on layouts with nine or fewer conductors. We kept the networks trained on the original prior because retraining them on the fixed prior made them worse on layouts of a single conductor in a ground cut, whose priors had not changed. The far field has one fitted constant, the gap share of the effective area , where and are the conductor’s area and perimeter and is the mean distance from its boundary to the nearest other metal. We fitted it once on 92 training layouts, before any network was trained, and got , so the grids test the prior as much as the model. When the distance between conductors is not small compared to the substrate thickness (as in adjacent ground pockets), the field below the plane sees a substrate of finite thickness, not a half-space. With no back-side metal the dipole images alternate in sign, as in the image-dipole series of Ref. [52], and Eq. (4) holds with in place of , where
with and as in Eq. (11). For this is the half-space form, and for the coupling drops toward its vacuum value. For 350 of silicon it lowers the coupling between conductors in adjacent ground pockets by about at the 1.6 mm qubit pitch of the grids (Figure 11(b)). We chose which form applies where by comparing with Q3D. The far couplings are tiny, below one attofarad in median, and beyond 2 mm are below the Q3D solver noise, so on the validation layouts we compare the pairs between 1 and 2 mm. Across pockets the half-space form overestimates them about twofold on the validation layouts and sevenfold on the far pairs of the five- and nine-qubit grids, and the substrate form brings them to 0.88 and 1.34–1.47 times Q3D. What remains is at most about an attofarad, MAE 0.022 aF on the validation pairs and 0.068–0.13 aF on the grids (RMSE 15.1 and 0.90–0.96 aF), hundreds of times below QCap’s error on the near pairs, and on the grids the network brings these far pairs to 0.86–1.13 times Q3D (Sec. IV C 2). Inside one pocket it is the other way round. On the most crowded validation layouts the half-space form matches Q3D (0.97 in median) and the substrate form falls well below it (0.55). The prior therefore uses the half-space form inside a pocket and the substrate form across pockets.
ML Model Architecture and Training Details
Each perceptron of § 2 A is two affine maps with a SiLU nonlinearity between them. The two message-passing rounds have separate weights and read
so the message is symmetric in [53, 54]. After the last round the pair head reads , which makes . Besides the properties of § 2, the form of Eq. (5) makes the signal block of , the matrix a circuit is extracted from, positive definite as well. Relabeling the conductors permutes in the same way, and the number of parameters does not depend on .
The knob must cover the prior’s typical error, or the network cannot correct it, but not much more, or the bound stops protecting the prediction where the data run out. Our is therefore an empirical value, set once for our chosen optimized physics prior; a coarser or finer prior would need a different one. We also let the network learn , as one value for all entries, one per pair kind or one per entry. Learned freely, it rises to about 0.4, but we see no performance benefit to the overall network. Since this learning takes extra training time, we just keep at the empirical value as explained in § 2 B.
The loss of § 2 B over a minibatch is
where is the set of mutual entries with a finite positive reference and the bar denotes the mean. The logarithm makes the loss relative, so that it is insensitive to the absolute value of the capacitance, e.g., a 70 aF coupling and a 100 fF ground capacitance count alike. The Huber threshold keeps the few entries with errors above 5%, mostly small couplings at the chip margin, from setting the gradient. The ground self term is weighted down rather than left out, because it depends on the simulation box of the reference and the closure still needs a finite target.
Each step draws one family uniformly, then a conductor-count shard of that family in proportion to its layout count, then layouts, so a 68-conductor layout is never padded against three-conductor capacitors. AdamW runs at a learning rate of with weight decay , a cosine schedule to and gradient norms clipped at 5, with no early stopping, and every standardized input (Appendix § 2.1.4) is clipped to . Every fit in the paper uses these settings and takes a few minutes, depending on the machine and on how many fits share it. The solver-free network has the same size and settings. The three seeds of QCap were selected on the validation set and frozen before any test set was read.
QCap-Fast’s surrogate is a larger network of the same kind, with four message-passing rounds of width 128 and eleven times the parameters. It learns from the geometric embedding on the surrogate set of Appendix B, generated layouts that cost no field-solver time and cover the training geometry of every family. It trains for 60000 steps, about half an hour on the GPU of a GH200 node, and inference runs in 5.6 ms per layout.
Evaluation Details
We call two predictors tied unless a paired layout bootstrap (10000 resamples) over the same layouts and entries gives a 95% interval that excludes zero and a point estimate larger than 0.25 percentage points of median error or 0.05 fF of MAE.
The EPYC times of Table II were measured on EPYC nodes except for 3 of 61 timing batches, which ran on a Xeon Silver 4116 node. The laptop and GH200 times are estimated from them with a machine ratio fitted on 12 layouts timed on all three machines (26% RMS residual).2 For the first five families of Table III, interdigital to multipad star, the Q3D time is the median wall time of their training-data solves. These ran on 20 cores of our cluster, mostly on EPYC nodes (64–87% of each family’s designs) and otherwise on Xeon Silver 4116 nodes or across nodes of different CPUs, except 407 interdigital designs solved on 14 cores of a lab PC (AMD Threadripper PRO 3955WX) and 113 designs solved on one core. No solve times were recorded for Xmon, TransmonPocket and shielded concentric, and their Q3D time is the median of our own re-solves of ten designs per family on five substrate stacks, on one core.3 The Q3D time is over the 281 of the 348 QComponents that were solved on eight cores of our cluster.
Of the three published surrogates of Sec. IV A, the forward MLP of Seidel et al. [29] follows the authors’ released code. The forward MLP and the INN, read in the forward direction, of Nugraha and Shao [30] use assumed hyperparameters, since neither their settings nor their code is public, and for these two we tested two configurations before any fit and report the one with the lower validation error over all families. Each network is adapted to predict the mutual entries, with a mask loss over the conductor slots a design has and early stopping on the family’s validation split. At every of Figure 6, all predictors share the same three draws of designs and seeds.
We also checked the in-family test split for near duplicates of training layouts, and no test layout duplicates a training geometry. The test designs are a random split of gridded parameter sweeps, so a typical test design is one grid step away from its nearest training design in one or a few parameters, as the validation designs are. Leaving out the quarter of the test designs closest to training changes the in-family error by less than 0.01 percentage points, and its MAE and RMSE by at most 0.002 fF. Only on concentric, the family with the fewest training designs, does the error grow with the distance to training, by about 1.6 times in median in the farthest fifth.
Supporting Results
Family hold-out
To test the model on a family it has never seen but that resembles its training data, we remove one family at a time from the training data, train the same network on the rest and score it on the validation designs of the removed family. We do this for the five families with the most training designs, i.e., interdigital, paddle, concentric, star and multipad star, with three seeds each. The family is removed from everything the model learns from, including the standardization of its inputs. Table V gives the results. Without the family, the model’s error is about 2.4 times its error when trained on all families, and still about 14 times lower than that of the prior. Removing a family by name does not remove every similar geometry, though. The shielded concentric designs, for example, stay in training when concentric is removed.
| Family (Layouts) | Physics Prior | Trained without the Family | Trained on All Families |
| interdigital (1931) | 9.282 (0.931 / 0.895) | 0.413 (0.0392 / 0.0435) | 0.151 (0.0132 / 0.0163) |
| paddle (1592) | 9.668 (0.770 / 0.868) | 0.417 (0.0269 / 0.0312) | 0.210 (0.0120 / 0.0180) |
| concentric (170) | 2.312 (1.085 / 1.361) | 0.544 (0.2423 / 0.4906) | 0.176 (0.0816 / 0.1334) |
| star (202) | 3.360 (0.868 / 0.926) | 0.200 (0.0308 / 0.0492) | 0.083 (0.0160 / 0.0252) |
| multipad star (176) | 3.037 (0.188 / 0.446) | 0.376 (0.0125 / 0.0771) | 0.119 (0.0056 / 0.0216) |
| average of the five families | 5.532 (0.769 / 0.899) | 0.390 (0.0703 / 0.1383) | 0.148 (0.0257 / 0.0429) |
| all 4071 designs together | 8.578 (0.840 / 0.886) | 0.408 (0.0413 / 0.0591) | 0.171 (0.0154 / 0.0225) |
Table V. QCap’s network trained without one of the five largest families of Table I and scored on the validation designs of that family, averaged over three seeds. Errors are the median relative error in % (MAE / RMSE in fF). The physics prior is shown for comparison. Only the last column was trained on the family.
QCap-Fast behaves differently, because its learned prior is retrained without the family too. On families that the learned prior’s training data cover it is at 0.606% (MAE 0.079 fF, RMSE 0.128 fF), but on a removed family it is at 3.113% (0.449 / 0.633 fF), worse than the physics it learns to imitate. Adding the 48075 generated layouts of the generic set (Appendix B) to the learned prior’s training improves this by only about a tenth. A learned prior needs layouts of the new family itself, and those are the data our community is short of, which is why contributions to shared design databases such as SQuADDS matter (§ 2.2).
Substrates
Table VI shows the results of the substrate study of Sec. IV C1. On silicon the error of the naive model, which assumes the substrate is unchanged, closely tracks the change of the Q3D matrix itself from its 350 m solution. Figure 12 plots these silicon solves against , the substrate thickness over the lateral size of the layout. For the released model keeps its training-stack accuracy.
Large Qubit Grids
As seen from Table VIII, filling the far pairs with the half-space dipole instead of the substrate form leaves every entry within 100 m and every entry above 0.1 fF unchanged, but multiplies the MAE of the far pairs by about 8 and 12 on the five- and nine-qubit grids. One global solve instead of the windows makes the same networks less accurate in almost every scope of every grid and 3 to 18 times slower on the GH200 node. It is less accurate because the networks were trained on windowed priors, whose entries within 100 m differ from the global ones by 0.17-0.47% (MAE 0.043-0.079 fF, RMSE 0.102-0.215 fF), and slower because the windows run in parallel and one global solve does not. Without any prior, the solver-free network is more than five times less accurate than QCap on the near pairs.
The estimate for the Q3D solution time of simulating the 100-qubit chip in Sec. IV C2 is made by scaling the converged meshes of the three grids with the length of metal edge, 2221 mm on the chip, whose smallest gap is 6 µm. In the prediction, 100 windows per mesh level carry the solves, 294628 of the pairs take the far field of Eq. (4) in about two seconds per level, and from 16 CPUs up the embedding runs during the solves. The predicted matrix is symmetric to machine precision with every mutual entry negative, and its entries run from 124 fF for adjacent metal to fF across the chip. It is the same on the cluster nodes to relative,
and the laptop, whose meshes are not bit-compatible, agrees with them to 0.011 fF at most, with most entries bit-identical. The three seeds of the network disagree by 0.98% in median on the 1640 pairs within 100 µm (MAE 0.090 fF, RMSE 0.81 fF) and not at all beyond 1 mm, where all three apply the full correction of that allows.
TABLE VIII. The grids of Table VII with the physics prior changed. Global solve replaces the windows with one solve of the whole layout, half-space fills the far pairs without the substrate factor, the solver-free network has no prior and QCap-Fast has a learned one. Errors are the median relative error in % (MAE / RMSE in fF). Times are end to end, with the prior’s share in parentheses, from paired runs separate from those of Table II and Table VII. Peak is the resident memory on the Xeon node. *Embedding only, on two CPUs of an EPYC node.
Practical workflows, quantities, and outcomes
For the Xmon, with the cross as conductor S and the claw as conductor N, the charging energy is , where is the cross’s diagonal entry, and the claw coupling is minus the Maxwell entry between claw and cross. For the TransmonPocket, with its two floating pads and , is the charging energy of the differential mode, with
and the effective coupling of coupler to that mode is
where and are the Maxwell entries of coupler with the two pads, and .
For the Xmon screen, we solved in Q3D the candidate the model ranked best for each target. For the target (200 MHz, 3 fF) the pick has MHz and fF, for (250 MHz, 4 fF) it has 246.63 MHz and 3.971 fF, and for (300 MHz, 2 fF) it has 296.75 MHz and 1.949 fF. Every quantity is within 2.6% of its target. These misses come from how the 5000 random candidates cover each target and not from the model, since Q3D agrees with the model’s prediction for every pick to within 0.3% (Sec. IV D).
For the TransmonPocket, the initial screen of the candidates took about 25 min of wall time on 64 CPUs of our cluster and found no candidate within 10% of all four targets at once. Each refinement round takes the 20 designs the model ranks best, makes 49 variants of each (39 from the third round on), keeps the parents and runs the model on this set again. Four rounds found the candidate of Sec. IV D, the last one with five times smaller random changes. The first two rounds took 12 min on 32 CPUs of our cluster and the last two 21 min on a laptop with ten processes.
Performance against data quantity and diversity
We want to know how much of QCap’s accuracy comes from the amount of its training data and how much from its variety. To understand this, we train single networks of QCap on subsets of the training data in two studies. In the first we vary the amount, from 6.25% to all 35354 training layouts in nested fractions that keep the mix of families, and predict on the 4608 validation layouts. In the second we keep the amount fixed at 729 layouts, balanced over the families they are chosen from, and vary the number of families, or 8 of interdigital, paddle, concentric, star, multipad star, single conductor in a ground cut, random shape placements and mixed-shape layouts. These runs never see Xmon, TransmonPocket or shielded concentric and are scored on the 93 validation layouts of those three families. Every level is the mean of three runs, and the solver-free network is trained on the same subsets with the same seeds. QCap-Fast is left out, because its error is set by its learned prior, which is not trained on these subsets.
Since the 100% level is a mean of single networks, it is slightly worse than the released three-seed ensemble on the same layouts, 0.250% (MAE 0.089 fF, RMSE 0.107 fF) against 0.228% (0.061 / 0.079 fF).
Figure 13 shows the result of this study. On validation, more data helps QCap a little, lowering its MAE by 0.078 fF from 6.25% to all of the data, and helps the solver-free network much more. More families help both networks, the solver-free one by far the most. Evaluating these models on the in-family test set and on the nine zero-shot test sets of Table II allows us to probe which kind of data makes the model better on layouts it was not trained on (Figure 13 (c)). More families help far more than more of the same. Going from one family to eight, at the same 729 layouts, lowers the mean error over the nine zero-shot test sets from 1.46% to 0.92% (MAE 2.73 to 1.35 fF, RMSE 2.97 to 1.53 fF), while going from 6.25% to all of the data lowers it only from 0.91% to 0.65% (MAE 1.79 to 1.10 fF, RMSE 1.94 to 1.21 fF), a clear gain on five of the nine. Three of the nine test sets, the single conductors, random shapes and mixed shapes, come from families that some of the diversity runs train on, so for those runs they are not fully zero-shot. The in-family test set behaves differently. More data changes little there, since the in-family error has largely saturated already at 6.25% of the data, while more families help a lot, because with one family most of the in-family test families are missing from training. None of these single networks reaches the released model (dashed line), a three-seed ensemble trained on all of the data.
Figure 13. How the error of the model scales with the amount and the variety of its training data. (a) Validation error against nested fractions of the 35,354 training layouts (6.25% to 100%), given as the number of layouts in thousands. (b) Error on the validation layouts of Xmon, TransmonPocket and shielded concentric, which these runs never train on, against the number of training families at a fixed 729 layouts. (c) The runs of (a) and (b) on the in-family test set and on the nine zero-shot test sets of Table II (gray, with their mean in black). The dashed line is the zero-shot mean of the released model, a three-seed ensemble trained on all of the data. Every point is the mean of three single networks.
References
References
- [1]A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland, Surface codes: Towards practical large-scale quantum computation, Phys. Rev. A 86, 032324 (2012).
- [2]Google Quantum AI and Collaborators, Quantum error correction below the surface code threshold, Nature 638, 920 (2025).DOI
- [3]P. Krantz, M. Kjaergaard, F. Yan, T. P. Orlando, S. Gustavsson, and W. D. Oliver, A quantum engineer’s guide to superconducting qubits, Appl. Phys. Rev. 6, 021318 (2019).DOI
- [4]M. Kjaergaard, M. E. Schwartz, J. Braumüller, P. Krantz, J. I.-J. Wang, S. Gustavsson, and W. D. Oliver, Superconducting qubits: Current state of play, Annu. Rev. Condens. Matter Phys. 11, 369 (2020).
- [5]A. Blais, A. L. Grimsmo, S. M. Girvin, and A. Wallraff, Circuit quantum electrodynamics, Rev. Mod. Phys. 93, 020500 (2021).DOI
- [6]E. M. Levenson-Falk and S. A. Shanto, A review of design concerns in superconducting quantum circuits, Mater. Quantum Technol. 5, 022003 (2025).
- [7]J. Koch, T. M. Yu, J. Gambetta, A. A. Houck, D. I. Schuster, J. Majer, A. Blais, M. H. Devoret, S. M. Girvin, and R. J. Schoelkopf, Charge-insensitive qubit design derived from the Cooper pair box, Phys. Rev. A 76, 042319 (2007).DOI
- [8]E. Forati, B. W. Langley, A. Nersisyan, and R. Molavi, On the electromagnetic couplings in superconducting qubit circuits, IEEE Transactions on Applied Superconductivity 36, 1 (2026), arXiv:2405.11426.arxiv.org/abs/2405.11426
- [9]Z. K. Minev, T. G. McConkey, M. Takita, A. D. Corcoles, and J. M. Gambetta, Circuit quantum electrodynamics (cQED) with modular quasi-lumped models, arXiv:2103.10344 (2021).arxiv.org/abs/2103.10344
- [10]Ansys Inc., Ansys Q3D extractor, release 2025 R2, https://www.ansys.com/products/electronics/ansys-q3d-extractor (2025).
- [11]AWS Labs, Palace: 3D finite element solver for computational electromagnetics, https://github.com/awslabs/palace (2023).
- [12]D. Sommers, Z. Degnan, D. Gautam, Y.-H. Chen, C.-C. Chiu, A. Fedorov, and P. Pakkiam, Open-source highly parallel electromagnetic simulations for superconducting circuits (2025), arXiv:2511.01220 [quant-ph].arxiv.org/abs/2511.01220
- [13]Z. K. Minev, T. G. McConkey, J. Drysdale, P. Shah, D. Wang, M. Facchini, G. Harper, J. Blair, H. Zhang, N. Lanzillo, S. Mukesh, W. Shanks, C. Warren, and J. M. Gambetta, Qiskit Metal: An open-source framework for quantum device design & analysis, Zenodo (2021).
- [14]D. Cucurachi, S. R. Das, E. Damskägg, R. Giri, D. Gusenkova, A. Guthrie, J. Heinsoo, S. Inel, D. Janszō, M. Jenei, K. Juliusson, J. Kotilahti, A. Landra, R. Moretti, T. Mylläri, C. Ockeloen-Korppi, J. Räbinä, N. Savola, P. Smirnov, E. Takala, and L. Wubben, KQ-Circuits, Zenodo, https://github.com/iqm-finland/KQCircuits (2021).
- [15]H. Gehring, gdswell: high-performance chip design in Python, https://github.com/HelgeGehring/gdswell (2026).
- [16]S. A. Shanto, A. Kuo, C. Miyamoto, H. Zhang, V. Maurya, E. Vlachos, M. Hecht, C. W. Shum, and E. Levenson-Falk, SQuADDS: A validated design database and simulation workflow for superconducting qubit design, Quantum 8, 1465 (2024).DOI
- [17]P. Groszkowski and J. Koch, Squbits: a Python package for superconducting qubits, Quantum 5, 583 (2021).
- [18]S. P. Chitta, T. Zhao, Z. Huang, I. Mondragon-Shem, and J. Koch, Computer-aided quantization and numerical analysis of superconducting circuits, New J. Phys. 24, 103020 (2022).arxiv.org/abs/2206.08320
- [19]Z. K. Minev, Z. Leghtas, S. O. Mundhada, L. Christakis, I. M. Pop, and M. H. Devoret, Energy-participation quantization of Josephson circuits, npj Quantum Inf. 7, 131 (2021).arxiv.org/abs/2010.00620
- [20]E. H. Kunz and E. M. Levenson-Falk, Simple, accurate lumped-element models of distributed resonators for superconducting quantum circuits (2026), arXiv:2607.19543 [quant-ph].arxiv.org/abs/2607.19543
- [21]C. P. Wen, Coplanar waveguide: A surface strip transmission line suitable for nonreciprocal gyromagnetic device applications, IEEE Trans. Microw. Theory Tech. 17, 1087 (1969).
- [22]S. S. Geworgian, T. Martinsson, P. L. J. Linnér, and E. L. Kollberg, CAD models for multilayered substrate interdigital capacitors, IEEE Trans. Microw. Theory Tech. 44, 896 (1996).
- [23]R. N. Simons, Coplanar Waveguide Circuits, Components, and Systems (Wiley-IEEE Press, New York, 2001).DOI
- [24]K. Nabors and J. White, FastCap: a multipole accelerated 3-D capacitance extraction program, IEEE Trans. Comput.-Aided Des. Integr. Circuits Syst. 10, 1447 (1991).DOI
- [25]L. Greengard and V. Rokhlin, A fast algorithm for particle simulations, J. Comput. Phys. 73, 325 (1987).
- [26]W. Hackbusch, A sparse matrix arithmetic based on H-matrices. Part I: Introduction to H-matrices, Computing 62, 89 (1999).
- [27]M. Bebendorf, Approximation of boundary element matrices, Numer. Math. 86, 565 (2000).DOI
- [28]H. R. Rodriguez, J. Huang, and W. Yu, DeepRW-Cap: Neural-guided random-walk capacitance solver for IC design, in Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 40 (2026) pp. 971–979, arXiv:2511.06831.arxiv.org/abs/2511.06831
- [29]O. Seidel, F. Abouzaahr, A. Chakraborty, S. A. Shanto, S. Das, D. Baxter, J. Asaadi, N. Pancotti, H. Yang, B. Khailany, S. Sussman, E. Figueroa-Feliciano, E. M. Levenson-Falk, and T. L. Patti, Component-level inverse design of transmon qubits using neural networks (2026), code: https://github.com/CosmiQuantum/ML_qubit_design, arXiv:2607.20795 [quant-ph].arxiv.org/abs/2607.20795
- [30]F. P. Nugraha and Q. Shao, Machine learning-based predictive modeling for designing transmon superconducting qubits, in 2023 IEEE International Conference on Quantum Computing and Engineering (QCE) (IEEE, 2023) pp. 1360–1368.DOI
- [31]J. Yaker, J. Markovic, A. Reineri, D. M. Kourkouglou, and S. Zorzetti, Neural-network inverse design of SRF cavities and transmons for bosonic quantum computation (2026), arXiv:2607.02289 [quant-ph].arxiv.org/abs/2607.02289
- [32]L. Liu, F. Yang, L. Shang, and X. Zeng, GNN-Cap: Chip-scale interconnect capacitance extraction using graph neural network, IEEE Trans. Comput.-Aided Des. Integr. Circuits Syst. 43, 1206 (2024).DOI
- [33]J. Huang, H. R. Rodriguez, D. Yang, Z. Ye, Y. Lin, and W. Yu, AttentionCap: Transformer based capacitance matrix learning toward full-chip extraction, in Proceedings of the 63rd ACM/IEEE Design Automation Conference (DAC) (2026) pp. 1–7, arXiv:2606.08161.arxiv.org/abs/2606.08161
- [34]H. R. Rodriguez, J. Huang, and W. Yu, CapBench: A multi-PDK dataset for machine-learning-based post-layout capacitance extraction, in Proceedings of the 63rd ACM/IEEE Design Automation Conference (DAC) (2026) pp. 1–7, arXiv:2604.11202.DOI
- [35]H. Ren, G. F. Kokai, W. J. Turner, and T.-S. Ku, ParaGraph: Layout parasitics and device parameter prediction using graph neural networks, in 2020 57th ACM/IEEE Design Automation Conference (DAC) (IEEE, 2020) pp. 1–6.DOI
- [36]H. Ai and Y.-X. Liu, Scalable parameter design for superconducting quantum circuits with graph neural networks, Phys. Rev. Lett. 135, 040601 (2025).DOI
- [37]S. J. Pan and Q. Yang, A survey on transfer learning, IEEE Trans. Knowl. Data Eng. 22, 1345 (2010).DOI
- [38]J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova, BERT: Pre-training of deep bidirectional transformers for language understanding, in Proceedings of NAACL-HLT 2019 (2019) pp. 4171–4186.arxiv.org/abs/1810.04805
- [39]R. Bommasani et al., On the opportunities and risks of foundation models (2021), arXiv:2108.07258.arxiv.org/abs/2108.07258
- [40]T. Mikolov, K. Chen, G. Corrado, and J. Dean, Efficient estimation of word representations in vector space (2013), arXiv:1301.3781.arxiv.org/abs/1301.3781
- [41]M. Zaheer, S. Kottur, S. Ravanbakhsh, B. Póczos, R. Salakhutdinov, and A. J. Smola, Deep sets, in Advances in Neural Information Processing Systems 30 (2017).
- [42]M. M. Bronstein, J. Bruna, T. Cohen, and P. Velicković, Geometric deep learning: Grids, groups, graphs, geodesics, and gauges (2021), arXiv:2104.13478.arxiv.org/abs/2104.13478
- [43]S. Bilodeau, N. Savola, and H. Gehring, meshwell, Zenodo, https://github.com/simbilod/meshwell (2026), version 2.5.2.
- [44]G. H. Granlund, Fourier preprocessing for hand print character recognition, IEEE Trans. Comput. C-21, 195 (1972).DOI
- [45]R. Ramakrishnan, P. O. Dral, M. Rupp, and O. A. von Lilienfeld, Big data meets quantum chemistry approximations: the δ-machine learning approach, J. Chem. Theory Comput. 11, 2087 (2015).DOI
- [46]M. C. Kennedy and A. O’Hagan, Predicting the output from a complex computer code when fast approximations are available, Biometrika 87, 1 (2000).DOI
- [47]R. F. Harrington, Field Computation by Moment Meth- ods (Macmillan, New York, 1968).
- [48]T. Sometani, Image method for a dielectric plate and a point charge, Eur. J. Phys. 21, 549 (2000).DOI
- [49]Y. L. Chow, J. J. Yang, D. G. Fang, and G. E. Howard, A closed-form spatial Green’s function for the thick microstrip substrate, IEEE Trans. Microw. Theory Tech. 39, 588 (1991).DOI
- [50]K. S. Oh, D. I. Kuznetsov, and J. E. Schutt-Aine, Capacitance computations in a multilayered dielectric medium using closed-form spatial Green’s functions, IEEE Trans. Microw. Theory Tech. 42, 1443 (1994).
- [51]L. F. Richardson, The approximate arithmetical solution by finite differences of physical problems involving differential equations, with an application to the stresses in a masonry dam, Philosophical Transactions of the Royal Society of London. Series A 210, 307 (1911).
- [52]J. M. Martinis, R. Barends, and A. N. Korotkov, Calculation of coupling capacitance in planar electrodes (2014), arXiv:1410.3458 [physics.class-ph].arxiv.org/abs/1410.3458
- [53]J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals, and G. E. Dahl, Neural message passing for quantum chemistry, in Proceedings of the 34th International Conference on Machine Learning, PMLR, Vol. 70 (2017) pp. 1263–1272.arxiv.org/abs/1704.01212
- [54]P. W. Battaglia et al., Relational inductive biases, deep learning, and graph networks, arXiv:1806.01261 (2018).arxiv.org/abs/1806.01261
- [55]P. J. Huber, Robust estimation of a location parameter, Ann. Math. Stat. 35, 73 (1964).
- [56]I. Loshchilov and F. Hutter, Decoupled weight decay regularization, in International Conference on Learning Representations (2019).
- [57]S. Molesky, Z. Lin, A. Y. Piggott, W. Jin, J. Vučković, and A. W. Rodriguez, Inverse design in nanophotonics, Nat. Photonics 12, 659 (2018).
- [58]A. M. Eriksson, L. J. Splitthoff, H. V. Upadhyay, P. Campana, O. Lundström, N. Pittan Narendiran, K. Helambe, L. Andersson, and S. Gasparinetti, QDesignOptimizer based on ANMod: an automated, physics-guided, multi-parameter design optimizer for superconducting quantum devices, Quantum Sci. Technol. 11, 035024 (2026).DOI
- [59]D. Rosenberg, S. Chowber, D. Conway, D.-R. W. Yost, J. Mallek, G. Calusine, R. Das, D. Kim, M. E. Schwartz, W. Woods, J. L. Yoder, and W. D. Oliver, Solid-State Qubits: 3D Integration and Packaging, IEEE Microwave Magazine 21, 72 (2020), conference Name: IEEE Microwave Magazine.DOI












