{ "cells": [ { "cell_type": "markdown", "id": "61783c18", "metadata": {}, "source": [ "# Welcome to Quito!" ] }, { "cell_type": "markdown", "id": "52af0b48", "metadata": {}, "source": [ "## Description" ] }, { "cell_type": "markdown", "id": "300ff571", "metadata": {}, "source": [ "Automation in quantum software testing is essential to support systematic and cost-effective testing. Towards this direction, here we introduce a quantum software testing tool called Quito that can automatically generate test suites covering three coverage criteria defined on inputs and outputs of a quantum program coded in Qiskit, i.e., input coverage, output coverage, and input-output coverage. Quito also implements two types of test oracles based on program specifications, i.e., checking whether a quantum program produced a wrong output or checking a probabilistic test oracle with statistical test." ] }, { "cell_type": "markdown", "id": "93fc857f", "metadata": {}, "source": [ "### Coverage Criteria\n", "Users select one of three below coverage criteria to run Quito.\n", "- Input Coverage\n", "- Output Coverage\n", "- Input-Output Coverage" ] }, { "cell_type": "markdown", "id": "aec548ae", "metadata": {}, "source": [ "### Test oracles\n", "Quito evaluates the results according to the two test oracles that have been proposed in this paper:\n", "- WOO: Whether an observed output is correct according to program specification. If not, the program is failed;\n", "- OPO: If all the observed outputs corresponding to an input are valid, then it compares their observed probabilities with the ones specified in the Program Specification file. If the differences are statistically significant (i.e., a p-value lower than the chosen significance level), the program is failed." ] }, { "cell_type": "markdown", "id": "9162f5ab", "metadata": {}, "source": [ "## How to use Quito\n", "Please prepare the **quantum program file** and the **configuration file**, then input them into the Quito tool. Here we introduce the example algorithm *Swap Test*, and the introduce the structure of the two input files." ] }, { "cell_type": "markdown", "id": "3716b210", "metadata": {}, "source": [ "### Example Algorithm Swap Test." ] }, { "cell_type": "markdown", "id": "e16f900b-a5f0-48a8-b2fb-19df52e3bc91", "metadata": {}, "source": [ "Let's take **Swap Test** algorithm as an example! This algorithm is used to check how much two quantum states differ.\n", "The following shows the corresponding Qiskit code of this algorithm, including generating the visualized circuit diagram and execution result." ] }, { "cell_type": "code", "execution_count": 1, "id": "10d1a181", "metadata": {}, "outputs": [ { "data": { "text/plain": "
", "image/png": "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" }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n", "from qiskit_aer import AerSimulator\n", "\n", "q = QuantumRegister(3)\n", "c = ClassicalRegister(1)\n", "qc = QuantumCircuit(q, c)\n", "qc.h(2)\n", "qc.cswap(2, 0, 1)\n", "qc.h(2)\n", "qc.x(2)\n", "\n", "qc.measure(2, 0)\n", "\n", "qc.draw(output=\"mpl\")" ] }, { "cell_type": "code", "execution_count": 2, "id": "f44a9e7f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'1': 1024}" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "simulator = AerSimulator()\n", "result = simulator.run(qc, shots=1024).result()\n", "counts = result.get_counts(qc)" ] }, { "cell_type": "markdown", "id": "2367227c", "metadata": {}, "source": [ "### Quantum Program File\n", "Here we show the structure of this input file:\n", "- The quantum program should be written with Qiskit in Python.\n", "- The code has to be structured in a function named as 'run' with one parameter that refers to the quantum circuit.\n", "- Users only need to add gates to the circuit and measure output qubits to get the output. They don't need to set any register, initialize circuits, choose the simulation, or execute the circuits in 'run' function." ] }, { "cell_type": "raw", "id": "abe20a3e", "metadata": {}, "source": [ "def run(qc):\n", " qc.gate(...)\n", "\n", " qc.measure(...)" ] }, { "cell_type": "markdown", "id": "ba21263c", "metadata": {}, "source": [ "### Example Quantum Program File\n", "Here is the corresponding quantum program file of *SWAP.py* for Quito." ] }, { "cell_type": "code", "execution_count": 3, "id": "acb54f83", "metadata": {}, "outputs": [], "source": [ "def run(qc):\n", " qc.h(2)\n", " qc.cswap(2, 0, 1)\n", " qc.h(2)\n", " qc.x(2)\n", "\n", " qc.measure(2, 0)" ] }, { "cell_type": "markdown", "id": "1e4333fe", "metadata": {}, "source": [ "### Configuration File\n", "Here we show the structure of this the program configuration file. It is an INI file, which contains four sections defined by headers enclosed in brackets [ ] and contains several properties represented by key-value pairs, called properties. This configuration file describes the program information, Quito execution information and program specification of the algorithm under test. Some properties are required and some properties are optional." ] }, { "cell_type": "raw", "id": "a40939d2", "metadata": {}, "source": [ "[program]\n", "root=\n", ";(Required)\n", ";Description: The absolute root of your quantum program file.\n", "num_qubit=\n", ";(Required)\n", ";Description: The total number of qubits of your quantum program.\n", "inputID=\n", ";(Required)\n", ";Description: The ID of input qubits.\n", ";Format: A non-repeating sequence separated by commas.\n", "outputID=\n", ";(Required)\n", ";Description: The ID of output qubits which are the qubits to be measured.\n", ";Format: A non-repeating sequence separated by commas.\n", "\n", "[program_specification_category]\n", "ps_category=\n", ";(Required)\n", ";Description: The category of your program specification.\n", ";Choice: full/partial/no\n", "\n", "[quito_configuration]\n", "coverage_criterion=\n", ";Description: The coverage criterion you choose.\n", ";Choice: IC/OC/IOC\n", "K=\n", ";(Optional)\n", ";Description: The total number of test suites, K=200 by default.\n", "M=\n", ";(Optional)\n", ";Description: The number of test suite groups, M=20 by default.\n", "BUDGET=\n", ";(Optional)\n", ";Description: The budget of the number of test cases in one test suite, BUDGET=10*number of inputs by default.\n", "confidence_level=\n", ";(Optional)\n", ";Description: The confidence level for statistical test, confidence_level=0.01 by default.\n", "statistical_test=one-sample Wilcoxon signed rank test \n", ";(Optional)\n", ";Description: The statistical test for assessment, statistical_test=one-sample Wilcoxon signed rank test by default.\n", "\n", "[program_specification]\n", ";(Required for full and partial program specification)\n", ";Description: The program specification.\n", ";Format:input string,output string=probability" ] }, { "cell_type": "markdown", "id": "dd85a36f", "metadata": {}, "source": [ "Here is the corresponding configuration file for **Swap Test** algorithm." ] }, { "cell_type": "raw", "id": "1d702e12", "metadata": {}, "source": [ "[program]\n", "root=/home/user/SWAP.py\n", "num_qubit=3\n", "inputID=0,1\n", "outputID=2\n", "\n", "[program_specification_category]\n", "ps_category=full\n", "\n", "[quito_configuration]\n", "coverage_criterion=IC\n", "K=200\n", "M=10\n", "BUDGET=20\n", "confidence_level=0.01\n", "statistical_test=one-sample Wilcoxon signed rank test \n", "\n", "[program_specification]\n", "01,1=0.5\n", "01,0=0.5\n", "00,1=1\n", "11,1=1\n", "10,1=0.5\n", "10,0=0.5" ] }, { "cell_type": "markdown", "id": "4152f6e8", "metadata": {}, "source": [ "### Test with Quito Directly" ] }, { "cell_type": "markdown", "id": "1f0a9077", "metadata": {}, "source": [ "Import quito and use quito method directly. The parameter is the absolute path of the configuration file." ] }, { "cell_type": "code", "execution_count": 10, "id": "27b5b84c", "metadata": {}, "outputs": [], "source": [ "from quito.quito_coverage import quito\n", "\n", "quito(\"/home/user/configuration.ini\")" ] }, { "cell_type": "markdown", "id": "9072a46b", "metadata": {}, "source": [ "We can check the process bar to see whether quito is running. After the whole process is finished, you can find the result file in a folder named **\"result\"**, which is located in the same directory of the **quantum program file**." ] }, { "cell_type": "markdown", "id": "77690117", "metadata": {}, "source": [ "### Submit with by Slurm Job" ] }, { "cell_type": "markdown", "id": "2b4f8e5e", "metadata": {}, "source": [ "Please first create an **executing file** and a **slurm file** to run the experiment." ] }, { "cell_type": "markdown", "id": "66432653", "metadata": {}, "source": [ "Here is the executing file *quito_test.py*." ] }, { "cell_type": "code", "execution_count": null, "id": "3b150a23", "metadata": {}, "outputs": [], "source": [ "import time\n", "\n", "from quito.quito_coverage import quito\n", "\n", "start = time.time()\n", "i = 0\n", "quito(\"/home/user/configuration.ini\")\n", "end = time.time()\n", "\n", "print(end - start)" ] }, { "cell_type": "markdown", "id": "51331353", "metadata": {}, "source": [ "Here is the slurm file. It shows the configuration of running on a CPU node." ] }, { "cell_type": "raw", "id": "62afe73f", "metadata": {}, "source": [ "#!/bin/bash\n", "#SBATCH -p defq\n", "#SBATCH --job-name=Quito_CPU\n", "#SBATCH -n 10\n", "#SBATCH --time 00-1:00:00 # time (D-HH:MM:SS)\n", "module purge\n", "module load slurm/slurm/21.08.8\n", "module use /cm/shared/ex3-qc-modules/modulefiles\n", "module load quito/quito-py311-1.0.3\n", "export PYTHONPATH=root_path:$PYTHONPATH\n", "srun python quito_test.py" ] }, { "cell_type": "markdown", "id": "aa7c4b7d", "metadata": {}, "source": [ "The following is the version of configuration file running on a GPU node." ] }, { "cell_type": "raw", "id": "ecdb0ffe", "metadata": {}, "source": [ "#!/bin/bash\n", "#SBATCH -p dgx2q\n", "#SBATCH --job-name=Quito_GPU\n", "#SBATCH -n 10\n", "#SBATCH --gres=gpu:1\n", "#SBATCH --time 00-1:00:00 # time (D-HH:MM:SS)\n", "module purge\n", "module load slurm/slurm/21.08.8\n", "module use /cm/shared/ex3-qc-modules/modulefiles\n", "module load quito/quito-py311-cu118-1.0\n", "export PYTHONPATH=root_path:$PYTHONPATH\n", "srun python quito_test.py" ] }, { "cell_type": "markdown", "id": "76d85a45", "metadata": {}, "source": [ "Please prepare the following files before submitting to the eX3.\n", "\n", "- quantum program file\n", "- configuration file\n", "- executing file\n", "- slurm file\n", "\n", "Run the following code to submit the job." ] }, { "cell_type": "code", "execution_count": 9, "id": "1214a583", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Submitted batch job 293033\n" ] }, { "data": { "text/plain": [ "0" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import os\n", "\n", "command = \"sbatch /home/user/quito.slurm\"\n", "os.system(command)" ] }, { "cell_type": "markdown", "id": "d2cef420", "metadata": {}, "source": [ "It will print the job number after a successful submission. You can check the running statu by using the \"squeue\" command. After completing the execution, you can check the file *slurm-[job number].out* to know the the execution time. Result files can be found in the same directory of the quantum program file." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.12" } }, "nbformat": 4, "nbformat_minor": 5 }