)=(f_idle^q⁰⁰,f_idle^q⁰¹)⁻¹

For a grid of qubits, the above two—qubit detuning cost may be summed over all qubit—pairs in the grid

$C_{\det}^{grid} (\vec{f_{idle}}, \vec{f_{int}}) = \sum_{pairs} C_{\det}^{pair} (f_{idle}^{pair [0]}, f_{idle}^{pair [1]})$

where pair represents a generic qubit pair and pair [0] and pair [1] represent qubits in that pair.

To perform a two-qubit computational gate, the participating qubits are brought into resonance. This requires the sweeping of both qubits' operating frequencies from their respective idling frequencies towards their common interaction frequency. The first cost function may include an interaction cost term that penalizes undesirable properties of interaction frequencies. For example, the first cost function may penalize low qubit relaxation time interaction frequencies.

Alternatively or in addition, the interaction cost term may penalize low qubit relaxation time frequency regions between qubit idling frequencies and a common interaction frequency, i.e., each qubit should be swept past as few defects as possible when approaching the common interaction frequency. An illustration showing an example sweeping of two qubit's operating frequencies from their respective idling frequency towards a common interaction frequency is described below with reference to FIG. 10. A comparison of two example sweepings of two qubit's operating frequencies from their respective idling frequency towards a common interaction frequency is described below with reference to FIG. 11.

The interaction cost term depends on an average T1 a qubit has during its frequency sweep from idling frequency to interaction frequency, weighted by the amount of time spent at each frequency. For example, for a qubit pair q00-q01, the interaction costs may include

$\begin{matrix} C_{int}^{q 00} (f_{idle}^{q 00}, f_{int}^{q 00 - q 01}) = 1 - \exp (- \int_{t_{start}}^{t_{end}} T_{1, q 00}^{- 1} (t) dt) \\ = 1 - \exp (- \int_{f_{idle}^{q 00}}^{f_{int}^{q 00 - q 01}} T_{1, q 00}^{- 1} (f_{q 00} (t)) \frac{dt}{{df}_{q 00} (t)} df) \end{matrix} \begin{matrix} C_{int}^{q 01} (f_{idle}^{q 01}, f_{int}^{q 00 - q 01}) = 1 - \exp (- \int_{t_{start}}^{t_{end}} T_{1, q 01}^{- 1} (t) dt) \\ = 1 - \exp (- \int_{f_{idle}^{q 01}}^{f_{int}^{q 00 - q 01}} T_{1, q 01}^{- 1} (f_{q 01} (t)) \frac{dt}{{df}_{q 01} (t)} df) \end{matrix} C_{int}^{q 00 - q 01} (f_{idle}^{q 00}, f_{idle}^{q 01}, f_{int}^{q 00 - q 01}) = C_{int}^{q 00} (f_{idle}^{q 00}, f_{int}^{q 00 - q 01}) + C_{int}^{q 01} (f_{idle}^{q 01}, f_{int}^{q 00 - q 01})$

where t_startand t_endrepresent start and end times of the frequency trajectory f_qXY(t) which starts and ends at f_idle^qXY, f_int^pair, respectively. T_1,qXY⁻¹(t) represents relaxation time during the frequency sweep qXY, which depends on f_qXY(t). Here it is assumed that the interaction frequency f_int^q00-q01is the same for q00 and q01, although in some implementations this may not be the case.

For the full qubit grid the interaction cost term is summed over all pairs in the grid

$C_{int}^{grid} (\vec{f_{idle}}, \vec{f_{int}}) = \sum_{pairs} C_{int}^{pair} (f_{idle}^{pair [0]}, f_{idle}^{pair [1]}, f_{int}^{pair})$

where pair represents a generic qubit pair and pair [0] and pair [1] represents qubits in that pair.

The first cost function may be given by a weighted sum of the individual cost terms, e.g., the idling cost term and the interaction cost term described above. The weights may be design parameters that take any value between 0 and 1 and may be chosen based on an importance of the associated cost. For example, the first cost function may be given by

