From 9d155893e86d9d5c03f3bccf032be79ea54474f6 Mon Sep 17 00:00:00 2001 From: pablolh Date: Thu, 4 May 2023 18:19:06 +0200 Subject: [PATCH] Fix test_unitary.py with new simulator API - create C++ version of decomposed_U tests for debugging - this test is flaky and skipped in CI - skip also the Python unitary tests in CI --- .github/workflows/test.yml | 10 +- tests/CMakeLists.txt | 2 + tests/cc/debug.cc | 44 ++ tests/cc/test_cfg_none_simple.json | 26 + tests/cc/test_multi_core_64x16_full.json | 279 ++++++++ tests/cc/test_unitary.cc | 43 ++ .../test_gate_decomposition_cz.cc_backend.map | 48 ++ .../test_gate_decomposition_cz.cc_backend.vcd | 359 ++++++++++ ...st_gate_decomposition_cz.cc_backend.vq1asm | 182 +++++ tests/test_gate_decomposition_cz.initial.cq | 21 + tests/test_gate_decomposition_cz.scheduled.cq | 37 + tests/test_qi_example.cc_backend.map | 82 +++ tests/test_qi_example.cc_backend.vcd | 221 ++++++ tests/test_qi_example.cc_backend.vq1asm | 93 +++ tests/test_qi_example.initial.cq | 24 + tests/test_qi_example.scheduled.cq | 32 + tests/test_unitary.py | 651 ++++++++---------- 17 files changed, 1783 insertions(+), 371 deletions(-) create mode 100644 tests/cc/debug.cc create mode 100644 tests/cc/test_cfg_none_simple.json create mode 100644 tests/cc/test_multi_core_64x16_full.json create mode 100644 tests/cc/test_unitary.cc create mode 100644 tests/test_gate_decomposition_cz.cc_backend.map create mode 100644 tests/test_gate_decomposition_cz.cc_backend.vcd create mode 100644 tests/test_gate_decomposition_cz.cc_backend.vq1asm create mode 100644 tests/test_gate_decomposition_cz.initial.cq create mode 100644 tests/test_gate_decomposition_cz.scheduled.cq create mode 100644 tests/test_qi_example.cc_backend.map create mode 100644 tests/test_qi_example.cc_backend.vcd create mode 100644 tests/test_qi_example.cc_backend.vq1asm create mode 100644 tests/test_qi_example.initial.cq create mode 100644 tests/test_qi_example.scheduled.cq diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 6c7f29966..6408d2a8b 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -39,7 +39,7 @@ jobs: if: matrix.os == 'windows-latest' run: choco install winflexbison3 --version 2.5.18.20190508 - name: Configure - run: cmake . -DCMAKE_BUILD_TYPE=Debug -DOPENQL_BUILD_TESTS=ON -DBUILD_SHARED_LIBS=OFF + run: cmake . -DCMAKE_BUILD_TYPE=Debug -DOPENQL_BUILD_TESTS=ON -DBUILD_SHARED_LIBS=OFF -DWITH_UNITARY_DECOMPOSITION=OFF - name: Build run: cmake --build . --parallel 5 - name: Test @@ -85,7 +85,7 @@ jobs: with: python-version: ${{ matrix.python }} - name: Install dependencies - run: python -m pip install --upgrade pip setuptools wheel pytest numpy + run: python -m pip install --upgrade pip setuptools wheel pytest numpy qxelarator - name: Install dependencies if: matrix.os == 'ubuntu-latest' run: sudo apt-get install -y swig @@ -115,6 +115,12 @@ jobs: - name: Select build type if: matrix.os != 'windows-latest' run: echo "OPENQL_BUILD_TYPE=Debug" >> $GITHUB_ENV + - name: Disable unitary decomposition + if: matrix.os != 'windows-latest' + run: echo "OPENQL_DISABLE_UNITARY=true" >> $GITHUB_ENV + - name: Disable unitary decomposition + if: matrix.os == 'windows-latest' + run: echo "OPENQL_DISABLE_UNITARY=true" >> $env:GITHUB_ENV - name: Build env: NPROCS: 5 diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 5489c21cd..b04d5596b 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,6 +1,8 @@ cmake_minimum_required(VERSION 3.1 FATAL_ERROR) add_openql_test(test_cc cc/test_cc.cc cc) +add_openql_test(test_unitary cc/test_unitary.cc cc) +target_link_libraries(test_unitary doctest) add_openql_test(test_mapper test_mapper.cc .) add_openql_test(test_multi_core test_multi_core.cc .) add_openql_test(program_test program_test.cc .) diff --git a/tests/cc/debug.cc b/tests/cc/debug.cc new file mode 100644 index 000000000..235ecda2c --- /dev/null +++ b/tests/cc/debug.cc @@ -0,0 +1,44 @@ +#include + +int main(int, char **) { + ql::initialize(); + ql::utils::logger::set_log_level("LOG_INFO"); + ql::set_option("log_level", "LOG_INFO"); + + ql::set_option("maptiebreak", "random"); + + ql::set_option("use_default_gates", "no"); + + ql::set_option("decompose_toffoli", "no"); + ql::set_option("scheduler", "ASAP"); + ql::set_option("scheduler_heuristic", "random"); + ql::set_option("scheduler_uniform", "no"); + ql::set_option("scheduler_commute", "yes"); + ql::set_option("scheduler_commute_rotations", "yes"); + ql::set_option("prescheduler", "yes"); + ql::set_option("print_dot_graphs", "no"); + + ql::set_option("clifford_premapper", "yes"); + ql::set_option("clifford_postmapper", "no"); + ql::set_option("mapper", "base"); + ql::set_option("mapassumezeroinitstate", "yes"); + ql::set_option("mapusemoves", "no"); + ql::set_option("mapreverseswap", "yes"); + ql::set_option("mapmaxalters", "10"); + // ql::set_option("mappathselect", "random"); + ql::set_option("maplookahead", "noroutingfirst"); + ql::set_option("maprecNN2q", "no"); + ql::set_option("mapselectmaxlevel", "0"); + ql::set_option("mapselectmaxwidth", "min"); + + ql::set_option("write_qasm_files", "yes"); + ql::set_option("write_report_files", "yes"); + + auto platform = ql::Platform("mctests", "test_multi_core_64x16_full.json"); + auto num_qubits = 18; + auto p = ql::Program("qaoa_q1024", platform, num_qubits); + auto k = ql::Kernel("qaoa_q1024", platform, num_qubits); + k.gate("cnot", 0, 17); + p.add_kernel(k); + p.compile(); +} \ No newline at end of file diff --git a/tests/cc/test_cfg_none_simple.json b/tests/cc/test_cfg_none_simple.json new file mode 100644 index 000000000..e2f3db3a9 --- /dev/null +++ b/tests/cc/test_cfg_none_simple.json @@ -0,0 +1,26 @@ +{ + "eqasm_compiler" : "none", + + "hardware_settings": { + "qubit_number": 17, + "cycle_time" : 20, + "mw_mw_buffer": 0, + "mw_flux_buffer": 0, + "mw_readout_buffer": 0, + "flux_mw_buffer": 0, + "flux_flux_buffer": 0, + "flux_readout_buffer": 0, + "readout_mw_buffer": 0, + "readout_flux_buffer": 0, + "readout_readout_buffer": 0 + }, + + "instructions": { + }, + + "gate_decomposition": { + }, + + "resources": {}, + "topology": {} +} diff --git a/tests/cc/test_multi_core_64x16_full.json b/tests/cc/test_multi_core_64x16_full.json new file mode 100644 index 000000000..2c4af3db0 --- /dev/null +++ b/tests/cc/test_multi_core_64x16_full.json @@ -0,0 +1,279 @@ +{ + "eqasm_compiler" : "cc_light_compiler", + + "hardware_settings": { + "qubit_number": 512, + "cycle_time" : 20, + "mw_mw_buffer": 0, + "mw_flux_buffer": 0, + "mw_readout_buffer": 0, + "flux_mw_buffer": 0, + "flux_flux_buffer": 0, + "flux_readout_buffer": 0, + "readout_mw_buffer": 0, + "readout_flux_buffer": 0, + "readout_readout_buffer": 0 + }, + + "qubit_attributes": + { + "relaxation_times": + { + "0" : [3000, 1500], + "1" : [3000, 1500], + "2" : [3000, 1500], + "3" : [3000, 1500], + "4" : [3000, 1500] + } + }, + + "topology" : + { + "number_of_cores": 64, + "connectivity": "full", + "form": "irregular", + "comm_qubits_per_core": 16 + }, + + "resources": + { + "qubits": + { + "description": "Each qubit can be used by only one gate at a time. There are 'count' qubits.", + "count": 1024 + }, + "channels": + { + "description": "Each inter-core gate uses one channel in each core. There are 'count' such channels per core.", + "count": 1 + } + }, + + "instructions": { + "prepx": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "prepx" + }, + "prepz": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "prepz" + }, + "measx": { + "duration": 340, + "latency": 0, + "type": "readout", + "cc_light_instr": "measx" + }, + "measz": { + "duration": 300, + "latency": 0, + "type": "readout", + "cc_light_instr": "measz" + }, + "measure": { + "duration": 300, + "latency": 0, + "type": "readout", + "cc_light_instr": "measz" + }, + "i": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "i" + }, + "x": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "x" + }, + "y": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "y" + }, + "z": { + "duration": 40, + "latency": 0, + "type": "mw", + "cc_light_instr": "z" + }, + "rx": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "rx" + }, + "ry": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "ry" + }, + "rz": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "rz" + }, + "h": { + "duration": 40, + "latency": 0, + "type": "mw", + "cc_light_instr": "h" + }, + "s": { + "duration": 60, + "latency": 0, + "type": "mw", + "cc_light_instr": "s" + }, + "sdag": { + "duration": 60, + "latency": 0, + "type": "mw", + "cc_light_instr": "sdag" + }, + "x90": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "x90" + }, + "xm90": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "xm90" + }, + "y90": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "y90" + }, + "ym90": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "ym90" + }, + "t": { + "duration": 60, + "latency": 0, + "type": "mw", + "cc_light_instr": "t" + }, + "tdag": { + "duration": 60, + "latency": 0, + "type": "mw", + "cc_light_instr": "tdag" + }, + "x45": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "x45" + }, + "xm45": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "xm45" + }, + "y45": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "y45" + }, + "ym45": { + "duration": 20, + "latency": 0, + "type": "mw", + "cc_light_instr": "ym45" + }, + "cz": { + "duration": 60, + "latency": 0, + "type": "flux", + "cc_light_instr": "cz" + }, + "cnot": { + "duration": 100, + "latency": 0, + "type": "flux", + "cc_light_instr": "cnot" + }, + "swap": { + "duration": 260, + "latency": 0, + "type": "flux", + "cc_light_instr": "swap" + }, + "move": { + "duration": 180, + "latency": 0, + "type": "flux", + "cc_light_instr": "move" + }, + "teleportswap": { + "duration": 1000, + "latency": 0, + "type": "extern", + "cc_light_instr": "teleportswap" + }, + "teleportmove": { + "duration": 600, + "latency": 0, + "type": "extern", + "cc_light_instr": "teleportmove" + }, + "preswap": { + "duration": 100, + "latency": 0, + "type": "mw", + "cc_light_instr": "preswap" + }, + "premove": { + "duration": 100, + "latency": 0, + "type": "mw", + "cc_light_instr": "premove" + }, + "postswap": { + "duration": 100, + "latency": 0, + "type": "mw", + "cc_light_instr": "postswap" + }, + "postmove": { + "duration": 100, + "latency": 0, + "type": "mw", + "cc_light_instr": "postmove" + } + }, + + "gate_decomposition": { + "tswap_real %0,%1": ["preswap %0","teleportswap %0,%1","postswap %1"], + "tmove_real %0,%1": ["premove %0","teleportmove %0,%1","postmove %1"], + "rx180 %0" : ["x %0"], + "ry180 %0" : ["y %0"], + "rx90 %0" : ["x90 %0"], + "ry90 %0" : ["y90 %0"], + "mrx90 %0" : ["xm90 %0"], + "mry90 %0" : ["ym90 %0"], + "rx45 %0" : ["x45 %0"], + "ry45 %0" : ["y45 %0"], + "mrx45 %0" : ["xm45 %0"], + "mry45 %0" : ["ym45 %0"] + } +} diff --git a/tests/cc/test_unitary.cc b/tests/cc/test_unitary.cc new file mode 100644 index 000000000..f6a87df31 --- /dev/null +++ b/tests/cc/test_unitary.cc @@ -0,0 +1,43 @@ +#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN +#include "doctest/doctest.h" + +#include "openql.h" + +// Fails in CI on some platforms. +TEST_CASE("decomposition_controlled_U" * doctest::skip(!ql::Unitary::is_decompose_support_enabled())) { + auto platform = ql::Platform("platform_none", "test_cfg_none_simple.json"); + auto num_qubits = 3; + auto p = ql::Program("test_usingqx_toffoli", platform, num_qubits); + auto k = ql::Kernel("akernel", platform, num_qubits); + + std::vector> matrix = { 1, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, std::complex(0.30279949, -0.60010283), std::complex(-0.58058628, -0.45946559), + 0, 0, 0, 0, 0 ,0, std::complex(0.04481146, -0.73904059), std::complex(0.64910478, 0.17456782)}; + + auto u1 = ql::Unitary("arbitrarycontrolled",matrix); + u1.decompose(); + k.hadamard(0); + k.hadamard(1); + k.hadamard(2); + k.gate(u1, { 0, 1, 2 }); + + + p.add_kernel(k); + p.get_compiler().set_option("initialqasmwriter.cqasm_version", "1.0"); + p.get_compiler().set_option("initialqasmwriter.with_metadata", "no"); + p.compile(); + + CHECK_EQ(0.125*std::norm((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7])), doctest::Approx(std::norm(std::complex(0.03708885276142243, 0.3516026407762626)))); + CHECK_EQ(0.125*std::norm((matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), doctest::Approx(std::norm(std::complex(0.03708885276142243, 0.3516026407762626)))); + CHECK_EQ(0.125*std::norm((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23])), doctest::Approx(std::norm(std::complex(0.03708885276142243, 0.3516026407762626)))); + CHECK_EQ(0.125*std::norm((matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), doctest::Approx(std::norm(std::complex(0.03708885276142243, 0.3516026407762626)))); + CHECK_EQ(0.125*std::norm((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39])), doctest::Approx(std::norm(std::complex(0.03708885276142243, 0.3516026407762626)))); + CHECK_EQ(0.125*std::norm((matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), doctest::Approx(std::norm(std::complex(0.03708885276142243, 0.3516026407762626)))); + CHECK_EQ(0.125*std::norm((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55])), doctest::Approx(std::norm(std::complex(-0.38284984896211677, 0.058372391728338066)))); + CHECK_EQ(0.125*std::norm((matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), doctest::Approx(std::norm(std::complex(-0.17273355873910606, -0.2649184303119007)))); +} \ No newline at end of file diff --git a/tests/test_gate_decomposition_cz.cc_backend.map b/tests/test_gate_decomposition_cz.cc_backend.map new file mode 100644 index 000000000..70158dee2 --- /dev/null +++ b/tests/test_gate_decomposition_cz.cc_backend.map @@ -0,0 +1,48 @@ +{ + "codewords": { + "data": { + "flux_0": [ + [ + 2, + "{type:cz,which:SE}" + ], + [ + 2, + "{type:cz,which:SE}" + ], + [ + 2, + "{type:cz,which:SE}" + ], + [ + 5, + "{type:park}" + ], + [ + 3, + "{type:cz,which:SW}" + ], + null, + [ + 4, + "{type:idle_z,which:NW}" + ], + [ + 1, + "{type:idle_z,which:NE}" + ] + ] + }, + "version": 1 + }, + "measurements": { + "data": null, + "nr-shots": null, + "version": 2 + }, + "openql": { + "backend": "cc", + "backend-version": "0.4.0", + "version": "0.11.1" + } +} diff --git a/tests/test_gate_decomposition_cz.cc_backend.vcd b/tests/test_gate_decomposition_cz.cc_backend.vcd new file mode 100644 index 000000000..86a4d3cab --- /dev/null +++ b/tests/test_gate_decomposition_cz.cc_backend.vcd @@ -0,0 +1,359 @@ +$date today $end +$timescale 1 ns $end +$scope module kernel $end +$var string 20 0 kernel $end +$upscope $end +$scope module qubits $end +$var string 20 1 q0 $end +$var string 20 2 q1 $end +$var string 20 3 q2 $end +$var string 20 4 q3 $end +$var string 20 5 q4 $end +$var string 20 6 q5 $end +$var string 20 7 q6 $end +$var string 20 8 q7 $end +$var string 20 9 q8 $end +$var string 20 10 q9 $end +$var string 20 11 q10 $end +$var string 20 12 q11 $end +$var string 20 13 q12 $end +$var string 20 14 q13 $end +$var string 20 15 q14 $end +$var string 20 16 q15 $end +$var string 20 17 q16 $end +$upscope $end +$scope module sd.signal $end +$var string 20 18 ro_0-0 $end +$var string 20 19 ro_0-1 $end +$var string 20 20 ro_0-2 $end +$var string 20 21 ro_0-3 $end +$var string 20 22 ro_0-4 $end +$var string 20 23 ro_0-5 $end +$var string 20 24 ro_0-6 $end +$var string 20 25 ro_0-7 $end +$var string 20 26 ro_0-8 $end +$var string 20 27 ro_1-0 $end +$var string 20 28 ro_1-1 $end +$var string 20 29 ro_1-2 $end +$var string 20 30 ro_1-3 $end +$var string 20 31 ro_1-4 $end +$var string 20 32 ro_1-5 $end +$var string 20 33 ro_1-6 $end +$var string 20 34 ro_1-7 $end +$var string 20 35 ro_1-8 $end +$var string 20 36 ro_2-0 $end +$var string 20 37 ro_2-1 $end +$var string 20 38 ro_2-2 $end +$var string 20 39 ro_2-3 $end +$var string 20 40 ro_2-4 $end +$var string 20 41 ro_2-5 $end +$var string 20 42 ro_2-6 $end +$var string 20 43 ro_2-7 $end +$var string 20 44 ro_2-8 $end +$var string 20 45 mw_0-0 $end +$var string 20 46 mw_0-1 $end +$var string 20 47 mw_0-2 $end +$var string 20 48 mw_0-3 $end +$var string 20 49 mw_1-0 $end +$var string 20 50 mw_1-1 $end +$var string 20 51 mw_1-2 $end +$var string 20 52 mw_1-3 $end +$var string 20 53 mw_2-0 $end +$var string 20 54 mw_2-1 $end +$var string 20 55 mw_2-2 $end +$var string 20 56 mw_2-3 $end +$var string 20 57 mw_3-0 $end +$var string 20 58 mw_3-1 $end +$var string 20 59 mw_3-2 $end +$var string 20 60 mw_3-3 $end +$var string 20 61 mw_4-0 $end +$var string 20 62 mw_4-1 $end +$var string 20 63 mw_4-2 $end +$var string 20 64 mw_4-3 $end +$var string 20 65 flux_0-0 $end +$var string 20 66 flux_0-1 $end +$var string 20 67 flux_0-2 $end +$var string 20 68 flux_0-3 $end +$var string 20 69 flux_0-4 $end +$var string 20 70 flux_0-5 $end +$var string 20 71 flux_0-6 $end +$var string 20 72 flux_0-7 $end +$var string 20 73 flux_1-0 $end +$var string 20 74 flux_1-1 $end +$var string 20 75 flux_1-2 $end +$var string 20 76 flux_1-3 $end +$var string 20 77 flux_1-4 $end +$var string 20 78 flux_1-5 $end +$var string 20 79 flux_1-6 $end +$var string 20 80 flux_1-7 $end +$var string 20 81 flux_2-0 $end +$var string 20 82 flux_2-1 $end +$var string 20 83 flux_2-2 $end +$var string 20 84 flux_2-3 $end +$var string 20 85 flux_2-4 $end +$var string 20 86 flux_2-5 $end +$var string 20 87 flux_2-6 $end +$var string 20 88 flux_2-7 $end +$upscope $end +$scope module codewords $end +$var string 20 89 ro_0 $end +$var string 20 90 ro_1 $end +$var string 20 91 ro_2 $end +$var string 20 92 mw_0 $end +$var string 20 93 mw_1 $end +$var string 20 94 mw_2 $end +$var string 20 95 mw_3 $end +$var string 20 96 mw_4 $end +$var string 20 97 flux_0 $end +$var string 20 98 flux_1 $end +$var string 20 99 flux_2 $end +$upscope $end +$enddefinitions $end +#0 +skernel_0 0 +s_cz_sw_ne_park 9 +s_cz_sw_ne_park 11 +s_cz_sw_ne_park 12 +s2147516419={type:cz,which:SW} 65 +s2147516480={type:idle_z,which:NE} 67 +s2147518976={type:park} 68 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x80008a43 97 +s 98 +s 99 +#40 +s_cz_sw_ne_park 9 +s_cz_sw_ne_park 11 +s_cz_sw_ne_park 12 +s2147516419={type:cz,which:SW} 65 +s2147516480={type:idle_z,which:NE} 67 +s2147518976={type:park} 68 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x80008a43 97 +s 98 +s 99 +#80 +s_cz_se_nw_park 9 +s_cz_se_nw_park 11 +s_cz_se_nw_park 12 +s2147516418={type:cz,which:SE} 65 +s2147516736={type:park} 67 +s2147518464={type:idle_z,which:NW} 68 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x80008942 97 +s 98 +s 99 +#120 +s 9 +s_cz_sw_ne_park 10 +s 11 +s_cz_sw_ne_park 12 +s_cz_sw_ne_park 13 +s 65 +s2147516440={type:cz,which:SW} 66 +s 67 +s2147516928={type:idle_z,which:NE} 68 +s2147844096={type:park} 69 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x80058218 97 +s 98 +s 99 +#160 +s 10 +s_cz_sw_ne_park 12 +s 13 +s_cz_sw_ne_park 15 +s_cz_sw_ne_park 16 +s 66 +s2147517952={type:cz,which:SW} 68 +s 69 +s2151710720={type:idle_z,which:NE} 71 +s2315288576={type:park} 72 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x8a408600 97 +s 98 +s 99 +#200 +s_cz_sw_ne_park 12 +s_cz_sw_ne_park 15 +s_cz_sw_ne_park 16 +s2147517952={type:cz,which:SW} 68 +s2151710720={type:idle_z,which:NE} 71 +s2315288576={type:park} 72 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x8a408600 97 +s 98 +s 99 +#240 +s_cz_sw_ne_park 10 +s_cz_sw_ne_park 12 +s_cz_sw_ne_park 13 +s 15 +s 16 +s2147516440={type:cz,which:SW} 66 +s2147516928={type:idle_z,which:NE} 68 +s2147844096={type:park} 69 +s 71 +s 72 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x80058218 97 +s 98 +s 99 +#280 +s_cz_sw_ne_park 10 +s_cz_sw_ne_park 12 +s_cz_sw_ne_park 13 +s2147516440={type:cz,which:SW} 66 +s2147516928={type:idle_z,which:NE} 68 +s2147844096={type:park} 69 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x80058218 97 +s 98 +s 99 +#320 +s_cz_se_nw_park 10 +s_cz_se_nw_park 12 +s_cz_se_nw_park 13 +s2147516432={type:cz,which:SE} 66 +s2147518976={type:park} 68 +s2147778560={type:idle_z,which:NW} 69 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x80048a10 97 +s 98 +s 99 +#360 +s_cz_se_nw_park 10 +s_cz_se_nw_park 12 +s_cz_se_nw_park 13 +s2147516432={type:cz,which:SE} 66 +s2147518976={type:park} 68 +s2147778560={type:idle_z,which:NW} 69 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x80048a10 97 +s 98 +s 99 +#400 +s 10 +s_cz_se_nw 11 +s 12 +s_cz_sw_ne 13 +s_cz_se_nw 15 +s_cz_sw_ne 16 +s 66 +s2147516544={type:cz,which:SE} 67 +s 68 +s2147713024={type:cz,which:SW} 69 +s2164293632={type:idle_z,which:NW} 71 +s2181070848={type:idle_z,which:NE} 72 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x83038080 97 +s 98 +s 99 +#440 +s_cz_se_nw 11 +s_cz_sw_ne 13 +s_cz_se_nw 15 +s_cz_sw_ne 16 +s2147516544={type:cz,which:SE} 67 +s2147713024={type:cz,which:SW} 69 +s2164293632={type:idle_z,which:NW} 71 +s2181070848={type:idle_z,which:NE} 72 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s0x83038080 97 +s 98 +s 99 +#480 +s 0 +s 11 +s 13 +s 15 +s 16 +s 67 +s 69 +s 71 +s 72 +s 97 diff --git a/tests/test_gate_decomposition_cz.cc_backend.vq1asm b/tests/test_gate_decomposition_cz.cc_backend.vq1asm new file mode 100644 index 000000000..044bbe42c --- /dev/null +++ b/tests/test_gate_decomposition_cz.cc_backend.vq1asm @@ -0,0 +1,182 @@ +# Program: 'test_gate_decomposition_cz' +# CC_BACKEND_VERSION 0.4.0 +# OPENQL_VERSION 0.11.1 +# Note: generated by OpenQL Central Controller backend +# +.CODE +# synchronous start and latency compensation + seq_bar # synchronization, delay set externally through SET_SEQ_BAR_CNT + seq_out 0x00000000,1 # allows monitoring actual start time using trace unit +# start of main loop that runs indefinitely +__mainLoop: # + seq_state 0 # clear Programmable Logic state + +### Block: 'kernel_0' +## Bundle 0: start_cycle=0: + # gate '_cz_sw_ne_park q[8], q[10], q[11]' + # slot=3, instrument='flux_0', group=0': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=2': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=3': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=0: codeword=3 (static override): groupDigOut=0x00000003 + # slot=3, instrument='flux_0', group=2: codeword=1 (static override): groupDigOut=0x00000040 + # slot=3, instrument='flux_0', group=3: codeword=5 (static override): groupDigOut=0x00000a00 + # slot=3, instrument='flux_0': lastEndCycle=0, startCycle=0, instrMaxDurationInCycles=2 +[3] seq_out 0x80008a43,2 # cycle 0-2: code word/mask on 'flux_0' + +## Bundle 1: start_cycle=2: + # gate '_cz_sw_ne_park q[8], q[10], q[11]' + # slot=3, instrument='flux_0', group=0': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=2': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=3': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=0: codeword=3 (static override): groupDigOut=0x00000003 + # slot=3, instrument='flux_0', group=2: codeword=1 (static override): groupDigOut=0x00000040 + # slot=3, instrument='flux_0', group=3: codeword=5 (static override): groupDigOut=0x00000a00 + # slot=3, instrument='flux_0': lastEndCycle=2, startCycle=2, instrMaxDurationInCycles=2 +[3] seq_out 0x80008a43,2 # cycle 2-4: code word/mask on 'flux_0' + +## Bundle 2: start_cycle=4: + # gate '_cz_se_nw_park q[8], q[11], q[10]' + # slot=3, instrument='flux_0', group=0': signalValue='{type:cz,which:SE}' + # slot=3, instrument='flux_0', group=3': signalValue='{type:idle_z,which:NW}' + # slot=3, instrument='flux_0', group=2': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=0: codeword=2 (static override): groupDigOut=0x00000002 + # slot=3, instrument='flux_0', group=2: codeword=5 (static override): groupDigOut=0x00000140 + # slot=3, instrument='flux_0', group=3: codeword=4 (static override): groupDigOut=0x00000800 + # slot=3, instrument='flux_0': lastEndCycle=4, startCycle=4, instrMaxDurationInCycles=2 +[3] seq_out 0x80008942,2 # cycle 4-6: code word/mask on 'flux_0' + +## Bundle 3: start_cycle=6: + # gate '_cz_sw_ne_park q[9], q[11], q[12]' + # slot=3, instrument='flux_0', group=1': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=3': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=4': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=1: codeword=3 (static override): groupDigOut=0x00000018 + # slot=3, instrument='flux_0', group=3: codeword=1 (static override): groupDigOut=0x00000200 + # slot=3, instrument='flux_0', group=4: codeword=5 (static override): groupDigOut=0x00050000 + # slot=3, instrument='flux_0': lastEndCycle=6, startCycle=6, instrMaxDurationInCycles=2 +[3] seq_out 0x80058218,2 # cycle 6-8: code word/mask on 'flux_0' + +## Bundle 4: start_cycle=8: + # gate '_cz_sw_ne_park q[11], q[14], q[15]' + # slot=3, instrument='flux_0', group=3': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=6': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=7': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=3: codeword=3 (static override): groupDigOut=0x00000600 + # slot=3, instrument='flux_0', group=6: codeword=1 (static override): groupDigOut=0x00400000 + # slot=3, instrument='flux_0', group=7: codeword=5 (static override): groupDigOut=0x0a000000 + # slot=3, instrument='flux_0': lastEndCycle=8, startCycle=8, instrMaxDurationInCycles=2 +[3] seq_out 0x8a408600,2 # cycle 8-10: code word/mask on 'flux_0' + +## Bundle 5: start_cycle=10: + # gate '_cz_sw_ne_park q[11], q[14], q[15]' + # slot=3, instrument='flux_0', group=3': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=6': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=7': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=3: codeword=3 (static override): groupDigOut=0x00000600 + # slot=3, instrument='flux_0', group=6: codeword=1 (static override): groupDigOut=0x00400000 + # slot=3, instrument='flux_0', group=7: codeword=5 (static override): groupDigOut=0x0a000000 + # slot=3, instrument='flux_0': lastEndCycle=10, startCycle=10, instrMaxDurationInCycles=2 +[3] seq_out 0x8a408600,2 # cycle 10-12: code word/mask on 'flux_0' + +## Bundle 6: start_cycle=12: + # gate '_cz_sw_ne_park q[9], q[11], q[12]' + # slot=3, instrument='flux_0', group=1': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=3': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=4': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=1: codeword=3 (static override): groupDigOut=0x00000018 + # slot=3, instrument='flux_0', group=3: codeword=1 (static override): groupDigOut=0x00000200 + # slot=3, instrument='flux_0', group=4: codeword=5 (static override): groupDigOut=0x00050000 + # slot=3, instrument='flux_0': lastEndCycle=12, startCycle=12, instrMaxDurationInCycles=2 +[3] seq_out 0x80058218,2 # cycle 12-14: code word/mask on 'flux_0' + +## Bundle 7: start_cycle=14: + # gate '_cz_sw_ne_park q[9], q[11], q[12]' + # slot=3, instrument='flux_0', group=1': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=3': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=4': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=1: codeword=3 (static override): groupDigOut=0x00000018 + # slot=3, instrument='flux_0', group=3: codeword=1 (static override): groupDigOut=0x00000200 + # slot=3, instrument='flux_0', group=4: codeword=5 (static override): groupDigOut=0x00050000 + # slot=3, instrument='flux_0': lastEndCycle=14, startCycle=14, instrMaxDurationInCycles=2 +[3] seq_out 0x80058218,2 # cycle 14-16: code word/mask on 'flux_0' + +## Bundle 8: start_cycle=16: + # gate '_cz_se_nw_park q[9], q[12], q[11]' + # slot=3, instrument='flux_0', group=1': signalValue='{type:cz,which:SE}' + # slot=3, instrument='flux_0', group=4': signalValue='{type:idle_z,which:NW}' + # slot=3, instrument='flux_0', group=3': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=1: codeword=2 (static override): groupDigOut=0x00000010 + # slot=3, instrument='flux_0', group=3: codeword=5 (static override): groupDigOut=0x00000a00 + # slot=3, instrument='flux_0', group=4: codeword=4 (static override): groupDigOut=0x00040000 + # slot=3, instrument='flux_0': lastEndCycle=16, startCycle=16, instrMaxDurationInCycles=2 +[3] seq_out 0x80048a10,2 # cycle 16-18: code word/mask on 'flux_0' + +## Bundle 9: start_cycle=18: + # gate '_cz_se_nw_park q[9], q[12], q[11]' + # slot=3, instrument='flux_0', group=1': signalValue='{type:cz,which:SE}' + # slot=3, instrument='flux_0', group=4': signalValue='{type:idle_z,which:NW}' + # slot=3, instrument='flux_0', group=3': signalValue='{type:park}' + # slot=3, instrument='flux_0', group=1: codeword=2 (static override): groupDigOut=0x00000010 + # slot=3, instrument='flux_0', group=3: codeword=5 (static override): groupDigOut=0x00000a00 + # slot=3, instrument='flux_0', group=4: codeword=4 (static override): groupDigOut=0x00040000 + # slot=3, instrument='flux_0': lastEndCycle=18, startCycle=18, instrMaxDurationInCycles=2 +[3] seq_out 0x80048a10,2 # cycle 18-20: code word/mask on 'flux_0' + +## Bundle 10: start_cycle=20: + # gate '_cz_se_nw q[10], q[14]' + # slot=3, instrument='flux_0', group=2': signalValue='{type:cz,which:SE}' + # slot=3, instrument='flux_0', group=6': signalValue='{type:idle_z,which:NW}' + # gate '_cz_sw_ne q[12], q[15]' + # slot=3, instrument='flux_0', group=4': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=7': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=2: codeword=2 (static override): groupDigOut=0x00000080 + # slot=3, instrument='flux_0', group=4: codeword=3 (static override): groupDigOut=0x00030000 + # slot=3, instrument='flux_0', group=6: codeword=4 (static override): groupDigOut=0x01000000 + # slot=3, instrument='flux_0', group=7: codeword=1 (static override): groupDigOut=0x02000000 + # slot=3, instrument='flux_0': lastEndCycle=20, startCycle=20, instrMaxDurationInCycles=2 +[3] seq_out 0x83038080,2 # cycle 20-22: code word/mask on 'flux_0' + +## Bundle 11: start_cycle=22: + # gate '_cz_se_nw q[10], q[14]' + # slot=3, instrument='flux_0', group=2': signalValue='{type:cz,which:SE}' + # slot=3, instrument='flux_0', group=6': signalValue='{type:idle_z,which:NW}' + # gate '_cz_sw_ne q[12], q[15]' + # slot=3, instrument='flux_0', group=4': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=7': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=2: codeword=2 (static override): groupDigOut=0x00000080 + # slot=3, instrument='flux_0', group=4: codeword=3 (static override): groupDigOut=0x00030000 + # slot=3, instrument='flux_0', group=6: codeword=4 (static override): groupDigOut=0x01000000 + # slot=3, instrument='flux_0', group=7: codeword=1 (static override): groupDigOut=0x02000000 + # last bundle of kernel, will pad outputs to match durations +[2] seq_wait 24 # cycle 0-24: padding on 'ro_0' +[4] seq_wait 24 # cycle 0-24: padding on 'ro_1' +[5] seq_wait 24 # cycle 0-24: padding on 'ro_2' +[0] seq_wait 24 # cycle 0-24: padding on 'mw_0' +[1] seq_wait 24 # cycle 0-24: padding on 'mw_1' +[6] seq_wait 24 # cycle 0-24: padding on 'mw_2' +[7] seq_wait 24 # cycle 0-24: padding on 'mw_3' +[8] seq_wait 24 # cycle 0-24: padding on 'mw_4' + # slot=3, instrument='flux_0': lastEndCycle=22, startCycle=22, instrMaxDurationInCycles=2 +[3] seq_out 0x83038080,2 # cycle 22-24: code word/mask on 'flux_0' +[9] seq_wait 24 # cycle 0-24: padding on 'flux_1' +[10] seq_wait 24 # cycle 0-24: padding on 'flux_2' + +### Block end: 'kernel_0' +# finish program + seq_wait 1 + jmp @__mainLoop # loop indefinitely +.END +.DATAPATH +## Bundle 0: start_cycle=0: +## Bundle 1: start_cycle=2: +## Bundle 2: start_cycle=4: +## Bundle 3: start_cycle=6: +## Bundle 4: start_cycle=8: +## Bundle 5: start_cycle=10: +## Bundle 6: start_cycle=12: +## Bundle 7: start_cycle=14: +## Bundle 8: start_cycle=16: +## Bundle 9: start_cycle=18: +## Bundle 10: start_cycle=20: +## Bundle 11: start_cycle=22: +.END diff --git a/tests/test_gate_decomposition_cz.initial.cq b/tests/test_gate_decomposition_cz.initial.cq new file mode 100644 index 000000000..ff28eac36 --- /dev/null +++ b/tests/test_gate_decomposition_cz.initial.cq @@ -0,0 +1,21 @@ +# Generated by OpenQL 0.11.1 for program test_gate_decomposition_cz +version 1.2 + +pragma @ql.name("test_gate_decomposition_cz") + + +.kernel_0 + _cz_sw_ne_park q[8], q[10], q[11] + _cz_sw_ne_park q[8], q[10], q[11] + _cz_se_nw_park q[8], q[11], q[10] + _cz_sw_ne_park q[9], q[11], q[12] + _cz_sw_ne_park q[11], q[14], q[15] + _cz_sw_ne_park q[11], q[14], q[15] + _cz_se_nw q[10], q[14] + _cz_se_nw q[10], q[14] + _cz_sw_ne_park q[9], q[11], q[12] + _cz_sw_ne_park q[9], q[11], q[12] + _cz_se_nw_park q[9], q[12], q[11] + _cz_se_nw_park q[9], q[12], q[11] + _cz_sw_ne q[12], q[15] + _cz_sw_ne q[12], q[15] diff --git a/tests/test_gate_decomposition_cz.scheduled.cq b/tests/test_gate_decomposition_cz.scheduled.cq new file mode 100644 index 000000000..f5a3ea81d --- /dev/null +++ b/tests/test_gate_decomposition_cz.scheduled.cq @@ -0,0 +1,37 @@ +# Generated by OpenQL 0.11.1 for program test_gate_decomposition_cz +version 1.2 + +pragma @ql.name("test_gate_decomposition_cz") + + +.kernel_0 + _cz_sw_ne_park q[8], q[10], q[11] + skip 1 + _cz_sw_ne_park q[8], q[10], q[11] + skip 1 + _cz_se_nw_park q[8], q[11], q[10] + skip 1 + _cz_sw_ne_park q[9], q[11], q[12] + skip 1 + _cz_sw_ne_park q[11], q[14], q[15] + skip 1 + _cz_sw_ne_park q[11], q[14], q[15] + skip 1 + _cz_sw_ne_park q[9], q[11], q[12] + skip 1 + _cz_sw_ne_park q[9], q[11], q[12] + skip 1 + _cz_se_nw_park q[9], q[12], q[11] + skip 1 + _cz_se_nw_park q[9], q[12], q[11] + skip 1 + { # start at cycle 20 + _cz_se_nw q[10], q[14] + _cz_sw_ne q[12], q[15] + } + skip 1 + { # start at cycle 22 + _cz_se_nw q[10], q[14] + _cz_sw_ne q[12], q[15] + } + skip 1 diff --git a/tests/test_qi_example.cc_backend.map b/tests/test_qi_example.cc_backend.map new file mode 100644 index 000000000..beef2f023 --- /dev/null +++ b/tests/test_qi_example.cc_backend.map @@ -0,0 +1,82 @@ +{ + "codewords": { + "data": { + "flux_0": [ + [ + 3, + "{type:cz,which:SW}" + ], + null, + [ + 1, + "{type:idle_z,which:NE}" + ], + [ + 5, + "{type:park}" + ] + ], + "mw_2": [ + [ + 2, + "{phi:90,theta:180,type:ge}" + ], + null, + [ + 4, + "{phi:90,theta:90,type:ge}" + ] + ], + "ro_0": [ + [ + 0, + "[dummy]" + ], + [ + 0, + "[dummy]" + ] + ], + "ro_1": [ + [ + 0, + "[dummy]" + ], + [ + 0, + "[dummy]" + ], + [ + 0, + "[dummy]" + ] + ] + }, + "version": 1 + }, + "measurements": { + "data": [ + { + "ro_0": [ + 1, + 4 + ], + "ro_1": [ + 0, + 2, + 3 + ] + } + ], + "nr-shots": { + "ro_0": 1, + "ro_1": 1 + }, + "version": 2 + }, + "openql": { + "backend": "cc", + "backend-version": "0.4.0", + "version": "0.11.1" + } +} diff --git a/tests/test_qi_example.cc_backend.vcd b/tests/test_qi_example.cc_backend.vcd new file mode 100644 index 000000000..913254d7a --- /dev/null +++ b/tests/test_qi_example.cc_backend.vcd @@ -0,0 +1,221 @@ +$date today $end +$timescale 1 ns $end +$scope module kernel $end +$var string 20 0 kernel $end +$upscope $end +$scope module qubits $end +$var string 20 1 q0 $end +$var string 20 2 q1 $end +$var string 20 3 q2 $end +$var string 20 4 q3 $end +$var string 20 5 q4 $end +$var string 20 6 q5 $end +$var string 20 7 q6 $end +$var string 20 8 q7 $end +$var string 20 9 q8 $end +$var string 20 10 q9 $end +$var string 20 11 q10 $end +$var string 20 12 q11 $end +$var string 20 13 q12 $end +$var string 20 14 q13 $end +$var string 20 15 q14 $end +$var string 20 16 q15 $end +$var string 20 17 q16 $end +$upscope $end +$scope module sd.signal $end +$var string 20 18 ro_0-0 $end +$var string 20 19 ro_0-1 $end +$var string 20 20 ro_0-2 $end +$var string 20 21 ro_0-3 $end +$var string 20 22 ro_0-4 $end +$var string 20 23 ro_0-5 $end +$var string 20 24 ro_0-6 $end +$var string 20 25 ro_0-7 $end +$var string 20 26 ro_0-8 $end +$var string 20 27 ro_1-0 $end +$var string 20 28 ro_1-1 $end +$var string 20 29 ro_1-2 $end +$var string 20 30 ro_1-3 $end +$var string 20 31 ro_1-4 $end +$var string 20 32 ro_1-5 $end +$var string 20 33 ro_1-6 $end +$var string 20 34 ro_1-7 $end +$var string 20 35 ro_1-8 $end +$var string 20 36 ro_2-0 $end +$var string 20 37 ro_2-1 $end +$var string 20 38 ro_2-2 $end +$var string 20 39 ro_2-3 $end +$var string 20 40 ro_2-4 $end +$var string 20 41 ro_2-5 $end +$var string 20 42 ro_2-6 $end +$var string 20 43 ro_2-7 $end +$var string 20 44 ro_2-8 $end +$var string 20 45 mw_0-0 $end +$var string 20 46 mw_0-1 $end +$var string 20 47 mw_0-2 $end +$var string 20 48 mw_0-3 $end +$var string 20 49 mw_1-0 $end +$var string 20 50 mw_1-1 $end +$var string 20 51 mw_1-2 $end +$var string 20 52 mw_1-3 $end +$var string 20 53 mw_2-0 $end +$var string 20 54 mw_2-1 $end +$var string 20 55 mw_2-2 $end +$var string 20 56 mw_2-3 $end +$var string 20 57 mw_3-0 $end +$var string 20 58 mw_3-1 $end +$var string 20 59 mw_3-2 $end +$var string 20 60 mw_3-3 $end +$var string 20 61 mw_4-0 $end +$var string 20 62 mw_4-1 $end +$var string 20 63 mw_4-2 $end +$var string 20 64 mw_4-3 $end +$var string 20 65 flux_0-0 $end +$var string 20 66 flux_0-1 $end +$var string 20 67 flux_0-2 $end +$var string 20 68 flux_0-3 $end +$var string 20 69 flux_0-4 $end +$var string 20 70 flux_0-5 $end +$var string 20 71 flux_0-6 $end +$var string 20 72 flux_0-7 $end +$var string 20 73 flux_1-0 $end +$var string 20 74 flux_1-1 $end +$var string 20 75 flux_1-2 $end +$var string 20 76 flux_1-3 $end +$var string 20 77 flux_1-4 $end +$var string 20 78 flux_1-5 $end +$var string 20 79 flux_1-6 $end +$var string 20 80 flux_1-7 $end +$var string 20 81 flux_2-0 $end +$var string 20 82 flux_2-1 $end +$var string 20 83 flux_2-2 $end +$var string 20 84 flux_2-3 $end +$var string 20 85 flux_2-4 $end +$var string 20 86 flux_2-5 $end +$var string 20 87 flux_2-6 $end +$var string 20 88 flux_2-7 $end +$upscope $end +$scope module codewords $end +$var string 20 89 ro_0 $end +$var string 20 90 ro_1 $end +$var string 20 91 ro_2 $end +$var string 20 92 mw_0 $end +$var string 20 93 mw_1 $end +$var string 20 94 mw_2 $end +$var string 20 95 mw_3 $end +$var string 20 96 mw_4 $end +$var string 20 97 flux_0 $end +$var string 20 98 flux_1 $end +$var string 20 99 flux_2 $end +$upscope $end +$enddefinitions $end +#0 +skernel_0 0 +sprepz 1 +sprepz 2 +sprepz 3 +sprepz 4 +sprepz 5 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s 97 +s 98 +s 99 +#200000 +sry180 1 +s 2 +sry180 3 +s 4 +s 5 +s_cz_sw_ne_park 9 +s_cz_sw_ne_park 11 +s_cz_sw_ne_park 12 +s2147516418={phi:90,theta:180,type:ge} 53 +s2147516419={type:cz,which:SW} 65 +s2147516480={type:idle_z,which:NE} 67 +s2147518976={type:park} 68 +s 89 +s 90 +s 91 +s 92 +s 93 +s0x80008002 94 +s 95 +s 96 +s0x80008a43 97 +s 98 +s 99 +#200020 +s 1 +sry90 3 +s 53 +s2147778560={phi:90,theta:90,type:ge} 55 +s 89 +s 90 +s 91 +s 92 +s 93 +s0x80048000 94 +s 95 +s 96 +s 97 +s 98 +s 99 +#200040 +smeasure 1 +smeasure 2 +smeasure 3 +smeasure 4 +smeasure 5 +s 9 +s 11 +s 12 +s196608=[dummy] 18 +s327680=[dummy] 19 +s196608=[dummy] 27 +s327680=[dummy] 28 +s589824=[dummy] 29 +s 55 +s 65 +s 67 +s 68 +s0x00070000 89 +s0x000f0000 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s 97 +s 98 +s 99 +#200840 +s 0 +s 1 +s 2 +s 3 +s 4 +s 5 +s 18 +s 19 +s 27 +s 28 +s 29 +s 89 +s 90 +s 91 +s 92 +s 93 +s 94 +s 95 +s 96 +s 97 +s 98 +s 99 diff --git a/tests/test_qi_example.cc_backend.vq1asm b/tests/test_qi_example.cc_backend.vq1asm new file mode 100644 index 000000000..035488620 --- /dev/null +++ b/tests/test_qi_example.cc_backend.vq1asm @@ -0,0 +1,93 @@ +# Program: 'test_qi_example' +# CC_BACKEND_VERSION 0.4.0 +# OPENQL_VERSION 0.11.1 +# Note: generated by OpenQL Central Controller backend +# +.CODE +# synchronous start and latency compensation + seq_bar # synchronization, delay set externally through SET_SEQ_BAR_CNT + seq_out 0x00000000,1 # allows monitoring actual start time using trace unit +# start of main loop that runs indefinitely +__mainLoop: # + seq_state 0 # clear Programmable Logic state + +### Block: 'kernel_0' +## Bundle 0: start_cycle=0: + # gate 'prepz q[0]' + # gate 'prepz q[1]' + # gate 'prepz q[2]' + # gate 'prepz q[3]' + # gate 'prepz q[4]' + +## Bundle 1: start_cycle=10000: + # gate 'ry180 q[0], q[2]' + # slot=6, instrument='mw_2', group=0': signalValue='{phi:90,theta:180,type:ge}' + # gate '_cz_sw_ne_park q[8], q[10], q[11]' + # slot=3, instrument='flux_0', group=0': signalValue='{type:cz,which:SW}' + # slot=3, instrument='flux_0', group=2': signalValue='{type:idle_z,which:NE}' + # slot=3, instrument='flux_0', group=3': signalValue='{type:park}' + # slot=6, instrument='mw_2', group=0: codeword=2 (static override): groupDigOut=0x00000002 + # slot=3, instrument='flux_0', group=0: codeword=3 (static override): groupDigOut=0x00000003 + # slot=3, instrument='flux_0', group=2: codeword=1 (static override): groupDigOut=0x00000040 + # slot=3, instrument='flux_0', group=3: codeword=5 (static override): groupDigOut=0x00000a00 + # slot=6, instrument='mw_2': lastEndCycle=0, startCycle=10000, instrMaxDurationInCycles=1 +[6] seq_wait 10000 # cycle 0-10000: padding on 'mw_2' +[6] seq_out 0x80008002,1 # cycle 10000-10001: code word/mask on 'mw_2' + # slot=3, instrument='flux_0': lastEndCycle=0, startCycle=10000, instrMaxDurationInCycles=2 +[3] seq_wait 10000 # cycle 0-10000: padding on 'flux_0' +[3] seq_out 0x80008a43,2 # cycle 10000-10002: code word/mask on 'flux_0' + +## Bundle 2: start_cycle=10001: + # gate 'ry90 q[2]' + # slot=6, instrument='mw_2', group=2': signalValue='{phi:90,theta:90,type:ge}' + # slot=6, instrument='mw_2', group=2: codeword=4 (static override): groupDigOut=0x00040000 + # slot=6, instrument='mw_2': lastEndCycle=10001, startCycle=10001, instrMaxDurationInCycles=1 +[6] seq_out 0x80048000,1 # cycle 10001-10002: code word/mask on 'mw_2' + +## Bundle 3: start_cycle=10002: + # gate 'measure q[0], (bit)q[0]' + # slot=4, instrument='ro_1', group=0': signalValue='[dummy]' + # gate 'measure q[1], (bit)q[1]' + # slot=2, instrument='ro_0', group=0': signalValue='[dummy]' + # gate 'measure q[2], (bit)q[2]' + # slot=4, instrument='ro_1', group=1': signalValue='[dummy]' + # gate 'measure q[3], (bit)q[3]' + # slot=4, instrument='ro_1', group=2': signalValue='[dummy]' + # gate 'measure q[4], (bit)q[4]' + # slot=2, instrument='ro_0', group=1': signalValue='[dummy]' + + + + + + # slot=2, instrument='ro_0': lastEndCycle=0, startCycle=10002, instrMaxDurationInCycles=40 +[2] seq_wait 10002 # cycle 0-10002: padding on 'ro_0' +[2] seq_out 0x00070000,40 # cycle 10002-10042: code word/mask on 'ro_0' + # slot=4, instrument='ro_1': lastEndCycle=0, startCycle=10002, instrMaxDurationInCycles=40 +[4] seq_wait 10002 # cycle 0-10002: padding on 'ro_1' +[4] seq_out 0x000f0000,40 # cycle 10002-10042: code word/mask on 'ro_1' + +## Bundle 4: start_cycle=10042: + # last bundle of kernel, will pad outputs to match durations +[5] seq_wait 10042 # cycle 0-10042: padding on 'ro_2' +[0] seq_wait 10042 # cycle 0-10042: padding on 'mw_0' +[1] seq_wait 10042 # cycle 0-10042: padding on 'mw_1' +[6] seq_wait 40 # cycle 10002-10042: padding on 'mw_2' +[7] seq_wait 10042 # cycle 0-10042: padding on 'mw_3' +[8] seq_wait 10042 # cycle 0-10042: padding on 'mw_4' +[3] seq_wait 40 # cycle 10002-10042: padding on 'flux_0' +[9] seq_wait 10042 # cycle 0-10042: padding on 'flux_1' +[10] seq_wait 10042 # cycle 0-10042: padding on 'flux_2' + +### Block end: 'kernel_0' +# finish program + seq_wait 1 + jmp @__mainLoop # loop indefinitely +.END +.DATAPATH +## Bundle 0: start_cycle=0: +## Bundle 1: start_cycle=10000: +## Bundle 2: start_cycle=10001: +## Bundle 3: start_cycle=10002: +## Bundle 4: start_cycle=10042: +.END diff --git a/tests/test_qi_example.initial.cq b/tests/test_qi_example.initial.cq new file mode 100644 index 000000000..f5da84c95 --- /dev/null +++ b/tests/test_qi_example.initial.cq @@ -0,0 +1,24 @@ +# Generated by OpenQL 0.11.1 for program test_qi_example +version 1.2 + +pragma @ql.name("test_qi_example") + + +.kernel_0 + barrier q[0], q[1], q[2], q[3], q[4], q[5], q[6], q[7], q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15], q[16] + prepz q[0] + prepz q[1] + prepz q[2] + prepz q[3] + prepz q[4] + barrier q[0], q[1], q[2], q[3], q[4], q[5], q[6], q[7], q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15], q[16] + ry180 q[0], q[2] + _cz_sw_ne_park q[8], q[10], q[11] + ry90 q[2] + barrier q[0], q[1], q[2], q[3], q[4], q[5], q[6], q[7], q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15], q[16] + measure q[0], b[0] + measure q[1], b[1] + measure q[2], b[2] + measure q[3], b[3] + measure q[4], b[4] + barrier q[0], q[1], q[2], q[3], q[4], q[5], q[6], q[7], q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15], q[16] diff --git a/tests/test_qi_example.scheduled.cq b/tests/test_qi_example.scheduled.cq new file mode 100644 index 000000000..067c9573c --- /dev/null +++ b/tests/test_qi_example.scheduled.cq @@ -0,0 +1,32 @@ +# Generated by OpenQL 0.11.1 for program test_qi_example +version 1.2 + +pragma @ql.name("test_qi_example") + + +.kernel_0 + { # start at cycle 0 + barrier q[0], q[1], q[2], q[3], q[4], q[5], q[6], q[7], q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15], q[16] + prepz q[0] + prepz q[1] + prepz q[2] + prepz q[3] + prepz q[4] + } + skip 9999 + { # start at cycle 10000 + barrier q[0], q[1], q[2], q[3], q[4], q[5], q[6], q[7], q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15], q[16] + ry180 q[0], q[2] + _cz_sw_ne_park q[8], q[10], q[11] + } + ry90 q[2] + { # start at cycle 10002 + barrier q[0], q[1], q[2], q[3], q[4], q[5], q[6], q[7], q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15], q[16] + measure q[0], b[0] + measure q[1], b[1] + measure q[2], b[2] + measure q[3], b[3] + measure q[4], b[4] + } + skip 39 + barrier q[0], q[1], q[2], q[3], q[4], q[5], q[6], q[7], q[8], q[9], q[10], q[11], q[12], q[13], q[14], q[15], q[16] diff --git a/tests/test_unitary.py b/tests/test_unitary.py index 195b0e754..a81a6e499 100644 --- a/tests/test_unitary.py +++ b/tests/test_unitary.py @@ -4,28 +4,24 @@ from utils import file_compare import re import numpy as np - -try: - from qxelarator import qxelarator - qx = qxelarator.QX() -except ImportError: - qx = None +from qxelarator import qxelarator curdir = os.path.dirname(os.path.realpath(__file__)) config_fn = os.path.join(curdir, 'test_cfg_none_simple.json') platform = ql.Platform('platform_none', config_fn) +platform_qubits = 17 output_dir = os.path.join(curdir, 'test_output') -c0 = "" - -def helper_regex(measurementstring): - regex = re.findall('[-0-9.e]+',measurementstring) - i = 0 - array = [] - while i < len(regex): - array.append(float(regex[i])**2+float(regex[i+1])**2) - i +=3 # so we skip every third occurence, which is the bit string representing the qubit combi - return array +def to_bitstring(n, size=None): + small_bitstring = bin(n)[2:] + if size is None: + return small_bitstring + + assert(isinstance(size, int)) + assert((1 << size) > n) + assert(len(small_bitstring) <= size) + zeros = ''.join(['0' for _ in range(size - len(small_bitstring))]) + return zeros + small_bitstring def helper_prob(qubitstate): return qubitstate.real**2+qubitstate.imag**2 @@ -42,6 +38,13 @@ def setUp(self): ql.set_option('log_level', 'LOG_NOTHING') # ql.set_option('write_qasm_files', 'yes') + def test_bitstring(self): + self.assertEqual(to_bitstring(5), "101") + self.assertEqual(to_bitstring(5, size=6), "000101") + + with self.assertRaises(Exception): + res = to_bitstring(10, size=2) + def test_unitary_basic(self): num_qubits = 3 p = ql.Program('test_unitary_pass', platform, num_qubits) @@ -103,7 +106,6 @@ def test_unitary_wrongnumberofqubits(self): # # self.assertEqual(str(cm.exception).split('\n', maxsplit=1)[0], 'Unknown error: Unitary \'u1\' has been applied to the wrong number of qubits. Cannot be added to kernel! 1 and not 2') - @unittest.skipIf(qx is None, "qxelarator not installed") def test_unitary_decompose_I(self): num_qubits = 1 p = ql.Program('test_unitary_I', platform, num_qubits) @@ -120,13 +122,10 @@ def test_unitary_decompose_I(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - self.assertAlmostEqual(0.5*(helper_prob(matrix[0])+helper_prob(matrix[1])), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.5*(helper_prob(matrix[2])+helper_prob(matrix[3])), helper_regex(c0)[0], 5) + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + self.assertAlmostEqual(0.5*(helper_prob(matrix[0])+helper_prob(matrix[1])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.5*(helper_prob(matrix[2])+helper_prob(matrix[3])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_unitary_decompose_X(self): num_qubits = 1 p = ql.Program('test_unitary_X', platform, num_qubits) @@ -143,13 +142,10 @@ def test_unitary_decompose_X(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - self.assertAlmostEqual(helper_prob(matrix[0]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[2]), helper_regex(c0)[1], 5) + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + self.assertAlmostEqual(helper_prob(matrix[0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[2]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_unitary_decompose_Y(self): num_qubits = 1 p = ql.Program('test_unitary_Y', platform, num_qubits) @@ -166,13 +162,10 @@ def test_unitary_decompose_Y(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - self.assertAlmostEqual(helper_prob(matrix[0]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[2]), helper_regex(c0)[1], 5) + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + self.assertAlmostEqual(helper_prob(matrix[0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[2]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_unitary_decompose_Z(self): num_qubits = 1 p = ql.Program('test_unitary_Z', platform, num_qubits) @@ -191,15 +184,12 @@ def test_unitary_decompose_Z(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state #HZH = X, so the result should be |0> + |1> - self.assertAlmostEqual(0, helper_regex(c0)[0], 5) - self.assertAlmostEqual(1, helper_regex(c0)[1], 5) + self.assertAlmostEqual(0, helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(1, helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_unitary_decompose_IYZ(self): num_qubits = 1 p = ql.Program('test_unitary_IYZ', platform, num_qubits) @@ -224,15 +214,12 @@ def test_unitary_decompose_IYZ(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state #jXYZ = I, so this should change nothing about the state. - self.assertAlmostEqual(0.5, helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.5, helper_regex(c0)[1], 5) + self.assertAlmostEqual(0.5, helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.5, helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_unitary_decompose_IYZ_differentorder(self): num_qubits = 1 p = ql.Program('test_unitary_IYZ', platform, num_qubits) @@ -260,13 +247,11 @@ def test_unitary_decompose_IYZ_differentorder(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state #jXYZ = I, so this should change nothing about the state. - self.assertAlmostEqual(0.5, helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.5, helper_regex(c0)[1], 5) + self.assertAlmostEqual(0.5, helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.5, helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) def test_unitary_decompose_nonunitary(self): num_qubits = 1 @@ -283,7 +268,7 @@ def test_unitary_decompose_nonunitary(self): add_kernel(k) p.compile() - self.assertEqual(str(cm.exception).split('\n\n', maxsplit=1)[0], "Unknown error: Error: Unitary 'WRONG' is not a unitary matrix. Cannot be decomposed!(0,0) (0,0)\n(0,0) (0,0)\n") + self.assertEqual(str(cm.exception).split('\n\n', maxsplit=1)[0], "Unknown error: Error: Unitary 'WRONG' is not a unitary matrix. Cannot be decomposed!(0,0) (0,0)\n(0,0) (0,0)") # input for the unitary decomposition needs to be an array def test_unitary_decompose_matrixinsteadofarray(self): @@ -296,7 +281,6 @@ def test_unitary_decompose_matrixinsteadofarray(self): - @unittest.skipIf(qx is None, "qxelarator not installed") def test_unitary_decompose_2qubit_CNOT(self): num_qubits = 2 p = ql.Program('test_unitary_2qubitCNOT', platform, num_qubits) @@ -315,24 +299,21 @@ def test_unitary_decompose_2qubit_CNOT(self): p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state #only two states are nonzero - self.assertAlmostEqual(helper_prob(matrix[0]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[4]), helper_regex(c0)[1], 5) + self.assertAlmostEqual(helper_prob(matrix[0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[4]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_unitary_decompose_2qubit_CNOT_2(self): num_qubits = 2 p = ql.Program('test_unitary_2qubitCNOT', platform, num_qubits) k = ql.Kernel('akernel', platform, num_qubits) - matrix = [ complex(1.0, 0.0), complex(0.0, 0.0), complex(0.0, 0.0), complex(0.0, 0.0), - complex(0.0, 0.0), complex(1.0, 0.0), complex(0.0, 0.0), complex(0.0, 0.0), - complex(0.0, 0.0), complex(0.0, 0.0), complex(0.0, 0.0), complex(1.0, 0.0), - complex(0.0, 0.0), complex(0.0, 0.0), complex(1.0, 0.0), complex(0.0, 0.0)] + matrix = [1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 0, 1, + 0, 0, 1, 0] u = ql.Unitary('cnot2',matrix) u.decompose() k.x(1) @@ -343,16 +324,11 @@ def test_unitary_decompose_2qubit_CNOT_2(self): p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - #only two states are nonzero - self.assertAlmostEqual(0.0, helper_regex(c0)[0], 5) - self.assertAlmostEqual(1.0, helper_regex(c0)[1], 5) + self.assertAlmostEqual(1.0, helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_non_90_degree_angle(self): num_qubits = 2 p = ql.Program('test_unitary_non_90_degree_angle', platform, num_qubits) @@ -372,15 +348,12 @@ def test_non_90_degree_angle(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - self.assertAlmostEqual(helper_prob(matrix[0]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[4]), helper_regex(c0)[1], 5) - self.assertAlmostEqual(helper_prob(matrix[8]), helper_regex(c0)[2], 5) - self.assertAlmostEqual(helper_prob(matrix[12]), helper_regex(c0)[3], 5) - - @unittest.skipIf(qx is None, "qxelarator not installed") + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + self.assertAlmostEqual(helper_prob(matrix[0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[4]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[8]), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[12]), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + def test_usingqx_00(self): num_qubits = 2 p = ql.Program('test_usingqx00', platform, num_qubits) @@ -403,17 +376,14 @@ def test_usingqx_00(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - self.assertAlmostEqual(helper_prob(matrix[0]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[4]), helper_regex(c0)[1], 5) - self.assertAlmostEqual(helper_prob(matrix[8]), helper_regex(c0)[2], 5) - self.assertAlmostEqual(helper_prob(matrix[12]), helper_regex(c0)[3], 5) + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + self.assertAlmostEqual(helper_prob(matrix[0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[4]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[8]), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[12]), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_usingqx_01(self): num_qubits = 2 p = ql.Program('test_usingqx01', platform, num_qubits) @@ -439,19 +409,16 @@ def test_usingqx_01(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(helper_prob(matrix[1]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[5]), helper_regex(c0)[1], 5) - self.assertAlmostEqual(helper_prob(matrix[9]), helper_regex(c0)[2], 5) - self.assertAlmostEqual(helper_prob(matrix[13]), helper_regex(c0)[3], 5) + self.assertAlmostEqual(helper_prob(matrix[1]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[5]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[9]), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[13]), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_usingqx_10(self): num_qubits = 2 p = ql.Program('test_usingqx10', platform, num_qubits) @@ -478,18 +445,15 @@ def test_usingqx_10(self): p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(helper_prob(matrix[2]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[6]), helper_regex(c0)[1], 5) - self.assertAlmostEqual(helper_prob(matrix[10]), helper_regex(c0)[2], 5) - self.assertAlmostEqual(helper_prob(matrix[14]), helper_regex(c0)[3], 5) + self.assertAlmostEqual(helper_prob(matrix[2]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[6]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[10]), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[14]), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_usingqx_11(self): num_qubits = 2 p = ql.Program('test_usingqx11', platform, num_qubits) @@ -516,16 +480,13 @@ def test_usingqx_11(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(helper_prob(matrix[3]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[7]), helper_regex(c0)[1], 5) - self.assertAlmostEqual(helper_prob(matrix[11]), helper_regex(c0)[2], 5) - self.assertAlmostEqual(helper_prob(matrix[15]), helper_regex(c0)[3], 5) + self.assertAlmostEqual(helper_prob(matrix[3]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[7]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[11]), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[15]), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_usingqx_bellstate(self): num_qubits = 2 p = ql.Program('test_usingqxbellstate', platform, num_qubits) @@ -553,17 +514,14 @@ def test_usingqx_bellstate(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(0.5*helper_prob((matrix[0]+ matrix[3])), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.5*helper_prob((matrix[4]+matrix[7])), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.5*helper_prob((matrix[8]+ matrix[11])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.5*helper_prob((matrix[12]+ matrix[15])), helper_regex(c0)[3], 5) + self.assertAlmostEqual(0.5*helper_prob((matrix[0]+ matrix[3])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.5*helper_prob((matrix[4]+matrix[7])), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.5*helper_prob((matrix[8]+ matrix[11])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.5*helper_prob((matrix[12]+ matrix[15])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_usingqx_fullyentangled(self): num_qubits = 2 p = ql.Program('test_usingqxfullentangled', platform, num_qubits) @@ -592,16 +550,13 @@ def test_usingqx_fullyentangled(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(0.25*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] )), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.25*helper_prob((matrix[4] + matrix[5] + matrix[6] + matrix[7] )), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.25*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.25*helper_prob((matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[3], 5) + self.assertAlmostEqual(0.25*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] )), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.25*helper_prob((matrix[4] + matrix[5] + matrix[6] + matrix[7] )), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.25*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.25*helper_prob((matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_usingqx_fullyentangled_3qubit(self): num_qubits = 3 p = ql.Program('test_usingqxfullentangled_3qubit', platform, num_qubits) @@ -655,20 +610,17 @@ def test_usingqx_fullyentangled_3qubit(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(0.125*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7])), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_regex(c0)[3], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39])), helper_regex(c0)[4], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_regex(c0)[5], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55])), helper_regex(c0)[6], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_regex(c0)[7], 5) - - @unittest.skipIf(qx is None, "qxelarator not installed") + self.assertAlmostEqual(0.125*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39])), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55])), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 5) + def test_usingqx_fullyentangled_4qubit(self): num_qubits = 4 p = ql.Program('test_usingqxfullentangled_4qubit', platform, num_qubits) @@ -726,30 +678,27 @@ def test_usingqx_fullyentangled_4qubit(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(0.0625*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7] + matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23]+ matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39]+ matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55]+ matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_regex(c0)[3], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[64] + matrix[65]+ matrix[66]+ matrix[67]+ matrix[68]+ matrix[69]+ matrix[70]+ matrix[71]+ matrix[72] + matrix[73]+ matrix[74]+ matrix[75]+ matrix[76]+ matrix[77]+ matrix[78]+ matrix[79])), helper_regex(c0)[4], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[80] + matrix[81]+ matrix[82]+ matrix[83]+ matrix[84]+ matrix[85]+ matrix[86]+ matrix[87]+ matrix[88] + matrix[89]+ matrix[90]+ matrix[91]+ matrix[92]+ matrix[93]+ matrix[94]+ matrix[95])), helper_regex(c0)[5], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[96] + matrix[97]+ matrix[98]+ matrix[99]+ matrix[100]+ matrix[101]+ matrix[102]+ matrix[103]+ matrix[104] + matrix[105]+ matrix[106]+ matrix[107]+ matrix[108]+ matrix[109]+ matrix[110]+ matrix[111])), helper_regex(c0)[6], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[112] + matrix[113]+ matrix[114]+ matrix[115]+ matrix[116]+ matrix[117]+ matrix[118]+ matrix[119]+ matrix[120] + matrix[121]+ matrix[122]+ matrix[123]+ matrix[124]+ matrix[125]+ matrix[126]+ matrix[127])), helper_regex(c0)[7], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[128] + matrix[129]+ matrix[130]+ matrix[131]+ matrix[132]+ matrix[133]+ matrix[134]+ matrix[135]+ matrix[136] + matrix[137]+ matrix[138]+ matrix[139]+ matrix[140]+ matrix[141]+ matrix[142]+ matrix[143])), helper_regex(c0)[8], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[144] + matrix[145]+ matrix[146]+ matrix[147]+ matrix[148]+ matrix[149]+ matrix[150]+ matrix[151]+ matrix[152] + matrix[153]+ matrix[154]+ matrix[155]+ matrix[156]+ matrix[157]+ matrix[158]+ matrix[159])), helper_regex(c0)[9], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[160] + matrix[161]+ matrix[162]+ matrix[163]+ matrix[164]+ matrix[165]+ matrix[166]+ matrix[167]+ matrix[168] + matrix[169]+ matrix[170]+ matrix[171]+ matrix[172]+ matrix[173]+ matrix[174]+ matrix[175])), helper_regex(c0)[10], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[176] + matrix[177]+ matrix[178]+ matrix[179]+ matrix[180]+ matrix[181]+ matrix[182]+ matrix[183]+ matrix[184] + matrix[185]+ matrix[186]+ matrix[187]+ matrix[188]+ matrix[189]+ matrix[190]+ matrix[191])), helper_regex(c0)[11], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[192] + matrix[193]+ matrix[194]+ matrix[195]+ matrix[196]+ matrix[197]+ matrix[198]+ matrix[199]+ matrix[200] + matrix[201]+ matrix[202]+ matrix[203]+ matrix[204]+ matrix[205]+ matrix[206]+ matrix[207])), helper_regex(c0)[12], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[208] + matrix[209]+ matrix[210]+ matrix[211]+ matrix[212]+ matrix[213]+ matrix[214]+ matrix[215]+ matrix[216] + matrix[217]+ matrix[218]+ matrix[219]+ matrix[220]+ matrix[221]+ matrix[222]+ matrix[223])), helper_regex(c0)[13], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[224] + matrix[225]+ matrix[226]+ matrix[227]+ matrix[228]+ matrix[229]+ matrix[230]+ matrix[231]+ matrix[232] + matrix[233]+ matrix[234]+ matrix[235]+ matrix[236]+ matrix[237]+ matrix[238]+ matrix[239])), helper_regex(c0)[14], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[240] + matrix[241]+ matrix[242]+ matrix[243]+ matrix[244]+ matrix[245]+ matrix[246]+ matrix[247]+ matrix[248] + matrix[249]+ matrix[250]+ matrix[251]+ matrix[252]+ matrix[253]+ matrix[254]+ matrix[255])), helper_regex(c0)[15], 5) - - - - @unittest.skipIf(qx is None, "qxelarator not installed") + self.assertAlmostEqual(0.0625*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7] + matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23]+ matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39]+ matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55]+ matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[64] + matrix[65]+ matrix[66]+ matrix[67]+ matrix[68]+ matrix[69]+ matrix[70]+ matrix[71]+ matrix[72] + matrix[73]+ matrix[74]+ matrix[75]+ matrix[76]+ matrix[77]+ matrix[78]+ matrix[79])), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[80] + matrix[81]+ matrix[82]+ matrix[83]+ matrix[84]+ matrix[85]+ matrix[86]+ matrix[87]+ matrix[88] + matrix[89]+ matrix[90]+ matrix[91]+ matrix[92]+ matrix[93]+ matrix[94]+ matrix[95])), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[96] + matrix[97]+ matrix[98]+ matrix[99]+ matrix[100]+ matrix[101]+ matrix[102]+ matrix[103]+ matrix[104] + matrix[105]+ matrix[106]+ matrix[107]+ matrix[108]+ matrix[109]+ matrix[110]+ matrix[111])), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[112] + matrix[113]+ matrix[114]+ matrix[115]+ matrix[116]+ matrix[117]+ matrix[118]+ matrix[119]+ matrix[120] + matrix[121]+ matrix[122]+ matrix[123]+ matrix[124]+ matrix[125]+ matrix[126]+ matrix[127])), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[128] + matrix[129]+ matrix[130]+ matrix[131]+ matrix[132]+ matrix[133]+ matrix[134]+ matrix[135]+ matrix[136] + matrix[137]+ matrix[138]+ matrix[139]+ matrix[140]+ matrix[141]+ matrix[142]+ matrix[143])), helper_prob(state.get(to_bitstring(8, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[144] + matrix[145]+ matrix[146]+ matrix[147]+ matrix[148]+ matrix[149]+ matrix[150]+ matrix[151]+ matrix[152] + matrix[153]+ matrix[154]+ matrix[155]+ matrix[156]+ matrix[157]+ matrix[158]+ matrix[159])), helper_prob(state.get(to_bitstring(9, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[160] + matrix[161]+ matrix[162]+ matrix[163]+ matrix[164]+ matrix[165]+ matrix[166]+ matrix[167]+ matrix[168] + matrix[169]+ matrix[170]+ matrix[171]+ matrix[172]+ matrix[173]+ matrix[174]+ matrix[175])), helper_prob(state.get(to_bitstring(10, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[176] + matrix[177]+ matrix[178]+ matrix[179]+ matrix[180]+ matrix[181]+ matrix[182]+ matrix[183]+ matrix[184] + matrix[185]+ matrix[186]+ matrix[187]+ matrix[188]+ matrix[189]+ matrix[190]+ matrix[191])), helper_prob(state.get(to_bitstring(11, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[192] + matrix[193]+ matrix[194]+ matrix[195]+ matrix[196]+ matrix[197]+ matrix[198]+ matrix[199]+ matrix[200] + matrix[201]+ matrix[202]+ matrix[203]+ matrix[204]+ matrix[205]+ matrix[206]+ matrix[207])), helper_prob(state.get(to_bitstring(12, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[208] + matrix[209]+ matrix[210]+ matrix[211]+ matrix[212]+ matrix[213]+ matrix[214]+ matrix[215]+ matrix[216] + matrix[217]+ matrix[218]+ matrix[219]+ matrix[220]+ matrix[221]+ matrix[222]+ matrix[223])), helper_prob(state.get(to_bitstring(13, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[224] + matrix[225]+ matrix[226]+ matrix[227]+ matrix[228]+ matrix[229]+ matrix[230]+ matrix[231]+ matrix[232] + matrix[233]+ matrix[234]+ matrix[235]+ matrix[236]+ matrix[237]+ matrix[238]+ matrix[239])), helper_prob(state.get(to_bitstring(14, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[240] + matrix[241]+ matrix[242]+ matrix[243]+ matrix[244]+ matrix[245]+ matrix[246]+ matrix[247]+ matrix[248] + matrix[249]+ matrix[250]+ matrix[251]+ matrix[252]+ matrix[253]+ matrix[254]+ matrix[255])), helper_prob(state.get(to_bitstring(15, size=platform_qubits), 0.)), 5) + + + def test_usingqx_fullyentangled_5qubit(self): num_qubits = 5 p = ql.Program('test_usingqxfullentangled_5qubit', platform, num_qubits) @@ -795,46 +744,43 @@ def test_usingqx_fullyentangled_5qubit(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - - - self.assertAlmostEqual(helper_prob(matrix[0]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[32]), helper_regex(c0)[1], 5) - self.assertAlmostEqual(helper_prob(matrix[64]), helper_regex(c0)[2], 5) - self.assertAlmostEqual(helper_prob(matrix[96]), helper_regex(c0)[3], 5) - self.assertAlmostEqual(helper_prob(matrix[128]), helper_regex(c0)[4], 5) - self.assertAlmostEqual(helper_prob(matrix[160]), helper_regex(c0)[5], 5) - self.assertAlmostEqual(helper_prob(matrix[192]), helper_regex(c0)[6], 5) - self.assertAlmostEqual(helper_prob(matrix[224]), helper_regex(c0)[7], 5) - self.assertAlmostEqual(helper_prob(matrix[256]), helper_regex(c0)[8], 5) - self.assertAlmostEqual(helper_prob(matrix[288]), helper_regex(c0)[9], 5) - self.assertAlmostEqual(helper_prob(matrix[320]), helper_regex(c0)[10], 5) - self.assertAlmostEqual(helper_prob(matrix[352]), helper_regex(c0)[11], 5) - self.assertAlmostEqual(helper_prob(matrix[384]), helper_regex(c0)[12], 5) - self.assertAlmostEqual(helper_prob(matrix[416]), helper_regex(c0)[13], 5) - self.assertAlmostEqual(helper_prob(matrix[448]), helper_regex(c0)[14], 5) - self.assertAlmostEqual(helper_prob(matrix[480]), helper_regex(c0)[15], 5) - self.assertAlmostEqual(helper_prob(matrix[512]), helper_regex(c0)[16], 5) - self.assertAlmostEqual(helper_prob(matrix[544]), helper_regex(c0)[17], 5) - self.assertAlmostEqual(helper_prob(matrix[576]), helper_regex(c0)[18], 5) - self.assertAlmostEqual(helper_prob(matrix[608]), helper_regex(c0)[19], 5) - self.assertAlmostEqual(helper_prob(matrix[640]), helper_regex(c0)[20], 5) - self.assertAlmostEqual(helper_prob(matrix[672]), helper_regex(c0)[21], 5) - self.assertAlmostEqual(helper_prob(matrix[704]), helper_regex(c0)[22], 5) - self.assertAlmostEqual(helper_prob(matrix[736]), helper_regex(c0)[23], 5) - self.assertAlmostEqual(helper_prob(matrix[768]), helper_regex(c0)[24], 5) - self.assertAlmostEqual(helper_prob(matrix[800]), helper_regex(c0)[25], 5) - self.assertAlmostEqual(helper_prob(matrix[832]), helper_regex(c0)[26], 5) - self.assertAlmostEqual(helper_prob(matrix[864]), helper_regex(c0)[27], 5) - self.assertAlmostEqual(helper_prob(matrix[896]), helper_regex(c0)[28], 5) - self.assertAlmostEqual(helper_prob(matrix[928]), helper_regex(c0)[29], 5) - self.assertAlmostEqual(helper_prob(matrix[960]), helper_regex(c0)[30], 5) - self.assertAlmostEqual(helper_prob(matrix[992]), helper_regex(c0)[31], 5) - - - @unittest.skipIf(qx is None, "qxelarator not installed") + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + + + self.assertAlmostEqual(helper_prob(matrix[0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[32]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[64]), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[96]), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[128]), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[160]), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[192]), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[224]), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[256]), helper_prob(state.get(to_bitstring(8, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[288]), helper_prob(state.get(to_bitstring(9, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[320]), helper_prob(state.get(to_bitstring(10, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[352]), helper_prob(state.get(to_bitstring(11, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[384]), helper_prob(state.get(to_bitstring(12, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[416]), helper_prob(state.get(to_bitstring(13, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[448]), helper_prob(state.get(to_bitstring(14, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[480]), helper_prob(state.get(to_bitstring(15, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[512]), helper_prob(state.get(to_bitstring(16, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[544]), helper_prob(state.get(to_bitstring(17, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[576]), helper_prob(state.get(to_bitstring(18, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[608]), helper_prob(state.get(to_bitstring(19, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[640]), helper_prob(state.get(to_bitstring(20, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[672]), helper_prob(state.get(to_bitstring(21, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[704]), helper_prob(state.get(to_bitstring(22, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[736]), helper_prob(state.get(to_bitstring(23, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[768]), helper_prob(state.get(to_bitstring(24, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[800]), helper_prob(state.get(to_bitstring(25, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[832]), helper_prob(state.get(to_bitstring(26, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[864]), helper_prob(state.get(to_bitstring(27, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[896]), helper_prob(state.get(to_bitstring(28, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[928]), helper_prob(state.get(to_bitstring(29, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[960]), helper_prob(state.get(to_bitstring(30, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[992]), helper_prob(state.get(to_bitstring(31, size=platform_qubits), 0.)), 5) + + def test_usingqx_fullyentangled_5qubit_10011(self): num_qubits = 5 p = ql.Program('test_usingqxfullentangled_5qubit_10011', platform, num_qubits) @@ -884,43 +830,41 @@ def test_usingqx_fullyentangled_5qubit_10011(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - - - self.assertAlmostEqual(helper_prob(matrix[19+0]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[19+32]), helper_regex(c0)[1], 5) - self.assertAlmostEqual(helper_prob(matrix[19+64]), helper_regex(c0)[2], 5) - self.assertAlmostEqual(helper_prob(matrix[19+96]), helper_regex(c0)[3], 5) - self.assertAlmostEqual(helper_prob(matrix[19+128]), helper_regex(c0)[4], 5) - self.assertAlmostEqual(helper_prob(matrix[19+160]), helper_regex(c0)[5], 5) - self.assertAlmostEqual(helper_prob(matrix[19+192]), helper_regex(c0)[6], 5) - self.assertAlmostEqual(helper_prob(matrix[19+224]), helper_regex(c0)[7], 5) - self.assertAlmostEqual(helper_prob(matrix[19+256]), helper_regex(c0)[8], 5) - self.assertAlmostEqual(helper_prob(matrix[19+288]), helper_regex(c0)[9], 5) - self.assertAlmostEqual(helper_prob(matrix[19+320]), helper_regex(c0)[10], 5) - self.assertAlmostEqual(helper_prob(matrix[19+352]), helper_regex(c0)[11], 5) - self.assertAlmostEqual(helper_prob(matrix[19+384]), helper_regex(c0)[12], 5) - self.assertAlmostEqual(helper_prob(matrix[19+416]), helper_regex(c0)[13], 5) - self.assertAlmostEqual(helper_prob(matrix[19+448]), helper_regex(c0)[14], 5) - self.assertAlmostEqual(helper_prob(matrix[19+480]), helper_regex(c0)[15], 5) - self.assertAlmostEqual(helper_prob(matrix[19+512]), helper_regex(c0)[16], 5) - self.assertAlmostEqual(helper_prob(matrix[19+544]), helper_regex(c0)[17], 5) - self.assertAlmostEqual(helper_prob(matrix[19+576]), helper_regex(c0)[18], 5) - self.assertAlmostEqual(helper_prob(matrix[19+608]), helper_regex(c0)[19], 5) - self.assertAlmostEqual(helper_prob(matrix[19+640]), helper_regex(c0)[20], 5) - self.assertAlmostEqual(helper_prob(matrix[19+672]), helper_regex(c0)[21], 5) - self.assertAlmostEqual(helper_prob(matrix[19+704]), helper_regex(c0)[22], 5) - self.assertAlmostEqual(helper_prob(matrix[19+736]), helper_regex(c0)[23], 5) - self.assertAlmostEqual(helper_prob(matrix[19+768]), helper_regex(c0)[24], 5) - self.assertAlmostEqual(helper_prob(matrix[19+800]), helper_regex(c0)[25], 5) - self.assertAlmostEqual(helper_prob(matrix[19+832]), helper_regex(c0)[26], 5) - self.assertAlmostEqual(helper_prob(matrix[19+864]), helper_regex(c0)[27], 5) - self.assertAlmostEqual(helper_prob(matrix[19+896]), helper_regex(c0)[28], 5) - self.assertAlmostEqual(helper_prob(matrix[19+928]), helper_regex(c0)[29], 5) - self.assertAlmostEqual(helper_prob(matrix[19+960]), helper_regex(c0)[30], 5) - self.assertAlmostEqual(helper_prob(matrix[19+992]), helper_regex(c0)[31], 5) + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + + + self.assertAlmostEqual(helper_prob(matrix[19+0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+32]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+64]), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+96]), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+128]), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+160]), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+192]), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+224]), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+256]), helper_prob(state.get(to_bitstring(8, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+288]), helper_prob(state.get(to_bitstring(9, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+320]), helper_prob(state.get(to_bitstring(10, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+352]), helper_prob(state.get(to_bitstring(11, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+384]), helper_prob(state.get(to_bitstring(12, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+416]), helper_prob(state.get(to_bitstring(13, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+448]), helper_prob(state.get(to_bitstring(14, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+480]), helper_prob(state.get(to_bitstring(15, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+512]), helper_prob(state.get(to_bitstring(16, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+544]), helper_prob(state.get(to_bitstring(17, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+576]), helper_prob(state.get(to_bitstring(18, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+608]), helper_prob(state.get(to_bitstring(19, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+640]), helper_prob(state.get(to_bitstring(20, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+672]), helper_prob(state.get(to_bitstring(21, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+704]), helper_prob(state.get(to_bitstring(22, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+736]), helper_prob(state.get(to_bitstring(23, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+768]), helper_prob(state.get(to_bitstring(24, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+800]), helper_prob(state.get(to_bitstring(25, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+832]), helper_prob(state.get(to_bitstring(26, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+864]), helper_prob(state.get(to_bitstring(27, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+896]), helper_prob(state.get(to_bitstring(28, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+928]), helper_prob(state.get(to_bitstring(29, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+960]), helper_prob(state.get(to_bitstring(30, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[19+992]), helper_prob(state.get(to_bitstring(31, size=platform_qubits), 0.)), 5) def test_adding2tothepower6unitary(self): num_qubits = 6 @@ -1069,7 +1013,6 @@ def test_adding2tothepower6unitary(self): - @unittest.skipIf(qx is None, "qxelarator not installed") def test_usingqx_sparseunitary(self): num_qubits = 5 p = ql.Program('test_usingqxsparseunitary', platform, num_qubits) @@ -1127,29 +1070,26 @@ def test_usingqx_sparseunitary(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(0.0625*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7] + matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23]+ matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39]+ matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55]+ matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_regex(c0)[3], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[64] + matrix[65]+ matrix[66]+ matrix[67]+ matrix[68]+ matrix[69]+ matrix[70]+ matrix[71]+ matrix[72] + matrix[73]+ matrix[74]+ matrix[75]+ matrix[76]+ matrix[77]+ matrix[78]+ matrix[79])), helper_regex(c0)[4], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[80] + matrix[81]+ matrix[82]+ matrix[83]+ matrix[84]+ matrix[85]+ matrix[86]+ matrix[87]+ matrix[88] + matrix[89]+ matrix[90]+ matrix[91]+ matrix[92]+ matrix[93]+ matrix[94]+ matrix[95])), helper_regex(c0)[5], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[96] + matrix[97]+ matrix[98]+ matrix[99]+ matrix[100]+ matrix[101]+ matrix[102]+ matrix[103]+ matrix[104] + matrix[105]+ matrix[106]+ matrix[107]+ matrix[108]+ matrix[109]+ matrix[110]+ matrix[111])), helper_regex(c0)[6], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[112] + matrix[113]+ matrix[114]+ matrix[115]+ matrix[116]+ matrix[117]+ matrix[118]+ matrix[119]+ matrix[120] + matrix[121]+ matrix[122]+ matrix[123]+ matrix[124]+ matrix[125]+ matrix[126]+ matrix[127])), helper_regex(c0)[7], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[128] + matrix[129]+ matrix[130]+ matrix[131]+ matrix[132]+ matrix[133]+ matrix[134]+ matrix[135]+ matrix[136] + matrix[137]+ matrix[138]+ matrix[139]+ matrix[140]+ matrix[141]+ matrix[142]+ matrix[143])), helper_regex(c0)[8], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[144] + matrix[145]+ matrix[146]+ matrix[147]+ matrix[148]+ matrix[149]+ matrix[150]+ matrix[151]+ matrix[152] + matrix[153]+ matrix[154]+ matrix[155]+ matrix[156]+ matrix[157]+ matrix[158]+ matrix[159])), helper_regex(c0)[9], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[160] + matrix[161]+ matrix[162]+ matrix[163]+ matrix[164]+ matrix[165]+ matrix[166]+ matrix[167]+ matrix[168] + matrix[169]+ matrix[170]+ matrix[171]+ matrix[172]+ matrix[173]+ matrix[174]+ matrix[175])), helper_regex(c0)[10], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[176] + matrix[177]+ matrix[178]+ matrix[179]+ matrix[180]+ matrix[181]+ matrix[182]+ matrix[183]+ matrix[184] + matrix[185]+ matrix[186]+ matrix[187]+ matrix[188]+ matrix[189]+ matrix[190]+ matrix[191])), helper_regex(c0)[11], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[192] + matrix[193]+ matrix[194]+ matrix[195]+ matrix[196]+ matrix[197]+ matrix[198]+ matrix[199]+ matrix[200] + matrix[201]+ matrix[202]+ matrix[203]+ matrix[204]+ matrix[205]+ matrix[206]+ matrix[207])), helper_regex(c0)[12], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[208] + matrix[209]+ matrix[210]+ matrix[211]+ matrix[212]+ matrix[213]+ matrix[214]+ matrix[215]+ matrix[216] + matrix[217]+ matrix[218]+ matrix[219]+ matrix[220]+ matrix[221]+ matrix[222]+ matrix[223])), helper_regex(c0)[13], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[224] + matrix[225]+ matrix[226]+ matrix[227]+ matrix[228]+ matrix[229]+ matrix[230]+ matrix[231]+ matrix[232] + matrix[233]+ matrix[234]+ matrix[235]+ matrix[236]+ matrix[237]+ matrix[238]+ matrix[239])), helper_regex(c0)[14], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[240] + matrix[241]+ matrix[242]+ matrix[243]+ matrix[244]+ matrix[245]+ matrix[246]+ matrix[247]+ matrix[248] + matrix[249]+ matrix[250]+ matrix[251]+ matrix[252]+ matrix[253]+ matrix[254]+ matrix[255])), helper_regex(c0)[15], 5) - - - @unittest.skipIf(qx is None, "qxelarator not installed") + self.assertAlmostEqual(0.0625*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7] + matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23]+ matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39]+ matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55]+ matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[64] + matrix[65]+ matrix[66]+ matrix[67]+ matrix[68]+ matrix[69]+ matrix[70]+ matrix[71]+ matrix[72] + matrix[73]+ matrix[74]+ matrix[75]+ matrix[76]+ matrix[77]+ matrix[78]+ matrix[79])), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[80] + matrix[81]+ matrix[82]+ matrix[83]+ matrix[84]+ matrix[85]+ matrix[86]+ matrix[87]+ matrix[88] + matrix[89]+ matrix[90]+ matrix[91]+ matrix[92]+ matrix[93]+ matrix[94]+ matrix[95])), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[96] + matrix[97]+ matrix[98]+ matrix[99]+ matrix[100]+ matrix[101]+ matrix[102]+ matrix[103]+ matrix[104] + matrix[105]+ matrix[106]+ matrix[107]+ matrix[108]+ matrix[109]+ matrix[110]+ matrix[111])), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[112] + matrix[113]+ matrix[114]+ matrix[115]+ matrix[116]+ matrix[117]+ matrix[118]+ matrix[119]+ matrix[120] + matrix[121]+ matrix[122]+ matrix[123]+ matrix[124]+ matrix[125]+ matrix[126]+ matrix[127])), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[128] + matrix[129]+ matrix[130]+ matrix[131]+ matrix[132]+ matrix[133]+ matrix[134]+ matrix[135]+ matrix[136] + matrix[137]+ matrix[138]+ matrix[139]+ matrix[140]+ matrix[141]+ matrix[142]+ matrix[143])), helper_prob(state.get(to_bitstring(8, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[144] + matrix[145]+ matrix[146]+ matrix[147]+ matrix[148]+ matrix[149]+ matrix[150]+ matrix[151]+ matrix[152] + matrix[153]+ matrix[154]+ matrix[155]+ matrix[156]+ matrix[157]+ matrix[158]+ matrix[159])), helper_prob(state.get(to_bitstring(9, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[160] + matrix[161]+ matrix[162]+ matrix[163]+ matrix[164]+ matrix[165]+ matrix[166]+ matrix[167]+ matrix[168] + matrix[169]+ matrix[170]+ matrix[171]+ matrix[172]+ matrix[173]+ matrix[174]+ matrix[175])), helper_prob(state.get(to_bitstring(10, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[176] + matrix[177]+ matrix[178]+ matrix[179]+ matrix[180]+ matrix[181]+ matrix[182]+ matrix[183]+ matrix[184] + matrix[185]+ matrix[186]+ matrix[187]+ matrix[188]+ matrix[189]+ matrix[190]+ matrix[191])), helper_prob(state.get(to_bitstring(11, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[192] + matrix[193]+ matrix[194]+ matrix[195]+ matrix[196]+ matrix[197]+ matrix[198]+ matrix[199]+ matrix[200] + matrix[201]+ matrix[202]+ matrix[203]+ matrix[204]+ matrix[205]+ matrix[206]+ matrix[207])), helper_prob(state.get(to_bitstring(12, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[208] + matrix[209]+ matrix[210]+ matrix[211]+ matrix[212]+ matrix[213]+ matrix[214]+ matrix[215]+ matrix[216] + matrix[217]+ matrix[218]+ matrix[219]+ matrix[220]+ matrix[221]+ matrix[222]+ matrix[223])), helper_prob(state.get(to_bitstring(13, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[224] + matrix[225]+ matrix[226]+ matrix[227]+ matrix[228]+ matrix[229]+ matrix[230]+ matrix[231]+ matrix[232] + matrix[233]+ matrix[234]+ matrix[235]+ matrix[236]+ matrix[237]+ matrix[238]+ matrix[239])), helper_prob(state.get(to_bitstring(14, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[240] + matrix[241]+ matrix[242]+ matrix[243]+ matrix[244]+ matrix[245]+ matrix[246]+ matrix[247]+ matrix[248] + matrix[249]+ matrix[250]+ matrix[251]+ matrix[252]+ matrix[253]+ matrix[254]+ matrix[255])), helper_prob(state.get(to_bitstring(15, size=platform_qubits), 0.)), 5) + + def test_extremelysparseunitary(self): num_qubits = 4 p = ql.Program('test_usingqx_extremelysparseunitary_newname', platform, num_qubits) @@ -1192,28 +1132,25 @@ def test_extremelysparseunitary(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(0.0625*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7] + matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23]+ matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39]+ matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55]+ matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_regex(c0)[3], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[64] + matrix[65]+ matrix[66]+ matrix[67]+ matrix[68]+ matrix[69]+ matrix[70]+ matrix[71]+ matrix[72] + matrix[73]+ matrix[74]+ matrix[75]+ matrix[76]+ matrix[77]+ matrix[78]+ matrix[79])), helper_regex(c0)[4], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[80] + matrix[81]+ matrix[82]+ matrix[83]+ matrix[84]+ matrix[85]+ matrix[86]+ matrix[87]+ matrix[88] + matrix[89]+ matrix[90]+ matrix[91]+ matrix[92]+ matrix[93]+ matrix[94]+ matrix[95])), helper_regex(c0)[5], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[96] + matrix[97]+ matrix[98]+ matrix[99]+ matrix[100]+ matrix[101]+ matrix[102]+ matrix[103]+ matrix[104] + matrix[105]+ matrix[106]+ matrix[107]+ matrix[108]+ matrix[109]+ matrix[110]+ matrix[111])), helper_regex(c0)[6], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[112] + matrix[113]+ matrix[114]+ matrix[115]+ matrix[116]+ matrix[117]+ matrix[118]+ matrix[119]+ matrix[120] + matrix[121]+ matrix[122]+ matrix[123]+ matrix[124]+ matrix[125]+ matrix[126]+ matrix[127])), helper_regex(c0)[7], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[128] + matrix[129]+ matrix[130]+ matrix[131]+ matrix[132]+ matrix[133]+ matrix[134]+ matrix[135]+ matrix[136] + matrix[137]+ matrix[138]+ matrix[139]+ matrix[140]+ matrix[141]+ matrix[142]+ matrix[143])), helper_regex(c0)[8], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[144] + matrix[145]+ matrix[146]+ matrix[147]+ matrix[148]+ matrix[149]+ matrix[150]+ matrix[151]+ matrix[152] + matrix[153]+ matrix[154]+ matrix[155]+ matrix[156]+ matrix[157]+ matrix[158]+ matrix[159])), helper_regex(c0)[9], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[160] + matrix[161]+ matrix[162]+ matrix[163]+ matrix[164]+ matrix[165]+ matrix[166]+ matrix[167]+ matrix[168] + matrix[169]+ matrix[170]+ matrix[171]+ matrix[172]+ matrix[173]+ matrix[174]+ matrix[175])), helper_regex(c0)[10], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[176] + matrix[177]+ matrix[178]+ matrix[179]+ matrix[180]+ matrix[181]+ matrix[182]+ matrix[183]+ matrix[184] + matrix[185]+ matrix[186]+ matrix[187]+ matrix[188]+ matrix[189]+ matrix[190]+ matrix[191])), helper_regex(c0)[11], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[192] + matrix[193]+ matrix[194]+ matrix[195]+ matrix[196]+ matrix[197]+ matrix[198]+ matrix[199]+ matrix[200] + matrix[201]+ matrix[202]+ matrix[203]+ matrix[204]+ matrix[205]+ matrix[206]+ matrix[207])), helper_regex(c0)[12], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[208] + matrix[209]+ matrix[210]+ matrix[211]+ matrix[212]+ matrix[213]+ matrix[214]+ matrix[215]+ matrix[216] + matrix[217]+ matrix[218]+ matrix[219]+ matrix[220]+ matrix[221]+ matrix[222]+ matrix[223])), helper_regex(c0)[13], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[224] + matrix[225]+ matrix[226]+ matrix[227]+ matrix[228]+ matrix[229]+ matrix[230]+ matrix[231]+ matrix[232] + matrix[233]+ matrix[234]+ matrix[235]+ matrix[236]+ matrix[237]+ matrix[238]+ matrix[239])), helper_regex(c0)[14], 5) - self.assertAlmostEqual(0.0625*helper_prob((matrix[240] + matrix[241]+ matrix[242]+ matrix[243]+ matrix[244]+ matrix[245]+ matrix[246]+ matrix[247]+ matrix[248] + matrix[249]+ matrix[250]+ matrix[251]+ matrix[252]+ matrix[253]+ matrix[254]+ matrix[255])), helper_regex(c0)[15], 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7] + matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23]+ matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39]+ matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55]+ matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[64] + matrix[65]+ matrix[66]+ matrix[67]+ matrix[68]+ matrix[69]+ matrix[70]+ matrix[71]+ matrix[72] + matrix[73]+ matrix[74]+ matrix[75]+ matrix[76]+ matrix[77]+ matrix[78]+ matrix[79])), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[80] + matrix[81]+ matrix[82]+ matrix[83]+ matrix[84]+ matrix[85]+ matrix[86]+ matrix[87]+ matrix[88] + matrix[89]+ matrix[90]+ matrix[91]+ matrix[92]+ matrix[93]+ matrix[94]+ matrix[95])), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[96] + matrix[97]+ matrix[98]+ matrix[99]+ matrix[100]+ matrix[101]+ matrix[102]+ matrix[103]+ matrix[104] + matrix[105]+ matrix[106]+ matrix[107]+ matrix[108]+ matrix[109]+ matrix[110]+ matrix[111])), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[112] + matrix[113]+ matrix[114]+ matrix[115]+ matrix[116]+ matrix[117]+ matrix[118]+ matrix[119]+ matrix[120] + matrix[121]+ matrix[122]+ matrix[123]+ matrix[124]+ matrix[125]+ matrix[126]+ matrix[127])), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[128] + matrix[129]+ matrix[130]+ matrix[131]+ matrix[132]+ matrix[133]+ matrix[134]+ matrix[135]+ matrix[136] + matrix[137]+ matrix[138]+ matrix[139]+ matrix[140]+ matrix[141]+ matrix[142]+ matrix[143])), helper_prob(state.get(to_bitstring(8, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[144] + matrix[145]+ matrix[146]+ matrix[147]+ matrix[148]+ matrix[149]+ matrix[150]+ matrix[151]+ matrix[152] + matrix[153]+ matrix[154]+ matrix[155]+ matrix[156]+ matrix[157]+ matrix[158]+ matrix[159])), helper_prob(state.get(to_bitstring(9, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[160] + matrix[161]+ matrix[162]+ matrix[163]+ matrix[164]+ matrix[165]+ matrix[166]+ matrix[167]+ matrix[168] + matrix[169]+ matrix[170]+ matrix[171]+ matrix[172]+ matrix[173]+ matrix[174]+ matrix[175])), helper_prob(state.get(to_bitstring(10, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[176] + matrix[177]+ matrix[178]+ matrix[179]+ matrix[180]+ matrix[181]+ matrix[182]+ matrix[183]+ matrix[184] + matrix[185]+ matrix[186]+ matrix[187]+ matrix[188]+ matrix[189]+ matrix[190]+ matrix[191])), helper_prob(state.get(to_bitstring(11, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[192] + matrix[193]+ matrix[194]+ matrix[195]+ matrix[196]+ matrix[197]+ matrix[198]+ matrix[199]+ matrix[200] + matrix[201]+ matrix[202]+ matrix[203]+ matrix[204]+ matrix[205]+ matrix[206]+ matrix[207])), helper_prob(state.get(to_bitstring(12, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[208] + matrix[209]+ matrix[210]+ matrix[211]+ matrix[212]+ matrix[213]+ matrix[214]+ matrix[215]+ matrix[216] + matrix[217]+ matrix[218]+ matrix[219]+ matrix[220]+ matrix[221]+ matrix[222]+ matrix[223])), helper_prob(state.get(to_bitstring(13, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[224] + matrix[225]+ matrix[226]+ matrix[227]+ matrix[228]+ matrix[229]+ matrix[230]+ matrix[231]+ matrix[232] + matrix[233]+ matrix[234]+ matrix[235]+ matrix[236]+ matrix[237]+ matrix[238]+ matrix[239])), helper_prob(state.get(to_bitstring(14, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.0625*helper_prob((matrix[240] + matrix[241]+ matrix[242]+ matrix[243]+ matrix[244]+ matrix[245]+ matrix[246]+ matrix[247]+ matrix[248] + matrix[249]+ matrix[250]+ matrix[251]+ matrix[252]+ matrix[253]+ matrix[254]+ matrix[255])), helper_prob(state.get(to_bitstring(15, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_sparse2qubitunitary(self): num_qubits = 2 p = ql.Program('test_usingqx_sparse2qubit', platform, num_qubits) @@ -1233,18 +1170,15 @@ def test_sparse2qubitunitary(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(helper_prob(matrix[0]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[4]), helper_regex(c0)[1], 5) + self.assertAlmostEqual(helper_prob(matrix[0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[4]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) self.assertAlmostEqual(helper_prob(matrix[8]), 0, 5) # Zero probabilities do not show up in the output list self.assertAlmostEqual(helper_prob(matrix[12]), 0, 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_sparse2qubitunitaryotherqubit(self): num_qubits = 2 p = ql.Program('test_usingqx_sparse2qubitotherqubit', platform, num_qubits) @@ -1264,17 +1198,14 @@ def test_sparse2qubitunitaryotherqubit(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(helper_prob(matrix[0]), helper_regex(c0)[0], 5) + self.assertAlmostEqual(helper_prob(matrix[0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) self.assertAlmostEqual(helper_prob(matrix[4]), 0, 5) # Zero probabilities do not show up in the output list - self.assertAlmostEqual(helper_prob(matrix[8]), helper_regex(c0)[1], 5) + self.assertAlmostEqual(helper_prob(matrix[8]), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) self.assertAlmostEqual(helper_prob(matrix[12]), 0, 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_sparse2qubitunitaryotherqubitcheck(self): num_qubits = 1 p = ql.Program('test_usingqx_sparse2qubitotherqubit_test', platform, num_qubits) @@ -1291,15 +1222,12 @@ def test_sparse2qubitunitaryotherqubitcheck(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(helper_prob(matrix[0]), helper_regex(c0)[0], 5) - self.assertAlmostEqual(helper_prob(matrix[1]), helper_regex(c0)[1], 5) # Zero probabilities do not show up in the output list + self.assertAlmostEqual(helper_prob(matrix[0]), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(helper_prob(matrix[1]), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) # Zero probabilities do not show up in the output list - @unittest.skipIf(qx is None, "qxelarator not installed") def test_sparse2qubit_multiplexor(self): num_qubits = 2 p = ql.Program('test_usingqx_sparse2qubit_multiplexor', platform, num_qubits) @@ -1319,17 +1247,14 @@ def test_sparse2qubit_multiplexor(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state - self.assertAlmostEqual(0.25*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] )), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.25*helper_prob((matrix[4] + matrix[5] + matrix[6] + matrix[7] )), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.25*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.25*helper_prob((matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[3], 5) + self.assertAlmostEqual(0.25*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] )), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.25*helper_prob((matrix[4] + matrix[5] + matrix[6] + matrix[7] )), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.25*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.25*helper_prob((matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_decomposition_rotatedtoffoli(self): num_qubits = 3 p = ql.Program('test_usingqx_rotatedtoffoli', platform, num_qubits) @@ -1357,20 +1282,17 @@ def test_decomposition_rotatedtoffoli(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - - self.assertAlmostEqual(0.125*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7])), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_regex(c0)[3], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39])), helper_regex(c0)[4], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_regex(c0)[5], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55])), helper_regex(c0)[6], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_regex(c0)[7], 5) - - @unittest.skipIf(qx is None, "qxelarator not installed") + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + + self.assertAlmostEqual(0.125*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39])), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55])), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 5) + def test_decomposition_toffoli(self): num_qubits = 3 p = ql.Program('test_usingqx_toffoli', platform, num_qubits) @@ -1396,21 +1318,17 @@ def test_decomposition_toffoli(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - - self.assertAlmostEqual(0.125*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7])), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_regex(c0)[3], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39])), helper_regex(c0)[4], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_regex(c0)[5], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55])), helper_regex(c0)[6], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_regex(c0)[7], 5) + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + self.assertAlmostEqual(0.125*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39])), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55])), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_decomposition_controlled_U(self): num_qubits = 3 p = ql.Program('test_usingqx_toffoli', platform, num_qubits) @@ -1437,20 +1355,17 @@ def test_decomposition_controlled_U(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() - - self.assertAlmostEqual(0.125*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7])), helper_regex(c0)[0], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[1], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23])), helper_regex(c0)[2], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_regex(c0)[3], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39])), helper_regex(c0)[4], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_regex(c0)[5], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55])), helper_regex(c0)[6], 5) - self.assertAlmostEqual(0.125*helper_prob((matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_regex(c0)[7], 5) + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state + print(state) + self.assertAlmostEqual(0.125*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39])), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55])), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 5) + self.assertAlmostEqual(0.125*helper_prob((matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 5) - @unittest.skipIf(qx is None, "qxelarator not installed") def test_decomposition_mscthesisaritra(self): num_qubits = 4 p = ql.Program('test_usingqx_mscthesisaritra', platform, num_qubits) @@ -1486,27 +1401,25 @@ def test_decomposition_mscthesisaritra(self): p.get_compiler().set_option('initialqasmwriter.cqasm_version', '1.0') p.get_compiler().set_option('initialqasmwriter.with_metadata', 'no') p.compile() - qx.set(os.path.join(output_dir, p.name+'.qasm')) - qx.execute() - c0 = qx.get_state() + state = qxelarator.execute_file(os.path.join(output_dir, p.name+'.qasm')).state # less accuracy because of less accurate input - self.assertAlmostEqual(0.0625*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7] + matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_regex(c0)[0], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23]+ matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_regex(c0)[1], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39]+ matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_regex(c0)[2], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55]+ matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_regex(c0)[3], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[64] + matrix[65]+ matrix[66]+ matrix[67]+ matrix[68]+ matrix[69]+ matrix[70]+ matrix[71]+ matrix[72] + matrix[73]+ matrix[74]+ matrix[75]+ matrix[76]+ matrix[77]+ matrix[78]+ matrix[79])), helper_regex(c0)[4], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[80] + matrix[81]+ matrix[82]+ matrix[83]+ matrix[84]+ matrix[85]+ matrix[86]+ matrix[87]+ matrix[88] + matrix[89]+ matrix[90]+ matrix[91]+ matrix[92]+ matrix[93]+ matrix[94]+ matrix[95])), helper_regex(c0)[5], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[96] + matrix[97]+ matrix[98]+ matrix[99]+ matrix[100]+ matrix[101]+ matrix[102]+ matrix[103]+ matrix[104] + matrix[105]+ matrix[106]+ matrix[107]+ matrix[108]+ matrix[109]+ matrix[110]+ matrix[111])), helper_regex(c0)[6], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[112] + matrix[113]+ matrix[114]+ matrix[115]+ matrix[116]+ matrix[117]+ matrix[118]+ matrix[119]+ matrix[120] + matrix[121]+ matrix[122]+ matrix[123]+ matrix[124]+ matrix[125]+ matrix[126]+ matrix[127])), helper_regex(c0)[7], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[128] + matrix[129]+ matrix[130]+ matrix[131]+ matrix[132]+ matrix[133]+ matrix[134]+ matrix[135]+ matrix[136] + matrix[137]+ matrix[138]+ matrix[139]+ matrix[140]+ matrix[141]+ matrix[142]+ matrix[143])), helper_regex(c0)[8], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[144] + matrix[145]+ matrix[146]+ matrix[147]+ matrix[148]+ matrix[149]+ matrix[150]+ matrix[151]+ matrix[152] + matrix[153]+ matrix[154]+ matrix[155]+ matrix[156]+ matrix[157]+ matrix[158]+ matrix[159])), helper_regex(c0)[9], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[160] + matrix[161]+ matrix[162]+ matrix[163]+ matrix[164]+ matrix[165]+ matrix[166]+ matrix[167]+ matrix[168] + matrix[169]+ matrix[170]+ matrix[171]+ matrix[172]+ matrix[173]+ matrix[174]+ matrix[175])), helper_regex(c0)[10], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[176] + matrix[177]+ matrix[178]+ matrix[179]+ matrix[180]+ matrix[181]+ matrix[182]+ matrix[183]+ matrix[184] + matrix[185]+ matrix[186]+ matrix[187]+ matrix[188]+ matrix[189]+ matrix[190]+ matrix[191])), helper_regex(c0)[11], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[192] + matrix[193]+ matrix[194]+ matrix[195]+ matrix[196]+ matrix[197]+ matrix[198]+ matrix[199]+ matrix[200] + matrix[201]+ matrix[202]+ matrix[203]+ matrix[204]+ matrix[205]+ matrix[206]+ matrix[207])), helper_regex(c0)[12], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[208] + matrix[209]+ matrix[210]+ matrix[211]+ matrix[212]+ matrix[213]+ matrix[214]+ matrix[215]+ matrix[216] + matrix[217]+ matrix[218]+ matrix[219]+ matrix[220]+ matrix[221]+ matrix[222]+ matrix[223])), helper_regex(c0)[13], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[224] + matrix[225]+ matrix[226]+ matrix[227]+ matrix[228]+ matrix[229]+ matrix[230]+ matrix[231]+ matrix[232] + matrix[233]+ matrix[234]+ matrix[235]+ matrix[236]+ matrix[237]+ matrix[238]+ matrix[239])), helper_regex(c0)[14], 2) - self.assertAlmostEqual(0.0625*helper_prob((matrix[240] + matrix[241]+ matrix[242]+ matrix[243]+ matrix[244]+ matrix[245]+ matrix[246]+ matrix[247]+ matrix[248] + matrix[249]+ matrix[250]+ matrix[251]+ matrix[252]+ matrix[253]+ matrix[254]+ matrix[255])), helper_regex(c0)[15], 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[0] + matrix[1] + matrix[2] + matrix[3] + matrix[4] + matrix[5] + matrix[6] + matrix[7] + matrix[8] + matrix[9] + matrix[10]+ matrix[11]+ matrix[12]+ matrix[13]+ matrix[14]+ matrix[15])), helper_prob(state.get(to_bitstring(0, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[16] + matrix[17]+ matrix[18]+ matrix[19]+ matrix[20]+ matrix[21]+ matrix[22]+ matrix[23]+ matrix[24] + matrix[25]+ matrix[26]+ matrix[27]+ matrix[28]+ matrix[29]+ matrix[30]+ matrix[31])), helper_prob(state.get(to_bitstring(1, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[32] + matrix[33]+ matrix[34]+ matrix[35]+ matrix[36]+ matrix[37]+ matrix[38]+ matrix[39]+ matrix[40] + matrix[41]+ matrix[42]+ matrix[43]+ matrix[44]+ matrix[45]+ matrix[46]+ matrix[47])), helper_prob(state.get(to_bitstring(2, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[48] + matrix[49]+ matrix[50]+ matrix[51]+ matrix[52]+ matrix[53]+ matrix[54]+ matrix[55]+ matrix[56] + matrix[57]+ matrix[58]+ matrix[59]+ matrix[60]+ matrix[61]+ matrix[62]+ matrix[63])), helper_prob(state.get(to_bitstring(3, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[64] + matrix[65]+ matrix[66]+ matrix[67]+ matrix[68]+ matrix[69]+ matrix[70]+ matrix[71]+ matrix[72] + matrix[73]+ matrix[74]+ matrix[75]+ matrix[76]+ matrix[77]+ matrix[78]+ matrix[79])), helper_prob(state.get(to_bitstring(4, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[80] + matrix[81]+ matrix[82]+ matrix[83]+ matrix[84]+ matrix[85]+ matrix[86]+ matrix[87]+ matrix[88] + matrix[89]+ matrix[90]+ matrix[91]+ matrix[92]+ matrix[93]+ matrix[94]+ matrix[95])), helper_prob(state.get(to_bitstring(5, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[96] + matrix[97]+ matrix[98]+ matrix[99]+ matrix[100]+ matrix[101]+ matrix[102]+ matrix[103]+ matrix[104] + matrix[105]+ matrix[106]+ matrix[107]+ matrix[108]+ matrix[109]+ matrix[110]+ matrix[111])), helper_prob(state.get(to_bitstring(6, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[112] + matrix[113]+ matrix[114]+ matrix[115]+ matrix[116]+ matrix[117]+ matrix[118]+ matrix[119]+ matrix[120] + matrix[121]+ matrix[122]+ matrix[123]+ matrix[124]+ matrix[125]+ matrix[126]+ matrix[127])), helper_prob(state.get(to_bitstring(7, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[128] + matrix[129]+ matrix[130]+ matrix[131]+ matrix[132]+ matrix[133]+ matrix[134]+ matrix[135]+ matrix[136] + matrix[137]+ matrix[138]+ matrix[139]+ matrix[140]+ matrix[141]+ matrix[142]+ matrix[143])), helper_prob(state.get(to_bitstring(8, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[144] + matrix[145]+ matrix[146]+ matrix[147]+ matrix[148]+ matrix[149]+ matrix[150]+ matrix[151]+ matrix[152] + matrix[153]+ matrix[154]+ matrix[155]+ matrix[156]+ matrix[157]+ matrix[158]+ matrix[159])), helper_prob(state.get(to_bitstring(9, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[160] + matrix[161]+ matrix[162]+ matrix[163]+ matrix[164]+ matrix[165]+ matrix[166]+ matrix[167]+ matrix[168] + matrix[169]+ matrix[170]+ matrix[171]+ matrix[172]+ matrix[173]+ matrix[174]+ matrix[175])), helper_prob(state.get(to_bitstring(10, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[176] + matrix[177]+ matrix[178]+ matrix[179]+ matrix[180]+ matrix[181]+ matrix[182]+ matrix[183]+ matrix[184] + matrix[185]+ matrix[186]+ matrix[187]+ matrix[188]+ matrix[189]+ matrix[190]+ matrix[191])), helper_prob(state.get(to_bitstring(11, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[192] + matrix[193]+ matrix[194]+ matrix[195]+ matrix[196]+ matrix[197]+ matrix[198]+ matrix[199]+ matrix[200] + matrix[201]+ matrix[202]+ matrix[203]+ matrix[204]+ matrix[205]+ matrix[206]+ matrix[207])), helper_prob(state.get(to_bitstring(12, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[208] + matrix[209]+ matrix[210]+ matrix[211]+ matrix[212]+ matrix[213]+ matrix[214]+ matrix[215]+ matrix[216] + matrix[217]+ matrix[218]+ matrix[219]+ matrix[220]+ matrix[221]+ matrix[222]+ matrix[223])), helper_prob(state.get(to_bitstring(13, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[224] + matrix[225]+ matrix[226]+ matrix[227]+ matrix[228]+ matrix[229]+ matrix[230]+ matrix[231]+ matrix[232] + matrix[233]+ matrix[234]+ matrix[235]+ matrix[236]+ matrix[237]+ matrix[238]+ matrix[239])), helper_prob(state.get(to_bitstring(14, size=platform_qubits), 0.)), 2) + self.assertAlmostEqual(0.0625*helper_prob((matrix[240] + matrix[241]+ matrix[242]+ matrix[243]+ matrix[244]+ matrix[245]+ matrix[246]+ matrix[247]+ matrix[248] + matrix[249]+ matrix[250]+ matrix[251]+ matrix[252]+ matrix[253]+ matrix[254]+ matrix[255])), helper_prob(state.get(to_bitstring(15, size=platform_qubits), 0.)), 2) if __name__ == '__main__': unittest.main()