Estimation of Convex Polytopes for Automatic Discovery of Charge State Transitions in Quantum Dot Arrays

: In spin based quantum dot arrays, material or fabrication imprecisions affect the behaviour of the device, which must be taken into account when controlling it. This requires measuring the shape of speciﬁc convex polytopes. We present an algorithm that automatically discovers count, shape and size of the facets of a convex polytope from measurements by alternating a phase of model-ﬁtting with a phase of querying new measurements, based on the ﬁtted model. We evaluate the algorithm on simulated polytopes and devices, as well as a real 2 × 2 spin qubit array. Results show that we can reliably ﬁnd the facets of the convex polytopes, including small facets with sizes on the order of the measurement precision.


I. INTRODUCTION
Quantum devices controlled by gate voltages have wide-ranging applications, spanning from quantum computation, spintronics as well as the exploration of fundamental physics [1].An important class are spin based quantum dot arrays, which are candidates for universal quantum computers [2].In these devices, electrostatic forces are used to trap single electrons at discrete locations, so called quantum dots.Finding the correct control parameters to confine the desired amounts of electrons (e.g., one electron on each dot) or to move single electrons between different quantum dot locations is a key challenge and primary bottleneck in developing these devices.
In this work, we tackle the problem of controlling the electron transitions between quantum dot locations.We present an algorithm that is capable of discovering the set of possible electron transitions as well as their correct control parameters and demonstrate its performance on a real device.Our algorithm is based on a connection to computational geometry and phrases the optimization problem as estimating the facets of a convex polytope from measurements.While this problem is NP-hard, an approximated solution performs well and thus our algorithm represents the first practical automatic tuning algorithm which has the prospects to be scaled to more than 2 or 3 quantum dots on real devices.We demonstrate its practicality on a simulated device with four quantum dots as well as a real device with four quantum dots (three qubit dots plus one sensor dot), which is already outside the scope of human tuning capabilities.Our contributions are the following: 1. We develop an algorithm that aims to find a sparse approximate solution of a convex polytope from measurements with as few facets as possible.For this we extend the non-convex large margin approach introduced by [3].
2. We proof a lemma that can be used to test the correctness of a learned polytope from measurements.Our result leads to an active learning scheme that iteratively improves the polytope estimate by adding informative samples that systematically disproves the previous solution.
3. We show applicability of our algorithm on a real quantum dot array, specifically a foundry-fabricated silicon device that is currently being developed for spin qubit applications.
In this work, we target quantum dot arrays such as the one depicted in Figure 1(a) (see also [4]).In this device, each gate-electrode is able to create a quantum dot below it, by choosing appropriate gate-voltages.We will refer to the vector of electron occupations on each dot as the state of the device.The ground state of the device is essentially determined by classical physics and can be described well via the constant interaction model [5].In this model, the set of control parameters associated with a specific ground state forms a convex polytope.Its boundary is formed by the intersection of linear boundaries, each representing a state transition to another state [1].With this polytope, the control task can be solved directly by selecting a control parameter path that leaves the current state through the desired state transition into the neighbouring target state.Unfortunately, due to manufacturing imprecisions, the parameters of the constant interaction model are unknown and nonlinear effects lead to small deviations of the model, even though ground-states typically remain convex polytopes.Thus, each manufactured device must be tuned individually in order to find the correct control parameters.
The problem of finding the control parameters becomes daunting in larger devices, as each added dot requires at least one additional gate electrode with its own control parameter.Qubit-qubit connectivities required for quantum simulations and quantum computing also constraints the geometrical layout of the quantum dots and their gate electrodes on a chip: Instead of individual isolated qubit dots with dedicated sensor dots, the current trend is to fabricate dense arrays of coupled qubit dots that are monitored by as few proximal sensor dots as possible.This complicates the tune-up in several ways.First, individual gate voltages no longer act locally, meaning that changing the gate voltage of one qubit also affects the potential of other, nearby qubits.Second, the signal of each sensor dot responds to charge changes of multiple dots, making it more difficult to determine which of the dots is making a transition.For example, in our device, a single charge sensor is responsible for monitoring all quantum dots, which means that its signal must be interpreted and does not directly relate to individual electron transitions [6].Currently, experts find the correct control parameters manually using ad-hoc tuning protocols [7,8], which are tedious and time consuming.This limits devices to require tuning of at most three control parameters at once.The field has made first steps into automating parts of this process.For the problem of automating state identification, i.e., estimating the electron count on each quantum dot given a set of control parameters, estimation algorithms can be grouped in two main directions.The first direction uses CNN-based approaches [9,10], which requires dense rastering of image planes within the parameter space.An alternative approach explores the use of line searches to obtain a dataset of state transitions which are modeled using deep neural networks [11][12][13], which allows human experts to label the discovered regions.Both approaches have only been applied to devices with at most two quantum dots and a maximum of three tunable parameters.
While promising, these approaches are not easily transferred to the task of finding state transitions, as the important transitions are routinely very small and can only be found by high-resolution measurements.This makes rastering of images inefficient and random line searches unlikely to pass through them.Furthermore, modeling state transitions with a deep neural network suffers from the lack of interpretability of these models.Even if the correct model is learned, it is difficult to extract the number and sizes of state transitions, without difficult analysis of the learned model.
We will extend the second approach and use line searches to obtain a dataset, which we iteratively improve upon.We combine this with an interpretable model of the polytope which learns individual state transitions.In line with the device limitations and measurement challenges outlined above, we will only assume that the sensor reliably detects that a state transition occurred, but not which state the device transitioned to.Using such a sensor, it is possible to locate a state transition in control parameter space using a line search procedure starting from a point within the convex polytope of a state.The resulting line search brackets the position of a state transition by pairs of control parameters (x + , x − ), each defining one point inside and outside of the (unknown) polytope.This allows for high precision measurements and locates the boundary within a margin of δ = x + − x − , which is a tuneable parameter chosen based on the trade-off between line search precision and short measurement times.
Under the conditions outlined above, finding the true polytope from measurements is a hard machine learning task.Even if all parameters of the constant interaction model are known, computing the boundary of the polytope requires solving the subspace intersection problem [14], with the number of intersections exponential in the number of quantum dots.Indeed, already finding the device state given a set of known parameters of the constant interaction model requires solving an integer quadratic program, which is NP-hard in the number of quantum dots [15].Thus, it is unlikely that learning the polytope from measurements is substantially easier.In fact, if we are given a training set of points which are labeled according to whether they are in-or outside the polytope, then finding the optimal large margin polytope is NP-hard.(See [3] for a review on recent results).When relaxing the task to allowing a polytope with more facets than the optimal polytope, it has been shown that there exists a polynomial time algorithm which fits points to a polytope that has at most a factor of O(log ) more facets than the optimal polytope and has strong approximation guarantees [3].However, the algorithmic complexity in our setting is O(1/δ 2 ) and thus too large for practical application.It is clear that allowing even more facets will make the task substantially easier, e.g., by adding one facet for each point outside the polytope, the task can be solved using O( ) classification tasks, each separating one point outside the polytope from all points inside it.Practical algorithms therefore forego finding the optimal number of facets and use an approximate polynomial time solver [16,17].Howevever, there is a lack of numerically stable general purpose optimization algorithms that aim for a minimal amount of facets and which go beyond convergence in a volume metric (for example Hausdorff in [17]).This is especially problematic in our task, as each facet of the unknown polytope constitutes an operational resource (relocation of individual electrons in the array).Producing an estimate with too many (unphysical) facets might make it impractical to filter out the relevant facets.Our approach is similar to [3] in that we repeatedly solve convex relaxations of a large margin classification problem.In contrast to the related work, we use a numerically stable second order solver instead of SGD and design the problem such that it produces solutions with as few facets as possible.Random perturbations to the solutions found allow the discovery of different local optima from which we choose the best.
Our machine learning task extends over pure polytope estimation from measurements as our goal is not only to find the optimal polytope given a fixed set of points, but a polytope that generalizes well and accurately reflects the true polytope with all its facets.This is difficult to achieve using an i.i.d.dataset as facets with small surface area are unlikely to be found using random samples.Instead, a scheme is required that actively improves our dataset and ensures that we find all relevant facets that are detectable by our hardware.We base our scheme on a theoretical result which can be used to assess whether two polytopes are the same.Intuitively, we must perform validation measurements on each facet to show that it is a facet of the true polytope, but we must also search for small (still undetected) facets that might be hiding near vertices of the current polytope.The resulting algorithm performs a line search in the directions of the corners and through each facet of our current best estimate of the polytope.If our polytope is correct, all state transitions of our model will be contained between the pairs (x + , x − ) of the performed line searches .Otherwise, we obtain examples of new points which we can add to our dataset and fit a new convex polytope.This process is repeated until we either run out of computation time or all performed line searches are correct.The details of our algorithm are given in the method section.
To investigate the performance and quality of our algorithm, we test it on three different setups: Two simulated problems in 3 or 4 dimensions based on either a device simulation or using constructed polytopes from Voronoi regions, and as third application the real device shown in Figure 1(a), where we activate two qubit dots (and the sensor dot) and let human experts verify the result.We further apply the algorithm to the same device with all three qubit dots activated.However, in this case no ground truth is available for comparison.In all simulated experiments, we compare our algorithm to an idealized baseline algorithm that additionally has access to the exact state information while estimating the polytope from measurements and otherwise uses the same active learning protocol.This algorithm assumes a more powerful device with a sensor signal that provides exact state information.(In principle, such a device can be realized by careful design of the charge sensor.)This idealized algorithm is useful to differentiate between the impact of our active learning scheme and the impact of approximately solving the NP-hard estimation problem.
The structure of the paper is as follows: We begin by defining the notation of our paper.In Section III, we introduce the constant interaction model which links between polytope estimation and charge transitions in quantum dot devices.In Section IV, we describe the main algorithm by first introducing a meta algorithm for active learning followed by a description of our algorithm for fitting a polytope to measurements.We describe our experiments in Section V, present our results in Section VI and end with a discussion and conclusion of the paper in Section VII.
N is the number of inequality constraints and A k is a column vector representing the k-th row of A. We will denote the boundary of P as ∂P = {x ∈ P | ∃k : We will also refer to A l as the normal of f l .We define as the inside of f l the open set of points {x ∈ f l | x / ∈ f k , k = l}.We will call the extreme points of P its vertices.We assume P to be finite and non-degenerate and thus there exist exactly N unique facets.

III. THE CONSTANT INTERACTION MODEL
In the following, we give a short introduction to the constant interaction model of quantum dot devices [5].A quantum dot is modeled as a capacitor which can be charged with single electrons.The state of the device s ∈ N n D is the vector of electron occupancies, where, s i is the number of electrons on the ith quantum dot.When applying a vector of gate voltages V g ∈ R ng , the system will assume the state that minimizes the free energy: Here, |e| is the charge of a single electron and the matrices C DD ∈ R n D ×n D (symmetric positive definite) and C Dg ∈ R n D ×ng are capacitance matrices which model the interaction strength between dots and between dots and gates, respectively.The state that achieves the minimum free energy given a fixed V g can be computed by iterating over all possible states: Since (1) consists of terms which are at most linear in V g , the boundary between neighbouring states s and r in state parameter space lies on a plane where the free energy of both states is equal and the plane fulfills Here, ) is its offset.Since all boundaries are linear, the set of gate voltages V g that lead to a given state s form a convex polytope created by the intersection of the planes: While the definition of (2) runs over an infinite number of states, the number of facets which compose the boundary are finite.We will refer to states r which share a facet with s in P (s) as neighbouring states.Thus, the polytope carries information about which state transitions to neighbouring states exist and can be used to control the device.