$C_{total}^{grid} (\vec{f_{idle}}, \vec{f_{int}}) = w_{idle} \sum_{qubit} C_{idle} (f_{idle}^{qubit}) + w_{\det} \sum_{pairs} C_{\det}^{pair} (f_{idle}^{pair [0]}, f_{idle}^{pair [1]}) + \dots + w_{int} \sum_{pairs} C_{int}^{pair} (f_{idle}^{pair [0]}, f_{idle}^{pair [1]}, f_{int}^{pair})$

The formal solution to the first cost function may be given by

$\underset{\vec{f_{idle}}, \vec{f_{int}}}{argmin} (C_{total}^{grid} (\vec{f_{idle}}, \vec{f_{int}})) .$

In general, this this problem has high dimension and is non-convex. To demonstrate the complexity: if there were only 2 possible frequency configurations for each qubit, the number of possible frequency configurations would be equal to the size of the Hilbert space of the quantum processor. In realistic situations, there are far more configurations and so evaluating the cost function for all possible configurations is not tractable.

The system applies one or more optimization constraints to the defined first cost function to define an adjusted cost function (step 304). Example optimization constraints are described above with reference to FIG. 2.

The system adjusts qubit operation frequency values to vary the cost according to the adjusted cost function such that the operating state of the quantum device is improved (step 306). Adjusting the qubit operation frequency values to vary the cost according to the adjusted cost function such that the operating state of the quantum device is improved is a simpler task than adjusting the qubit operation frequency values to vary the cost according to the first cost function such that the operating state of the quantum device is improved due to the application of the one or more optimization constraints described above with reference to step 304, since the one or more optimization constraints reduce the number of permissible operating frequency configurations and can break the task of adjusting the qubit operation frequency values into multiple independent sub-tasks that may be solved quickly and in parallel using standard optimization techniques, e.g., basin hopping.

To adjust the qubit operation frequency values to vary the cost according to the adjusted cost function, the system may perform one or more multi-qubit optimization routines to obtain initial qubit operation frequency values. As described in more detail below, performing a multi-qubit optimization routine may include performing a grid-scale optimization routine to obtain coarse-grained initial qubit operation frequency values and performing a pair-scale optimization routine to adjust the coarse-grained initial qubit operation frequency values to fine-grained initial qubit operation frequency values. The system may then perform one or more single qubit optimization routines to adjust the initial qubit operation frequency values to obtain final qubit operation frequency values.

In some implementations the one or more multi-qubit optimization routines and the one or more single qubit optimization routines may be performed in parallel.

In some implementations the T1 spectrum for each qubit can vary in time. This gives the first cost function an additional time dependence. To account for this time dependence, the system may repeatedly adjust qubit operation frequency values to vary the cost according to the adjusted cost function such that the operating state of the quantum device is improved. The characteristic timescales of the time dependence—which may be determined through physics experiments—determines how often the system should repeat the process 300.

Optimization Preparation

In some implementations adjusting the qubit operation frequency values to vary the cost according to the adjusted cost function may include a preparation step that includes identifying an idling frequency arrangement for the grid described above with reference to FIG. 3. FIG. 4A is a flow diagram of an example process 400 for identifying an idling frequency arrangement for a two dimensional grid of qubits. For convenience, the process 400 will be described as being performed by a system of one or more classical or quantum computing devices located in one or more locations. For example, the system 200 of FIG. 2 appropriately programmed in accordance with this specification can perform the process 400.

The system defines an idling frequency splitting pattern for the grid (step 402). As described below, the idling frequency splitting pattern may be represented by a vector of frequency deviations {right arrow over (df)} that is dependent on the one or more physics and engineering constraints of the quantum device described above with reference to step 304 of FIG. 3. For example, the one or more constraints may include a constraint that specifies that neighboring qubits idle at respective frequencies that are at least 1 GHz from one another. This constraint may be used to define the idling frequency splitting pattern.

