{screen}

©2023 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes, creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works.

Design by Contract Framework for
Quantum Software
^†^†thanks: This research is based on the discussion at Top SE education program.

1^st Masaomi Yamaguchi Quantum Laboratory
Fujitsu Limited
Kanagawa, Japan
y.masaomi@fujitsu.com 2^nd Nobukazu Yoshioka Waseda University / National Institute of Informatics
Tokyo, Japan
nobukazuy@acm.org

Abstract

To realize reliable quantum software, techniques to automatically ensure the quantum software’s correctness have recently been investigated. However, they primarily focus on fixed quantum circuits rather than the procedure of building quantum circuits. Despite being a common approach, the correctness of building circuits using different parameters following the same procedure is not guaranteed. To this end, we propose a design-by-contract framework for quantum software. Our framework provides a python-embedded language to write assertions on the input and output states of all quantum circuits built by certain procedures. Additionally, it provides a method to write assertions about the statistical processing of measurement results to ensure the procedure’s correctness for obtaining the final result. These assertions are automatically checked using a quantum computer simulator. For evaluation, we implemented our framework and wrote assertions for some widely used quantum algorithms. Consequently, we found that our framework has sufficient expressive power to verify the whole procedure of quantum software.

Index Terms:

Programming by contract, Testing and Debugging, quantum computing

I Introduction

Quantum computing is an emerging technology that accelerates many computing-heavy tasks. Recently, software development frameworks for quantum software, such as Qiskit [1], have been developed. However, realizing reliable quantum software is still challenging because of the property of quantum computing: superposition, entanglement and interference.

For those challenges, different approaches have been studied, such as formal verification [2, 3, 4], checking assertions on quantum computers [5, 6], equivalence checking of circuits [7], and automatic testing [8, 9]. However, these techniques mainly focus on fixed quantum circuits, so the correctness of building circuits using different parameters following the same procedure is not guaranteed despite being a common practice.

In this study, we propose a design-by-contract framework [10] for quantum software. Our contributions are as follows:

•

We present a python-embedded language to write assertions about the input states (termed pre-state) and output states (termed post-state) of all quantum circuits built by certain procedures. This enables us to verify the procedure of constructing quantum circuits. Additionally, one can write assertions about the statistical processing of measurement results for obtaining the final result. These assertions are checked on a quantum computer simulator.
•

We provide a module-like feature to construct a bigger circuit from smaller circuits verified by assertions.

II Motivating Example

As a motivating example, we use the Hadamard test. The circuit is shown in Fig. 1. It is a basic algorithm to estimate the expected value of a unitary matrix $U$ for a state $\left\lvert{\psi}\right\rangle$ , i.e., estimate $\left\langle{\psi}\middle|{U}\middle|{\psi}\right\rangle$ .

Refer to caption — Figure 1: The circuit for the Hadamard test

It changes the qubits’ state as follows:

\left\lvert{\psi}\right\rangle\otimes\left\lvert{0}\right\rangle\rightarrow\frac{1}{2}\{(I+U)\left\lvert{\psi}\right\rangle\otimes\left\lvert{0}\right\rangle+(I-U)\left\lvert{\psi}\right\rangle\otimes\left\lvert{1}\right\rangle\}

(1)

Thus, the real part of $\left\langle{\psi}\middle|{U}\middle|{\psi}\right\rangle$ is obtained by:

\mathrm{Re}\left\langle{\psi}\middle|{U}\middle|{\psi}\right\rangle=p_{0}-p_{1}\approx\frac{N_{0}-N_{1}}{N_{0}+N_{1}}

(2)

where $p_{i}$ and $N_{i}$ are the probability and count of obtaining $\left\lvert{i}\right\rangle$ when measuring the first qubit, respectively.

The circuit adopts $U$ as a parameter. Thus, we need to verify the procedure for building the circuit from the gate $U$ . This includes complex steps such as the decomposition of gates to run on quantum computers. Moreover, we need statistical postprocessing according to (2) to obtain the final result. Unfortunately, existing works cannot verify these procedures.

III Proposed Approach

Our approach is based on the design-by-contract framework [10]. We provide a language leveraging Qiskit to write assertions about pre/post-states of all circuits built by certain procedures and the statistical processing of measurement results.

III-A Verifying the Procedure of Building Quantum Circuits

\start@align