IV. POLYTOPE ESTIMATION
In this section, we describe our main contribution, an algorithm that can be used to find the facets of a convex polytope from measurements.First, we introduce a meta algorithm that describes our active-learning procedure.It relies on an algorithm to estimate a convex polytope from measurements, which we describe afterwards.

A. A Meta Algorithm For Finding Polytopes
We employ a meta algorithm to iteratively improve an estimate P of a convex polytope P based on line searches.For this, we use an algorithm A which computes P = A(X), where X is a training dataset of previously collected measurements.Our goal is to use active learning to propose new line search directions in order to add new points to X.The meta algorithm is based on the following lemma: Lemma 1.Let P and P be two convex polytopes in R d .Let c k , k = 1, . . ., Nc be the vertices of P and f l , l = 1, . . ., N its facets with normals Âl .If 1. c k ∈ ∂P, ∀k = 1, . . ., Nc 2. for each facet f l , there exists a point x l inside of f l such that x l ∈ ∂P , then P = P .
Proof.From the first point, we directly obtain P ⊆ P due to the definition of convexity.To show P ⊆ P , pick any l ∈ {1, . . ., N }.Since x l ∈ ∂P , there must exist a direction p l ∈ R d such that all x ∈ P fulfill the constraint p T l x − p T l x l ≤ 0. Since x l lies inside a facet of P , we also have ÂT l x − ÂT l x l ≤ 0 for all x ∈ P .Finally, as P ⊆ P and x l is inside of f l , we have p = Âl .As this holds for all facets of P , we obtain This suggests a simple algorithm for iteratively improving an estimate of a convex polytope P , by generating a set of query points R on the boundary of P which includes the vertices of P as well as a point inside each facet.To obtain points inside the facets, we take all vertices which are on a given facet and compute their mean.Then, for each point R i , we perform a line search from a point o ∈ P ∩ P (for example the mean of points in the training set) in direction of R i − o and search for the intersection with P .All intersections (or a bracket containing the likely intersection interval) are added to X.The algorithm terminates if all new points in X lie sufficiently close to the boundary of P , i.e., dist(∂ P , x) < end , ∀x ∈ X.Otherwise, we repeat using the updated training set.