The system bounds the range over which the splitting pattern can be slid in frequency without exceeding any qubit's accessible frequency range to determine a corresponding vector of operating frequencies for the qubits in the grid (step 404). During the preparation step, it may be assumed that qubit relaxation time T1 is constant.

The process 400 may be described as follows:

1. Input:

- a) a vector of frequency deviations {right arrow over (df)}=(df^qoo, df^qo1, . . . , df^qNM) with {right arrow over (f_idle)}={right arrow over (f₀)}+{right arrow over (df)}, where {right arrow over (f₀)} represents a vector of center frequencies, the vector having arbitrary length with spacing between points given by f_0,step. The vector of frequency deviations {right arrow over (df)} represents the splitting pattern for the grid, and can be used to define physics and engineering constraints of the quantum device (and control system).
- b) a vector containing minimum accessible frequency values for each qubit, i.e., values representing dynamic range minimums, {right arrow over (f_min)}=(f_min^q00, f_min^q01, . . . , f_min^qNM). The minimum accessible frequency values are fixed and determined by the quantum device hardware and fabrication parameters.
- c) a vector containing maximum accessible frequency values for each qubit, i.e., values representing dynamic range maximums, {right arrow over (f_max)}=(f_max^q00, f_max^q01, . . . , f_max^qNM) The maximum accessible frequency values are fixed and determined by the quantum device hardware and fabrication parameters.
- d) f_0,step
  
  2. Algorithm:
- a) Compute bounds f_0,min, f_0,maxsuch that each f_idle^qubit∈{right arrow over (f_idle)}=f₀+{right arrow over (df)} does not exceed its qubit's dynamic range defined by f_min^qubit, f_max^qubit.
  
  i. f_0,min=f₀such that min[(f₀+{right arrow over (df)})−{right arrow over (f_min)}]=0
  
  ii. f_0,max=f₀such that min[{right arrow over (f_max−)}(f₀+{right arrow over (df)})]=0
  
  3. Output:
- a) {right arrow over (f₀)}=(f_0,min, f_0,min+f_0,step, . . . , f_0,max−f_0,step, f_0,max)

FIG. 4B is an illustration 450 of an example splitting pattern for a two dimensional grid of qubits. The left panel 452 represents a two-dimensional grid of qubits, e.g., qubit 454, with nearest neighbor interactions. The central panel 456 illustrates an initial seeding of the idling frequencies for the qubits in the two-dimensional grid. Each box in the central panel plots qubit frequency versus T1 for a respective qubit. For example, box 458 plots qubit frequency versus T1 for qubit 454. As shown in the central panel 456, the idling frequencies of the qubits are initially set at a same value. The right panel 460 illustrates an example idling frequency pattern for the qubits in the two-dimensional grid. In the example idling frequency pattern, a detuning has been implemented simultaneously for all qubits in the two-dimensional grid through the addition of a vector of frequency deviations {right arrow over (df)} as described above. As shown in the right panel 460, the qubit idling frequencies satisfy the example constraint that nearest neighbors need to be detuned. It is noted that this configuration of idling frequencies would be optimal in the case of no material defects and no stray couplings between qubits.

Grid-Scale Optimization

FIG. 5A is a flow diagram of an example process 500 performing a grid-scale optimization routine. For convenience, the process 500 will be described as being performed by a system of one or more classical or quantum computing devices located in one or more locations. For example, the system 200 of FIG. 2 appropriately programmed in accordance with this specification can perform the process 500.

The system evaluates the adjusted cost function (defined above with reference to FIG. 3) for each identified idling frequency arrangement for the grid (defined above with reference to FIG. 4A). This includes setting the interaction frequency for each qubit pair to approximately the mean value of the idling frequencies of the pairs constituent qubits (step 502), and optimizing the adjusted cost function to determine coarse-grained initial qubit idling frequency values (step 504). The system may further set the mean idling frequency for each qubit pair as the coarse-grained initial two-qubit interaction frequency for that pair (step 506).