Θ\st@rredtrue $\mathbf{def}$ $\mathit{make\_circ\_hadamard\_test}$ ( $\mathit{Ugate}$ , $\mathit{U}$ )→ $\mathsf{AssertQuantumCircuit}$ : $\mathit{circ}$ = $\mathsf{AssertQuantumCircuit}$ ( $\mathit{size}$ = $\mathit{Ugate.num\_qubits}$ + 1) $\mathit{circ}$ . $\mathit{append}$ ( $\mathsf{HGate}$ (), [0]) $\mathit{ctrl\_U}$ = $\mathit{decompose}$ ( $\mathit{Ugate}$ . $\mathit{control}$ (), $\mathit{basis\_gates}$ =[ $\mathtt{"h"}$ , $\mathtt{"rx"}$ , $\mathtt{"rz"}$ , $\mathtt{"cx"}$ ]) $\mathit{circ}$ . $\mathit{append}$ ( $\mathit{ctrl\_U}$ , $\mathit{range}$ ( $\mathit{Ugate}$ . $\mathit{num\_qubits}$ + 1)) $\mathit{circ}$ . $\mathit{append}$ ( $\mathsf{HGate}$ (), [0]) $\mathbf{def}$ $\mathit{condition}$ ( $\mathit{pre\_state}$ , $\mathit{post\_state}$ ) → $\mathsf{bool}$ : $\mathit{psi}$ = $\mathsf{StateFn}$ ( $\mathit{partial\_state}$ ( $\mathit{pre\_state}$ , $\mathit{range}$ (1, $\mathit{Ugate}$ . $\mathit{num\_qubits}$ + 1))) $\mathit{state0}$ = (( $\mathit{psi}$ + ( $\mathit{U}$ @ $\mathit{psi}$ )) / 2)^ $\mathsf{Zero}$ $\mathit{state1}$ = (( $\mathit{psi}$ - ( $\mathit{U}$ @ $\mathit{psi}$ )) / 2)^ $\mathsf{One}$ $\mathbf{return}$ $\mathit{eq\_state}$ ( $\mathit{post\_state}$ , $\mathit{state0}$ + $\mathit{state1}$ ) $\mathit{circ}$ . $\mathit{add\_condition}$ ( $\mathtt{"condition1"}$ , $\mathit{condition}$ ) $\mathbf{return}$ $\mathit{circ}$

Figure 2: Code with assertions for Hadamard test written in our framework

Fig. 2 is an example code for the Hadamard test written in our framework. It takes the gate $\mathit{Ugate}$ and its unitary representation $U$ and returns a circuit with an assertion for (1). This code represents the procedure of building the circuit from the gate $Ugate$ . It consists of three parts: define a circuit including a decomposing step, define an assertion, and return the circuit with the assertion tagged $\mathtt{"condition1"}$ .

III-B Checking the Correctness of Statistical Postprocessing

In quantum computing, we must measure qubits and statistically process the measurement result to obtain the final result. Our framework can verify this process, as shown in Fig. 3.

\start@align

Θ\st@rredtrue $\mathit{U}$ = $\mathsf{PrimitiveOp}$ ( $\mathsf{Operator}$ ([[1, 0], [0, $\mathit{cmath}$ . $\mathit{exp}$ (1j * $\mathit{math}$ . $\mathit{pi}$ / 4)]]) ) $\mathit{Ugate}$ = $\mathsf{TGate}$ () $\mathit{circ\_hadamard\_test}$ = $\mathit{make\_circ\_hadamard\_test}$ ( $\mathit{Ugate}$ , $\mathit{U}$ ) $\mathit{psi}$ = $\mathsf{Plus}$ $\mathit{circ}$ = $\mathsf{AssertQuantumCircuit}$ ( $\mathit{size}$ = 2) $\mathit{circ}$ . $\mathit{append}$ ( $\mathsf{HGate}$ (), [1]) $\mathit{circ}$ . $\mathit{append}$ ( $\mathit{circ\_hadamard\_test}$ , [0, 1]) $\mathbf{def}$ $\mathit{estimate\_exp}$ ( $\mathit{result}$ ) → $\mathsf{float}$ : $\mathit{c}$ = $\mathit{result}$ . $\mathit{get\_counts}$ () $\mathbf{return}$ ( $\mathit{c}$ [ $\mathtt{"0"}$ ] - $\mathit{c}$ [ $\mathtt{"1"}$ ]) / ( $\mathit{c}$ [ $\mathtt{"0"}$ ] + $\mathit{c}$ [ $\mathtt{"1"}$ ]) $\mathit{circ\_measure}$ : $\mathsf{AssertQuantumCircuitMeasure}$ = $\mathit{circ}$ . $\mathit{measure}$ ( $\mathit{postprocess}$ = $\mathit{estimate\_exp}$ , $\mathit{qubit}$ =[0]) $\mathbf{def}$ $\mathit{measure\_condition}$ ( $\mathit{pre\_measure\_state}$ , $\mathit{result}$ , $\mathit{est\_exp}$ )→ $\mathsf{bool}$ : $\mathit{actual\_exp}$ = ((~ $\mathit{psi}$ ) @ $\mathit{U}$ @ $\mathit{psi}$ ). $\mathit{eval}$ (). $\mathit{real}$ $\mathbf{return}$ $\mathit{math}$ . $\mathit{isclose}$ ( $\mathit{actual\_exp}$ , $\mathit{est\_exp}$ , $\mathit{abs\_tol}$ =0.01) $\mathit{circ\_measure}$ . $\mathit{add\_condition}$ ( $\mathtt{"condition2"}$ , $\mathit{measure\_condition}$ ) $\mathit{print}$ ( $\mathit{circ\_measure}$ . $\mathit{run}$ ( $\mathit{shots}$ =100_000))>> 0.85514 &

