🔬 physics

Component-Level Inverse Design of Transmon Qubits Using Neural Networks

This paper presents a neural network-based inverse design workflow that directly maps target Hamiltonian parameters to transmon qubit layout geometries, achieving high accuracy comparable to fabrication uncertainties while delivering speedups of up to $4.6 \times 10^7$ times over conventional electromagnetic simulations, even with small training datasets.

Original authors: Olivia Seidel, Firas Abouzahr, Abhishek Chakraborty, Sadman Ahmed Shanto, Saikat Das, Daniel Baxter, Jonathan Asaadi, Nicola Pancotti, Haoyu Yang, Brucek Khailany, Sara Sussman, Enectali Figueroa-Feli

Published 2026-10-14

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Olivia Seidel, Firas Abouzahr, Abhishek Chakraborty, Sadman Ahmed Shanto, Saikat Das, Daniel Baxter, Jonathan Asaadi, Nicola Pancotti, Haoyu Yang, Brucek Khailany, Sara Sussman, Enectali Figueroa-Feliciano, Eli M Levenson-Falk, Taylor L. Patti

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Building a quantum computer is like trying to tune a radio that has no dial, where the station you want to hear depends on the exact shape of the antenna. In the world of superconducting quantum circuits, the fundamental building blocks are tiny circuits called qubits, which act as the processors for these machines. To make them work, engineers must design the physical layout of metal and insulators on a chip so that the circuit vibrates at a very specific frequency and behaves in a precise way. Traditionally, finding the right shape for these circuits has been a slow, frustrating process. Designers sketch a layout, run a complex computer simulation to see how electricity flows through it, and then guess how to change the drawing to get the result they want. They repeat this cycle over and over, a method that consumes vast amounts of computing power and human time, often yielding only small improvements.

A team of researchers has now demonstrated a way to flip this process on its head. Instead of guessing a shape and checking the result, they trained a computer system to start with the desired result and instantly work backward to find the shape that creates it. Using a dataset of about 1,900 existing designs, they taught a neural network to map specific target behaviors directly to the physical dimensions of a transmon qubit, a common type of superconducting circuit. The system learned to predict the exact length of metal strips and the spacing between them required to hit a target frequency and a specific measure of stability known as anharmonicity. When tested, the new method produced usable designs 97 percent of the time, with errors so small they are comparable to the natural variations found in the manufacturing process itself.

The core of this achievement lies in a clever two-step training strategy that solves a major problem in reverse engineering. Usually, when you ask a computer to find a shape for a specific electrical behavior, there is often more than one correct answer; many different layouts can produce the same result. If a computer tries to learn this by simply matching shapes to targets, it often gets confused and averages the answers, creating a design that doesn't work at all. To avoid this, the researchers first trained a "surrogate" model to act as a fast, accurate simulator. This surrogate learned to predict the electrical behavior of any given shape almost instantly. They then froze this surrogate in place and used it to train the inverse model. Instead of comparing the new design to a list of correct shapes, the system compared the predicted electrical behavior of the new design against the target. If the behavior was wrong, the system adjusted the shape. This allowed the network to learn the complex relationship between geometry and physics without getting lost in the confusion of multiple possible solutions.

The results show that this approach is not only accurate but incredibly fast. A traditional simulation to check a single design takes about two minutes on a standard computer. The new neural network pipeline can generate and validate a candidate design in roughly 60 milliseconds on the same hardware. When the system processes designs in large batches, the time per design drops to just a few microseconds. This represents a speedup of millions of times compared to the old method. The researchers found that the system works well even with a relatively small dataset of fewer than 2,000 samples, suggesting that this technique does not require massive amounts of data to be effective. In fact, the errors in the predicted designs were often smaller than the uncertainty introduced by the physical manufacturing process, meaning the computer's predictions are as good as the best simulations currently available.

This work demonstrates that component-level inverse design is a practical tool for accelerating the creation of quantum hardware. The system successfully generated novel layouts that were different from the original training examples but still achieved the exact target performance. This proves that the model learned the underlying physics rather than just memorizing previous drawings. While the current study focused on a specific type of transmon layout, the method is generic and could be applied to other quantum devices. By turning a slow, iterative guessing game into a direct calculation, this approach offers a powerful new way to explore the design space of quantum computers, potentially allowing engineers to test thousands of ideas in the time it used to take to test one.

Technical Summary: Component-Level Inverse Design of Transmon Qubits Using Neural Networks

