Automate Resource Estimation with QIR

This value represents the total number of physical qubits, which is the sum of 4200 physical qubits to implement the algorithm logic, and 3960 physical qubits to execute the T factories that are responsible to produce the T states that are consumed by the algorithm.

This is a runtime estimate (in nanosecond precision) for the execution time of the algorithm. In general, the execution time corresponds to the duration of one logical cycle (10us) multiplied by the 608 logical cycles to run the algorithm. If however the duration of a single T factory (here: 82us 500ns) is larger than the algorithm runtime, we extend the number of logical cycles artificially in order to exceed the runtime of a single T factory.

Laying out the logical qubits in the presence of nearest-neighbor constraints requires additional logical qubits. In particular, to layout the $Q_{alg}=33$$Q_{\mathrm{a}\mathrm{l}\mathrm{g}}=33$$Q_{\rm alg} = 33$ logical qubits in the input algorithm, we require in total $2\cdot Q_{alg}+\lceil \sqrt{8\cdot Q_{alg}}\rceil +1=84$$2\cdot Q_{\mathrm{a}\mathrm{l}\mathrm{g}}+\lceil \sqrt{8\cdot Q_{\mathrm{a}\mathrm{l}\mathrm{g}}}\rceil +1=84$$2 \cdot Q_{\rm alg} + \lceil \sqrt{8 \cdot Q_{\rm alg}}\rceil + 1 = 84$ logical qubits.

To execute the algorithm using Parallel Synthesis Sequential Pauli Computation (PSSPC), operations are scheduled in terms of multi-qubit Pauli measurements, for which assume an execution time of one logical cycle. Based on the input algorithm, we require one multi-qubit measurement for the 8 single-qubit measurements, the 0 arbitrary single-qubit rotations, and the 0 T gates, three multi-qubit measurements for each of the 192 CCZ and 8 CCiX gates in the input program, as well as No rotations in algorithm multi-qubit measurements for each of the 0 non-Clifford layers in which there is at least one single-qubit rotation with an arbitrary angle rotation.

This number is usually equal to the logical depth of the algorithm, which is 608. However, in the case in which a single T factory is slower than the execution time of the algorithm, we adjust the logical cycle depth to exceed the T factory’s execution time.

To execute the algorithm, we require one T state for each of the 0 T gates, four T states for each of the 192 CCZ and 8 CCiX gates, as well as No rotations in algorithm for each of the 0 single-qubit rotation gates with arbitrary angle rotation.

The total number of T factories 11 that are executed in parallel is computed as $\lceil \frac{800\text{T states}\cdot 82us500ns\text{T factory duration}}{1\text{T states per T factory}\cdot 6ms80us\text{algorithm runtime}}\rceil$$\lceil {\displaystyle \frac{800\text{T states}\cdot 82us500ns\text{T factory duration}}{1\text{T states per T factory}\cdot 6ms80us\text{algorithm runtime}}}\rceil$$\left\lceil\dfrac{800\;\text{T states} \cdot 82us 500ns\;\text{T factory duration}}{1\;\text{T states per T factory} \cdot 6ms 80us\;\text{algorithm runtime}}\right\rceil$

In order to prepare the 800 T states, the 11 copies of the T factory are repeatedly invoked 73 times.

The 4200 are the product of the 84 logical qubits after layout and the 50 physical qubits that encode a single logical qubit.

Each T factory requires 360 physical qubits and we run 11 in parallel, therefore we need $3960=360\cdot 11$$3960=360\cdot 11$$3960 = 360 \cdot 11$ qubits.

The minimum logical qubit error rate is obtained by dividing the logical error probability 5.00e-4 by the product of 84 logical qubits and the total cycle count 608.

The minimum T state error rate is obtained by dividing the T distillation error probability 5.00e-4 by the total number of T states 800.