The grid-scale optimization routine may be described as follows:

1. Input:

- a) C_total({right arrow over (f_idle)}, {right arrow over (f_int)})=C_int^grid({right arrow over (f_idle)}, {right arrow over (f_int)})+C_idle^grid({right arrow over (f_idle)}, {right arrow over (f_int)})
- b) {right arrow over (f₀)}
- c) {right arrow over (df)}
  
  2. Algorithm:
- a) For each f₀∈{right arrow over (f₀)}:
  - i) Set {right arrow over (f_idle)}=f₀+{right arrow over (df)}
  - ii) Set f_int^pair=mean(f_int^pair[0], f_int^pair[1]) for each f_int^pair∈{right arrow over (f_int)}
  - iii) Compute C_total({right arrow over (f_idle)}, {right arrow over (f_int)})

$b) Find {\tilde{f}}_{0} = \arg \min_{f_{0}} (C_{total} (\vec{f_{idle}}, \vec{f_{int}}))$

- - using standard optimization techniques such as basin hopping.
    
    3. Output:
- a) {right arrow over (f_idle)}^coarse={tilde over (f)}₀+{right arrow over (df)}
- b) {right arrow over (f_int)}^coarse=coarse interaction frequencies at idling means
  
  The number of cost function evaluations is N dim({right arrow over (f₀)}) where N represents the total number of qubits.

In some implementations the system may select several {tilde over (f)}₀corresponding to different (and optimally distant) minima. All of these {tilde over (f)}₀can then be explored via the below steps. The system may then select a frequency configuration corresponding to the lowest final cost minimum.

FIG. 5B is an illustration 550 of an example grid-scale optimization routine. For convenience, the illustration 550 builds upon illustration 450 described above with reference to FIG. 4B. The left panel 552 illustrates a result of sweeping the frequencies illustrated in panel 460 described with reference to FIG. 4B over the T1 spectra of the qubits and evaluating the (adjusted) cost function at each step in the dynamic range of the qubits, e.g., using an optimizer, as shown in the right panel 554. This information is used to determine a frequency range over which to operate the qubit.

Pair-Scale Optimization

FIG. 6A is a flow diagram of an example process 600 performing a pair-scale optimization routine to adjust the coarse-grained initial qubit operation frequency values to fine-grained initial qubit operation frequency values. For convenience, the process 600 will be described as being performed by a system of one or more classical or quantum computing devices located in one or more locations. For example, the system 200 of FIG. 2 appropriately programmed in accordance with this specification can perform the process 600.

The system fixes the coarse-grained initial qubit idling frequency values (step 602) and determines fine-grained interaction qubit frequencies by varying the interaction frequency independently for each qubit pair to optimize the cost (step 604). In some implementations the system may bound the range of interaction frequency values to a predetermined frequency range such that the coarse grained idling frequencies determined during the grid-scale optimization step remain valid and such that the quantum device constrains remain satisfied.

The pair-scale optimization routine may be described as follows:

1. Input:

- a) {right arrow over (f_idle)}^coarse
- b) {right arrow over (f_int)}^coarse
- c) C_int^grid({right arrow over (f_idle)}, {right arrow over (f_int)})
  
  2. Algorithm:
- a) Fix {right arrow over (f_idle)}={right arrow over (f_idle)}^coarse
- b) Initialize {right arrow over (f_int)}={right arrow over (f_int)}^coarse
- c) Choose δf_intrepresenting an amount that the interaction frequencies are allowed to vary during the optimization steps

$d) Find \arg \min_{\vec{f_{int}}} (C_{int}^{grid} (\vec{f_{idle}}, \vec{f_{int}}))$

- via standard optimization techniques.
  - i) Let each f_int^pair∈{right arrow over (f_int)} vary independently
  - ii) Bound each f_int^pair∈f_int^{pair, coarse}∓δf_int
    
    3. Output:

