Benchmark
The following benchmark is from IBM's Qiskit benchpress. We forked the repository and added test items for pyqpanda3 to complete the relevant tests. Our test repository can be found at https://github.com/OriginQ/benchpress. We have introduced more detailed experimental content in the literature QPanda3: A High-Performance Software-Hardware Collaborative Framework for Large-Scale Quantum-Classical Computing Integration. This webpage cited important experimental results from the article.
"The Benchpress open-source benchmarking suite comprises over 1,000 different tests. These are standardized benchmarking tests designed by other members of the quantum community. For example, Benchpress compares SDKs' abilities to generate QASMBench circuits, Feynman circuits, and Hamiltonian circuits. It also includes tests designed to test a language's ability to transpiler circuits for specific hardware, including the heavy hex architecture of IBM quantum processors and other generic qubit layouts."
— IBM Qiskit
Quantum Circuit Construct
The performance of several SDKs in circuit construction is illustrated in Figure Quantum Circuit Construct. It can be observed that QPanda3, qiskit, and cirq passed all seven test cases. For the four test cases, namely test_multi_control_circuit, test_bigint_qasm2_import, test_param_circSU2_100_build, and test_clifford_build, QPanda3 demonstrated the shortest execution time. In the case of the three test cases test_QV100_qasm2_import, test_param_circSU2_100_build, and test_QV100_build QPanda3 took longer than qiskit but significantly less time compared to cirq, braket, and bqskit. For the test case test_DTC100_set_build, QPanda3's execution time was shorter than that of qiskit but longer than cirq's, ranking as the second shortest. This figure highlights the advantages of QPanda3 in circuit construction.
Manipulate
The Benchmarking the performance of quantum computing software literature highlights that Manipulate is a crucial metric for evaluating SDKs. As shown in Figure Manipulate, only QPanda3 and qiskit passed all four test cases. In the test_QV100_basis_change test case, QPanda3 demonstrated the shortest execution time. For the three test cases: test_random_clifford_decompose, test_multi_control_decompose, and test_DTC100_twirling, QPanda3's execution time slightly exceeded that of qiskit, with a minimal difference. This figure suggests that QPanda3 holds an advantage in terms of the Manipulate metric.
Quantum Circuit Transpilation
In our experiments, only QPanda3 and qiskit passed the majority of the test cases related to compilation. We have plotted the corresponding experimental results into multiple scatter plots, as shown in Figure Quantum Circuit Transpilation, which illustrate the differences between QPanda3 and qiskit in terms of 2Q Gate Count, 2Q Gate Depth, and compilation time for various topological structures. In each plot, the blue dashed line represents the point where the values for QPanda3 and qiskit are equal for the corresponding metric. Points above the blue dashed line indicate that the corresponding value for QPanda3 is less than that for qiskit. As observed from Figure Quantum Circuit Transpilation, for both 2Q Gate Count and 2Q Gate Depth, the majority of the scatter points are densely distributed along or very close to the blue dashed line, suggesting that the performance of QPanda3 and qiskit is essentially the same. However, regarding compilation time, all scatter points in the four subplots of Figure Quantum Circuit Transpilation are located above the blue dashed line, indicating that QPanda3 exhibits higher compilation efficiency than qiskit. This characteristic is not limited by topological structure and is effective for a large number of different circuits. Additionally, it can be observed that only a very few test cases result in compilation times exceeding 10 seconds when using QPanda3. These observations collectively demonstrate the high compilation efficiency of QPanda3.
pyqpanda3 0.5.0 vs Qiskit 2.5.2 — Full benchpress Comparison (September 2026)
Measurement configuration
With the release of pyqpanda3 0.5.0, the complete benchpress suite was re-run against Qiskit 2.5.2. Both SDKs were executed on the same server, under the same interpreter and the same benchpress revision, so that each case is paired one-to-one and no cross-machine calibration is required. The measurement configuration was as follows:
| Item | Value |
|---|---|
| Host | Intel(R) Xeon(R) Gold 6226R CPU @ 2.90 GHz, 64 cores |
| Interpreter | CPython 3.14.7 |
| Numerical stack | NumPy 2.5.3, SciPy 1.18.1 |
| Candidate | pyqpanda3 0.5.0 — benchpress run 0069_qpanda3 (2026-09-21) |
| Reference | Qiskit 2.5.2 with qiskit-ibm-runtime 0.49.0 — benchpress run 0055_qiskit (2026-09-15) |
| Paired cases | 1,044 |
| Suite status | 1,044 passed, 0 failed on each side; 22 parameterized placeholders skipped on each side |
| Circuit size range | 1 to 930 qubits |
Both legs passed every one of the 1,044 cases, so no case is missing from the comparison and no result is imputed. Timing is the pytest-benchmark stats.mean of the paired case, taken from the harness's own result artifact.
Two ratio statistics are reported throughout this section, and they answer different questions:
- the geometric mean of per-case ratios describes the typical case, weighting every circuit equally;
- the ratio of summed mean times describes the aggregate, and is therefore dominated by the slowest circuits.
Quoting only one of them can mislead in either direction, so the per-suite table below carries both.
Aggregate result
Over the full suite, pyqpanda3 0.5.0 recorded the shorter time in 1,040 of the 1,044 paired cases, a geometric-mean time ratio of 0.233x and a ratio of summed mean times of 0.259x. Summed over the whole run, the candidate leg completed in 2,708.3 s against 5,191.2 s for the reference — a wall-clock ratio of 0.522.
Splitting the suite by compilation target, the 892 abstract-compilation cases (no device coupling map) ran at a geometric mean of 0.212x, and the 140 device-targeted cases at 0.400x.
Per-suite results
| Suite | Cases | Geometric-mean ratio | Ratio of summed means | Cases faster | 2Q gate ratio | 2Q depth ratio |
|---|---|---|---|---|---|---|
| Abstract Hamiltonians | 400 | 0.303x | 0.234x | 399 | 0.834x | 0.783x |
| QASMBench small | 168 | 0.140x | 0.340x | 168 | 1.009x | 1.003x |
| QASMBench medium | 92 | 0.207x | 0.289x | 92 | 0.981x | 0.976x |
| QASMBench large | 232 | 0.157x | 0.259x | 232 | 0.985x | 0.942x |
| Device Hamiltonians | 81 | 0.380x | 0.282x | 81 | 0.776x | 0.748x |
| Feynman | 50 | 0.452x | 0.320x | 50 | 1.013x | 1.006x |
| Summit 100Q | 9 | 0.329x | 0.200x | 9 | 1.049x | 1.100x |
| Circuit manipulation | 4 | 0.790x | 0.973x | 3 | — | — |
| Circuit construction | 8 | 0.400x | 0.468x | 6 | 1.000x | 1.000x |
| Full suite | 1,044 | 0.233x | 0.259x | 1,040 | 0.957x | 0.915x |
Two observations follow. First, the advantage is not confined to one circuit family: every compilation suite is faster in the geometric mean, ranging from 0.140x for the small QASMBench circuits to 0.452x for the Feynman suite. Second, the geometric mean is consistently more favourable than the ratio of summed means, indicating that the advantage is broad-based across cases rather than carried by a few extreme ones.
The per-category mean time per case is summarized in Figure pyqpanda3 0.5.0 vs Qiskit 2.5.2 — Mean Time per Case, which is drawn on the ratio-of-summed-means basis.
Dependence on coupling-map topology
The 892 abstract-compilation cases are distributed over four coupling maps. On the ratio-of-summed-means basis used by the figure, pyqpanda3 0.5.0 completed the paired cases in 0.18x (all-to-all), 0.24x (heavy-hex), 0.28x (square) and 0.29x (linear) of the time taken by Qiskit 2.5.2. On the geometric-mean basis the same four topological families read 0.12x, 0.24x, 0.25x and 0.27x respectively.
The all-to-all map shows the largest margin on either basis, and in that family every one of the 223 cases is faster. The three sparse maps cluster within a narrow band of one another. Notably, the advantage does not diminish as the coupling map becomes more constrained: linear and square, the most restrictive maps in the set, remain well below parity.
Figure pyqpanda3 0.5.0 vs Qiskit 2.5.2 — Per-Case Compilation Time plots the per-case compilation time of the two SDKs against each other on a logarithmic scale for the 892 abstract-compilation cases, one panel per topology; points below the dashed line are cases in which pyqpanda3 is faster. It can be observed that the scatter points of all four panels fall almost entirely below the dashed line (891 of 892 cases), and that the margin is not confined to a particular topology or circuit family.
Distribution of per-case ratios
The aggregate figures above describe central tendency; the distribution describes consistency. Over the 1,044 paired cases the per-case time ratio falls into the following bands:
| Ratio band (pyqpanda3 / Qiskit) | Cases |
|---|---|
| below 0.10x | 231 |
| 0.10x – 0.25x | 214 |
| 0.25x – 0.50x | 317 |
| 0.50x – 0.75x | 247 |
| 0.75x – 1.00x | 31 |
| 1.00x and above | 4 |
The percentiles are p10 = 0.056, p25 = 0.112, median = 0.310, p75 = 0.525 and p90 = 0.629. A substantial minority of cases — 445 of 1,044, or roughly 43% — complete in under one quarter of the reference time, and 1,009 of 1,044 (96.6%) fall below 0.75x. Only four cases reach or exceed parity.
Among the 1,032 compilation cases, exactly one exceeds parity, at 1.07x (ham_fh-graph-1D-grid-nonpbc-qubitnodes_Lx-90). Counting cases whose compilation time exceeded 10 seconds, pyqpanda3 recorded 6 against 28 for the reference; the slowest candidate case took 22.0 s against 76.3 s for the corresponding reference case.
Output quality
Speed is only meaningful if the circuits produced remain comparable, so the transpiled output was compared directly. Summed over the full suite, the two-qubit gate count of the pyqpanda3 0.5.0 outputs was 0.957x that of Qiskit 2.5.2, and over the 892 abstract-compilation cases the total two-qubit depth was 0.918x. The speed advantage therefore did not come at the cost of circuit quality overall.
On the device-targeted cases the candidate was ahead on both metrics (0.921x gate count, 0.883x depth); on the abstract cases it was ahead on depth (0.918x) and level on gate count (0.960x). Across the individual suites the picture is more granular: for the Hamiltonian families the candidate produces materially fewer two-qubit gates (0.834x abstract, 0.776x device) and correspondingly shallower circuits, while for the Summit 100Q and Feynman families it produces marginally more (1.049x and 1.013x) — a difference of a few percent in exchange for the time reduction reported above.
Of the 1,035 cases in which both sides report a two-qubit count, pyqpanda3 0.5.0 emits fewer two-qubit gates in 277 cases, an identical count in 410 cases, and more in 348 cases. The distribution is therefore not one-sided: the aggregate 0.957x is the net effect of a substantial number of both improvements and regressions, dominated by the Hamiltonian families where the reduction is largest.
Cases in which the reference recorded the shorter time
Four of the 1,044 cases went to Qiskit 2.5.2. All four are confined to millisecond-scale operations, and none exceeds 1.6x:
| Case | Group | Ratio | pyqpanda3 | Qiskit 2.5.2 |
|---|---|---|---|---|
test_QV100_build | Circuit construction | 1.58x | 6.43 ms | 4.08 ms |
test_multi_control_decompose | Circuit manipulation | 1.29x | 17.35 ms | 13.42 ms |
test_param_circSU2_100_build | Circuit construction | 1.28x | 2.06 ms | 1.61 ms |
ham_fh-graph-1D-grid-nonpbc-qubitnodes_Lx-90 | Abstract Hamiltonians | 1.07x | 122.5 ms | 114.6 ms |
Three of the four belong to the construction and manipulation groups, which cover only 12 of the 1,044 cases between them; the compilation groups, which carry 1,032 cases, contribute a single entry just above parity.