The number of T states to implement a rotation with an arbitrary angle is $\lceil 0.53{\log }_2\left(0/0\right)+5.3\rceil$$\lceil 0.53{\log }_2(0/0)+5.3\rceil$$\lceil 0.53 \log_2(0 / 0) + 5.3\rceil$ [arXiv:2203.10064]. For simplicity, we use this formula for all single-qubit arbitrary angle rotations, and do not distinguish between best, worst, and average cases.

You can load pre-defined QEC schemes by using the name surface_code or floquet_code. The latter only works with Majorana qubits.

The code distance is the smallest odd integer greater or equal to $\frac{2\log \left(0.08/0.000000009790100250626566\right)}{\log \left(0.0015/0.000001\right)}-1$${\displaystyle \frac{2\log (0.08/0.000000009790100250626566)}{\log (0.0015/0.000001)}}-1$$\dfrac{2\log(0.08 / 0.000000009790100250626566)}{\log(0.0015/0.000001)} - 1$

The number of physical qubits per logical qubit are evaluated using the formula 2 * codeDistance * codeDistance that can be user-specified.

The runtime of one logical cycle in nanoseconds is evaluated using the formula 20 * oneQubitMeasurementTime * codeDistance that can be user-specified.

The logical qubit error rate is computed as $0.08\cdot {\left(\frac{0.000001}{0.0015}\right)}^{\frac{5+1}{2}}$$0.08\cdot {\left({\displaystyle \frac{0.000001}{0.0015}}\right)}^{\frac{5+1}{2}}$$0.08 \cdot \left(\dfrac{0.000001}{0.0015}\right)^\frac{5 + 1}{2}$

The crossing prefactor is usually extracted numerically from simulations when fitting an exponential curve to model the relationship between logical and physical error rate.

The error correction threshold is the physical error rate below which the error rate of the logical qubit is less than the error rate of the physical qubit that constitute it. This value is usually extracted numerically from simulations of the logical error rate.

This is the formula that is used to compute the logical cycle time 10us.

This is the formula that is used to compute the number of physical qubits per logical qubits 50.

This corresponds to the maximum number of physical qubits over all rounds of T distillation units in a T factory. A round of distillation contains of multiple copies of distillation units to achieve the required success probability of producing a T state with the expected logical T state error rate.

The runtime of a single T factory is the accumulated runtime of executing each round in a T factory.

The T factory takes as input 345 noisy physical T states with an error rate of 0.01 and produces 1 T states with an error rate of 2.52e-7.

This value includes the physical input T states of all copies of the distillation unit in the first round.

This is the number of distillation rounds. In each round one or multiple copies of some distillation unit is executed.

This is the number of copies for the distillation units per round.

These are the types of distillation units that are executed in each round. The units can be either physical or logical, depending on what type of qubit they are operating. Space-efficient units require fewer qubits for the cost of longer runtime compared to Reed-Muller preparation units.

This is the code distance used for the units in each round. If the code distance is 1, then the distillation unit operates on physical qubits instead of error-corrected logical qubits.

The maximum number of physical qubits over all rounds is the number of physical qubits for the T factory, since qubits are reused by different rounds.

The runtime of the T factory is the sum of the runtimes in all rounds.

This is the logical T state error rate achieved by the T factory which is equal or smaller than the required error rate 6.25e-7.

We determine 84 from this number by assuming to align them in a 2D grid. Auxiliary qubits are added to allow for sufficient space to execute multi-qubit Pauli measurements on all or a subset of the logical qubits.

This includes all T gates and adjoint T gates, but not T gates used to implement rotation gates with arbitrary angle, CCZ gates, or CCiX gates.

This is the number of all rotation gates. If an angle corresponds to a Pauli, Clifford, or T gate, it is not accounted for in this number.

This is the number of all non-Clifford layers that include at least one single-qubit rotation gate with an arbitrary angle.

This is the number of CCZ gates.