Figure 3: Code to check the post process of the Hadamard test

This code estimates $\mathrm{Re}\left\langle{+}\middle|{T}\middle|{+}\right\rangle$ . Here, we defined an assertion to check whether statistical processing follows (2). The assertion’s arguments are the qubits’ state before measurement, result of measurement, and result of post-processing. Note that we separated the class of the measurement and the other steps because the former contains classical functions. We built the circuit from smaller circuits by using our module-like system. The assertions in nested circuits are verified in runtime.

By running the code, it prints the estimated value without any assertion error, which means that the whole procedure of the Hadamard test is correct with respect to $T$ and $\left\lvert{+}\right\rangle$ .

If the circuit does not behave as expected, our framework raises an exception to notify the user, as shown in Fig. 4.

Cell In[8], line 22
---> 22 print(circ_measure.run(shots=100_000))
...
StateConditionError: Condition Error occurred in ’condition1’

Figure 4: Exception when the assertion of the Hadamard test fails

IV Evaluation

We evaluated our framework by writing three quantum algorithms that are widely used: the Hadamard test, quantum Fourier transform (QFT), and quantum phase estimation (QPE). The details of the evaluation are not provided for the sake of brevity. As explained in section III, our framework can express the whole procedure of quantum software and rapidly detects mistakes through the failure of the assertions.

The limitation of our framework is the lack of intermediate measurements. We only allow measurements in the last of the circuit, but some cases, such as error correction, need it.

V Conclusion and Future Direction

We proposed a design-by-contract framework for quantum software, whose novelty is that it can verify the procedure of building quantum circuits and statistical post-processing. We demonstrated the effectiveness of our framework and clarified its limitations. In future studies, we will expand our method to handle intermediate measurements. Another direction is to evaluate the effectiveness of our method using more examples.

References

[1] IBM. Qiskit. [Online]. Available: https://qiskit.org/
[2] K. Hietala, R. Rand, S.-H. Hung, L. Li, and M. Hicks, “Proving Quantum Programs Correct,” in 12th International Conference on Interactive Theorem Proving (ITP 2021), ser. Leibniz International Proceedings in Informatics (LIPIcs), L. Cohen and C. Kaliszyk, Eds., vol. 193. Dagstuhl, Germany: Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021, pp. 21:1–21:19.
[3] J. Paykin, R. Rand, and S. Zdancewic, “QWIRE: A core language for quantum circuits,” in Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, ser. POPL ’17. NY, USA: Association for Computing Machinery, 2017, p. 846–858.
[4] C. Chareton, S. Bardin, F. Bobot, V. Perrelle, and B. Valiron, “An automated deductive verification framework for circuit-building quantum programs,” in Programming Languages and Systems, ESOP 2021, ser. Lecture Notes in Computer Science, N. Yoshida, Ed., vol. 12648. Cham: Springer International Publishing, March 2021, pp. 148–177.
[5] Y. Huang and M. Martonosi, “Statistical assertions for validating patterns and finding bugs in quantum programs,” in Proceedings of the 46th International Symposium on Computer Architecture, ser. ISCA ’19. New York, USA: Association for Computing Machinery, 2019, p. 541–553.
[6] G. Li, L. Zhou, N. Yu, Y. Ding, M. Ying, and Y. Xie, “Projection-based runtime assertions for testing and debugging quantum programs,” Proc. ACM Program. Lang., vol. 4, no. OOPSLA, nov 2020.
[7] L. Burgholzer and R. Wille, “Advanced equivalence checking for quantum circuits,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 40, no. 9, pp. 1810–1824, 2021.
[8] S. Honarvar, M. R. Mousavi, and R. Nagarajan, “Property-based testing of quantum programs in Q#,” in Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops, ser. ICSEW’20. New York, NY, USA: Association for Computing Machinery, 2020, p. 430–435.
[9] X. Wang, P. Arcaini, T. Yue, and S. Ali, “Generating failing test suites for quantum programs with search,” in Search-Based Software Engineering, U.-M. O’Reilly and X. Devroey, Eds. Cham: Springer International Publishing, 2021, pp. 9–25.
[10] B. Meyer, “Design by contract,” Interactive Software Engineering Inc, Tech. Rep., 1986.

Design by Contract Framework for Quantum Software ††thanks: This research is based on the discussion at Top SE education program.