B. Large Margin Polytopes
The algorithm introduced above works well given an exact line search.In this case, we could choose A as a convex hull algorithm.However, this has two disadvantages: 1.In the presence of noise in the line search, points within a facet will never lie on a hyperplane.
2. Even with exact line searches, the number of facets found by the algorithm tends to increase over time, far exceeding the true number of facets.This is because line searches will almost surely not hit a true vertex of P , resulting in additional facets.
Both problems can be understood by seeing the convex hull as a non-parametric model for estimating a convex polytope.Each sampled point increases the complexity of the model, which makes it prone to overfitting, and thus requires regularization.Instead of using a convex hull, we model this estimation problem via regularized large margin classification [18].To this end, we require that the line search does not return an estimate of the point x ∈ ∂P , but instead a confidence interval (x − , x + ), where x − ∈ P and x + / ∈ P .For this, an existing line search can be adapted, for example by adding confidence bounds to its estimate.As a decision function to optimize, we use as with this choice it holds P Â and b are the optimizable parameters and N must be chosen larger than the number of facets in P .With this model, the task is to find a function f which separates the training set of points x − j , j = 1, . . ., from x + j , j = 1, . . ., .Our approach is similar to the large margin approach in [3].The soft-constrained large margin primal optimization problem can be stated as min where Ω : R N ×d → R is a regularizer with complexity parameter C and ξ + i and ξ − i are slack variables.The constraint (6) turns the problem into a non-convex optimization problem, and to find the global optimum, we would need to infer correctly for each Âj those pairs of points that are separated by it (or, in the context of the application, the state of the device associated with x + i ).The problem can be relaxed and solved iteratively using a sequence of convex problems with solutions ( Â(t) , b(t) ), t = 1, 2, . . . .This can be achieved via a convex relaxation of (6) based on the fact that if we find any hyperplane Âsi , bsi for which ÂT si x + i + bsi > 1 − ξ + i , we automatically fulfill constraint (6).Thus, in iteration t of the algorithm, we can take the previous estimate Â(t−1) , b(t−1) to find s i and solve the subproblem min In the algorithm by [3], Ω was chosen as the squared L 2 -norm of the rows of Â, Ω( Â) = N i=1 Âi 2 and the problem was solved via stochastic gradient descent using a variant of the Pegasos [19] solver, that re-estimated s i in (8) during each stochastic gradient step.Additionally, the solver in [3] would assign points to boundaries that are not assigned enough points to prevent a sparse solution.In initial experiments, this solver did not lead to usable or even plausible results in our setting.This is likely due to the ill-conditioning introduced by creating pairs of samples which are very close to the boundary.The resulting ill-conditioning of up to 10 8 necessitates second order optimization algorithms.
Algorithm 1 Algorithm for approximate solution of the polytope estimation problem Ânoise ← Â(0) sol + N (0, σ 2 ) Solve (7) starting from Ânoise , bnoise and prune to obtain We therefore included the following changes: To minimize the number of facets of the polytope, we use a regularizer, which enforces setting whole rows Âi to zero.To this end, we propose to use the This regularizer can be seen as a generalization of 1-norm regularization to impose sparsity on row vectors and has among other applications been used successfully in the context of joint feature selection for multi task learning [20].With this regulariser, the problem (7) becomes a second order cone program (SOCP) which we minimize in each iteration using a second order solver before re-computing s i .We stop the optimization when the s i in two iterations are the same.To save computation time, we prune the solution of each subproblem by removing all hyperplanes with Âi = 0 as they won't get assigned new points and thus they would remain zero due to the regularization term.Finally, we use a restarting strategy to find a good local optimum as described in Algorithm 1.We first create an initial value Âinit , binit by computing the convex hull of the points x − j .We subtract 1 from binit so that the initial solution fulfills (5) with ξ − = 0. Afterwards, we repeatedly solve problem (7) to obtain a first local optimum Â(0) sol , b(0) sol .In our experience, this solution still has too many facets.Thus, we repeatedly add noise to this solution, solve the problem and return the best solution found [21].