This is the number of CCiX gates, which applies $-iX$$-iX$$-iX$ controlled on two control qubits [1212.5069].

This is the number of single qubit measurements in Pauli basis that are used in the input program. Note that all measurements are counted, however, the measurement result is is determined randomly (with a fixed seed) to be 0 or 1 with a probability of 50%.

The total error budget sets the overall allowed error for the algorithm, i.e., the number of times it is allowed to fail. Its value must be between 0 and 1 and the default value is 0.001, which corresponds to 0.1%, and means that the algorithm is allowed to fail once in 1000 executions. This parameter is highly application specific. For example, if one is running Shor’s algorithm for factoring integers, a large value for the error budget may be tolerated as one can check that the output are indeed the prime factors of the input. On the other hand, a much smaller error budget may be needed for an algorithm solving a problem with a solution which cannot be efficiently verified. This budget $ϵ={ϵ}_{\log }+{ϵ}_{dis}+{ϵ}_{syn}$$ϵ={ϵ}_{\log }+{ϵ}_{\mathrm{d}\mathrm{i}\mathrm{s}}+{ϵ}_{\mathrm{s}\mathrm{y}\mathrm{n}}$$\epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn}$ is uniformly distributed and applies to errors ${ϵ}_{\log }$${ϵ}_{\log }$$\epsilon_{\log}$ to implement logical qubits, an error budget ${ϵ}_{dis}$${ϵ}_{\mathrm{d}\mathrm{i}\mathrm{s}}$$\epsilon_{\rm dis}$ to produce T states through distillation, and an error budget ${ϵ}_{syn}$${ϵ}_{\mathrm{s}\mathrm{y}\mathrm{n}}$$\epsilon_{\rm syn}$ to synthesize rotation gates with arbitrary angles. Note that for distillation and rotation synthesis, the respective error budgets ${ϵ}_{dis}$${ϵ}_{\mathrm{d}\mathrm{i}\mathrm{s}}$$\epsilon_{\rm dis}$ and ${ϵ}_{syn}$${ϵ}_{\mathrm{s}\mathrm{y}\mathrm{n}}$$\epsilon_{\rm syn}$ are uniformly distributed among all T states and all rotation gates, respectively. If there are no rotation gates in the input algorithm, the error budget is uniformly distributed to logical errors and T state errors.

This is one third of the total error budget 1.00e-3 if the input algorithm contains rotation with gates with arbitrary angles, or one half of it, otherwise.

This is one third of the total error budget 1.00e-3 if the input algorithm contains rotation with gates with arbitrary angles, or one half of it, otherwise.

This is one third of the total error budget 1.00e-3.

You can load pre-defined qubit parameters by using the names qubit_gate_ns_e3, qubit_gate_ns_e4, qubit_gate_us_e3, qubit_gate_us_e4, qubit_maj_ns_e4, or qubit_maj_ns_e6. The names of these pre-defined qubit parameters indicate the instruction set (gate-based or Majorana), the operation speed (ns or µs regime), as well as the fidelity (e.g., e3 for ${10}^{-3}$${10}^{-3}$$10^{-3}$ gate error rates).

When modeling the physical qubit abstractions, we distinguish between two different physical instruction sets that are used to operate the qubits. The physical instruction set can be either gate-based or Majorana. A gate-based instruction set provides single-qubit measurement, single-qubit gates (incl. T gates), and two-qubit gates. A Majorana instruction set provides a physical T gate, single-qubit measurement and two-qubit joint measurement operations.

This is the operation time in nanoseconds to perform a single-qubit measurement in the Pauli basis.

This is the operation time in nanoseconds to perform a non-destructive two-qubit joint Pauli measurement.

This is the operation time in nanoseconds to execute a T gate.

This is the probability in which a single-qubit measurement in the Pauli basis may fail.

This is the probability in which a non-destructive two-qubit joint Pauli measurement may fail.

This is the probability in which executing a single T gate may fail.