Polyestimate: Fast Logical Error Estimation

• Polyestimate is an open-source software tool that quickly estimates logical error rates in surface code quantum error correction systems using a precomputed simulation database.
• It uses interpolation for small code distances and exponential extrapolation for larger distances, reducing computation times from hours to fractions of a second.
• The tool supports both detailed stochastic and depolarizing error models, enabling hardware designers to effectively assess fault-tolerance feasibility in quantum systems.

Polyestimate is an open-source software tool designed to provide rapid, user-friendly estimates of logical error rates in the surface code, a leading quantum error-correcting code architecture. Unlike full-scale “Autotune” simulations that incorporate exhaustive details of hardware noise models at considerable computational expense, Polyestimate functions as a fast, lightweight alternative aimed at quantum hardware designers and theorists requiring immediate feedback on whether specific physical gate error rates and code distances will meet target logical error thresholds. By leveraging a precomputed database of Autotune results for key code distances and a principled interpolation and extrapolation scheme, Polyestimate circumvents the need for in-depth expertise in surface code protocols, providing reliable error estimates in a fraction of a second (Fowler, 2013).

1. Purpose and Scope

Polyestimate targets the practical challenge of mapping physical gate-level error rates—typically characterized by quantum hardware designers—onto logical error rates for surface codes of arbitrary distance, crucial in determining the feasibility of fault-tolerant quantum computation. The surface code’s practicality stems from its reliance only on a two-dimensional nearest-neighbor array of qubits, requiring gate error rates below roughly 1%. However, detailed Autotune simulations for evaluating logical error rates can demand hours or days per data point, making rapid design iteration impractical. Polyestimate addresses this by enabling essentially instantaneous logical error rate estimation without requiring surface code expertise or in-depth simulation, focusing on logical $X$ and $Z$ failure probabilities for any code distance $d$ in under a second. It is principally intended for rapid, iterative exploration by quantum hardware development teams and theorists comparing code and hardware parameters (Fowler, 2013).

2. Supported Input Error Models

Polyestimate is constructed around the standard surface-code syndrome-measurement circuits, encompassing initialization (Init), Pauli-$Z$ measurement ($M_Z$), Hadamard ($H$), controlled-NOT (CNOT), and identity gates (with durations matched to the nontrivial gates). Input error models can be provided at varying levels of detail:

• Detailed stochastic error models: The user can specify an explicit error probability for each outcome of each of eight gate types. For example, each CNOT can have a complete 15-parameter error specification, listing $p_{IX}$, $p_{IY}$, …, $p_{ZZ}$.
• Depolarizing error rates: Alternatively, a single depolarizing error probability per gate can be provided, with designated rates for each gate and matching identity gate durations: $p_\text{Init}$, $Z$0, $Z$1, $Z$2, $Z$3, $Z$4, $Z$5, and $Z$6.

Irrespective of input specificity, Polyestimate reduces the full gate-level descriptions to three effective parameters per error type $Z$7:

• $Z$8: Syndrome-qubit error per round,
• $Z$9: Data-qubit identity error per round,
• $d$0: Two-qubit depolarizing error.

Single-qubit gate error contributions are mapped onto independent $d$1 and $d$2 error channels by $d$3 and $d$4.

3. Logical Error Rate Estimation Framework

Logical error rates in the surface code decrease exponentially with increasing code distance $d$5 when physical gate error rates remain below the threshold ($d$6–$d$7). Polyestimate’s methodology is as follows:

• For small $d$8 ($d$9), values of $Z$0 for $Z$1 are obtained by direct interpolation from the database over a grid in $Z$2, where $Z$3 and $Z$4, parameterizing a wide array of physical scenarios.
• For $Z$5, the logical error rate is extrapolated exponentially:
  • For odd $Z$6:

  $Z$7

  with $Z$8 and $Z$9. - For even $M_Z$0:

  $M_Z$1

  with $M_Z$2 and $M_Z$3.

This approach obviates the need to recompute weight coefficients $M_Z$4 from the conventional expression $M_Z$5 for each new hardware scenario, dramatically simplifying the estimation process (Fowler, 2013).

4. Implementation and Computational Characteristics

Polyestimate’s implementation consists of a lightweight C++ core with an optional Python interface. Upon initialization, it loads a compact database containing precomputed Autotune simulation results spanning relevant error parameter regimes and code distances ($M_Z$6). The core estimation algorithms execute:

• Reduction of arbitrary gate errors to the effective $M_Z$7 and $M_Z$8 descriptors.
• Linear interpolation in three-dimensional $M_Z$9 space for database-backed code distances.
• Exponential extrapolation as described above for any $H$0.

Performance benchmarks indicate that a typical estimation query—encompassing database load, parameter reduction, and logical error lookup or extrapolation—executes in approximately $H$1 seconds on a conventional laptop. For comparison, a single Autotune simulation at $H$2 can require hundreds of CPU-hours, demonstrating the significant computational advantage of Polyestimate for quick design exploration. The tool is engineered for both command-line and API-driven workflows, with dedicated constructs for specifying depolarizing rates and obtaining logical $H$3 and $H$4 error rates for arbitrary code distances.

Feature	Polyestimate	Full Autotune Simulation
Underlying Method	Interpolation + Exponential	Full circuit-level simulation
Supported Distances (fast)	$H$5–$H$6 (direct); $H$7 (extrapolated)	Arbitrary (with time cost)
Time per Query	$H$8	Hours to days

5. Example Workflows

Users may interact with Polyestimate through straightforward interfaces:

• Command-line usage:

$p_{IX}$8 This workflow produces estimates for logical error rates at the specified code distance, given gate-wise depolarizing rates.

• C++-style API usage:

$p_{IX}$9

These interfaces are designed such that users need not be experts in surface code elaborations, facilitating rapid evaluation in hardware optimization cycles.

6. Limitations and Underlying Assumptions

Polyestimate presumes two-dimensional nearest-neighbor qubit connectivity and employs minimum-weight perfect matching for error correction, treating $H$9 and $p_{IX}$0 error chains independently and neglecting $p_{IX}$1-correlated errors. This simplification is generally appropriate for standard hardware noise profiles but may introduce inaccuracies when error correlations are significant or when input CNOT error models are highly asymmetric (e.g., $p_{IX}$2). In such cases, Polyestimate’s forced balancing of error rates can overestimate logical errors, and full Autotune simulations or analytic asymptotic methods may be required.

Additionally, the precomputed Polyestimate database covers two-qubit depolarizing error rates $p_{IX}$3 in the range $p_{IX}$4 to $p_{IX}$5; estimate fidelity outside this region would necessitate supplementing the database with further simulations. In practice, Polyestimate achieves logical error rate estimates within $p_{IX}$6 of full Autotune results across diverse error profiles, including instances with $p_{IX}$7 measurement error rates. This trade-off between speed and accuracy positions Polyestimate primarily as a tool for early-stage quantum hardware assessment and iterative architectural design (Fowler, 2013).