V. EXPERIMENTS
We implemented our algorithm by solving problem (7) with cvxpy [22,23] using the ECOS solver for SOCP problems [24].We compute halfspace intersections, convex hulls and their volumes using the Qhull library [14].To save computation time, we include new point pairs (x − , x + ) into the training dataset only if it does not already contain any pair (x − i , x + i ) with x − i − x − < close .The algorithm terminates when the distance between the sampled points (x − i , x + i ) to the boundary of the polytope is smaller than end .To assess the performance of our algorithms, we compared our approach, where possible, to an algorithm that has perfect information regarding which point pair is cut by which hyperplane.For this, we additionally compute the state s i of x + i , pick N as the number of different observed states and solve (7) using the obtained s i .This way, the problem becomes convex and can be solved efficiently.We refer to this algorithm as our baseline.
To quantify the quality of the obtained convex polytopes, we define a matching error between the set of facets in the ground truth f l = {x ∈ P | A T l x + b l = 0} ∈ F and the facets in the estimated convex polytope fk = {x ∈ P | ÂT k x + bk = 0} ∈ F .For this, we compute the minimum angle between the normal of the facet f l and the normals of all fk : We report an error if there is no fk with angle smaller than 10 degrees: This is a sufficient metric for estimating closeness of the facets: as the stopping condition of the algorithm already ensures that the estimated polytope must be very similar to the true polytope in terms of intersection over union, it is only the directions of the facet hyperplanes and their number that needs to be assessed here.To verify this claim, we also compute the intersection over union between the estimated and true ground truth polytopes: IoU(P, P ) = Vol(P ∩ P ) Vol( P ) + Vol( P ) − Vol(P ∩ P ) To test our algorithms, we devise three experiments: Two simulated problems as well as one application on a real device.As application, we consider the device shown in Figure 1(a), consisting of a narrow silicon nanowire through which electrons can flow from source (S) to drain (D).Four gate electrodes (G 1,...4 ) are capacitively coupled to the nanowire, and under correct tuning of their voltages, quantum dots are formed that confine single electrons in small regions (tens of nanometers) of the nanowire.One of the gate electrodes (G 4 ) is connected to a high frequency circuit and produces a sensor signal that responds very quickly to any rearrangements of electrons inside the nanowire.This sensor signal remains constant under voltage changes (line searches) of gate electrodes G 1 , G 2 , and G 3 , as long as the state does not change.Experimentally, this is accomplished by compensating V 4 for any voltage changes applied to G 1,2,3 , such that the potential of the sensor dot is independent of the three control voltages V 1,2,3 .This requires estimating the coefficients of a linear compensation function, which was done once before the algorithm is run.As soon as the charge state changes, i.e., a state boundary is encountered, the sensor signal drops and generates one (x − i , x + i ) pair.The device in Figure 1(a) can create up to four quantum dots.We applied our algorithm to a state with dot 1 and dot 2 each occupied by one electron, and use the two gate voltage parameters V 1 and V 2 to control this [1,1] configuration.(Dot 3 is kept empty by keeping V 3 fixed at a sufficiently negative voltage).We repeat this experiment tuned such that an electron occupies the dot under G 3 as well and estimate the polytope using all three gate voltage parameters in the [1, 1, 1] configuration.
For the simulated experiments, we implement a line search which returns point pairs such that x + i − x − i < δ, where we vary δ across the experiments to measure the impact of the quality of the line search.As our first simulated problem, we generate a set of polytopes via Voronoi regions.For this, we sample 30 points from a d-dimensional normal distribution in R d with zero mean and diagonal covariance matrix Σ with entries Σ ii = 2 • 10 i d .For each set, we compute a Voronoi triangulation.We discard the sample if the origin is not inside a closed Voronoi region or this region extends outside the set [−10, 10] d .On this problem, we can use the Voronoi region around the origin as ground truth.This way, we obtain 100 convex polytopes with between 6 and 12 facets for d = 3 and d = 4.For the baseline algorithm, we use the index of the closest point as state of the Voronoi region.
As our second problem, we simulate a quantum dot array with 3 or 4 qubit dots using the constant interaction model.For simplicity, we omit an additional sensor dot that would normally sense the charge transitions within these triple-and quadruple-dot devices.Specifically, we generate 100 different device simulations by choosing one set of realistic device capacitances and adding noise to simulate variations in device manufacturing.To be able to use a similar tuning as in the Voronoi experiment, we re-scale the parameter space by a factor of 100 so that the polytopes cover roughly the [−10, 10] d volume.As the ground truth polytope for each simulated device we compute that region in control-voltage space that has a ground state with a [1,1,1] or [1,1,1,1] charge configuration, i.e. exactly one electron per dot.These calculations yield 14 facets for all simulated triple-dot devices, and 30 facets for all simulated quadruple-dot devices.Errors made by the algorithm in finding the correct facets are discussed below.
As parameters, we chose in all experiments end = 1.5δ, close = δ and n repeat = 10.In the simulated experiments, we vary δ ∈ {0.01, 0.05, 0.1, 0.2}, choose σ = 0.001/δ and C = 75/δ.For the baseline algorithm, we use the same parameters except C = 750/δ.We obtain the initial dataset X by performing 100 line searches in random directions starting from a known point inside P (e.g., the origin for the Voronoi region based dataset).For the real device, we implemented a line search in hardware using a DAC voltage generator.Instead of using the single point x i returned by the hardware, we add a confidence interval x ± i = x i ± δ/2 with δ = 0.001, which takes into account the experimental measurement uncertainty.This choice of δ is equivalent to the δ = 0.1 setting in the simulated device on the re-scaled parameters.Further, we pick σ = 0.05/δ and C = 10/δ.The initial dataset was obtained via line searches using 10 random directions.