Problem Statement
The systematic design of superconducting qubits, particularly transmons, remains a bottleneck due to its reliance on a heuristic, forward-loop process. Designers typically sketch a layout, simulate it using computationally intensive finite-element electromagnetic (EM) solvers, extract circuit parameters (capacitance, impedance), compute Hamiltonian parameters (qubit frequency $f_q$ and anharmonicity $\alpha$ ), and intuitively adjust the geometry. This cycle is time-consuming, non-systematic, and inefficient, especially given that small geometric changes can yield large, counterintuitive effects on circuit parameters. Furthermore, the inverse problem—mapping target Hamiltonian parameters directly to physical geometry—is ill-posed; multiple distinct geometries can yield nearly identical Hamiltonian responses. A simple inverse model trained solely on geometry labels may "average" these incompatible solutions, producing physically non-viable designs.

Methodology
The authors propose a component-level inverse-design workflow that maps target Hamiltonian parameters directly to layout parameters using a neural network (NN) tandem architecture. The workflow is demonstrated on a planar "cross-claw" transmon layout within the Quantum Metal design environment.

Data Source: The study utilizes the SQuADDS open-source database, specifically a subset of 1,934 cross-claw transmon samples. The dataset links three variable geometry parameters (claw length, ground spacing, and cross length) to Hamiltonian parameters ( $f_q$ and $\alpha$ ), with the Josephson energy ( $E_J$ ) fixed at 10 nH.
Tandem Architecture: To address the ill-posed nature of the inverse problem, the authors employ a two-stage network:
- Forward Surrogate: A Multi-Layer Perceptron (MLP) is trained first to approximate the mapping from geometry parameters to Hamiltonian parameters ( $f_q, \alpha$ ). This model is frozen after training.
- Inverse Model: A second, compact MLP maps target Hamiltonian parameters back to the three geometry parameters.
Training Strategy: The inverse model is trained by passing its predicted geometries through the frozen forward surrogate. The loss is computed in Hamiltonian space (comparing the surrogate's reconstructed $f_q, \alpha$ against the target $f_q, \alpha$ ) rather than in geometry space. This ensures the inverse model learns to produce geometries that satisfy the physical constraints of the target Hamiltonian, avoiding the averaging of incompatible solutions.
Normalization: Min-max normalization is applied to both inputs and outputs using only the training set distribution to prevent data leakage.

Key Contributions

Efficient Forward Surrogate: Development of an MLP surrogate capable of predicting $f_q$ and $\alpha$ from geometry with high accuracy (average errors of 0.136% and 0.293%, respectively) using only ~1,000 training samples.
Inverse-Design Workflow: Demonstration of a tandem inverse pipeline that maps target Hamiltonian parameters to valid cross-claw transmon geometries with a median error of 0.53% for $f_q$ and 1.14% for $\alpha$ .
Small-Data Scaling Analysis: A rigorous analysis showing that the methodology is highly data-efficient, with performance plateauing after approximately 50% of the available training data is used, suggesting the remaining error is due to design space coverage rather than data volume.
Runtime Benchmarking: Comprehensive speedup analysis comparing the neural pipeline against conventional EM solvers (Ansys Q3D).

Results

Accuracy: In validation against a conventional EM solver, 97% of the 100 generated designs produced usable geometries (3 failed due to geometric layout rules like metal overlap). For the 97 valid designs, the pipeline achieved mean percent errors of 0.73% for qubit frequency and 1.58% for anharmonicity. These errors are comparable to or below the expected fabrication and simulation-to-measurement uncertainties for academic-process transmon devices.
Speedup:
- A single conventional EM capacitance extraction takes approximately 2 minutes.
- A single query of the inverse-plus-surrogate pipeline takes ~60 ms on a CPU (a ~2,000× speedup).
- When batched (size 2048), the inference time drops to 3.1 µs per sample on CPU and 2.6 µs per sample on GPU, representing speedups of $3.9 \times 10^7$ and $4.6 \times 10^7$ respectively, relative to a single CPU EM extraction.
Generative Capability: The model successfully generates novel, valid layouts distinct from the training references that satisfy the target Hamiltonian, demonstrating the ability to navigate the "one-to-many" nature of the inverse mapping.
Stress Testing: A nearest-neighbor stress test on 50,000 random geometries showed that the surrogate degrades more slowly with distance from training data than a simple nearest-neighbor baseline, confirming the model learns a smooth empirical approximation of the geometry-to-Hamiltonian map.

Significance and Claims
The authors claim that this component-level inverse design workflow effectively extends and complements conventional EM simulation. The primary significance lies in the ability to rapidly generate and screen candidate designs, reducing the design loop from hours of iterative simulation to milliseconds. The authors emphasize that the achieved accuracy is sufficient for practical design purposes, as the model's error is comparable to the inherent uncertainties of the fabrication and simulation stack. They note that further reductions in model error would be difficult to verify experimentally without significant improvements in fabrication uniformity. The workflow is presented as a data-efficient solution suitable for small datasets (~1,000 samples) and is designed to be generic, applicable to any design tool supporting parameterized layout generation, with future potential for expansion to more complex coupled systems and qubit modalities.

More like this