$c) {\vec{f_{int}}}^{fine} = \arg \min_{\vec{f_{int}}} (C_{int}^{grid} (\vec{f_{idle}}, \vec{f_{int}}))$

The number of cost function evaluations is (2(N_x×N_y)−(N_x+N_y))×M_{int steps}where N_xand N_yrepresent the number of qubits along the two axes of the grid, and M_{int steps}represents the total number of interaction frequencies to explore per pair.

FIG. 6B is an illustration 650 of an example pair-scale optimization routine for an example pair of qubits 652. For convenience, the illustration 650 builds upon illustrations 450, 550 described above with reference to FIGS. 4B and 5B. As shown in illustration 650, to perform the pair-scale optimization routine for the example pair of qubits 652 the idling frequencies 654 and 656 are fixed, and the interaction frequency 658 is moved from the midpoint between the idling frequencies 654 and 656 to determine an optimal interaction frequency.

Qubit-Scale Optimization

FIG. 7A is a flow diagram of an example process 700 performing a single qubit optimization routine to adjust initial qubit operation frequency values to obtain final qubit operation frequency values. For convenience, the process 700 will be described as being performed by a system of one or more classical or quantum computing devices located in one or more locations. For example, the system 200 of FIG. 2 appropriately programmed in accordance with this specification can perform the process 700.

The system determines final qubit idling frequency values by fixing the fine-grained interaction qubit frequencies (step 702) and varies the idling frequencies for each qubit independently to optimize the cost (step 704). In some implementations the system may bound the range of idling frequency values to a predetermined frequency range such that fine grained interaction frequencies determined in the pair-scale optimization routine remain valid and such the quantum device constrains remain satisfied.

The qubit-scale optimization routine may be described as follows:

1. Input:

- a) {right arrow over (f_idle)}^coarse
- b) C_idle^grid({right arrow over (f_idle)})
  
  2. Algorithm:
- a) Initialize {right arrow over (f_idle)}={right arrow over (f_idle)}^coarse
- b) Choose δf_idlerepresenting an amount that the idling frequencies are allowed to vary during the optimization steps
- c) Find

$\arg \min_{\vec{f_{idle}}} (C_{idle}^{grid} (\vec{f_{idle}}))$

- via standard optimization techniques.
  - iii) Let each f_idle^qubit∈{right arrow over (f_qubit)} vary independently
  - iv) Bound each f_idle^qubit∈f_idle^{qubit, coarse}∓δf_idle
    
    3. Output:

$a) {\vec{f_{idle}}}^{fine} = \arg \min_{\vec{f_{idle}}} (C_{idle}^{grid} (\vec{f_{idle}}))$

The number of cost function evaluations is N×M_{idle steps}where N represents the number of qubits and M_{int steps}represents the total number of idling frequencies to explore per qubit. The total number of cost function evaluations (including the grid-scale optimization routine, pair-scale optimization routine and single qubit optimization routine) is therefore N dim({right arrow over (f₀)})+NM_{idle steps}+(2N−(N_x+N_y))×M_{int steps}˜O(N).

FIG. 7B is an illustration 750 of an example qubit-scale optimization routine for a qubit 752. For convenience, the illustration 750 builds upon illustrations 450, 550, 650 described above with reference to FIGS. 4B, 5B and 6B. As shown in illustration 750, to perform the qubit-scale optimization routine for the example qubit 753, the idling frequency is adjusted within a bound δf_idleto determine an optimal idling frequency.

Example Operating Frequencies

FIG. 8 is a plot 800 showing two example qubit idling frequencies. The plot 800 illustrates an example relationship between qubit frequency and qubit relaxation time T1 for qubit q00. The plot marks a first possible operating point 802 and a second operating point 804. The relaxation time T1 is higher at the first operating point 802 than the second operating point 804, which overlaps with a downward spike (a defect). The first operating point 802 therefore represents a better choice of qubit idling frequency than the second operating point 804.

FIG. 9 illustrates an example unintentional detuning between different idling qubit frequencies for two qubits q00 and q01. Plot