VI. RESULTS
In our experiments, we first investigated how close the learned polytope is to the true polytope on the simulated devices, depending on the line search accuracy δ = x + − x − .For this, we computed the intersection over union of true and estimated polytopes and found an expected value between 0.9996 (δ = 0.01) and 0.995 (δ = 0.02), which are both very close to the optimum of 1.We did neither observe any relevant differences to the baseline algorithm, nor large differences between 3 and 4 dimensions.We then measured how many of the linear decision functions in the ground truth polytope were not approximated well in the estimated polytope.The recorded number of matching errors on the two simulated datasets as a function of the precision of the line search, δ, can be seen in Figure 2.For both datasets, the error increased with δ, where for the simulated devices, we saw a far steeper increase than for the Voronoi regions.For small values of δ, we observed less than 0.1 matching errors, which increased to 4.5 at δ = 0.2 in 4D.Here, the baseline algorithm performed better.
To investigate the nature of the errors, we computed the hyper volume of the state transitions as a measure of size of the facet in the polytope.The histograms of volumes as well as relative distributions of errors are shown in Figure 3.As can be seen from the figure, most errors appeared on facets with small volume.Further, we observed that facets with small volumes were estimated more reliably as the line search accuracy improved.To give a more qualitative impression of the errors observed, we visualized two examples of an error by creating random cuts through the 4D parameter space of the simulated device in such a way that an unmatched facet in the ground truth is visible within the cut.See Figure 4 for common examples, extracted from a problem instance with 4 errors and obtained with δ = 0.2.
For the real device, the obtained model of our algorithm is shown in Figure 1 in red color.In 2D, human experts verified the correctness of the state transitions and annotated the resulting states, based on a dense 2D raster scan shown in the background of Fig. 1(b).We can see that the algorithm found two very small facets which are invisible on the raster scan.In 3D no ground truth was available, but qualitatively the 10 facets found by the algorithm (six local optimum is likely caught and results in an new training iteration.This hypothesis is strengthened by the fact that we observe that with higher precision of the line search the distribution of errors is shifted towards smaller facets, showing that we are better at disproving local optima.An example of the superiority of our approach to rastering can be seen in Figure 1(b).Here, we can see that the algorithm managed to find two very small facets (labeled [0,2] and [2,0]) which are invisible on the raster scan.Operationally, these are two very important facets in the device as they amount to transitions of electrons between quantum dots, while the other transitions are electrons entering or leaving the array.For the purposes of quantum computation, such inter-dot tunneling processes effectively turn on wave-function overlap between two electrons, which is a key resource to manipulate their spin states via Heisenberg exchange coupling [25].The same holds for the 3D polytope estimated in Figure 1(c), where small facets corresponding to inter-dot transitions have been found.
Compared to random sampling, our sampling approach using active learning seems to be superior.For random sampling, the number of samples requires depends largely on the relative size of a facet compared to the overall surface area [26].Thus, for the small size of facets on our polytope, an average of 1500 samples is significantly less than expected via random sampling.
Still, our algorithm is not perfect.Comparing the performance of our algorithm to the idealized baseline algorithm indicates that the majority of errors are introduced by the difficulties of solving the NP-hard polytope estimation problem, while our active learning scheme seems to works very well.Thus, our work will likely profit from continued development of improved and faster estimation algorithms.
We have successfully applied our algorithm to a real 2x2 quantum dot array, constituting the first automatic discovery of state transitions in the literature.As the underlying estimation problems are NP-hard and we observed a steep increase of run-time already going from 3D to 4D, we foresee practical limits of our algorithm for controlling large quantum dot arrays.However, in practice, one may not need to find all facets in order to implement desired qubit functionalities.For example, universal quantum computers can be constructed entirely from single-and twoqubit operations, meaning that many facets associated with a multi-dot state may be operationally irrelevant (such as facets corresponding to multi-electron co-tunneling transitions, which are likely very small facets that are hard to find).Alternatively, it might be possible to partition the device in blocks of smaller arrays, for which polytopes can be estimated independently.For example, for a linear array of many quantum dots, it might be possible to estimate all relevant local transitions of a quantum dot using its two-neighbourhood in the dot connection graph, a 5-dimensional subspace, which we have shown is already within our estimation capabilities.Another possible solution is to use more and better sensor signals to identify the state transitions.
A potential shortcoming is our assumption of linear state transitions, which form a convex polytope.This assumption is not true for devices that exhibit device instabilities.However, stable, non-hysteretic materials are essential prerequisites for quantum processors, and recent material improvements already led to very stable materials.Thus, we expect that future devices will fulfill this assumption to a much higher degree than devices that are available today.
Aside from requiring an initial point inside a target state, the algorithm runs unsupervised and automatically proposes new measurement points to refine the estimate of the state transitions.Thus, we foresee our method to have major impact in tuning quantum dot devices where human tuning capability is the limiting factor, even on the small devices operated today.

FIG. 1 :
FIG. 1: Automatic discovery algorithm implemented on a real quantum dot array with a sensor dot coupled to either a double dot or a triple dot.(a) Micrograph of the device.Individual electrons originating from the source (S) or drain (D) reservoirs can be trapped by gate-induced quantum dots (circles), located below electrostatic gate electrodes G 1,...4 and controlled by voltages V 1,...4 .For the targeted [1, 1] state, each qubit dot (red) contains one electron, whereas the sensor dot (black) is used to generate a high bandwidth sensor signal.(b) 2D map of the sensor signal as a function of the control voltages V 1 and V 2 , acquired in high resolution to illustrate the convex polytope of this device configuration.For all yellow pixels, the qubit array is in the [1, 1] state.(Whenever V 1,...3 is changed, V 4 is not held constant but compensates the sensor dot potential for capacitive cross talk from G 1 , G 2 and G 3 , see experiments.)Our algorithm estimates state transitions to other states (red lines), based on a small number of point pairs (x + , x − ) (blue and orange dots) obtained via line searches.Target states of transitions are annotated by [x, y].(c) Estimated state boundaries of the 3D polytope associated with single-electron occupation of three quantum dots (under G 1 , G 2 and G 3 ).The ground truth of this triple-dot system is already tedious to measure and unknown for this device tuning.

FIG. 2 :
FIG. 2: Average number of matching errors made by the algorithm as function of line search precision (see text).We show results on the 3D and 4D problems for our algorithm and the idealized baseline.Left: Voronoi region problem.Right: Problems drawn from the quantum device simulator.

FIG. 3 :FIG. 4 :
FIG. 3: Histograms of the volumes of the facets of the convex polytopes in 4D, the relative distribution of matching errors and the error rate at a given volume and for different δ.Top: Voronoi problem.Bottom: Simulated quantum devices.