diff --git a/algorithms/algebraic/discrete_log/discrete_log.ipynb b/algorithms/algebraic/discrete_log/discrete_log.ipynb index 960d8353..e8e9ccd3 100644 --- a/algorithms/algebraic/discrete_log/discrete_log.ipynb +++ b/algorithms/algebraic/discrete_log/discrete_log.ipynb @@ -65,16 +65,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "id": "2bbc4aa3-8f61-433d-a1cd-c58df445a2fd", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:37:07.913701Z", - "iopub.status.busy": "2024-05-07T14:37:07.912478Z", - "iopub.status.idle": "2024-05-07T14:37:11.003827Z", - "shell.execute_reply": "2024-05-07T14:37:11.003192Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "from classiq.qmod import (\n", @@ -122,16 +115,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "id": "d7fb63ac-023d-40ac-9395-13c1274d446f", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:37:11.006726Z", - "iopub.status.busy": "2024-05-07T14:37:11.006374Z", - "iopub.status.idle": "2024-05-07T14:37:11.011232Z", - "shell.execute_reply": "2024-05-07T14:37:11.010657Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "from classiq.qmod import hadamard_transform, invert, qft\n", @@ -140,9 +126,9 @@ "\n", "@qfunc\n", "def discrete_log(\n", - " g_generator: CInt,\n", - " x_element: CInt,\n", - " N_modulus: CInt,\n", + " g: CInt,\n", + " x: CInt,\n", + " N: CInt,\n", " order: CInt,\n", " x1: Output[QArray[QBit]],\n", " x2: Output[QArray[QBit]],\n", @@ -155,7 +141,7 @@ " hadamard_transform(x1)\n", " hadamard_transform(x2)\n", "\n", - " discrete_log_oracle(g_generator, x_element, N_modulus, order, x1, x2, func_res)\n", + " discrete_log_oracle(g, x, N, order, x1, x2, func_res)\n", "\n", " invert(lambda: qft(x1))\n", " invert(lambda: qft(x2))" @@ -209,16 +195,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "id": "8ef24bb4-b063-42d6-a5ea-ddcd5310ae13", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:37:11.014022Z", - "iopub.status.busy": "2024-05-07T14:37:11.013527Z", - "iopub.status.idle": "2024-05-07T14:37:11.017516Z", - "shell.execute_reply": "2024-05-07T14:37:11.016883Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "from classiq import Constraints, create_model\n", @@ -240,22 +219,15 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "id": "8e9d0b08-f3f8-4e95-a468-bfeec010d97c", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:37:11.019590Z", - "iopub.status.busy": "2024-05-07T14:37:11.019416Z", - "iopub.status.idle": "2024-05-07T14:40:05.740675Z", - "shell.execute_reply": "2024-05-07T14:40:05.739982Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/2f88183e-39d4-4d7d-8a4c-fc6acdce4b40?version=0.41.0.dev39%2B79c8fd0855\n" + "Opening: http://localhost:4200/circuit/41ec5ffb-0221-449a-962a-a438c8c1a193?version=0.0.0\n" ] } ], @@ -272,36 +244,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "0aef2760-aa9a-4710-8c60-08333a0a9b0b", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:40:05.743207Z", - "iopub.status.busy": "2024-05-07T14:40:05.742818Z", - "iopub.status.idle": "2024-05-07T14:40:17.227966Z", - "shell.execute_reply": "2024-05-07T14:40:17.227272Z" - } - }, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[{'x1': 2.0, 'x2': 2.0, 'func_res': 2.0}: 78,\n", - " {'x1': 2.0, 'x2': 2.0, 'func_res': 1.0}: 77,\n", - " {'x1': 0.0, 'x2': 0.0, 'func_res': 2.0}: 73,\n", - " {'x1': 3.0, 'x2': 1.0, 'func_res': 2.0}: 72,\n", - " {'x1': 3.0, 'x2': 1.0, 'func_res': 1.0}: 69,\n", - " {'x1': 1.0, 'x2': 3.0, 'func_res': 4.0}: 68,\n", - " {'x1': 0.0, 'x2': 0.0, 'func_res': 4.0}: 62,\n", - " {'x1': 1.0, 'x2': 3.0, 'func_res': 2.0}: 60,\n", - " {'x1': 3.0, 'x2': 1.0, 'func_res': 4.0}: 60,\n", - " {'x1': 2.0, 'x2': 2.0, 'func_res': 4.0}: 58,\n", - " {'x1': 1.0, 'x2': 3.0, 'func_res': 3.0}: 58,\n", - " {'x1': 2.0, 'x2': 2.0, 'func_res': 3.0}: 57,\n", - " {'x1': 0.0, 'x2': 0.0, 'func_res': 3.0}: 54,\n", - " {'x1': 3.0, 'x2': 1.0, 'func_res': 3.0}: 54,\n", - " {'x1': 0.0, 'x2': 0.0, 'func_res': 1.0}: 53,\n", - " {'x1': 1.0, 'x2': 3.0, 'func_res': 1.0}: 47]" + "[{'x1': 3.0, 'x2': 1.0, 'func_res': 4.0}: 79,\n", + " {'x1': 1.0, 'x2': 3.0, 'func_res': 1.0}: 67,\n", + " {'x1': 0.0, 'x2': 0.0, 'func_res': 1.0}: 66,\n", + " {'x1': 2.0, 'x2': 2.0, 'func_res': 3.0}: 66,\n", + " {'x1': 0.0, 'x2': 0.0, 'func_res': 2.0}: 66,\n", + " {'x1': 0.0, 'x2': 0.0, 'func_res': 3.0}: 66,\n", + " {'x1': 2.0, 'x2': 2.0, 'func_res': 2.0}: 64,\n", + " {'x1': 1.0, 'x2': 3.0, 'func_res': 2.0}: 63,\n", + " {'x1': 2.0, 'x2': 2.0, 'func_res': 4.0}: 62,\n", + " {'x1': 3.0, 'x2': 1.0, 'func_res': 1.0}: 62,\n", + " {'x1': 3.0, 'x2': 1.0, 'func_res': 2.0}: 61,\n", + " {'x1': 0.0, 'x2': 0.0, 'func_res': 4.0}: 60,\n", + " {'x1': 1.0, 'x2': 3.0, 'func_res': 3.0}: 57,\n", + " {'x1': 1.0, 'x2': 3.0, 'func_res': 4.0}: 56,\n", + " {'x1': 3.0, 'x2': 1.0, 'func_res': 3.0}: 55,\n", + " {'x1': 2.0, 'x2': 2.0, 'func_res': 1.0}: 50]" ] }, "execution_count": 5, @@ -332,14 +297,7 @@ "cell_type": "code", "execution_count": 6, "id": "4aa286cd-7e4e-408f-90ed-910485becd71", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:40:17.230735Z", - "iopub.status.busy": "2024-05-07T14:40:17.230196Z", - "iopub.status.idle": "2024-05-07T14:40:17.234073Z", - "shell.execute_reply": "2024-05-07T14:40:17.233495Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -357,14 +315,7 @@ "cell_type": "code", "execution_count": 7, "id": "444d0916-e611-49fa-afc4-324e65240b34", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:40:17.236527Z", - "iopub.status.busy": "2024-05-07T14:40:17.236174Z", - "iopub.status.idle": "2024-05-07T14:40:17.239674Z", - "shell.execute_reply": "2024-05-07T14:40:17.239031Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -382,14 +333,7 @@ "cell_type": "code", "execution_count": 8, "id": "cbb1b0b3-6091-421b-85bb-7b9b8da0b724", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:40:17.242019Z", - "iopub.status.busy": "2024-05-07T14:40:17.241522Z", - "iopub.status.idle": "2024-05-07T14:40:17.245044Z", - "shell.execute_reply": "2024-05-07T14:40:17.244483Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -447,7 +391,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/algorithms/algebraic/discrete_log/discrete_log.json b/algorithms/algebraic/discrete_log/discrete_log.metadata.json similarity index 100% rename from algorithms/algebraic/discrete_log/discrete_log.json rename to algorithms/algebraic/discrete_log/discrete_log.metadata.json diff --git a/algorithms/algebraic/discrete_log/discrete_log.qmod b/algorithms/algebraic/discrete_log/discrete_log.qmod index d2b4ae34..0d1dd4b7 100644 --- a/algorithms/algebraic/discrete_log/discrete_log.qmod +++ b/algorithms/algebraic/discrete_log/discrete_log.qmod @@ -5,12 +5,12 @@ qfunc discrete_log_oracle(func_res, x2); } -qfunc discrete_log(output x1: qbit[], output x2: qbit[], output func_res: qbit[]) { +qfunc discrete_log(output x1: qbit[], output x2: qbit[], output func_res: qbit[]) { allocate(x1); allocate(x2); hadamard_transform(x1); hadamard_transform(x2); - discrete_log_oracle(x1, x2, func_res); + discrete_log_oracle(x1, x2, func_res); invert { qft(x1); } @@ -22,4 +22,3 @@ qfunc discrete_log qfunc main(output x1: qnum, output x2: qnum, output func_res: qnum) { discrete_log<3, 2, 5, 4>(x1, x2, func_res); } - diff --git a/algorithms/algebraic/hidden_shift/hidden_shift_complex.json b/algorithms/algebraic/hidden_shift/hidden_shift_complex.metadata.json similarity index 100% rename from algorithms/algebraic/hidden_shift/hidden_shift_complex.json rename to algorithms/algebraic/hidden_shift/hidden_shift_complex.metadata.json diff --git a/algorithms/algebraic/hidden_shift/hidden_shift_complex.qmod b/algorithms/algebraic/hidden_shift/hidden_shift_complex.qmod index d3d809ed..8e4b31e2 100644 --- a/algorithms/algebraic/hidden_shift/hidden_shift_complex.qmod +++ b/algorithms/algebraic/hidden_shift/hidden_shift_complex.qmod @@ -52,13 +52,13 @@ qfunc hidden_shift(s); - hidden_shift(arg0); - }, lambda(arg0) { - phase_oracle(arg0); + hidden_shift(y); + }, lambda(y) { + phase_oracle(y); }>(s); } diff --git a/algorithms/algebraic/hidden_shift/hidden_shift_no_dual.json b/algorithms/algebraic/hidden_shift/hidden_shift_no_dual.metadata.json similarity index 100% rename from algorithms/algebraic/hidden_shift/hidden_shift_no_dual.json rename to algorithms/algebraic/hidden_shift/hidden_shift_no_dual.metadata.json diff --git a/algorithms/algebraic/hidden_shift/hidden_shift_no_dual.qmod b/algorithms/algebraic/hidden_shift/hidden_shift_no_dual.qmod index ec410b87..6be97f1c 100644 --- a/algorithms/algebraic/hidden_shift/hidden_shift_no_dual.qmod +++ b/algorithms/algebraic/hidden_shift/hidden_shift_no_dual.qmod @@ -53,9 +53,9 @@ qfunc hidden_shift_no_dual(target); allocate<1>(ind); - hidden_shift_no_dual(target, ind); } diff --git a/algorithms/algebraic/hidden_shift/hidden_shift_simple.json b/algorithms/algebraic/hidden_shift/hidden_shift_simple.metadata.json similarity index 100% rename from algorithms/algebraic/hidden_shift/hidden_shift_simple.json rename to algorithms/algebraic/hidden_shift/hidden_shift_simple.metadata.json diff --git a/algorithms/algebraic/hidden_shift/hidden_shift_simple.qmod b/algorithms/algebraic/hidden_shift/hidden_shift_simple.qmod index 1cb74934..dbfb9ee6 100644 --- a/algorithms/algebraic/hidden_shift/hidden_shift_simple.qmod +++ b/algorithms/algebraic/hidden_shift/hidden_shift_simple.qmod @@ -28,13 +28,13 @@ qfunc hidden_shift(s); - hidden_shift(arg0); - }, lambda(arg0) { - phase_oracle(arg0); + hidden_shift(y); + }, lambda(y) { + phase_oracle(y); }>(s); } diff --git a/algorithms/algebraic/shor/doubly_controlled_modular_adder.json b/algorithms/algebraic/shor/doubly_controlled_modular_adder.metadata.json similarity index 100% rename from algorithms/algebraic/shor/doubly_controlled_modular_adder.json rename to algorithms/algebraic/shor/doubly_controlled_modular_adder.metadata.json diff --git a/algorithms/algebraic/shor/doubly_controlled_modular_adder.qmod b/algorithms/algebraic/shor/doubly_controlled_modular_adder.qmod index e435021d..c7f2c335 100644 --- a/algorithms/algebraic/shor/doubly_controlled_modular_adder.qmod +++ b/algorithms/algebraic/shor/doubly_controlled_modular_adder.qmod @@ -58,7 +58,7 @@ qfunc ccmod_add(phi_b: qbit[], c1: qbit, c2: qbit, aux: qbit) { ctrl -> {c1, c2}; } -qfunc main(output b: qnum, output ctrl: qbit[], output aux: qbit) { +qfunc main(output b: qnum, output ctrl: qbit[2], output aux: qbit) { allocate<5>(b); allocate<2>(ctrl); allocate<1>(aux); diff --git a/algorithms/algebraic/shor/shor.json b/algorithms/algebraic/shor/shor.metadata.json similarity index 100% rename from algorithms/algebraic/shor/shor.json rename to algorithms/algebraic/shor/shor.metadata.json diff --git a/algorithms/algebraic/shor/shor_modular_exponentiation.json b/algorithms/algebraic/shor/shor_modular_exponentiation.metadata.json similarity index 100% rename from algorithms/algebraic/shor/shor_modular_exponentiation.json rename to algorithms/algebraic/shor/shor_modular_exponentiation.metadata.json diff --git a/algorithms/algebraic/shor/shor_modular_exponentiation.qmod b/algorithms/algebraic/shor/shor_modular_exponentiation.qmod index 300cb590..4324dc69 100644 --- a/algorithms/algebraic/shor/shor_modular_exponentiation.qmod +++ b/algorithms/algebraic/shor/shor_modular_exponentiation.qmod @@ -93,7 +93,7 @@ qfunc mod_exp_func(x: qbit[], m: qbit[], aux: qbit) { } } -qfunc main(output x: qbit[], output power: qbit[], output aux: qbit) { +qfunc main(output x: qbit[], output power: qbit[6], output aux: qbit) { allocate<3>(x); allocate<6>(power); allocate<1>(aux); diff --git a/algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.json b/algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.metadata.json similarity index 79% rename from algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.json rename to algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.metadata.json index 32be60ee..d2dbb48e 100644 --- a/algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.json +++ b/algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.metadata.json @@ -1,7 +1,7 @@ { "friendly_name": "Amplitude Estimation", "description": "Integral Evaluation using Amplitude Estimation", - "problem_domain_tags": [], + "problem_domain_tags": ["risk analysis"], "qmod_type": ["algorithms"], "level": ["demos"] } diff --git a/algorithms/amplitude_estimation/quantum_counting/quantum_counting_iqae.json b/algorithms/amplitude_estimation/quantum_counting/quantum_counting_iqae.metadata.json similarity index 100% rename from algorithms/amplitude_estimation/quantum_counting/quantum_counting_iqae.json rename to algorithms/amplitude_estimation/quantum_counting/quantum_counting_iqae.metadata.json diff --git a/algorithms/amplitude_estimation/quantum_counting/quantum_counting_iqae.qmod b/algorithms/amplitude_estimation/quantum_counting/quantum_counting_iqae.qmod index ad819a1c..ec09c135 100644 --- a/algorithms/amplitude_estimation/quantum_counting/quantum_counting_iqae.qmod +++ b/algorithms/amplitude_estimation/quantum_counting/quantum_counting_iqae.qmod @@ -50,10 +50,10 @@ qfunc my_iqae_algorithm(output ind_reg: qbit) { full_reg: qbit[]; allocate<5>(full_reg); - my_iqae_algorithm(full_reg); state_reg: qbit[4]; full_reg -> {state_reg, ind_reg}; diff --git a/algorithms/amplitude_estimation/quantum_counting/quantum_counting_qpe.json b/algorithms/amplitude_estimation/quantum_counting/quantum_counting_qpe.metadata.json similarity index 100% rename from algorithms/amplitude_estimation/quantum_counting/quantum_counting_qpe.json rename to algorithms/amplitude_estimation/quantum_counting/quantum_counting_qpe.metadata.json diff --git a/algorithms/amplitude_estimation/quantum_counting/quantum_counting_qpe.qmod b/algorithms/amplitude_estimation/quantum_counting/quantum_counting_qpe.qmod index 79df473e..659d527a 100644 --- a/algorithms/amplitude_estimation/quantum_counting/quantum_counting_qpe.qmod +++ b/algorithms/amplitude_estimation/quantum_counting/quantum_counting_qpe.qmod @@ -47,10 +47,10 @@ qfunc main(output phase_reg: qnum) { allocate_num<5, False, 5>(phase_reg); hadamard_transform(state_reg); qpe(state_reg); }>(phase_reg); } diff --git a/algorithms/bernstein_vazirani/bernstein_vazirani.ipynb b/algorithms/bernstein_vazirani/bernstein_vazirani.ipynb index f17c8d65..d6c6aee1 100644 --- a/algorithms/bernstein_vazirani/bernstein_vazirani.ipynb +++ b/algorithms/bernstein_vazirani/bernstein_vazirani.ipynb @@ -107,7 +107,6 @@ "\n", "@qfunc\n", "def bv_predicate(a: CInt, x: QArray, res: QBit):\n", - "\n", " repeat(\n", " x.len,\n", " lambda i: if_(\n", @@ -165,7 +164,6 @@ "\n", "@qfunc\n", "def bv_function(a: CInt, x: QArray):\n", - "\n", " aux = QBit(\"aux\")\n", " hadamard_transform(x)\n", " within_apply(\n", @@ -414,7 +412,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/algorithms/bernstein_vazirani/bernstein_vazirani_example.json b/algorithms/bernstein_vazirani/bernstein_vazirani_example.metadata.json similarity index 100% rename from algorithms/bernstein_vazirani/bernstein_vazirani_example.json rename to algorithms/bernstein_vazirani/bernstein_vazirani_example.metadata.json diff --git a/algorithms/deutsch_jozsa/complex_deutsch_jozsa.json b/algorithms/deutsch_jozsa/complex_deutsch_jozsa.metadata.json similarity index 100% rename from algorithms/deutsch_jozsa/complex_deutsch_jozsa.json rename to algorithms/deutsch_jozsa/complex_deutsch_jozsa.metadata.json diff --git a/algorithms/deutsch_jozsa/complex_deutsch_jozsa.qmod b/algorithms/deutsch_jozsa/complex_deutsch_jozsa.qmod index 8c44f294..29eeb7aa 100644 --- a/algorithms/deutsch_jozsa/complex_deutsch_jozsa.qmod +++ b/algorithms/deutsch_jozsa/complex_deutsch_jozsa.qmod @@ -19,15 +19,15 @@ qfunc my_oracle(target: qnum) { qfunc deutsch_jozsa(x: qnum) { hadamard_transform(x); - my_oracle(x); hadamard_transform(x); } qfunc main(output x: qnum) { allocate<3>(x); - deutsch_jozsa(x); } diff --git a/algorithms/deutsch_jozsa/simple_deutsch_jozsa.json b/algorithms/deutsch_jozsa/simple_deutsch_jozsa.metadata.json similarity index 100% rename from algorithms/deutsch_jozsa/simple_deutsch_jozsa.json rename to algorithms/deutsch_jozsa/simple_deutsch_jozsa.metadata.json diff --git a/algorithms/deutsch_jozsa/simple_deutsch_jozsa.qmod b/algorithms/deutsch_jozsa/simple_deutsch_jozsa.qmod index af23eee0..0b00eb4f 100644 --- a/algorithms/deutsch_jozsa/simple_deutsch_jozsa.qmod +++ b/algorithms/deutsch_jozsa/simple_deutsch_jozsa.qmod @@ -19,15 +19,15 @@ qfunc my_oracle(target: qnum) { qfunc deutsch_jozsa(x: qnum) { hadamard_transform(x); - my_oracle(x); hadamard_transform(x); } qfunc main(output x: qnum) { allocate<4>(x); - deutsch_jozsa(x); } diff --git a/algorithms/glued_trees/figures/10_qubits.png b/algorithms/glued_trees/figures/10_qubits.png index 3268da7b..c6b7f940 100644 Binary files a/algorithms/glued_trees/figures/10_qubits.png and b/algorithms/glued_trees/figures/10_qubits.png differ diff --git a/algorithms/glued_trees/figures/20_qubits.png b/algorithms/glued_trees/figures/20_qubits.png index 1803bc43..bbfe2621 100644 Binary files a/algorithms/glued_trees/figures/20_qubits.png and b/algorithms/glued_trees/figures/20_qubits.png differ diff --git a/algorithms/glued_trees/glued_trees.ipynb b/algorithms/glued_trees/glued_trees.ipynb index 8e3a0d71..b0024f7c 100644 --- a/algorithms/glued_trees/glued_trees.ipynb +++ b/algorithms/glued_trees/glued_trees.ipynb @@ -28,16 +28,36 @@ "metadata": {}, "outputs": [], "source": [ + "import json\n", + "import pathlib\n", + "import random\n", "from typing import cast\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import tqdm\n", + "\n", "from classiq import *\n", "from classiq.execution import ExecutionPreferences\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import random\n", - "import json\n", - "%config InlineBackend.figure_format = 'retina' # improve graph image quality\n", - "#from qiskit.quantum_info import SparsePauliOp\n", - "#import networkx as nx" + "\n", + "# from qiskit.quantum_info import SparsePauliOp\n", + "# import networkx as nx" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# notebooks path issue\n", + "def get_path(file_name):\n", + " path = (\n", + " pathlib.Path(__file__).parent.resolve()\n", + " if \"__file__\" in globals()\n", + " else pathlib.Path(\".\")\n", + " )\n", + " return path / file_name" ] }, { @@ -78,15 +98,17 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "CHAR_TO_STUCT_DICT = {\"I\": Pauli.I, \"X\": Pauli.X, \"Y\": Pauli.Y, \"Z\": Pauli.Z}\n", "\n", + "\n", "def pauli_str_to_enums(pauli):\n", " return [CHAR_TO_STUCT_DICT[s] for s in pauli]\n", "\n", + "\n", "def pauli_list_to_hamiltonian(pauli_list):\n", " return [\n", " PauliTerm(\n", @@ -113,7 +135,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -122,10 +144,10 @@ " return pauli\n", " result = []\n", " idx = 0\n", - " while len(result) < round(size*0.6):\n", - " for i in range(len(pauli[0][0])-1, -1, -1):\n", + " while len(result) < round(size * 0.6):\n", + " for i in range(len(pauli[0][0]) - 1, -1, -1):\n", " for k in pauli:\n", - " if k[0][i] == 'IXYZ'[idx%4] and k not in result:\n", + " if k[0][i] == \"IXYZ\"[idx % 4] and k not in result:\n", " result.append(k)\n", " break\n", " idx += 1\n", @@ -136,33 +158,52 @@ " result.append(i)\n", " return result\n", "\n", + "\n", "def generate_pauli_list(qubits):\n", - " dim = qubits-2\n", - " T1 = nx.balanced_tree(2, dim-1)\n", - " T2 = nx.relabel_nodes(T1, lambda x: 2**(dim+1)-3-x)\n", + " dim = qubits - 2\n", + " T1 = nx.balanced_tree(2, dim - 1)\n", + " T2 = nx.relabel_nodes(T1, lambda x: 2 ** (dim + 1) - 3 - x)\n", " T = nx.union(T1, T2)\n", - " edges = {i:0 for i in range(2**dim-1, 2**(dim-1)+2**dim-1)}\n", - " for i in range(2**(dim-1)-1, 2**dim-1):\n", - " nums = [j for j in range(2**dim-1, 2**(dim-1)+2**dim-1) if edges[j] < 1]\n", + " edges = {i: 0 for i in range(2**dim - 1, 2 ** (dim - 1) + 2**dim - 1)}\n", + " for i in range(2 ** (dim - 1) - 1, 2**dim - 1):\n", + " nums = [\n", + " j for j in range(2**dim - 1, 2 ** (dim - 1) + 2**dim - 1) if edges[j] < 1\n", + " ]\n", " if len(nums) == 0:\n", - " nums = [j for j in range(2**dim-1, 2**(dim-1)+2**dim-1) if edges[j] < 2]\n", + " nums = [\n", + " j\n", + " for j in range(2**dim - 1, 2 ** (dim - 1) + 2**dim - 1)\n", + " if edges[j] < 2\n", + " ]\n", " vals = random.sample(nums, k=2)\n", " for j in vals:\n", " edges[j] += 1\n", " T.add_edges_from([(i, vals[0]), (i, vals[1])])\n", - " A = 3*np.identity(2**(dim+1)-2)-np.array(nx.adjacency_matrix(T, nodelist=sorted(T.nodes())).todense())\n", - " B = np.hstack((np.linalg.cholesky(A), np.zeros((2**(dim+1)-2, 4))))\n", - " H = -np.block([[np.zeros((B.shape[0], B.shape[0])), B], [B.conj().T, np.zeros((B.shape[1], B.shape[1]))]])\n", + " A = 3 * np.identity(2 ** (dim + 1) - 2) - np.array(\n", + " nx.adjacency_matrix(T, nodelist=sorted(T.nodes())).todense()\n", + " )\n", + " B = np.hstack((np.linalg.cholesky(A), np.zeros((2 ** (dim + 1) - 2, 4))))\n", + " H = -np.block(\n", + " [\n", + " [np.zeros((B.shape[0], B.shape[0])), B],\n", + " [B.conj().T, np.zeros((B.shape[1], B.shape[1]))],\n", + " ]\n", + " )\n", " c = SparsePauliOp.from_operator(H)\n", " result = [(str(c.paulis[i]), c.coeffs[i].real) for i in range(len(c))]\n", " return crop_pauli_list(sorted(result, key=lambda x: abs(x[1]), reverse=True), 200)\n", "\n", + "\n", "def pauli_str(qubits, recalculate=False):\n", - " cache = json.load(open('glued_trees_cache.json', 'r'))\n", + " with open(get_path(\"glued_trees_cache.json\"), \"r\") as f:\n", + " cache = json.load(f)\n", " if not recalculate and str(qubits) in cache:\n", " return cache[str(qubits)]\n", " if qubits > 13:\n", - " return [(i[0][0]+i[0][1]*(qubits-len(i[0]))+i[0][1:], i[1]) for i in generate_pauli_list(13)]\n", + " return [\n", + " (i[0][0] + i[0][1] * (qubits - len(i[0])) + i[0][1:], i[1])\n", + " for i in generate_pauli_list(13)\n", + " ]\n", " return generate_pauli_list(qubits)" ] }, @@ -199,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -213,17 +254,28 @@ " max_depth=1400,\n", " qbv=state,\n", " )\n", + "\n", " execution_preferences = ExecutionPreferences(num_shots=8192)\n", " model = set_execution_preferences(create_model(main), execution_preferences)\n", " quantum_program = synthesize(model)\n", " job = execute(quantum_program)\n", - " filename = str(qubits)+'-qubits/2n'+(str(t-2*qubits+4) if t < 2*qubits-4 else '+'+str(t-2*qubits+4))\n", - " json.dump(dict(job.result()[0].value), open('results/'+filename+'.json', 'w'))\n", + " filename = (\n", + " str(qubits)\n", + " + \"-qubits/2n\"\n", + " + (\n", + " str(t - 2 * qubits + 4)\n", + " if t < 2 * qubits - 4\n", + " else \"+\" + str(t - 2 * qubits + 4)\n", + " )\n", + " )\n", + " with open(get_path(\"results/\" + filename + \".json\"), \"w\") as f:\n", + " json.dump(dict(job.result()[0].value), f)\n", + "\n", "\n", "def run_range(qubits, recalculate=False):\n", " pauli_list = pauli_str(qubits, recalculate)\n", - " for i in range(-12, 13, 2):\n", - " run_point(qubits, 2*qubits-4+i, pauli_list)" + " for i in tqdm.tqdm(range(-12, 13, 2)):\n", + " run_point(qubits, 2 * qubits - 4 + i, pauli_list)" ] }, { @@ -237,9 +289,17 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:52<00:00, 4.01s/it]\n" + ] + } + ], "source": [ "run_range(10)" ] @@ -257,9 +317,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 13/13 [01:13<00:00, 5.65s/it]\n" + ] + } + ], "source": [ "run_range(20)" ] @@ -273,24 +341,34 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def graph_results(qubits):\n", - " states = [(str(i) if i < 0 else '+'+str(i)) for i in range(-12, 13, 2)]\n", - " times = [2*qubits-4+int(i) for i in states]\n", + " states = [(str(i) if i < 0 else \"+\" + str(i)) for i in range(-12, 13, 2)]\n", + " times = [2 * qubits - 4 + int(i) for i in states]\n", " data = []\n", " for i in states:\n", - " with open('results/'+str(qubits)+'-qubits'+'/2n'+i+'.json', 'r') as f:\n", + " with open(\n", + " get_path(\"results/\" + str(qubits) + \"-qubits\" + \"/2n\" + i + \".json\"), \"r\"\n", + " ) as f:\n", " j = json.load(f)\n", - " key = str('0'+bin(2**(qubits-1)-3)[2:])\n", - " data.append(j['counts'][key]/j['num_shots'] if key in j['counts'] else 0)\n", + " key = str(\"0\" + bin(2 ** (qubits - 1) - 3)[2:])\n", + " data.append(j[\"counts\"][key] / j[\"num_shots\"] if key in j[\"counts\"] else 0)\n", " plt.plot(times, data)\n", - " plt.xlabel('Time (s)')\n", - " plt.ylabel(\"Proportion of |\"+str(2**(qubits-1)-3)+\"> shots\")\n", - " plt.title(r'Glued Trees System at $t \\approx 2n$ for '+str(qubits)+r' Qubits ($n='+str(qubits-2)+r'$)')\n", - " plt.savefig('figures/'+str(qubits)+'_qubits.png', bbox_inches='tight', dpi=300)\n", + " plt.xlabel(\"Time (s)\")\n", + " plt.ylabel(\"Proportion of |\" + str(2 ** (qubits - 1) - 3) + \"> shots\")\n", + " plt.title(\n", + " r\"Glued Trees System at $t \\approx 2n$ for \"\n", + " + str(qubits)\n", + " + r\" Qubits ($n=\"\n", + " + str(qubits - 2)\n", + " + r\"$)\"\n", + " )\n", + " plt.savefig(\n", + " get_path(\"figures/\" + str(qubits) + \"_qubits.png\"), bbox_inches=\"tight\", dpi=300\n", + " )\n", " plt.show()" ] }, @@ -303,22 +381,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": { - "image/png": { - "height": 455, - "width": 576 - } - }, + "metadata": {}, "output_type": "display_data" } ], @@ -335,22 +408,17 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": { - "image/png": { - "height": 455, - "width": 594 - } - }, + "metadata": {}, "output_type": "display_data" } ], @@ -382,7 +450,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -396,9 +464,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.11.4" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/algorithms/glued_trees/glued_trees_cache.json b/algorithms/glued_trees/glued_trees_cache.json index 83de0d4e..9fa86097 100644 --- a/algorithms/glued_trees/glued_trees_cache.json +++ b/algorithms/glued_trees/glued_trees_cache.json @@ -1 +1,406 @@ -{"10": [["XIIIIIIIXI", -0.7526137035201601], ["XIIIIIIXXI", -0.37336084437331796], ["XIIIIIIYYI", -0.38415596887523673], ["XZIXIZZZZI", -0.006612905308067554], ["YIIIIIIIYI", -0.7526137035201601], ["XIIIXXYYXI", 0.051516042757856595], ["YIIYXYYYYI", -0.02787456236145021], ["XIZIIIIIXI", -0.013449113937452212], ["YIIIIIIXYI", 0.38415596887523673], ["XIIIIIYXYI", -0.19424150139041263], ["XIIIIIIYIY", 0.029720649244903058], ["XIIZZZXZZI", -0.007109908237121916], ["XZIIIIIIXI", -0.04933462211354994], ["YIIIIIXXYI", 0.19424150139041263], ["YIIIIYYXYI", 0.09797196440842665], ["XIIIZIIIXI", -0.007825806002393486], ["YIIIIIIYXI", -0.37336084437331796], ["XIXYYXYXYI", -0.014830501861161874], ["XYXXYYYXXI", 0.011070832097706011], ["ZXXXXXXXXI", -0.006572351502781893], ["XIIIIIXYYI", 0.19386532534886877], ["XIIIIIYYXI", -0.18678800030285186], ["YIIIIIYYYI", 0.19386532534886877], ["YZIYIZZZZI", -0.006612905308067554], ["YIIIIIXYXI", 0.18678800030285186], ["YIIIXXYXXI", 0.05105565386817196], ["XIIYYXYYXI", 0.027526204018504478], ["YIZIIIIIYI", -0.013449113937452212], ["XIIIIIXXXI", -0.18323015243607135], ["XIIIIXYXYI", 0.09797196440842665], ["YIIIIIIXIY", -0.029720649244903058], ["YIIZZZYZZI", -0.007109908237121916], ["YZIIIIIIYI", -0.04933462211354994], ["XIIIIYXYXI", -0.09790485429098861], ["XIIIIYXXYI", -0.09738539217062862], ["YIIIZIIIYI", -0.007825806002393486], ["YIIIIIYXXI", -0.18323015243607135], ["YIXXYXYXYI", -0.014830501861161874], ["YYYXYYYXXI", -0.011070832097706011], ["ZXXXXXXYYI", 0.006572351502781893], ["YIIIIXXYXI", 0.09790485429098861], ["XIIIIXYYXI", 0.09723073331248952], ["YIIIIYYYXI", 0.09723073331248952], ["XZIXIIZIII", -0.006442771857138567], ["XIIIIIIXIX", 0.03782159881982394], ["YIIIXYXYYI", -0.05081457021131695], ["XIIYYYYXXI", 0.02691422493459414], ["XZZIIIIIXI", 0.012785230601782186], ["YIIIIXXXYI", 0.09738539217062862], ["XIIIIXXYYI", 0.0936375449565515], ["XZIIIIIYIY", 0.02736493560510323], ["XIIXZXXZZI", 0.0070057024561532314], ["YZZIIIIIYI", 0.012785230601782186], ["YIIIIYXYYI", 0.0936375449565515], ["XIIIIYYYYI", 0.09298355472236805], ["XZIIZIIIXI", 0.007170911589543703], ["YIIIIXYYYI", -0.09298355472236805], ["XIXXYXXYXI", 0.014790913647481705], ["XYXXXXYXXI", -0.01068597467739666], ["ZXXXXXYXYI", 0.006572351502781893], ["XIIIIYYXXI", -0.09210460232707157], ["YIIIIXYXXI", 0.09210460232707157], ["YIIIYXYYXI", 0.051516042757856595], ["YZIYIIZIII", -0.006442771857138567], ["YIIIIIIYIX", 0.03782159881982394], ["XIIIXYXXYI", 0.050446601073475254], ["XIIYXXXXYI", -0.02666217783475839], ["XZZIIIIXXI", 0.00837965253402453], ["XIIIIXXXXI", -0.08891475352327935], ["XIIIYXYXXI", -0.05105565386817196], ["YZIIIIIXIY", -0.02736493560510323], ["YIIYZXXZZI", 0.0070057024561532314], ["XIIIIIXIII", 0.011189896923879047], ["YIIIIYXXXI", -0.08891475352327935], ["XIIIYYXYYI", 0.05081457021131695], ["YZIIZIIIYI", 0.007170911589543703], ["YIIIYYXXYI", 0.050446601073475254], ["YIXYYXXYXI", -0.014790913647481705], ["YYYXXXYXXI", 0.01068597467739666], ["ZXXXXXYYXI", 0.006572351502781893], ["XIIIYYYYXI", 0.05044317333961998], ["YIIIXYYYXI", -0.05044317333961998], ["XIIIXXXYYI", 0.04959844986045102], ["XIIIIIZIXI", -0.006432707991474218], ["XZIIIIIXIX", 0.027345400379519765], ["XIIIXYYXXI", 0.050092874043860355], ["XIIYYYYYYI", -0.026648596578796042], ["YZZIIIIYXI", 0.00837965253402453], ["YIIIYYYXXI", 0.050092874043860355], ["XIIIYXXXYI", -0.04930312270999021], ["XZIIIIXYIY", -0.015146886131722144], ["XZIIIIXIZI", -0.006899554288018264], ["YIIIIIYIII", 0.011189896923879047], ["YIIIYXXYYI", 0.04959844986045102], ["XIIIYYYXYI", 0.04521119690374699], ["XZIZZZXZII", 0.007169269812186064], ["YIIIXXXXYI", 0.04930312270999021], ["XIXXYYYXYI", -0.014729888610199814], ["XYXXYYXXYI", 0.010665312687926313], ["ZXXXXYXXYI", 0.006572351502781893], ["XIIIXXYXYI", 0.04587700432126865], ["XIIIXYXYXI", 0.04459788393254507], ["XIIIYXYYYI", 0.04560714016273523], ["YIIIIIZIYI", -0.006432707991474218], ["YZIIIIIYIX", 0.027345400379519765], ["YIIIXXYYYI", -0.04560714016273523], ["YIIYYYXXXI", 0.026636426365035736], ["XIZZZIIIXI", -0.006823631624625939], ["YIIIYXYXYI", 0.04587700432126865], ["XIIIXYYYYI", -0.04486088857347642], ["YZIIIIYYIY", -0.015146886131722144], ["YZIIIIYIZI", -0.006899554288018264], ["XIIZIIIIXI", -0.010013037009411004], ["YIIIYYXYXI", 0.04459788393254507], ["YIIIXYYXYI", -0.04521119690374699], ["YZIZZZYZII", 0.007169269812186064], ["YIIIYYYYYI", -0.04486088857347642], ["YIXYYYYXYI", 0.014729888610199814], ["YYYXYYXXYI", -0.010665312687926313], ["ZXXXXYXYXI", 0.006572351502781893], ["XIIIYYXXXI", -0.0437341322771147], ["YIIIXYXXXI", 0.0437341322771147], ["XIIIYXXYXI", -0.043159569527918745], ["YIIIXXXYXI", 0.043159569527918745], ["XIIIXXXXXI", -0.04150724130826612], ["YIIIYXXXXI", -0.04150724130826612], ["XIIXXYYYYI", -0.02787456236145021], ["YIIXYXYYXI", -0.027526204018504478], ["YIIXYYYXXI", -0.02691422493459414], ["YIIXXXXXYI", 0.02666217783475839], ["YIIXYYYYYI", 0.026648596578796042], ["XIIXYYXXXI", 0.026636426365035736], ["XIIXXXYYXI", 0.026403630605820266], ["YIIYXXYYXI", 0.026403630605820266], ["XIIXXXYXYI", 0.026362576038375586], ["YIIYXXYXYI", 0.026362576038375586], ["XIIXXYYXXI", 0.0261156926061024], ["YIIYXYYXXI", 0.0261156926061024], ["XIIYXYXYYI", 0.02596861341042802], ["YIIXXYXYYI", -0.02596861341042802], ["XIIXYXXXYI", 0.0258197989775319], ["YIIYYXXXYI", 0.0258197989775319], ["XIIXYXXYXI", 0.0257366367628273], ["YIIYYXXYXI", 0.0257366367628273], ["XIIYXYXXXI", -0.025684851821564002], ["YIIXXYXXXI", 0.025684851821564002], ["XIIYYXYXYI", 0.025466821824393464], ["YIIXYXYXYI", -0.025466821824393464], ["XIIXYYXYYI", -0.024756913701190417], ["YIIYYYXYYI", -0.024756913701190417], ["XIIYXXXYXI", -0.024433472934039593], ["YIIXXXXYXI", 0.024433472934039593], ["XIIYXYYXYI", 0.023332759688308016], ["YIIXXYYXYI", -0.023332759688308016], ["XZIIIIIYYI", -0.023142209116660137], ["YZIIIIIXYI", 0.023142209116660137], ["XIIIIIXXIX", 0.022895402429390692], ["YIIIIIYXIX", 0.022895402429390692], ["XIIXYXYXXI", 0.022719156992529476], ["YIIYYXYXXI", 0.022719156992529476], ["XIIXYYYXYI", -0.02211534108628905], ["YIIYYYYXYI", -0.02211534108628905], ["XIIXYYYYXI", -0.022114594999291054], ["YIIYYYYYXI", -0.022114594999291054], ["XIIYYYXYXI", 0.021932152598550934], ["YIIXYYXYXI", -0.021932152598550934], ["XIIYXXYYYI", 0.021902860602432215], ["YIIXXXYYYI", -0.021902860602432215], ["XZIIIIIXXI", -0.021780522375656204], ["YZIIIIIYXI", -0.021780522375656204], ["XIIXXXXYYI", 0.021612581396226377], ["YIIYXXXYYI", 0.021612581396226377], ["XIIYXXYXXI", -0.02158810464013425], ["YIIXXXYXXI", 0.02158810464013425], ["XIIYXYYYXI", 0.02131831369425804], ["YIIXXYYYXI", -0.02131831369425804], ["XIIXXYXXYI", 0.02114245861852753], ["YIIYXYXXYI", 0.02114245861852753], ["XIIXYXYYYI", -0.021003533985481704], ["YIIYYXYYYI", -0.021003533985481704], ["XIIXXYXYXI", 0.02099192408564843], ["YIIYXYXYXI", 0.02099192408564843], ["XIIYYXXYYI", 0.020761016521141717], ["YIIXYXXYYI", -0.020761016521141717], ["XIIYYYXXYI", 0.01993246796406775], ["YIIXYYXXYI", -0.01993246796406775], ["XIIYYXXXXI", -0.019920718063269928], ["YIIXYXXXXI", 0.019920718063269928], ["XIIIIIYYIX", 0.019417290274795877], ["YIIIIIXYIX", -0.019417290274795877], ["XIIXXXXXXI", -0.01857204712429268], ["YIIYXXXXXI", -0.01857204712429268], ["XZIIIIXXXI", -0.016348051075808806], ["YZIIIIYXXI", -0.016348051075808806], ["XZIIIIYXIY", 0.015110850469518992], ["YZIIIIXXIY", -0.015110850469518992], ["XIYXYXYXYI", 0.014830501861161874], ["YIYYYXYXYI", -0.014830501861161874], ["XIYYYXXYXI", 0.014790913647481705], ["YIYXYXXYXI", 0.014790913647481705]], "20": [["XIIIIIIIIIIIIIIIIIXI", -0.7597555791257463], ["XIIIIIIIIIIIIIIIIXXI", -0.3788134383984239], ["XIIIIIIIIIIIIIIIIYYI", -0.3816091687294096], ["XIIIIIIIIIZIZZZIZIXI", -0.000965140468847494], ["YIIIIIIIIIIIIIIIIIYI", -0.7597555791257463], ["YIIIIIIIIIIIIIXXXXYI", 0.048034693195222355], ["YIIIIIIIIIIIIYXYYYYI", -0.024288501533429433], ["XIIIIIIIIIIIZIIIIIXI", -0.0014745501558381339], ["YIIIIIIIIIIIIIIIIXYI", 0.3816091687294096], ["XIIIIIIIIIXXYYXXXXXI", 0.0034489756067628305], ["XIIIIIIIIYXYYYYXXXYI", -0.0018385588074672434], ["XZZZZZZZZIIIIIIIIIXI", -0.04247685949008335], ["IXXXXXXXXXXXXXXXXXXI", -0.0008215439378477366], ["XIIIIIIIIIIIIIIIIXIX", 0.032519358059862634], ["XIIIIIIIIIIIIIIIXYYI", 0.1911132990260518], ["XXXXXXXXXYZYYZZYXZIZ", -0.0009859910537224725], ["YIIIIIIIIIIIIIIIIYXI", -0.3788134383984239], ["YIIIIIIIIIIIIIIXXXYI", 0.09569082741024892], ["XIIIIIIIIIIIIIYXXXYI", -0.048034693195222355], ["XIIIIIIIIIIIIZIIIIXI", -0.0012072669323203635], ["YIIIIIIIIIIIIIIIYYYI", 0.1911132990260518], ["XIIIIIIIIIIXYXYXYXYI", -0.0063025199264490185], ["YIIIIIIIIIYXYYXXXXXI", 0.0034489756067628305], ["XIIIIIIIIZIIIIIIIIXI", -0.006678279604201871], ["XIIIIIIIIIIIIIIIYXYI", -0.1909251749011368], ["XIIIIIIIIIIIIIIIYYXI", -0.18982912184635464], ["XIIIIIIIIIIIIIIIIYIY", 0.029899797457073666], ["XZZZZZZZZIIIIIIIIXZZ", -0.004392057316095634], ["YZZZZZZZZIIIIIIIIIYI", -0.04247685949008335], ["YIIIIIIIIIIIIIIIXXYI", 0.1909251749011368], ["XIIIIIIIIIIIIIIYXXYI", -0.09569082741024892], ["XXXXXXXXXYYIZXZXYYXI", -0.0010722513190686877], ["YIIIIIIIIIIIIIIIXYXI", 0.18982912184635464], ["YIIIIIIIIIIIXYXYXXYI", -0.012374279005608061], ["YIIIIIIIIIIYYXYXYXYI", -0.0063025199264490185], ["XIIIIIIIIIZIIIIIIIXI", -0.0031537081858958207], ["XIIIIIIIIIIIIIIIXXXI", -0.1886473171987223], ["XXXXXXXXXXXIIXIXXXXI", 0.0010776146506793866], ["YIIIIIIIIIIIIIIIYXXI", -0.1886473171987223], ["YZZZZZZZZIIIIIIIIYZZ", -0.004392057316095634], ["YIIIIIIIIIIIIIIIIYIX", 0.032519358059862634], ["XIIIIIIIIIIIIIIXYXYI", 0.09564395067494046], ["YIIIIIIIIIIIIIIYYXYI", 0.09564395067494046], ["XIIIIIIIIIIIIIIZIIXI", -0.000986728020319752], ["XIIIIIIIIIIIIIIYXYXI", -0.09544725083131203], ["XIIIIIIIIIIIIXXYYYYI", -0.024288501533429433], ["XIIIIIIIIIIIYYXYXXYI", 0.012374279005608061], ["XIIIIIIIIIIZIIIIIIXI", -0.0020245744624640756], ["YIIIIIIIIIIIIIIXXYXI", 0.09544725083131203], ["XIIIIIIIIXYYYYYXXXYI", 0.0018385588074672434], ["XYYYYYYYYYXIIXIXXXXI", 0.0010776146506793866], ["ZXXXXXXXXXXXXXXXXXXI", -0.0008215439378477366], ["XIIIIIIIIIIIIIIXYYXI", 0.09542273913256943], ["YIIIIIIIIIIIIIIYYYXI", 0.09542273913256943], ["XIIIIIIIIIIIIIIXXYYI", 0.09501085307200312], ["YIIIIIIIIIZIZZZIZIYI", -0.000965140468847494], ["XZZZZZZZZIIIIIIIIXIX", 0.03036004987263414], ["XIIIIIIIIIIIIIXXXYYI", 0.04797669720376477], ["YIIIIIIIIIIIIYYYXYYI", -0.024283149819588574], ["YIIIIIIIIIIIZIIIIIYI", -0.0014745501558381339], ["YIIIIIIIIIIIIIIYXYYI", 0.09501085307200312], ["XIIIIIIIIIXYXYXXXYYI", -0.0034460998319557614], ["YIIIIIIIIYYYYYYXXXYI", 0.0018385588074672434], ["YZZZZZZZZIIIIIIIIYIX", 0.03036004987263414], ["IXXXXXXXXXXXXXXXXYYI", 0.0008215439378477366], ["XIIIIIIIIIIIIIIIXXIX", 0.016934143310274964], ["XIIIIIIIIIIIIIIYYYYI", 0.09500871845303184], ["XYYYYYYYYXZYYZZYXZIZ", 0.0009859910537224725], ["YIIIIIIIIIIIIIIIIXIY", -0.029899797457073666], ["YIIIIIIIIIIIIIIXYYYI", -0.09500871845303184], ["YIIIIIIIIIIIIIYXXYYI", 0.04797669720376477], ["YIIIIIIIIIIIIZIIIIYI", -0.0012072669323203635], ["XIIIIIIIIIIIIIIYYXXI", -0.09459704485910016], ["YIIIIIIIIIIXYXXYYXXI", -0.006296412913254014], ["YIIIIIIIIIYYXYXXXYYI", -0.0034460998319557614], ["YIIIIIIIIZIIIIIIIIYI", -0.006678279604201871], ["YIIIIIIIIIIIIIIXYXXI", 0.09459704485910016], ["XIIIIIIIIIIIIIIXXXXI", -0.09392136813839039], ["XZZZZZZZZIIIIIIIIYIY", 0.029648188325124326], ["XIIIIIIIIIIIIIIIIXZZ", -0.004347501257809116], ["XZZZZZZZZZIIIIIIIIXI", 0.006594960463259015], ["YIIIIIIIIIIIIIIYXXXI", -0.09392136813839039], ["XIIIIIIIIIIIIIXYXXYI", 0.047971572042292715], ["XYYYYYYYYXYIZXZXYYXI", 0.0010722513190686877], ["YIIIIIIIIIIIIIYYXXYI", 0.047971572042292715], ["YIIIIIIIIIIIXXXXXXYI", 0.01236283983073573], ["XIIIIIIIIIIYYXXYYXXI", 0.006296412913254014], ["YIIIIIIIIIZIIIIIIIYI", -0.0031537081858958207], ["XIIIIIIIIIIIIIYYXYYI", 0.04796639844692382], ["YXXXXXXXXYXIIXIXXXXI", -0.0010776146506793866], ["YIIIIIIIIIIIIIXYXYYI", -0.04796639844692382], ["YIIIIIIIIIIIIIIIIYZZ", -0.004347501257809116], ["YZZZZZZZZIIIIIIIIXIY", -0.029648188325124326], ["XIIIIIIIIIIIIIXYYXXI", 0.047836394705299566], ["XIIIIIIIIIIIIIXXYYXI", 0.04795217784026999], ["YIIIIIIIIIIIIIIZIIYI", -0.000986728020319752], ["XZZZZZZZZIIIIIIIIYYI", -0.021465538187191525], ["XIIIIIIIIIIIIXYYXYYI", -0.024283149819588574], ["XIIIIIIIIIIIYXXXXXYI", -0.01236283983073573], ["YIIIIIIIIIIZIIIIIIYI", -0.0020245744624640756], ["YIIIIIIIIIIIIIYXYYXI", 0.04795217784026999], ["YIIIIIIIIXXYYYYXXXYI", 0.0018385588074672434], ["YYYYYYYYYXXIIXIXXXXI", 0.0010776146506793866], ["ZXXXXXXXXXXXXXXXXYYI", 0.0008215439378477366], ["XIIIIIIIIIIIIIYYYYXI", 0.04785498815847788], ["YIIIIIIIIIIIIIXYYYXI", -0.04785498815847788], ["XIIIIIIIIIIIIIYXYYYI", 0.04736747465909179], ["XXXXXXXXXYYZZZYYZZYY", 0.0009404226016837798], ["YZZZZZZZZIIIIIIIIXYI", 0.021465538187191525], ["YIIIIIIIIIIIIIXXYXXI", 0.047831133668291004], ["YIIIIIIIIIIIIYXXYYXI", 0.024266198663343924], ["XZZZZZZZZIIIZIIIIIXI", 0.0013915658848147139], ["YIIIIIIIIIIIIIYYYXXI", 0.047836394705299566], ["YIIIIIIIIIXXXYXXXYYI", -0.0034428185573980993], ["XIIIIIIIIYYYYXXXXXXI", 0.001835428143108581], ["XZZZZZZZZIIIIIIIIXXI", -0.020457124625547614], ["IXXXXXXXXXXXXXXXYXYI", 0.0008215439378477366], ["YIIIIIIIIIIIIIIIYXIX", 0.016934143310274964], ["YIIIIIIIIIIIIIXXYYYI", -0.04736747465909179], ["YXXXXXXXXXZYYZZYXZIZ", -0.0009859910537224725], ["YZZZZZZZZIIIIIIIIYXI", -0.020457124625547614], ["XIIIIIIIIIIIIIYXYXXI", -0.047831133668291004], ["YIIIIIIIIIIIIIYXYXYI", 0.04736214327368851], ["XZZZZZZZZIIIIZIIIIXI", 0.0011246581686555233], ["XIIIIIIIIIIIIIXXYXYI", 0.04736214327368851], ["XIIIIIIIIIIXXYYXXXXI", 0.006293165273497527], ["XIIIIIIIIIYXXYXXXYYI", 0.0034428185573980993], ["YZZZZZZZZZIIIIIIIIYI", 0.006594960463259015], ["XIIIIIIIIIIIIIYYYXYI", 0.047320759424729644], ["XIIIIIIIIIIIIIXYYYYI", -0.04731583349766409], ["YIIIIIIIIIIIIIXYYXYI", -0.047320759424729644], ["YIIIIIIIIIIIIIYYYYYI", -0.04731583349766409], ["XIIIIIIIIIIIIIXYXYXI", 0.04715986341941597], ["YIIIIIIIIIIIIIYYXYXI", 0.04715986341941597], ["XIIIIIIIIIIIIIYXXYXI", -0.04708759877215153], ["YIIIIIIIIIIIIIXXXYXI", 0.04708759877215153], ["XIIIIIIIIIIIIIYYXXXI", -0.047077329797287154], ["YIIIIIIIIIIIIIXYXXXI", 0.047077329797287154], ["XIIIIIIIIIIIIIXXXXXI", -0.046483027941077046], ["YIIIIIIIIIIIIIYXXXXI", -0.046483027941077046], ["XIIIIIIIIIIIIXXXYYXI", 0.024266198663343924], ["XIIIIIIIIIIIIXYXXYXI", 0.024221035620844704], ["YIIIIIIIIIIIIYYXXYXI", 0.024221035620844704], ["XIIIIIIIIIIIIYYXYXYI", 0.02417081593949432], ["YIIIIIIIIIIIIXYXYXYI", -0.02417081593949432], ["XIIIIIIIIIIIIYYYYYYI", -0.024133364967802363], ["YIIIIIIIIIIIIXYYYYYI", 0.024133364967802363], ["XIIIIIIIIIIIIYXXXYXI", -0.024124159069099572], ["YIIIIIIIIIIIIXXXXYXI", 0.024124159069099572], ["XIIIIIIIIIIIIYXYXYYI", 0.024120661853799782], ["YIIIIIIIIIIIIXXYXYYI", -0.024120661853799782], ["XIIIIIIIIIIIIYXXXXYI", -0.024104542695134838], ["YIIIIIIIIIIIIXXXXXYI", 0.024104542695134838], ["XIIIIIIIIIIIIXYXXXYI", 0.02407886470764104], ["YIIIIIIIIIIIIYYXXXYI", 0.02407886470764104], ["XIIIIIIIIIIIIYYYYXXI", 0.02407821129564789], ["YIIIIIIIIIIIIXYYYXXI", -0.02407821129564789], ["XIIIIIIIIIIIIYYXYYXI", 0.024017344822110463], ["YIIIIIIIIIIIIXYXYYXI", -0.024017344822110463], ["XIIIIIIIIIIIIYXYXXXI", -0.024002206896584898], ["YIIIIIIIIIIIIXXYXXXI", 0.024002206896584898], ["XIIIIIIIIIIIIXXXYXYI", 0.023990998156616865], ["YIIIIIIIIIIIIYXXYXYI", 0.023990998156616865], ["XIIIIIIIIIIIIXXYYXXI", 0.023982327872627413], ["YIIIIIIIIIIIIYXYYXXI", 0.023982327872627413], ["XIIIIIIIIIIIIXYYXXXI", 0.02394658272119049], ["YIIIIIIIIIIIIYYYXXXI", 0.02394658272119049], ["XIIIIIIIIIIIIXXXXYYI", 0.023660364191832095], ["YIIIIIIIIIIIIYXXXYYI", 0.023660364191832095], ["XIIIIIIIIIIIIXYXYYYI", -0.023612924174725745], ["YIIIIIIIIIIIIYYXYYYI", -0.023612924174725745], ["XIIIIIIIIIIIIXYYYYXI", -0.02358264805064134], ["YIIIIIIIIIIIIYYYYYXI", -0.02358264805064134], ["XIIIIIIIIIIIIYXYYXYI", 0.023566828574144272], ["YIIIIIIIIIIIIXXYYXYI", -0.023566828574144272], ["XIIIIIIIIIIIIYXXYYYI", 0.023564398804039755], ["YIIIIIIIIIIIIXXXYYYI", -0.023564398804039755], ["XIIIIIIIIIIIIXXYXYXI", 0.02355396731440562], ["YIIIIIIIIIIIIYXYXYXI", 0.02355396731440562], ["XIIIIIIIIIIIIYXYYYXI", 0.02353003846923867], ["YIIIIIIIIIIIIXXYYYXI", -0.02353003846923867], ["XIIIIIIIIIIIIYYYXXYI", 0.023526624256680426], ["YIIIIIIIIIIIIXYYXXYI", -0.023526624256680426], ["XIIIIIIIIIIIIYYXXYYI", 0.02350411715197553], ["YIIIIIIIIIIIIXYXXYYI", -0.02350411715197553], ["XIIIIIIIIIIIIYYYXYXI", 0.02345419115622137], ["YIIIIIIIIIIIIXYYXYXI", -0.02345419115622137], ["XIIIIIIIIIIIIYXXYXXI", -0.02343504507272356], ["YIIIIIIIIIIIIXXXYXXI", 0.02343504507272356], ["XIIIIIIIIIIIIXYYYXYI", -0.023419194967496094], ["YIIIIIIIIIIIIYYYYXYI", -0.023419194967496094], ["XIIIIIIIIIIIIXXYXXYI", 0.023389512378306096], ["YIIIIIIIIIIIIYXYXXYI", 0.023389512378306096], ["XIIIIIIIIIIIIXYXYXXI", 0.023344194580454638], ["YIIIIIIIIIIIIYYXYXXI", 0.023344194580454638], ["XIIIIIIIIIIIIYYXXXXI", -0.023339545846585603], ["YIIIIIIIIIIIIXYXXXXI", 0.023339545846585603], ["XIIIIIIIIIIIIXXXXXXI", -0.02280862713889307], ["YIIIIIIIIIIIIYXXXXXI", -0.02280862713889307], ["XIIIIIIIIIIIIIIIYYIX", 0.01580047352304733]]} \ No newline at end of file +{ + "10": [ + ["XIIIIIIIXI", -0.7526137035201601], + ["XIIIIIIXXI", -0.37336084437331796], + ["XIIIIIIYYI", -0.38415596887523673], + ["XZIXIZZZZI", -0.006612905308067554], + ["YIIIIIIIYI", -0.7526137035201601], + ["XIIIXXYYXI", 0.051516042757856595], + ["YIIYXYYYYI", -0.02787456236145021], + ["XIZIIIIIXI", -0.013449113937452212], + ["YIIIIIIXYI", 0.38415596887523673], + ["XIIIIIYXYI", -0.19424150139041263], + ["XIIIIIIYIY", 0.029720649244903058], + ["XIIZZZXZZI", -0.007109908237121916], + ["XZIIIIIIXI", -0.04933462211354994], + ["YIIIIIXXYI", 0.19424150139041263], + ["YIIIIYYXYI", 0.09797196440842665], + ["XIIIZIIIXI", -0.007825806002393486], + ["YIIIIIIYXI", -0.37336084437331796], + ["XIXYYXYXYI", -0.014830501861161874], + ["XYXXYYYXXI", 0.011070832097706011], + ["ZXXXXXXXXI", -0.006572351502781893], + ["XIIIIIXYYI", 0.19386532534886877], + ["XIIIIIYYXI", -0.18678800030285186], + ["YIIIIIYYYI", 0.19386532534886877], + ["YZIYIZZZZI", -0.006612905308067554], + ["YIIIIIXYXI", 0.18678800030285186], + ["YIIIXXYXXI", 0.05105565386817196], + ["XIIYYXYYXI", 0.027526204018504478], + ["YIZIIIIIYI", -0.013449113937452212], + ["XIIIIIXXXI", -0.18323015243607135], + ["XIIIIXYXYI", 0.09797196440842665], + ["YIIIIIIXIY", -0.029720649244903058], + ["YIIZZZYZZI", -0.007109908237121916], + ["YZIIIIIIYI", -0.04933462211354994], + ["XIIIIYXYXI", -0.09790485429098861], + ["XIIIIYXXYI", -0.09738539217062862], + ["YIIIZIIIYI", -0.007825806002393486], + ["YIIIIIYXXI", -0.18323015243607135], + ["YIXXYXYXYI", -0.014830501861161874], + ["YYYXYYYXXI", -0.011070832097706011], + ["ZXXXXXXYYI", 0.006572351502781893], + ["YIIIIXXYXI", 0.09790485429098861], + ["XIIIIXYYXI", 0.09723073331248952], + ["YIIIIYYYXI", 0.09723073331248952], + ["XZIXIIZIII", -0.006442771857138567], + ["XIIIIIIXIX", 0.03782159881982394], + ["YIIIXYXYYI", -0.05081457021131695], + ["XIIYYYYXXI", 0.02691422493459414], + ["XZZIIIIIXI", 0.012785230601782186], + ["YIIIIXXXYI", 0.09738539217062862], + ["XIIIIXXYYI", 0.0936375449565515], + ["XZIIIIIYIY", 0.02736493560510323], + ["XIIXZXXZZI", 0.0070057024561532314], + ["YZZIIIIIYI", 0.012785230601782186], + ["YIIIIYXYYI", 0.0936375449565515], + ["XIIIIYYYYI", 0.09298355472236805], + ["XZIIZIIIXI", 0.007170911589543703], + ["YIIIIXYYYI", -0.09298355472236805], + ["XIXXYXXYXI", 0.014790913647481705], + ["XYXXXXYXXI", -0.01068597467739666], + ["ZXXXXXYXYI", 0.006572351502781893], + ["XIIIIYYXXI", -0.09210460232707157], + ["YIIIIXYXXI", 0.09210460232707157], + ["YIIIYXYYXI", 0.051516042757856595], + ["YZIYIIZIII", -0.006442771857138567], + ["YIIIIIIYIX", 0.03782159881982394], + ["XIIIXYXXYI", 0.050446601073475254], + ["XIIYXXXXYI", -0.02666217783475839], + ["XZZIIIIXXI", 0.00837965253402453], + ["XIIIIXXXXI", -0.08891475352327935], + ["XIIIYXYXXI", -0.05105565386817196], + ["YZIIIIIXIY", -0.02736493560510323], + ["YIIYZXXZZI", 0.0070057024561532314], + ["XIIIIIXIII", 0.011189896923879047], + ["YIIIIYXXXI", -0.08891475352327935], + ["XIIIYYXYYI", 0.05081457021131695], + ["YZIIZIIIYI", 0.007170911589543703], + ["YIIIYYXXYI", 0.050446601073475254], + ["YIXYYXXYXI", -0.014790913647481705], + ["YYYXXXYXXI", 0.01068597467739666], + ["ZXXXXXYYXI", 0.006572351502781893], + ["XIIIYYYYXI", 0.05044317333961998], + ["YIIIXYYYXI", -0.05044317333961998], + ["XIIIXXXYYI", 0.04959844986045102], + ["XIIIIIZIXI", -0.006432707991474218], + ["XZIIIIIXIX", 0.027345400379519765], + ["XIIIXYYXXI", 0.050092874043860355], + ["XIIYYYYYYI", -0.026648596578796042], + ["YZZIIIIYXI", 0.00837965253402453], + ["YIIIYYYXXI", 0.050092874043860355], + ["XIIIYXXXYI", -0.04930312270999021], + ["XZIIIIXYIY", -0.015146886131722144], + ["XZIIIIXIZI", -0.006899554288018264], + ["YIIIIIYIII", 0.011189896923879047], + ["YIIIYXXYYI", 0.04959844986045102], + ["XIIIYYYXYI", 0.04521119690374699], + ["XZIZZZXZII", 0.007169269812186064], + ["YIIIXXXXYI", 0.04930312270999021], + ["XIXXYYYXYI", -0.014729888610199814], + ["XYXXYYXXYI", 0.010665312687926313], + ["ZXXXXYXXYI", 0.006572351502781893], + ["XIIIXXYXYI", 0.04587700432126865], + ["XIIIXYXYXI", 0.04459788393254507], + ["XIIIYXYYYI", 0.04560714016273523], + ["YIIIIIZIYI", -0.006432707991474218], + ["YZIIIIIYIX", 0.027345400379519765], + ["YIIIXXYYYI", -0.04560714016273523], + ["YIIYYYXXXI", 0.026636426365035736], + ["XIZZZIIIXI", -0.006823631624625939], + ["YIIIYXYXYI", 0.04587700432126865], + ["XIIIXYYYYI", -0.04486088857347642], + ["YZIIIIYYIY", -0.015146886131722144], + ["YZIIIIYIZI", -0.006899554288018264], + ["XIIZIIIIXI", -0.010013037009411004], + ["YIIIYYXYXI", 0.04459788393254507], + ["YIIIXYYXYI", -0.04521119690374699], + ["YZIZZZYZII", 0.007169269812186064], + ["YIIIYYYYYI", -0.04486088857347642], + ["YIXYYYYXYI", 0.014729888610199814], + ["YYYXYYXXYI", -0.010665312687926313], + ["ZXXXXYXYXI", 0.006572351502781893], + ["XIIIYYXXXI", -0.0437341322771147], + ["YIIIXYXXXI", 0.0437341322771147], + ["XIIIYXXYXI", -0.043159569527918745], + ["YIIIXXXYXI", 0.043159569527918745], + ["XIIIXXXXXI", -0.04150724130826612], + ["YIIIYXXXXI", -0.04150724130826612], + ["XIIXXYYYYI", -0.02787456236145021], + ["YIIXYXYYXI", -0.027526204018504478], + ["YIIXYYYXXI", -0.02691422493459414], + ["YIIXXXXXYI", 0.02666217783475839], + ["YIIXYYYYYI", 0.026648596578796042], + ["XIIXYYXXXI", 0.026636426365035736], + ["XIIXXXYYXI", 0.026403630605820266], + ["YIIYXXYYXI", 0.026403630605820266], + ["XIIXXXYXYI", 0.026362576038375586], + ["YIIYXXYXYI", 0.026362576038375586], + ["XIIXXYYXXI", 0.0261156926061024], + ["YIIYXYYXXI", 0.0261156926061024], + ["XIIYXYXYYI", 0.02596861341042802], + ["YIIXXYXYYI", -0.02596861341042802], + ["XIIXYXXXYI", 0.0258197989775319], + ["YIIYYXXXYI", 0.0258197989775319], + ["XIIXYXXYXI", 0.0257366367628273], + ["YIIYYXXYXI", 0.0257366367628273], + ["XIIYXYXXXI", -0.025684851821564002], + ["YIIXXYXXXI", 0.025684851821564002], + ["XIIYYXYXYI", 0.025466821824393464], + ["YIIXYXYXYI", -0.025466821824393464], + ["XIIXYYXYYI", -0.024756913701190417], + ["YIIYYYXYYI", -0.024756913701190417], + ["XIIYXXXYXI", -0.024433472934039593], + ["YIIXXXXYXI", 0.024433472934039593], + ["XIIYXYYXYI", 0.023332759688308016], + ["YIIXXYYXYI", -0.023332759688308016], + ["XZIIIIIYYI", -0.023142209116660137], + ["YZIIIIIXYI", 0.023142209116660137], + ["XIIIIIXXIX", 0.022895402429390692], + ["YIIIIIYXIX", 0.022895402429390692], + ["XIIXYXYXXI", 0.022719156992529476], + ["YIIYYXYXXI", 0.022719156992529476], + ["XIIXYYYXYI", -0.02211534108628905], + ["YIIYYYYXYI", -0.02211534108628905], + ["XIIXYYYYXI", -0.022114594999291054], + ["YIIYYYYYXI", -0.022114594999291054], + ["XIIYYYXYXI", 0.021932152598550934], + ["YIIXYYXYXI", -0.021932152598550934], + ["XIIYXXYYYI", 0.021902860602432215], + ["YIIXXXYYYI", -0.021902860602432215], + ["XZIIIIIXXI", -0.021780522375656204], + ["YZIIIIIYXI", -0.021780522375656204], + ["XIIXXXXYYI", 0.021612581396226377], + ["YIIYXXXYYI", 0.021612581396226377], + ["XIIYXXYXXI", -0.02158810464013425], + ["YIIXXXYXXI", 0.02158810464013425], + ["XIIYXYYYXI", 0.02131831369425804], + ["YIIXXYYYXI", -0.02131831369425804], + ["XIIXXYXXYI", 0.02114245861852753], + ["YIIYXYXXYI", 0.02114245861852753], + ["XIIXYXYYYI", -0.021003533985481704], + ["YIIYYXYYYI", -0.021003533985481704], + ["XIIXXYXYXI", 0.02099192408564843], + ["YIIYXYXYXI", 0.02099192408564843], + ["XIIYYXXYYI", 0.020761016521141717], + ["YIIXYXXYYI", -0.020761016521141717], + ["XIIYYYXXYI", 0.01993246796406775], + ["YIIXYYXXYI", -0.01993246796406775], + ["XIIYYXXXXI", -0.019920718063269928], + ["YIIXYXXXXI", 0.019920718063269928], + ["XIIIIIYYIX", 0.019417290274795877], + ["YIIIIIXYIX", -0.019417290274795877], + ["XIIXXXXXXI", -0.01857204712429268], + ["YIIYXXXXXI", -0.01857204712429268], + ["XZIIIIXXXI", -0.016348051075808806], + ["YZIIIIYXXI", -0.016348051075808806], + ["XZIIIIYXIY", 0.015110850469518992], + ["YZIIIIXXIY", -0.015110850469518992], + ["XIYXYXYXYI", 0.014830501861161874], + ["YIYYYXYXYI", -0.014830501861161874], + ["XIYYYXXYXI", 0.014790913647481705], + ["YIYXYXXYXI", 0.014790913647481705] + ], + "20": [ + ["XIIIIIIIIIIIIIIIIIXI", -0.7597555791257463], + ["XIIIIIIIIIIIIIIIIXXI", -0.3788134383984239], + ["XIIIIIIIIIIIIIIIIYYI", -0.3816091687294096], + ["XIIIIIIIIIZIZZZIZIXI", -0.000965140468847494], + ["YIIIIIIIIIIIIIIIIIYI", -0.7597555791257463], + ["YIIIIIIIIIIIIIXXXXYI", 0.048034693195222355], + ["YIIIIIIIIIIIIYXYYYYI", -0.024288501533429433], + ["XIIIIIIIIIIIZIIIIIXI", -0.0014745501558381339], + ["YIIIIIIIIIIIIIIIIXYI", 0.3816091687294096], + ["XIIIIIIIIIXXYYXXXXXI", 0.0034489756067628305], + ["XIIIIIIIIYXYYYYXXXYI", -0.0018385588074672434], + ["XZZZZZZZZIIIIIIIIIXI", -0.04247685949008335], + ["IXXXXXXXXXXXXXXXXXXI", -0.0008215439378477366], + ["XIIIIIIIIIIIIIIIIXIX", 0.032519358059862634], + ["XIIIIIIIIIIIIIIIXYYI", 0.1911132990260518], + ["XXXXXXXXXYZYYZZYXZIZ", -0.0009859910537224725], + ["YIIIIIIIIIIIIIIIIYXI", -0.3788134383984239], + ["YIIIIIIIIIIIIIIXXXYI", 0.09569082741024892], + ["XIIIIIIIIIIIIIYXXXYI", -0.048034693195222355], + ["XIIIIIIIIIIIIZIIIIXI", -0.0012072669323203635], + ["YIIIIIIIIIIIIIIIYYYI", 0.1911132990260518], + ["XIIIIIIIIIIXYXYXYXYI", -0.0063025199264490185], + ["YIIIIIIIIIYXYYXXXXXI", 0.0034489756067628305], + ["XIIIIIIIIZIIIIIIIIXI", -0.006678279604201871], + ["XIIIIIIIIIIIIIIIYXYI", -0.1909251749011368], + ["XIIIIIIIIIIIIIIIYYXI", -0.18982912184635464], + ["XIIIIIIIIIIIIIIIIYIY", 0.029899797457073666], + ["XZZZZZZZZIIIIIIIIXZZ", -0.004392057316095634], + ["YZZZZZZZZIIIIIIIIIYI", -0.04247685949008335], + ["YIIIIIIIIIIIIIIIXXYI", 0.1909251749011368], + ["XIIIIIIIIIIIIIIYXXYI", -0.09569082741024892], + ["XXXXXXXXXYYIZXZXYYXI", -0.0010722513190686877], + ["YIIIIIIIIIIIIIIIXYXI", 0.18982912184635464], + ["YIIIIIIIIIIIXYXYXXYI", -0.012374279005608061], + ["YIIIIIIIIIIYYXYXYXYI", -0.0063025199264490185], + ["XIIIIIIIIIZIIIIIIIXI", -0.0031537081858958207], + ["XIIIIIIIIIIIIIIIXXXI", -0.1886473171987223], + ["XXXXXXXXXXXIIXIXXXXI", 0.0010776146506793866], + ["YIIIIIIIIIIIIIIIYXXI", -0.1886473171987223], + ["YZZZZZZZZIIIIIIIIYZZ", -0.004392057316095634], + ["YIIIIIIIIIIIIIIIIYIX", 0.032519358059862634], + ["XIIIIIIIIIIIIIIXYXYI", 0.09564395067494046], + ["YIIIIIIIIIIIIIIYYXYI", 0.09564395067494046], + ["XIIIIIIIIIIIIIIZIIXI", -0.000986728020319752], + ["XIIIIIIIIIIIIIIYXYXI", -0.09544725083131203], + ["XIIIIIIIIIIIIXXYYYYI", -0.024288501533429433], + ["XIIIIIIIIIIIYYXYXXYI", 0.012374279005608061], + ["XIIIIIIIIIIZIIIIIIXI", -0.0020245744624640756], + ["YIIIIIIIIIIIIIIXXYXI", 0.09544725083131203], + ["XIIIIIIIIXYYYYYXXXYI", 0.0018385588074672434], + ["XYYYYYYYYYXIIXIXXXXI", 0.0010776146506793866], + ["ZXXXXXXXXXXXXXXXXXXI", -0.0008215439378477366], + ["XIIIIIIIIIIIIIIXYYXI", 0.09542273913256943], + ["YIIIIIIIIIIIIIIYYYXI", 0.09542273913256943], + ["XIIIIIIIIIIIIIIXXYYI", 0.09501085307200312], + ["YIIIIIIIIIZIZZZIZIYI", -0.000965140468847494], + ["XZZZZZZZZIIIIIIIIXIX", 0.03036004987263414], + ["XIIIIIIIIIIIIIXXXYYI", 0.04797669720376477], + ["YIIIIIIIIIIIIYYYXYYI", -0.024283149819588574], + ["YIIIIIIIIIIIZIIIIIYI", -0.0014745501558381339], + ["YIIIIIIIIIIIIIIYXYYI", 0.09501085307200312], + ["XIIIIIIIIIXYXYXXXYYI", -0.0034460998319557614], + ["YIIIIIIIIYYYYYYXXXYI", 0.0018385588074672434], + ["YZZZZZZZZIIIIIIIIYIX", 0.03036004987263414], + ["IXXXXXXXXXXXXXXXXYYI", 0.0008215439378477366], + ["XIIIIIIIIIIIIIIIXXIX", 0.016934143310274964], + ["XIIIIIIIIIIIIIIYYYYI", 0.09500871845303184], + ["XYYYYYYYYXZYYZZYXZIZ", 0.0009859910537224725], + ["YIIIIIIIIIIIIIIIIXIY", -0.029899797457073666], + ["YIIIIIIIIIIIIIIXYYYI", -0.09500871845303184], + ["YIIIIIIIIIIIIIYXXYYI", 0.04797669720376477], + ["YIIIIIIIIIIIIZIIIIYI", -0.0012072669323203635], + ["XIIIIIIIIIIIIIIYYXXI", -0.09459704485910016], + ["YIIIIIIIIIIXYXXYYXXI", -0.006296412913254014], + ["YIIIIIIIIIYYXYXXXYYI", -0.0034460998319557614], + ["YIIIIIIIIZIIIIIIIIYI", -0.006678279604201871], + ["YIIIIIIIIIIIIIIXYXXI", 0.09459704485910016], + ["XIIIIIIIIIIIIIIXXXXI", -0.09392136813839039], + ["XZZZZZZZZIIIIIIIIYIY", 0.029648188325124326], + ["XIIIIIIIIIIIIIIIIXZZ", -0.004347501257809116], + ["XZZZZZZZZZIIIIIIIIXI", 0.006594960463259015], + ["YIIIIIIIIIIIIIIYXXXI", -0.09392136813839039], + ["XIIIIIIIIIIIIIXYXXYI", 0.047971572042292715], + ["XYYYYYYYYXYIZXZXYYXI", 0.0010722513190686877], + ["YIIIIIIIIIIIIIYYXXYI", 0.047971572042292715], + ["YIIIIIIIIIIIXXXXXXYI", 0.01236283983073573], + ["XIIIIIIIIIIYYXXYYXXI", 0.006296412913254014], + ["YIIIIIIIIIZIIIIIIIYI", -0.0031537081858958207], + ["XIIIIIIIIIIIIIYYXYYI", 0.04796639844692382], + ["YXXXXXXXXYXIIXIXXXXI", -0.0010776146506793866], + ["YIIIIIIIIIIIIIXYXYYI", -0.04796639844692382], + ["YIIIIIIIIIIIIIIIIYZZ", -0.004347501257809116], + ["YZZZZZZZZIIIIIIIIXIY", -0.029648188325124326], + ["XIIIIIIIIIIIIIXYYXXI", 0.047836394705299566], + ["XIIIIIIIIIIIIIXXYYXI", 0.04795217784026999], + ["YIIIIIIIIIIIIIIZIIYI", -0.000986728020319752], + ["XZZZZZZZZIIIIIIIIYYI", -0.021465538187191525], + ["XIIIIIIIIIIIIXYYXYYI", -0.024283149819588574], + ["XIIIIIIIIIIIYXXXXXYI", -0.01236283983073573], + ["YIIIIIIIIIIZIIIIIIYI", -0.0020245744624640756], + ["YIIIIIIIIIIIIIYXYYXI", 0.04795217784026999], + ["YIIIIIIIIXXYYYYXXXYI", 0.0018385588074672434], + ["YYYYYYYYYXXIIXIXXXXI", 0.0010776146506793866], + ["ZXXXXXXXXXXXXXXXXYYI", 0.0008215439378477366], + ["XIIIIIIIIIIIIIYYYYXI", 0.04785498815847788], + ["YIIIIIIIIIIIIIXYYYXI", -0.04785498815847788], + ["XIIIIIIIIIIIIIYXYYYI", 0.04736747465909179], + ["XXXXXXXXXYYZZZYYZZYY", 0.0009404226016837798], + ["YZZZZZZZZIIIIIIIIXYI", 0.021465538187191525], + ["YIIIIIIIIIIIIIXXYXXI", 0.047831133668291004], + ["YIIIIIIIIIIIIYXXYYXI", 0.024266198663343924], + ["XZZZZZZZZIIIZIIIIIXI", 0.0013915658848147139], + ["YIIIIIIIIIIIIIYYYXXI", 0.047836394705299566], + ["YIIIIIIIIIXXXYXXXYYI", -0.0034428185573980993], + ["XIIIIIIIIYYYYXXXXXXI", 0.001835428143108581], + ["XZZZZZZZZIIIIIIIIXXI", -0.020457124625547614], + ["IXXXXXXXXXXXXXXXYXYI", 0.0008215439378477366], + ["YIIIIIIIIIIIIIIIYXIX", 0.016934143310274964], + ["YIIIIIIIIIIIIIXXYYYI", -0.04736747465909179], + ["YXXXXXXXXXZYYZZYXZIZ", -0.0009859910537224725], + ["YZZZZZZZZIIIIIIIIYXI", -0.020457124625547614], + ["XIIIIIIIIIIIIIYXYXXI", -0.047831133668291004], + ["YIIIIIIIIIIIIIYXYXYI", 0.04736214327368851], + ["XZZZZZZZZIIIIZIIIIXI", 0.0011246581686555233], + ["XIIIIIIIIIIIIIXXYXYI", 0.04736214327368851], + ["XIIIIIIIIIIXXYYXXXXI", 0.006293165273497527], + ["XIIIIIIIIIYXXYXXXYYI", 0.0034428185573980993], + ["YZZZZZZZZZIIIIIIIIYI", 0.006594960463259015], + ["XIIIIIIIIIIIIIYYYXYI", 0.047320759424729644], + ["XIIIIIIIIIIIIIXYYYYI", -0.04731583349766409], + ["YIIIIIIIIIIIIIXYYXYI", -0.047320759424729644], + ["YIIIIIIIIIIIIIYYYYYI", -0.04731583349766409], + ["XIIIIIIIIIIIIIXYXYXI", 0.04715986341941597], + ["YIIIIIIIIIIIIIYYXYXI", 0.04715986341941597], + ["XIIIIIIIIIIIIIYXXYXI", -0.04708759877215153], + ["YIIIIIIIIIIIIIXXXYXI", 0.04708759877215153], + ["XIIIIIIIIIIIIIYYXXXI", -0.047077329797287154], + ["YIIIIIIIIIIIIIXYXXXI", 0.047077329797287154], + ["XIIIIIIIIIIIIIXXXXXI", -0.046483027941077046], + ["YIIIIIIIIIIIIIYXXXXI", -0.046483027941077046], + ["XIIIIIIIIIIIIXXXYYXI", 0.024266198663343924], + ["XIIIIIIIIIIIIXYXXYXI", 0.024221035620844704], + ["YIIIIIIIIIIIIYYXXYXI", 0.024221035620844704], + ["XIIIIIIIIIIIIYYXYXYI", 0.02417081593949432], + ["YIIIIIIIIIIIIXYXYXYI", -0.02417081593949432], + ["XIIIIIIIIIIIIYYYYYYI", -0.024133364967802363], + ["YIIIIIIIIIIIIXYYYYYI", 0.024133364967802363], + ["XIIIIIIIIIIIIYXXXYXI", -0.024124159069099572], + ["YIIIIIIIIIIIIXXXXYXI", 0.024124159069099572], + ["XIIIIIIIIIIIIYXYXYYI", 0.024120661853799782], + ["YIIIIIIIIIIIIXXYXYYI", -0.024120661853799782], + ["XIIIIIIIIIIIIYXXXXYI", -0.024104542695134838], + ["YIIIIIIIIIIIIXXXXXYI", 0.024104542695134838], + ["XIIIIIIIIIIIIXYXXXYI", 0.02407886470764104], + ["YIIIIIIIIIIIIYYXXXYI", 0.02407886470764104], + ["XIIIIIIIIIIIIYYYYXXI", 0.02407821129564789], + ["YIIIIIIIIIIIIXYYYXXI", -0.02407821129564789], + ["XIIIIIIIIIIIIYYXYYXI", 0.024017344822110463], + ["YIIIIIIIIIIIIXYXYYXI", -0.024017344822110463], + ["XIIIIIIIIIIIIYXYXXXI", -0.024002206896584898], + ["YIIIIIIIIIIIIXXYXXXI", 0.024002206896584898], + ["XIIIIIIIIIIIIXXXYXYI", 0.023990998156616865], + ["YIIIIIIIIIIIIYXXYXYI", 0.023990998156616865], + ["XIIIIIIIIIIIIXXYYXXI", 0.023982327872627413], + ["YIIIIIIIIIIIIYXYYXXI", 0.023982327872627413], + ["XIIIIIIIIIIIIXYYXXXI", 0.02394658272119049], + ["YIIIIIIIIIIIIYYYXXXI", 0.02394658272119049], + ["XIIIIIIIIIIIIXXXXYYI", 0.023660364191832095], + ["YIIIIIIIIIIIIYXXXYYI", 0.023660364191832095], + ["XIIIIIIIIIIIIXYXYYYI", -0.023612924174725745], + ["YIIIIIIIIIIIIYYXYYYI", -0.023612924174725745], + ["XIIIIIIIIIIIIXYYYYXI", -0.02358264805064134], + ["YIIIIIIIIIIIIYYYYYXI", -0.02358264805064134], + ["XIIIIIIIIIIIIYXYYXYI", 0.023566828574144272], + ["YIIIIIIIIIIIIXXYYXYI", -0.023566828574144272], + ["XIIIIIIIIIIIIYXXYYYI", 0.023564398804039755], + ["YIIIIIIIIIIIIXXXYYYI", -0.023564398804039755], + ["XIIIIIIIIIIIIXXYXYXI", 0.02355396731440562], + ["YIIIIIIIIIIIIYXYXYXI", 0.02355396731440562], + ["XIIIIIIIIIIIIYXYYYXI", 0.02353003846923867], + ["YIIIIIIIIIIIIXXYYYXI", -0.02353003846923867], + ["XIIIIIIIIIIIIYYYXXYI", 0.023526624256680426], + ["YIIIIIIIIIIIIXYYXXYI", -0.023526624256680426], + ["XIIIIIIIIIIIIYYXXYYI", 0.02350411715197553], + ["YIIIIIIIIIIIIXYXXYYI", -0.02350411715197553], + ["XIIIIIIIIIIIIYYYXYXI", 0.02345419115622137], + ["YIIIIIIIIIIIIXYYXYXI", -0.02345419115622137], + ["XIIIIIIIIIIIIYXXYXXI", -0.02343504507272356], + ["YIIIIIIIIIIIIXXXYXXI", 0.02343504507272356], + ["XIIIIIIIIIIIIXYYYXYI", -0.023419194967496094], + ["YIIIIIIIIIIIIYYYYXYI", -0.023419194967496094], + ["XIIIIIIIIIIIIXXYXXYI", 0.023389512378306096], + ["YIIIIIIIIIIIIYXYXXYI", 0.023389512378306096], + ["XIIIIIIIIIIIIXYXYXXI", 0.023344194580454638], + ["YIIIIIIIIIIIIYYXYXXI", 0.023344194580454638], + ["XIIIIIIIIIIIIYYXXXXI", -0.023339545846585603], + ["YIIIIIIIIIIIIXYXXXXI", 0.023339545846585603], + ["XIIIIIIIIIIIIXXXXXXI", -0.02280862713889307], + ["YIIIIIIIIIIIIYXXXXXI", -0.02280862713889307], + ["XIIIIIIIIIIIIIIIYYIX", 0.01580047352304733] + ] +} diff --git a/algorithms/glued_trees/glued_trees_example.json b/algorithms/glued_trees/glued_trees_example.json deleted file mode 100644 index 1fa3000a..00000000 --- a/algorithms/glued_trees/glued_trees_example.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "friendly_name": "Glued Trees Algorithm", - "description": "Glued Trees Algorithm for 20 Qubits at t=2n", - "qmod_type": ["algorithms"], - "problem_domain_tags": [], - "level": ["advanced"] -} \ No newline at end of file diff --git a/algorithms/glued_trees/glued_trees_example.metadata.json b/algorithms/glued_trees/glued_trees_example.metadata.json new file mode 100644 index 00000000..cf4c784f --- /dev/null +++ b/algorithms/glued_trees/glued_trees_example.metadata.json @@ -0,0 +1,7 @@ +{ + "friendly_name": "Glued Trees Algorithm", + "description": "Glued Trees Algorithm for 20 Qubits at t=2n", + "qmod_type": ["algorithms"], + "problem_domain_tags": [], + "level": ["advanced"] +} diff --git a/algorithms/glued_trees/glued_trees_example.qmod b/algorithms/glued_trees/glued_trees_example.qmod index 2a384ab4..f9e4013c 100644 --- a/algorithms/glued_trees/glued_trees_example.qmod +++ b/algorithms/glued_trees/glued_trees_example.qmod @@ -5003,4 +5003,3 @@ qfunc main(output state: qbit[]) { } ], 1048576, 1400>(state); } - diff --git a/algorithms/glued_trees/glued_trees_example.synthesis_options.json b/algorithms/glued_trees/glued_trees_example.synthesis_options.json index 9e26dfee..0967ef42 100644 --- a/algorithms/glued_trees/glued_trees_example.synthesis_options.json +++ b/algorithms/glued_trees/glued_trees_example.synthesis_options.json @@ -1 +1 @@ -{} \ No newline at end of file +{} diff --git a/algorithms/glued_trees/results/10-qubits/2n+0.json b/algorithms/glued_trees/results/10-qubits/2n+0.json index f9b5ad26..4fc73672 100644 --- a/algorithms/glued_trees/results/10-qubits/2n+0.json +++ b/algorithms/glued_trees/results/10-qubits/2n+0.json @@ -1 +1,446 @@ -{"vendor_format_result": {}, "counts": {"1111101100": 1, "1001010111": 1, "1100001101": 1, "0110111111": 1, "0000001100": 1, "0110101001": 2, "0000010101": 1, "1000011111": 1, "0111101011": 2, "0100000001": 2, "1100010000": 1, "0100011010": 1, "0001001110": 1, "0010110001": 1, "1000001010": 1, "1011101001": 4, "0011111010": 1, "1111100111": 1, "0110110011": 3, "0010111001": 1, "0100011100": 1, "0110101011": 1, "1110100010": 2, "0111100011": 7, "0000010001": 1, "1111101111": 1, "1110111000": 5, "0100010011": 2, "0110110100": 1, "0011110000": 5, "0110100001": 1, "1110110011": 7, "0111100000": 1, "1000001100": 2, "1111100011": 4, "1000010110": 8, "1110100110": 9, "0100000010": 12, "1100011010": 4, "1000000100": 5, "1011110011": 6, "0110110010": 3, "0000011000": 3, "1101000111": 1, "1000001111": 4, "1100001100": 2, "0100001100": 5, "0111101110": 2, "1100011001": 2, "1111101011": 11, "0101001110": 3, "0000000110": 1, "0111111001": 15, "0111111111": 22, "1000001101": 1, "0111110010": 80, "0100001011": 57, "0111101100": 2, "1011110101": 4, "1000000110": 24, "1111001111": 1, "0000001111": 47, "1000000101": 80, "0110110110": 15, "1011101110": 11, "1110101001": 1, "1000011110": 6, "0000000100": 55, "1011111011": 3, "0100010111": 5, "0011110101": 2, "0110100000": 10, "0111110000": 136, "0110110101": 6, "0010111101": 1, "1110111110": 32, "0110101000": 3, "1111110011": 209, "1111111110": 1193, "0111110001": 19, "1011111111": 1, "1100000000": 12, "0000001000": 44, "1111110101": 334, "0100000000": 225, "0000011111": 4, "1111101001": 42, "0111110110": 48, "0000000011": 78, "1000001000": 1, "1100001010": 65, "1110110110": 12, "0000000111": 330, "1000001110": 87, "0100001110": 5, "0100010000": 42, "0111111101": 1322, "1100010110": 14, "1111101010": 2, "0000001010": 3, "1111100001": 7, "1111110000": 2, "1110101011": 2, "1011110001": 5, "1111101110": 140, "0000011101": 1, "1011111110": 99, "1111100101": 10, "1111110110": 276, "0110100011": 22, "1100001011": 2, "0111101101": 5, "1000000001": 16, "1101001111": 1, "1000000000": 3, "0100011000": 9, "1110110101": 12, "1000010001": 3, "1111111001": 312, "1111110111": 9, "1111111111": 86, "1110110001": 18, "1100001110": 83, "1110110100": 3, "1000001001": 59, "1000000111": 2, "1111111101": 30, "1111111011": 96, "0110101010": 1, "0100000101": 1, "0110101110": 2, "0000000000": 88, "1111110001": 195, "1010110000": 2, "0110100100": 40, "0000010011": 4, "0110110001": 8, "1111111000": 371, "0111111100": 30, "1010110111": 2, "0001011101": 1, "0000010111": 47, "1100001001": 30, "0111110100": 75, "0100001101": 4, "0100001010": 5, "0111100101": 9, "0111110011": 119, "0000010100": 4, "1111100110": 29, "1011100100": 1, "0110111100": 4, "1110101110": 49, "0110101101": 4, "0111111010": 29, "0111100110": 1, "0000001101": 20, "0000000101": 1, "1110111001": 1, "0110111110": 3, "0100000111": 48, "0100001000": 105, "0110110000": 14, "1000000011": 9, "0011110010": 1, "0011111100": 10, "1000010101": 10, "0011101011": 1, "1011111001": 39, "0111111110": 19, "1111111100": 104, "0000011010": 1, "0011101100": 2, "0110111001": 1, "1111101000": 4, "1111110010": 28, "1111101101": 19, "1011111010": 37, "0100011011": 2, "0011110100": 4, "0000010000": 8, "0100000011": 31, "1100000110": 46, "1111000111": 1, "0110111010": 2, "0111101000": 4, "0110101100": 5, "0110101111": 3, "1110110000": 11, "0111100100": 6, "1101000010": 1, "0111111000": 4, "0011111000": 30, "1000010000": 1, "0011111011": 6, "0000001011": 10, "0110111101": 4, "1111111010": 25, "1110101101": 7, "0001000110": 1, "0000010010": 1, "0111110101": 11, "1110101010": 4, "0111111011": 19, "1110100001": 3, "0111110111": 119, "0000001110": 4, "0110111011": 13}, "counts_lsb_right": true, "parsed_states": {"1111101100": {"state": 1004.0}, "1001010111": {"state": 599.0}, "1100001101": {"state": 781.0}, "0110111111": {"state": 447.0}, "0000001100": {"state": 12.0}, "0110101001": {"state": 425.0}, "0000010101": {"state": 21.0}, "1000011111": {"state": 543.0}, "0111101011": {"state": 491.0}, "0100000001": {"state": 257.0}, "1100010000": {"state": 784.0}, "0100011010": {"state": 282.0}, "0001001110": {"state": 78.0}, "0010110001": {"state": 177.0}, "1000001010": {"state": 522.0}, "1011101001": {"state": 745.0}, "0011111010": {"state": 250.0}, "1111100111": {"state": 999.0}, "0110110011": {"state": 435.0}, "0010111001": {"state": 185.0}, "0100011100": {"state": 284.0}, "0110101011": {"state": 427.0}, "1110100010": {"state": 930.0}, "0111100011": {"state": 483.0}, "0000010001": {"state": 17.0}, "1111101111": {"state": 1007.0}, "1110111000": {"state": 952.0}, "0100010011": {"state": 275.0}, "0110110100": {"state": 436.0}, "0011110000": {"state": 240.0}, "0110100001": {"state": 417.0}, "1110110011": {"state": 947.0}, "0111100000": {"state": 480.0}, "1000001100": {"state": 524.0}, "1111100011": {"state": 995.0}, "1000010110": {"state": 534.0}, "1110100110": {"state": 934.0}, "0100000010": {"state": 258.0}, "1100011010": {"state": 794.0}, "1000000100": {"state": 516.0}, "1011110011": {"state": 755.0}, "0110110010": {"state": 434.0}, "0000011000": {"state": 24.0}, "1101000111": {"state": 839.0}, "1000001111": {"state": 527.0}, "1100001100": {"state": 780.0}, "0100001100": {"state": 268.0}, "0111101110": {"state": 494.0}, "1100011001": {"state": 793.0}, "1111101011": {"state": 1003.0}, "0101001110": {"state": 334.0}, "0000000110": {"state": 6.0}, "0111111001": {"state": 505.0}, "0111111111": {"state": 511.0}, "1000001101": {"state": 525.0}, "0111110010": {"state": 498.0}, "0100001011": {"state": 267.0}, "0111101100": {"state": 492.0}, "1011110101": {"state": 757.0}, "1000000110": {"state": 518.0}, "1111001111": {"state": 975.0}, "0000001111": {"state": 15.0}, "1000000101": {"state": 517.0}, "0110110110": {"state": 438.0}, "1011101110": {"state": 750.0}, "1110101001": {"state": 937.0}, "1000011110": {"state": 542.0}, "0000000100": {"state": 4.0}, "1011111011": {"state": 763.0}, "0100010111": {"state": 279.0}, "0011110101": {"state": 245.0}, "0110100000": {"state": 416.0}, "0111110000": {"state": 496.0}, "0110110101": {"state": 437.0}, "0010111101": {"state": 189.0}, "1110111110": {"state": 958.0}, "0110101000": {"state": 424.0}, "1111110011": {"state": 1011.0}, "1111111110": {"state": 1022.0}, "0111110001": {"state": 497.0}, "1011111111": {"state": 767.0}, "1100000000": {"state": 768.0}, "0000001000": {"state": 8.0}, "1111110101": {"state": 1013.0}, "0100000000": {"state": 256.0}, "0000011111": {"state": 31.0}, "1111101001": {"state": 1001.0}, "0111110110": {"state": 502.0}, "0000000011": {"state": 3.0}, "1000001000": {"state": 520.0}, "1100001010": {"state": 778.0}, "1110110110": {"state": 950.0}, "0000000111": {"state": 7.0}, "1000001110": {"state": 526.0}, "0100001110": {"state": 270.0}, "0100010000": {"state": 272.0}, "0111111101": {"state": 509.0}, "1100010110": {"state": 790.0}, "1111101010": {"state": 1002.0}, "0000001010": {"state": 10.0}, "1111100001": {"state": 993.0}, "1111110000": {"state": 1008.0}, "1110101011": {"state": 939.0}, "1011110001": {"state": 753.0}, "1111101110": {"state": 1006.0}, "0000011101": {"state": 29.0}, "1011111110": {"state": 766.0}, "1111100101": {"state": 997.0}, "1111110110": {"state": 1014.0}, "0110100011": {"state": 419.0}, "1100001011": {"state": 779.0}, "0111101101": {"state": 493.0}, "1000000001": {"state": 513.0}, "1101001111": {"state": 847.0}, "1000000000": {"state": 512.0}, "0100011000": {"state": 280.0}, "1110110101": {"state": 949.0}, "1000010001": {"state": 529.0}, "1111111001": {"state": 1017.0}, "1111110111": {"state": 1015.0}, "1111111111": {"state": 1023.0}, "1110110001": {"state": 945.0}, "1100001110": {"state": 782.0}, "1110110100": {"state": 948.0}, "1000001001": {"state": 521.0}, "1000000111": {"state": 519.0}, "1111111101": {"state": 1021.0}, "1111111011": {"state": 1019.0}, "0110101010": {"state": 426.0}, "0100000101": {"state": 261.0}, "0110101110": {"state": 430.0}, "0000000000": {"state": 0.0}, "1111110001": {"state": 1009.0}, "1010110000": {"state": 688.0}, "0110100100": {"state": 420.0}, "0000010011": {"state": 19.0}, "0110110001": {"state": 433.0}, "1111111000": {"state": 1016.0}, "0111111100": {"state": 508.0}, "1010110111": {"state": 695.0}, "0001011101": {"state": 93.0}, "0000010111": {"state": 23.0}, "1100001001": {"state": 777.0}, "0111110100": {"state": 500.0}, "0100001101": {"state": 269.0}, "0100001010": {"state": 266.0}, "0111100101": {"state": 485.0}, "0111110011": {"state": 499.0}, "0000010100": {"state": 20.0}, "1111100110": {"state": 998.0}, "1011100100": {"state": 740.0}, "0110111100": {"state": 444.0}, "1110101110": {"state": 942.0}, "0110101101": {"state": 429.0}, "0111111010": {"state": 506.0}, "0111100110": {"state": 486.0}, "0000001101": {"state": 13.0}, "0000000101": {"state": 5.0}, "1110111001": {"state": 953.0}, "0110111110": {"state": 446.0}, "0100000111": {"state": 263.0}, "0100001000": {"state": 264.0}, "0110110000": {"state": 432.0}, "1000000011": {"state": 515.0}, "0011110010": {"state": 242.0}, "0011111100": {"state": 252.0}, "1000010101": {"state": 533.0}, "0011101011": {"state": 235.0}, "1011111001": {"state": 761.0}, "0111111110": {"state": 510.0}, "1111111100": {"state": 1020.0}, "0000011010": {"state": 26.0}, "0011101100": {"state": 236.0}, "0110111001": {"state": 441.0}, "1111101000": {"state": 1000.0}, "1111110010": {"state": 1010.0}, "1111101101": {"state": 1005.0}, "1011111010": {"state": 762.0}, "0100011011": {"state": 283.0}, "0011110100": {"state": 244.0}, "0000010000": {"state": 16.0}, "0100000011": {"state": 259.0}, "1100000110": {"state": 774.0}, "1111000111": {"state": 967.0}, "0110111010": {"state": 442.0}, "0111101000": {"state": 488.0}, "0110101100": {"state": 428.0}, "0110101111": {"state": 431.0}, "1110110000": {"state": 944.0}, "0111100100": {"state": 484.0}, "1101000010": {"state": 834.0}, "0111111000": {"state": 504.0}, "0011111000": {"state": 248.0}, "1000010000": {"state": 528.0}, "0011111011": {"state": 251.0}, "0000001011": {"state": 11.0}, "0110111101": {"state": 445.0}, "1111111010": {"state": 1018.0}, "1110101101": {"state": 941.0}, "0001000110": {"state": 70.0}, "0000010010": {"state": 18.0}, "0111110101": {"state": 501.0}, "1110101010": {"state": 938.0}, "0111111011": {"state": 507.0}, "1110100001": {"state": 929.0}, "0111110111": {"state": 503.0}, "0000001110": {"state": 14.0}, "0110111011": {"state": 443.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "0101001110": 1, + "0000010010": 1, + "1000000100": 1, + "1000000010": 1, + "1011110100": 1, + "0110101001": 2, + "0000001100": 2, + "1000011111": 2, + "1010110000": 1, + "0011101000": 2, + "1000010111": 1, + "1101000100": 1, + "1001001100": 1, + "0100000110": 1, + "0010111101": 1, + "0100000010": 8, + "0011100111": 1, + "0110101000": 1, + "1100000001": 1, + "0011110001": 3, + "0110101111": 1, + "1110110000": 3, + "0110110011": 1, + "0110101011": 3, + "0110100010": 2, + "0100010111": 5, + "0110110111": 1, + "0110100111": 2, + "0100001001": 3, + "1110101010": 2, + "1100001100": 3, + "1100010000": 1, + "0111101111": 1, + "1011101001": 1, + "0010111001": 1, + "1111100000": 3, + "1000001000": 4, + "1100001111": 3, + "0110110101": 3, + "1100001101": 5, + "0111101011": 2, + "0111100111": 1, + "1110100010": 1, + "0011100011": 1, + "1001000110": 1, + "1110110010": 1, + "1100000111": 1, + "0110111111": 1, + "1100011100": 2, + "0011111010": 1, + "1110100110": 7, + "1110111101": 1, + "1110111000": 4, + "1111101000": 3, + "1001001000": 1, + "0011101011": 1, + "1100010001": 2, + "1100000011": 1, + "0111101110": 2, + "0100001100": 1, + "1100011001": 2, + "1110101101": 8, + "1100000000": 16, + "0000010111": 43, + "1100001001": 24, + "0100001011": 54, + "0111110100": 70, + "0000000000": 98, + "0000011111": 5, + "1111101001": 29, + "0100000000": 239, + "1000001010": 1, + "1111111100": 109, + "1000001100": 9, + "1111110001": 201, + "1111100101": 21, + "1111100111": 2, + "1111101101": 12, + "0000001111": 42, + "1000000101": 70, + "0111111011": 21, + "0111110110": 63, + "1000001001": 58, + "1110110100": 2, + "1100001011": 1, + "0111101101": 6, + "1000000001": 22, + "1000001101": 1, + "0111110010": 98, + "1010111011": 1, + "0111111010": 32, + "0100010000": 45, + "0100001010": 3, + "0100001101": 2, + "0000010100": 4, + "0111110011": 121, + "0111100101": 8, + "1011110101": 3, + "0111101100": 3, + "0111111101": 1343, + "1101001000": 2, + "1110100101": 2, + "1100010110": 13, + "0100011010": 1, + "1110101110": 42, + "1101000110": 2, + "0000010011": 8, + "0110100100": 46, + "0110111100": 1, + "1111111110": 1098, + "1111110011": 223, + "0111110001": 21, + "1000010001": 2, + "1111110111": 5, + "1111111001": 296, + "1111111010": 28, + "0111110000": 137, + "1110100100": 1, + "1111110101": 363, + "0000001000": 30, + "1000000110": 19, + "0000011100": 1, + "1111110000": 1, + "0110100110": 1, + "1111101110": 148, + "0110110001": 4, + "1001000011": 1, + "0111111100": 65, + "1111111000": 376, + "0110110110": 12, + "1000001111": 9, + "0011110100": 2, + "0000010000": 8, + "0000000111": 313, + "1000001110": 133, + "0100001110": 3, + "1001000111": 1, + "1011101010": 1, + "0011110101": 1, + "1110110011": 4, + "1011111010": 38, + "1111100011": 8, + "0000001001": 1, + "1110111110": 39, + "1111000000": 2, + "1111110110": 263, + "0110100011": 11, + "1111111111": 92, + "1110110001": 6, + "1100001110": 81, + "0110110010": 1, + "0000011000": 4, + "0110111101": 3, + "0000001011": 6, + "0000000011": 63, + "0100010011": 1, + "1100011110": 1, + "0011111000": 24, + "1100000110": 46, + "1000010110": 7, + "1000000000": 5, + "0100011000": 8, + "1110110101": 11, + "0100000001": 5, + "0100000011": 23, + "0110111010": 4, + "0111101000": 3, + "1111110010": 34, + "1000000011": 19, + "0011111011": 8, + "1111111011": 119, + "1111111101": 33, + "0100001000": 78, + "0100000111": 55, + "0110110000": 8, + "1111101111": 1, + "0111100011": 12, + "1111100001": 7, + "1111101010": 7, + "0000001010": 4, + "0111111001": 13, + "1011111110": 133, + "0000011101": 2, + "1111101011": 13, + "1000011110": 8, + "0000000100": 58, + "1110111001": 4, + "0111111000": 3, + "0111100100": 2, + "0111100110": 3, + "0000001101": 13, + "0110110100": 2, + "0011110000": 2, + "0100011110": 2, + "0110101100": 3, + "1011111001": 28, + "0111111110": 26, + "1100001010": 52, + "1110110110": 15, + "1011101110": 12, + "1111100110": 25, + "0011111100": 15, + "0011110010": 3, + "1000010101": 8, + "0111110101": 5, + "1011110011": 5, + "0111110111": 101, + "1110100001": 3, + "0110111011": 16, + "0000001110": 3, + "0111111111": 26, + "0011101100": 2, + "0110111001": 1, + "0001001110": 1, + "0011110111": 3, + "0110100000": 8 + }, + "counts_lsb_right": true, + "parsed_states": { + "0101001110": { "state": 334.0 }, + "0000010010": { "state": 18.0 }, + "1000000100": { "state": 516.0 }, + "1000000010": { "state": 514.0 }, + "1011110100": { "state": 756.0 }, + "0110101001": { "state": 425.0 }, + "0000001100": { "state": 12.0 }, + "1000011111": { "state": 543.0 }, + "1010110000": { "state": 688.0 }, + "0011101000": { "state": 232.0 }, + "1000010111": { "state": 535.0 }, + "1101000100": { "state": 836.0 }, + "1001001100": { "state": 588.0 }, + "0100000110": { "state": 262.0 }, + "0010111101": { "state": 189.0 }, + "0100000010": { "state": 258.0 }, + "0011100111": { "state": 231.0 }, + "0110101000": { "state": 424.0 }, + "1100000001": { "state": 769.0 }, + "0011110001": { "state": 241.0 }, + "0110101111": { "state": 431.0 }, + "1110110000": { "state": 944.0 }, + "0110110011": { "state": 435.0 }, + "0110101011": { "state": 427.0 }, + "0110100010": { "state": 418.0 }, + "0100010111": { "state": 279.0 }, + "0110110111": { "state": 439.0 }, + "0110100111": { "state": 423.0 }, + "0100001001": { "state": 265.0 }, + "1110101010": { "state": 938.0 }, + "1100001100": { "state": 780.0 }, + "1100010000": { "state": 784.0 }, + "0111101111": { "state": 495.0 }, + "1011101001": { "state": 745.0 }, + "0010111001": { "state": 185.0 }, + "1111100000": { "state": 992.0 }, + "1000001000": { "state": 520.0 }, + "1100001111": { "state": 783.0 }, + "0110110101": { "state": 437.0 }, + "1100001101": { "state": 781.0 }, + "0111101011": { "state": 491.0 }, + "0111100111": { "state": 487.0 }, + "1110100010": { "state": 930.0 }, + "0011100011": { "state": 227.0 }, + "1001000110": { "state": 582.0 }, + "1110110010": { "state": 946.0 }, + "1100000111": { "state": 775.0 }, + "0110111111": { "state": 447.0 }, + "1100011100": { "state": 796.0 }, + "0011111010": { "state": 250.0 }, + "1110100110": { "state": 934.0 }, + "1110111101": { "state": 957.0 }, + "1110111000": { "state": 952.0 }, + "1111101000": { "state": 1000.0 }, + "1001001000": { "state": 584.0 }, + "0011101011": { "state": 235.0 }, + "1100010001": { "state": 785.0 }, + "1100000011": { "state": 771.0 }, + "0111101110": { "state": 494.0 }, + "0100001100": { "state": 268.0 }, + "1100011001": { "state": 793.0 }, + "1110101101": { "state": 941.0 }, + "1100000000": { "state": 768.0 }, + "0000010111": { "state": 23.0 }, + "1100001001": { "state": 777.0 }, + "0100001011": { "state": 267.0 }, + "0111110100": { "state": 500.0 }, + "0000000000": { "state": 0.0 }, + "0000011111": { "state": 31.0 }, + "1111101001": { "state": 1001.0 }, + "0100000000": { "state": 256.0 }, + "1000001010": { "state": 522.0 }, + "1111111100": { "state": 1020.0 }, + "1000001100": { "state": 524.0 }, + "1111110001": { "state": 1009.0 }, + "1111100101": { "state": 997.0 }, + "1111100111": { "state": 999.0 }, + "1111101101": { "state": 1005.0 }, + "0000001111": { "state": 15.0 }, + "1000000101": { "state": 517.0 }, + "0111111011": { "state": 507.0 }, + "0111110110": { "state": 502.0 }, + "1000001001": { "state": 521.0 }, + "1110110100": { "state": 948.0 }, + "1100001011": { "state": 779.0 }, + "0111101101": { "state": 493.0 }, + "1000000001": { "state": 513.0 }, + "1000001101": { "state": 525.0 }, + "0111110010": { "state": 498.0 }, + "1010111011": { "state": 699.0 }, + "0111111010": { "state": 506.0 }, + "0100010000": { "state": 272.0 }, + "0100001010": { "state": 266.0 }, + "0100001101": { "state": 269.0 }, + "0000010100": { "state": 20.0 }, + "0111110011": { "state": 499.0 }, + "0111100101": { "state": 485.0 }, + "1011110101": { "state": 757.0 }, + "0111101100": { "state": 492.0 }, + "0111111101": { "state": 509.0 }, + "1101001000": { "state": 840.0 }, + "1110100101": { "state": 933.0 }, + "1100010110": { "state": 790.0 }, + "0100011010": { "state": 282.0 }, + "1110101110": { "state": 942.0 }, + "1101000110": { "state": 838.0 }, + "0000010011": { "state": 19.0 }, + "0110100100": { "state": 420.0 }, + "0110111100": { "state": 444.0 }, + "1111111110": { "state": 1022.0 }, + "1111110011": { "state": 1011.0 }, + "0111110001": { "state": 497.0 }, + "1000010001": { "state": 529.0 }, + "1111110111": { "state": 1015.0 }, + "1111111001": { "state": 1017.0 }, + "1111111010": { "state": 1018.0 }, + "0111110000": { "state": 496.0 }, + "1110100100": { "state": 932.0 }, + "1111110101": { "state": 1013.0 }, + "0000001000": { "state": 8.0 }, + "1000000110": { "state": 518.0 }, + "0000011100": { "state": 28.0 }, + "1111110000": { "state": 1008.0 }, + "0110100110": { "state": 422.0 }, + "1111101110": { "state": 1006.0 }, + "0110110001": { "state": 433.0 }, + "1001000011": { "state": 579.0 }, + "0111111100": { "state": 508.0 }, + "1111111000": { "state": 1016.0 }, + "0110110110": { "state": 438.0 }, + "1000001111": { "state": 527.0 }, + "0011110100": { "state": 244.0 }, + "0000010000": { "state": 16.0 }, + "0000000111": { "state": 7.0 }, + "1000001110": { "state": 526.0 }, + "0100001110": { "state": 270.0 }, + "1001000111": { "state": 583.0 }, + "1011101010": { "state": 746.0 }, + "0011110101": { "state": 245.0 }, + "1110110011": { "state": 947.0 }, + "1011111010": { "state": 762.0 }, + "1111100011": { "state": 995.0 }, + "0000001001": { "state": 9.0 }, + "1110111110": { "state": 958.0 }, + "1111000000": { "state": 960.0 }, + "1111110110": { "state": 1014.0 }, + "0110100011": { "state": 419.0 }, + "1111111111": { "state": 1023.0 }, + "1110110001": { "state": 945.0 }, + "1100001110": { "state": 782.0 }, + "0110110010": { "state": 434.0 }, + "0000011000": { "state": 24.0 }, + "0110111101": { "state": 445.0 }, + "0000001011": { "state": 11.0 }, + "0000000011": { "state": 3.0 }, + "0100010011": { "state": 275.0 }, + "1100011110": { "state": 798.0 }, + "0011111000": { "state": 248.0 }, + "1100000110": { "state": 774.0 }, + "1000010110": { "state": 534.0 }, + "1000000000": { "state": 512.0 }, + "0100011000": { "state": 280.0 }, + "1110110101": { "state": 949.0 }, + "0100000001": { "state": 257.0 }, + "0100000011": { "state": 259.0 }, + "0110111010": { "state": 442.0 }, + "0111101000": { "state": 488.0 }, + "1111110010": { "state": 1010.0 }, + "1000000011": { "state": 515.0 }, + "0011111011": { "state": 251.0 }, + "1111111011": { "state": 1019.0 }, + "1111111101": { "state": 1021.0 }, + "0100001000": { "state": 264.0 }, + "0100000111": { "state": 263.0 }, + "0110110000": { "state": 432.0 }, + "1111101111": { "state": 1007.0 }, + "0111100011": { "state": 483.0 }, + "1111100001": { "state": 993.0 }, + "1111101010": { "state": 1002.0 }, + "0000001010": { "state": 10.0 }, + "0111111001": { "state": 505.0 }, + "1011111110": { "state": 766.0 }, + "0000011101": { "state": 29.0 }, + "1111101011": { "state": 1003.0 }, + "1000011110": { "state": 542.0 }, + "0000000100": { "state": 4.0 }, + "1110111001": { "state": 953.0 }, + "0111111000": { "state": 504.0 }, + "0111100100": { "state": 484.0 }, + "0111100110": { "state": 486.0 }, + "0000001101": { "state": 13.0 }, + "0110110100": { "state": 436.0 }, + "0011110000": { "state": 240.0 }, + "0100011110": { "state": 286.0 }, + "0110101100": { "state": 428.0 }, + "1011111001": { "state": 761.0 }, + "0111111110": { "state": 510.0 }, + "1100001010": { "state": 778.0 }, + "1110110110": { "state": 950.0 }, + "1011101110": { "state": 750.0 }, + "1111100110": { "state": 998.0 }, + "0011111100": { "state": 252.0 }, + "0011110010": { "state": 242.0 }, + "1000010101": { "state": 533.0 }, + "0111110101": { "state": 501.0 }, + "1011110011": { "state": 755.0 }, + "0111110111": { "state": 503.0 }, + "1110100001": { "state": 929.0 }, + "0110111011": { "state": 443.0 }, + "0000001110": { "state": 14.0 }, + "0111111111": { "state": 511.0 }, + "0011101100": { "state": 236.0 }, + "0110111001": { "state": 441.0 }, + "0001001110": { "state": 78.0 }, + "0011110111": { "state": 247.0 }, + "0110100000": { "state": 416.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n+10.json b/algorithms/glued_trees/results/10-qubits/2n+10.json index a9f93103..e37ebddf 100644 --- a/algorithms/glued_trees/results/10-qubits/2n+10.json +++ b/algorithms/glued_trees/results/10-qubits/2n+10.json @@ -1 +1,444 @@ -{"vendor_format_result": {}, "counts": {"1111000000": 1, "1111000110": 1, "0100000110": 2, "0101000011": 1, "0101010000": 1, "1101011111": 1, "1101000101": 2, "0101011010": 1, "1101000001": 1, "0010111111": 1, "0100011010": 1, "1111010000": 1, "1011111110": 2, "0100011001": 3, "1110100001": 3, "0111110111": 2, "1110100101": 7, "0110110011": 3, "1111111010": 3, "1000001100": 1, "1110111101": 1, "0110101101": 1, "0100001001": 6, "1100000101": 18, "0110100011": 13, "1100010010": 14, "0100001111": 10, "0111111000": 1, "1111101001": 7, "1100000111": 11, "0111101011": 1, "0110101001": 6, "0111101111": 13, "1100001000": 6, "0110101110": 10, "1110110111": 4, "1101000000": 1, "0110100010": 15, "1101011010": 1, "0011111011": 2, "1100001100": 45, "1111100100": 20, "1111110011": 12, "0100010000": 6, "1100010001": 31, "1110111111": 33, "0101010001": 1, "1111101101": 18, "1110101011": 1, "0110100110": 5, "1111110000": 120, "0110101010": 10, "0100000101": 30, "1111101011": 41, "1101001111": 2, "0100011000": 11, "1110110101": 13, "1100011100": 15, "0110111111": 37, "1000011110": 1, "1110101001": 73, "1111101010": 45, "0111110000": 136, "0111100011": 3, "1111101111": 4, "0100010111": 1, "1110111100": 20, "1111100111": 20, "0100001100": 24, "1100011001": 27, "0111101110": 137, "1011100001": 2, "0111111010": 40, "0110101011": 35, "0100000011": 4, "0011100011": 1, "1110100010": 102, "1111101000": 249, "0100011011": 21, "0111111101": 528, "0100000100": 88, "1100010110": 28, "0111001011": 1, "0111110001": 166, "1100011110": 6, "1111111110": 41, "0110100101": 19, "1110101101": 50, "1100000010": 6, "1110110011": 14, "0110100001": 7, "0110100000": 32, "1111100000": 248, "0111100111": 6, "0111100000": 18, "0111100100": 63, "1111111011": 161, "1111111101": 37, "1111101100": 6, "1111101110": 51, "1011111001": 2, "0111111110": 350, "1100001101": 159, "1111110101": 122, "0111100110": 9, "1111100001": 52, "0111111100": 7, "1111111000": 564, "0110110110": 59, "1010110101": 1, "1100000001": 73, "0100000000": 7, "1110100011": 5, "0111111011": 5, "1110100111": 40, "0111000100": 1, "0111110110": 16, "1110110100": 34, "1100011111": 1, "0110111101": 26, "1111100010": 30, "0110111100": 97, "1111000011": 3, "0111111001": 576, "0100001011": 93, "1111110001": 286, "0111111111": 126, "1000000001": 1, "0111101101": 97, "1100001011": 10, "1110101110": 15, "1111110100": 17, "0100000010": 2, "0111101000": 31, "0110111010": 24, "1110100000": 18, "1100001010": 10, "1110110110": 81, "0110110101": 28, "1011100101": 2, "0100011110": 11, "0110101100": 17, "0110110111": 177, "0111101001": 216, "0110100111": 5, "1110101010": 28, "0100010001": 1, "1100000000": 4, "1000001011": 1, "1111111111": 17, "0000000011": 5, "1101011000": 4, "1111110110": 70, "0100011111": 14, "1100001001": 57, "0110110100": 19, "1110111011": 25, "0110101000": 2, "1110111110": 27, "1111110010": 76, "0110111000": 12, "1000001101": 1, "0111110010": 26, "1111110111": 257, "1111111001": 17, "0101000001": 1, "0111110100": 97, "1111100110": 23, "0110110010": 9, "1110111000": 1, "0111100010": 12, "0100010101": 5, "1100001110": 16, "1110110001": 46, "1111111100": 15, "0110101111": 86, "0100000111": 2, "0111100001": 7, "0110110000": 51, "0100001000": 41, "0111101010": 32, "1100000100": 25, "0110111110": 18, "1110111001": 15, "0100010011": 15, "1100010101": 4, "0111101100": 10, "0100001101": 1, "0100001010": 17, "0111110011": 133, "0111100101": 23, "0000001001": 1, "1111100011": 12, "0111001101": 1, "1100000110": 10, "0100001110": 20, "1111100101": 44, "1110101100": 4, "0111110101": 44, "0110111001": 8, "1000000110": 1, "1110111010": 2, "1110110010": 15, "1100011000": 3, "1110101000": 2}, "counts_lsb_right": true, "parsed_states": {"1111000000": {"state": 960.0}, "1111000110": {"state": 966.0}, "0100000110": {"state": 262.0}, "0101000011": {"state": 323.0}, "0101010000": {"state": 336.0}, "1101011111": {"state": 863.0}, "1101000101": {"state": 837.0}, "0101011010": {"state": 346.0}, "1101000001": {"state": 833.0}, "0010111111": {"state": 191.0}, "0100011010": {"state": 282.0}, "1111010000": {"state": 976.0}, "1011111110": {"state": 766.0}, "0100011001": {"state": 281.0}, "1110100001": {"state": 929.0}, "0111110111": {"state": 503.0}, "1110100101": {"state": 933.0}, "0110110011": {"state": 435.0}, "1111111010": {"state": 1018.0}, "1000001100": {"state": 524.0}, "1110111101": {"state": 957.0}, "0110101101": {"state": 429.0}, "0100001001": {"state": 265.0}, "1100000101": {"state": 773.0}, "0110100011": {"state": 419.0}, "1100010010": {"state": 786.0}, "0100001111": {"state": 271.0}, "0111111000": {"state": 504.0}, "1111101001": {"state": 1001.0}, "1100000111": {"state": 775.0}, "0111101011": {"state": 491.0}, "0110101001": {"state": 425.0}, "0111101111": {"state": 495.0}, "1100001000": {"state": 776.0}, "0110101110": {"state": 430.0}, "1110110111": {"state": 951.0}, "1101000000": {"state": 832.0}, "0110100010": {"state": 418.0}, "1101011010": {"state": 858.0}, "0011111011": {"state": 251.0}, "1100001100": {"state": 780.0}, "1111100100": {"state": 996.0}, "1111110011": {"state": 1011.0}, "0100010000": {"state": 272.0}, "1100010001": {"state": 785.0}, "1110111111": {"state": 959.0}, "0101010001": {"state": 337.0}, "1111101101": {"state": 1005.0}, "1110101011": {"state": 939.0}, "0110100110": {"state": 422.0}, "1111110000": {"state": 1008.0}, "0110101010": {"state": 426.0}, "0100000101": {"state": 261.0}, "1111101011": {"state": 1003.0}, "1101001111": {"state": 847.0}, "0100011000": {"state": 280.0}, "1110110101": {"state": 949.0}, "1100011100": {"state": 796.0}, "0110111111": {"state": 447.0}, "1000011110": {"state": 542.0}, "1110101001": {"state": 937.0}, "1111101010": {"state": 1002.0}, "0111110000": {"state": 496.0}, "0111100011": {"state": 483.0}, "1111101111": {"state": 1007.0}, "0100010111": {"state": 279.0}, "1110111100": {"state": 956.0}, "1111100111": {"state": 999.0}, "0100001100": {"state": 268.0}, "1100011001": {"state": 793.0}, "0111101110": {"state": 494.0}, "1011100001": {"state": 737.0}, "0111111010": {"state": 506.0}, "0110101011": {"state": 427.0}, "0100000011": {"state": 259.0}, "0011100011": {"state": 227.0}, "1110100010": {"state": 930.0}, "1111101000": {"state": 1000.0}, "0100011011": {"state": 283.0}, "0111111101": {"state": 509.0}, "0100000100": {"state": 260.0}, "1100010110": {"state": 790.0}, "0111001011": {"state": 459.0}, "0111110001": {"state": 497.0}, "1100011110": {"state": 798.0}, "1111111110": {"state": 1022.0}, "0110100101": {"state": 421.0}, "1110101101": {"state": 941.0}, "1100000010": {"state": 770.0}, "1110110011": {"state": 947.0}, "0110100001": {"state": 417.0}, "0110100000": {"state": 416.0}, "1111100000": {"state": 992.0}, "0111100111": {"state": 487.0}, "0111100000": {"state": 480.0}, "0111100100": {"state": 484.0}, "1111111011": {"state": 1019.0}, "1111111101": {"state": 1021.0}, "1111101100": {"state": 1004.0}, "1111101110": {"state": 1006.0}, "1011111001": {"state": 761.0}, "0111111110": {"state": 510.0}, "1100001101": {"state": 781.0}, "1111110101": {"state": 1013.0}, "0111100110": {"state": 486.0}, "1111100001": {"state": 993.0}, "0111111100": {"state": 508.0}, "1111111000": {"state": 1016.0}, "0110110110": {"state": 438.0}, "1010110101": {"state": 693.0}, "1100000001": {"state": 769.0}, "0100000000": {"state": 256.0}, "1110100011": {"state": 931.0}, "0111111011": {"state": 507.0}, "1110100111": {"state": 935.0}, "0111000100": {"state": 452.0}, "0111110110": {"state": 502.0}, "1110110100": {"state": 948.0}, "1100011111": {"state": 799.0}, "0110111101": {"state": 445.0}, "1111100010": {"state": 994.0}, "0110111100": {"state": 444.0}, "1111000011": {"state": 963.0}, "0111111001": {"state": 505.0}, "0100001011": {"state": 267.0}, "1111110001": {"state": 1009.0}, "0111111111": {"state": 511.0}, "1000000001": {"state": 513.0}, "0111101101": {"state": 493.0}, "1100001011": {"state": 779.0}, "1110101110": {"state": 942.0}, "1111110100": {"state": 1012.0}, "0100000010": {"state": 258.0}, "0111101000": {"state": 488.0}, "0110111010": {"state": 442.0}, "1110100000": {"state": 928.0}, "1100001010": {"state": 778.0}, "1110110110": {"state": 950.0}, "0110110101": {"state": 437.0}, "1011100101": {"state": 741.0}, "0100011110": {"state": 286.0}, "0110101100": {"state": 428.0}, "0110110111": {"state": 439.0}, "0111101001": {"state": 489.0}, "0110100111": {"state": 423.0}, "1110101010": {"state": 938.0}, "0100010001": {"state": 273.0}, "1100000000": {"state": 768.0}, "1000001011": {"state": 523.0}, "1111111111": {"state": 1023.0}, "0000000011": {"state": 3.0}, "1101011000": {"state": 856.0}, "1111110110": {"state": 1014.0}, "0100011111": {"state": 287.0}, "1100001001": {"state": 777.0}, "0110110100": {"state": 436.0}, "1110111011": {"state": 955.0}, "0110101000": {"state": 424.0}, "1110111110": {"state": 958.0}, "1111110010": {"state": 1010.0}, "0110111000": {"state": 440.0}, "1000001101": {"state": 525.0}, "0111110010": {"state": 498.0}, "1111110111": {"state": 1015.0}, "1111111001": {"state": 1017.0}, "0101000001": {"state": 321.0}, "0111110100": {"state": 500.0}, "1111100110": {"state": 998.0}, "0110110010": {"state": 434.0}, "1110111000": {"state": 952.0}, "0111100010": {"state": 482.0}, "0100010101": {"state": 277.0}, "1100001110": {"state": 782.0}, "1110110001": {"state": 945.0}, "1111111100": {"state": 1020.0}, "0110101111": {"state": 431.0}, "0100000111": {"state": 263.0}, "0111100001": {"state": 481.0}, "0110110000": {"state": 432.0}, "0100001000": {"state": 264.0}, "0111101010": {"state": 490.0}, "1100000100": {"state": 772.0}, "0110111110": {"state": 446.0}, "1110111001": {"state": 953.0}, "0100010011": {"state": 275.0}, "1100010101": {"state": 789.0}, "0111101100": {"state": 492.0}, "0100001101": {"state": 269.0}, "0100001010": {"state": 266.0}, "0111110011": {"state": 499.0}, "0111100101": {"state": 485.0}, "0000001001": {"state": 9.0}, "1111100011": {"state": 995.0}, "0111001101": {"state": 461.0}, "1100000110": {"state": 774.0}, "0100001110": {"state": 270.0}, "1111100101": {"state": 997.0}, "1110101100": {"state": 940.0}, "0111110101": {"state": 501.0}, "0110111001": {"state": 441.0}, "1000000110": {"state": 518.0}, "1110111010": {"state": 954.0}, "1110110010": {"state": 946.0}, "1100011000": {"state": 792.0}, "1110101000": {"state": 936.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "1000010000": 1, + "0011110111": 1, + "1100000110": 1, + "0111101011": 2, + "0111111000": 1, + "1111010011": 1, + "1111000100": 1, + "1000001110": 1, + "0110101101": 1, + "0101001111": 2, + "0111011101": 1, + "0110101000": 2, + "0110101001": 2, + "0100000110": 2, + "1000000010": 1, + "1101000100": 1, + "1101000101": 2, + "0110110011": 3, + "1101010011": 1, + "1101010010": 1, + "1100010111": 1, + "1100001000": 4, + "1101011100": 1, + "1111101001": 8, + "0100001111": 3, + "1111101100": 4, + "1111111100": 15, + "1110110111": 10, + "0111100110": 5, + "1110100101": 6, + "0000010011": 1, + "0101011001": 1, + "0000001001": 1, + "1000011010": 1, + "1111100011": 13, + "0011111100": 1, + "1100010000": 1, + "1110100000": 8, + "1111110011": 15, + "1110101000": 6, + "0110110010": 9, + "1100010010": 25, + "1100011000": 4, + "1110110010": 7, + "1111111010": 3, + "1111000000": 1, + "0100001001": 6, + "0100010110": 1, + "0111000110": 1, + "0100001110": 17, + "0110101111": 89, + "1100001100": 57, + "0110111100": 105, + "1111101111": 7, + "0111100011": 6, + "1101000000": 5, + "0110100010": 7, + "0111100010": 26, + "1010110101": 1, + "1100000001": 69, + "1000001101": 1, + "0111110010": 21, + "0111111010": 52, + "1100000101": 26, + "1100001101": 178, + "0111111110": 307, + "1100011100": 16, + "0110111111": 24, + "1111100100": 24, + "0111111111": 126, + "0111100111": 6, + "1111100000": 252, + "0111100000": 19, + "0110100001": 6, + "1110110011": 21, + "1110111111": 41, + "1100010001": 30, + "0110110101": 41, + "0100001011": 79, + "1111111110": 37, + "0111110001": 162, + "0110100101": 22, + "1100011110": 8, + "0111111101": 573, + "0100011011": 17, + "1111000011": 4, + "0111111001": 593, + "1111110001": 312, + "1011111110": 4, + "1111101010": 34, + "1100010110": 45, + "0100000100": 96, + "0111111100": 8, + "1111111000": 540, + "1011100111": 1, + "0110110110": 49, + "0100010001": 1, + "1011111111": 1, + "1100000000": 5, + "0110110100": 14, + "1111100010": 22, + "0110111101": 11, + "0100010111": 1, + "1110111100": 17, + "1111100111": 15, + "0100000010": 4, + "1111110100": 15, + "1110100010": 87, + "1111101110": 55, + "0100011000": 12, + "1110110101": 9, + "1101001111": 6, + "0111100100": 77, + "0111110111": 1, + "1110100001": 5, + "1100000010": 8, + "1110101101": 37, + "1100001001": 54, + "0100011111": 18, + "1000001011": 2, + "1111111111": 23, + "1111101000": 244, + "1101011000": 5, + "1111110110": 82, + "0110100011": 14, + "0110100000": 39, + "1100010101": 5, + "0111001010": 1, + "0111110100": 84, + "1111001001": 1, + "1111100110": 27, + "0111110000": 121, + "0100010011": 8, + "1110101010": 16, + "1110101110": 11, + "0011111011": 1, + "0111000010": 1, + "0110100110": 3, + "1111110000": 132, + "1110101011": 1, + "1111100001": 54, + "0100000011": 8, + "0111101110": 133, + "1100011001": 29, + "0100001100": 21, + "0100000101": 16, + "0110101010": 4, + "1111101011": 50, + "0111100101": 15, + "0111110011": 130, + "0100001010": 11, + "1110111110": 26, + "1110100111": 64, + "1110110100": 33, + "0111110110": 24, + "0101001100": 1, + "0110101011": 22, + "1110100011": 3, + "0111111011": 7, + "0111110101": 41, + "1100001010": 21, + "1110110110": 66, + "1100001011": 15, + "0111101101": 91, + "1000000001": 1, + "0111101111": 14, + "0011111111": 1, + "1110111011": 12, + "1111111011": 188, + "1111111101": 38, + "1101001101": 3, + "0101010001": 5, + "1111101101": 9, + "1011110101": 1, + "0101001101": 2, + "0111101100": 5, + "1100000111": 20, + "0100000111": 3, + "0111100001": 5, + "0100001000": 41, + "0110110000": 58, + "0111101010": 29, + "1100000100": 26, + "1111110010": 78, + "0110111000": 18, + "1111110101": 136, + "1110100100": 1, + "0000000000": 1, + "0101010101": 1, + "0110101110": 17, + "0111101001": 174, + "0110110111": 154, + "0110100111": 3, + "1110110001": 40, + "1100001110": 8, + "0100010101": 4, + "0100010000": 8, + "1110101111": 2, + "0000000011": 4, + "0100011001": 4, + "1011100101": 1, + "0110101100": 18, + "0100011110": 14, + "1110101001": 74, + "1000011110": 1, + "0111101000": 31, + "0110111010": 16, + "0110111001": 8, + "0110111110": 23, + "1110111001": 13, + "0100000000": 9, + "1111110111": 252, + "1111111001": 25, + "1111100101": 52, + "1110101100": 6 + }, + "counts_lsb_right": true, + "parsed_states": { + "1000010000": { "state": 528.0 }, + "0011110111": { "state": 247.0 }, + "1100000110": { "state": 774.0 }, + "0111101011": { "state": 491.0 }, + "0111111000": { "state": 504.0 }, + "1111010011": { "state": 979.0 }, + "1111000100": { "state": 964.0 }, + "1000001110": { "state": 526.0 }, + "0110101101": { "state": 429.0 }, + "0101001111": { "state": 335.0 }, + "0111011101": { "state": 477.0 }, + "0110101000": { "state": 424.0 }, + "0110101001": { "state": 425.0 }, + "0100000110": { "state": 262.0 }, + "1000000010": { "state": 514.0 }, + "1101000100": { "state": 836.0 }, + "1101000101": { "state": 837.0 }, + "0110110011": { "state": 435.0 }, + "1101010011": { "state": 851.0 }, + "1101010010": { "state": 850.0 }, + "1100010111": { "state": 791.0 }, + "1100001000": { "state": 776.0 }, + "1101011100": { "state": 860.0 }, + "1111101001": { "state": 1001.0 }, + "0100001111": { "state": 271.0 }, + "1111101100": { "state": 1004.0 }, + "1111111100": { "state": 1020.0 }, + "1110110111": { "state": 951.0 }, + "0111100110": { "state": 486.0 }, + "1110100101": { "state": 933.0 }, + "0000010011": { "state": 19.0 }, + "0101011001": { "state": 345.0 }, + "0000001001": { "state": 9.0 }, + "1000011010": { "state": 538.0 }, + "1111100011": { "state": 995.0 }, + "0011111100": { "state": 252.0 }, + "1100010000": { "state": 784.0 }, + "1110100000": { "state": 928.0 }, + "1111110011": { "state": 1011.0 }, + "1110101000": { "state": 936.0 }, + "0110110010": { "state": 434.0 }, + "1100010010": { "state": 786.0 }, + "1100011000": { "state": 792.0 }, + "1110110010": { "state": 946.0 }, + "1111111010": { "state": 1018.0 }, + "1111000000": { "state": 960.0 }, + "0100001001": { "state": 265.0 }, + "0100010110": { "state": 278.0 }, + "0111000110": { "state": 454.0 }, + "0100001110": { "state": 270.0 }, + "0110101111": { "state": 431.0 }, + "1100001100": { "state": 780.0 }, + "0110111100": { "state": 444.0 }, + "1111101111": { "state": 1007.0 }, + "0111100011": { "state": 483.0 }, + "1101000000": { "state": 832.0 }, + "0110100010": { "state": 418.0 }, + "0111100010": { "state": 482.0 }, + "1010110101": { "state": 693.0 }, + "1100000001": { "state": 769.0 }, + "1000001101": { "state": 525.0 }, + "0111110010": { "state": 498.0 }, + "0111111010": { "state": 506.0 }, + "1100000101": { "state": 773.0 }, + "1100001101": { "state": 781.0 }, + "0111111110": { "state": 510.0 }, + "1100011100": { "state": 796.0 }, + "0110111111": { "state": 447.0 }, + "1111100100": { "state": 996.0 }, + "0111111111": { "state": 511.0 }, + "0111100111": { "state": 487.0 }, + "1111100000": { "state": 992.0 }, + "0111100000": { "state": 480.0 }, + "0110100001": { "state": 417.0 }, + "1110110011": { "state": 947.0 }, + "1110111111": { "state": 959.0 }, + "1100010001": { "state": 785.0 }, + "0110110101": { "state": 437.0 }, + "0100001011": { "state": 267.0 }, + "1111111110": { "state": 1022.0 }, + "0111110001": { "state": 497.0 }, + "0110100101": { "state": 421.0 }, + "1100011110": { "state": 798.0 }, + "0111111101": { "state": 509.0 }, + "0100011011": { "state": 283.0 }, + "1111000011": { "state": 963.0 }, + "0111111001": { "state": 505.0 }, + "1111110001": { "state": 1009.0 }, + "1011111110": { "state": 766.0 }, + "1111101010": { "state": 1002.0 }, + "1100010110": { "state": 790.0 }, + "0100000100": { "state": 260.0 }, + "0111111100": { "state": 508.0 }, + "1111111000": { "state": 1016.0 }, + "1011100111": { "state": 743.0 }, + "0110110110": { "state": 438.0 }, + "0100010001": { "state": 273.0 }, + "1011111111": { "state": 767.0 }, + "1100000000": { "state": 768.0 }, + "0110110100": { "state": 436.0 }, + "1111100010": { "state": 994.0 }, + "0110111101": { "state": 445.0 }, + "0100010111": { "state": 279.0 }, + "1110111100": { "state": 956.0 }, + "1111100111": { "state": 999.0 }, + "0100000010": { "state": 258.0 }, + "1111110100": { "state": 1012.0 }, + "1110100010": { "state": 930.0 }, + "1111101110": { "state": 1006.0 }, + "0100011000": { "state": 280.0 }, + "1110110101": { "state": 949.0 }, + "1101001111": { "state": 847.0 }, + "0111100100": { "state": 484.0 }, + "0111110111": { "state": 503.0 }, + "1110100001": { "state": 929.0 }, + "1100000010": { "state": 770.0 }, + "1110101101": { "state": 941.0 }, + "1100001001": { "state": 777.0 }, + "0100011111": { "state": 287.0 }, + "1000001011": { "state": 523.0 }, + "1111111111": { "state": 1023.0 }, + "1111101000": { "state": 1000.0 }, + "1101011000": { "state": 856.0 }, + "1111110110": { "state": 1014.0 }, + "0110100011": { "state": 419.0 }, + "0110100000": { "state": 416.0 }, + "1100010101": { "state": 789.0 }, + "0111001010": { "state": 458.0 }, + "0111110100": { "state": 500.0 }, + "1111001001": { "state": 969.0 }, + "1111100110": { "state": 998.0 }, + "0111110000": { "state": 496.0 }, + "0100010011": { "state": 275.0 }, + "1110101010": { "state": 938.0 }, + "1110101110": { "state": 942.0 }, + "0011111011": { "state": 251.0 }, + "0111000010": { "state": 450.0 }, + "0110100110": { "state": 422.0 }, + "1111110000": { "state": 1008.0 }, + "1110101011": { "state": 939.0 }, + "1111100001": { "state": 993.0 }, + "0100000011": { "state": 259.0 }, + "0111101110": { "state": 494.0 }, + "1100011001": { "state": 793.0 }, + "0100001100": { "state": 268.0 }, + "0100000101": { "state": 261.0 }, + "0110101010": { "state": 426.0 }, + "1111101011": { "state": 1003.0 }, + "0111100101": { "state": 485.0 }, + "0111110011": { "state": 499.0 }, + "0100001010": { "state": 266.0 }, + "1110111110": { "state": 958.0 }, + "1110100111": { "state": 935.0 }, + "1110110100": { "state": 948.0 }, + "0111110110": { "state": 502.0 }, + "0101001100": { "state": 332.0 }, + "0110101011": { "state": 427.0 }, + "1110100011": { "state": 931.0 }, + "0111111011": { "state": 507.0 }, + "0111110101": { "state": 501.0 }, + "1100001010": { "state": 778.0 }, + "1110110110": { "state": 950.0 }, + "1100001011": { "state": 779.0 }, + "0111101101": { "state": 493.0 }, + "1000000001": { "state": 513.0 }, + "0111101111": { "state": 495.0 }, + "0011111111": { "state": 255.0 }, + "1110111011": { "state": 955.0 }, + "1111111011": { "state": 1019.0 }, + "1111111101": { "state": 1021.0 }, + "1101001101": { "state": 845.0 }, + "0101010001": { "state": 337.0 }, + "1111101101": { "state": 1005.0 }, + "1011110101": { "state": 757.0 }, + "0101001101": { "state": 333.0 }, + "0111101100": { "state": 492.0 }, + "1100000111": { "state": 775.0 }, + "0100000111": { "state": 263.0 }, + "0111100001": { "state": 481.0 }, + "0100001000": { "state": 264.0 }, + "0110110000": { "state": 432.0 }, + "0111101010": { "state": 490.0 }, + "1100000100": { "state": 772.0 }, + "1111110010": { "state": 1010.0 }, + "0110111000": { "state": 440.0 }, + "1111110101": { "state": 1013.0 }, + "1110100100": { "state": 932.0 }, + "0000000000": { "state": 0.0 }, + "0101010101": { "state": 341.0 }, + "0110101110": { "state": 430.0 }, + "0111101001": { "state": 489.0 }, + "0110110111": { "state": 439.0 }, + "0110100111": { "state": 423.0 }, + "1110110001": { "state": 945.0 }, + "1100001110": { "state": 782.0 }, + "0100010101": { "state": 277.0 }, + "0100010000": { "state": 272.0 }, + "1110101111": { "state": 943.0 }, + "0000000011": { "state": 3.0 }, + "0100011001": { "state": 281.0 }, + "1011100101": { "state": 741.0 }, + "0110101100": { "state": 428.0 }, + "0100011110": { "state": 286.0 }, + "1110101001": { "state": 937.0 }, + "1000011110": { "state": 542.0 }, + "0111101000": { "state": 488.0 }, + "0110111010": { "state": 442.0 }, + "0110111001": { "state": 441.0 }, + "0110111110": { "state": 446.0 }, + "1110111001": { "state": 953.0 }, + "0100000000": { "state": 256.0 }, + "1111110111": { "state": 1015.0 }, + "1111111001": { "state": 1017.0 }, + "1111100101": { "state": 997.0 }, + "1110101100": { "state": 940.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n+12.json b/algorithms/glued_trees/results/10-qubits/2n+12.json index 96cb39a2..1d1fab43 100644 --- a/algorithms/glued_trees/results/10-qubits/2n+12.json +++ b/algorithms/glued_trees/results/10-qubits/2n+12.json @@ -1 +1,474 @@ -{"vendor_format_result": {}, "counts": {"0000000010": 1, "0011100000": 1, "0101011011": 1, "0100000001": 1, "1011111100": 1, "1100011010": 1, "0110101101": 1, "1110101000": 2, "0101000011": 1, "1101010100": 1, "1100000111": 2, "1000000101": 1, "0101011100": 1, "1101001010": 1, "1101001011": 4, "0011101100": 2, "0011110101": 1, "1011101010": 1, "1111011100": 1, "1011110110": 1, "1101011101": 1, "1101011111": 1, "1101000101": 1, "1101011011": 2, "0100001001": 2, "1100001000": 8, "0100010011": 1, "1001000000": 1, "0100011010": 1, "0000000001": 2, "1001001111": 1, "0101000111": 5, "0100001011": 2, "1110100000": 3, "1011110001": 1, "0111111000": 4, "0111010001": 1, "0011110100": 4, "1110100111": 5, "1111100001": 9, "0111011010": 2, "1111111110": 6, "1100000000": 1, "0100010001": 6, "1111000100": 1, "1000001110": 7, "1110111100": 10, "0101011001": 1, "0101010111": 1, "1101000000": 1, "0010110010": 1, "0110100010": 3, "1111101110": 6, "1110110100": 16, "0111110110": 4, "1011110111": 3, "0100010110": 1, "0100011011": 2, "0100011001": 6, "1111100100": 20, "0101000110": 2, "1100011110": 7, "0110101100": 15, "1110101100": 4, "1111100101": 19, "1110100101": 34, "1111001100": 3, "0110100101": 30, "0101001001": 5, "0111110001": 180, "1111110011": 441, "0110110101": 66, "1110111110": 60, "0110101000": 35, "0110100000": 9, "0111100111": 164, "0111100000": 74, "1000000001": 1, "0111101101": 133, "1100001111": 38, "0110100111": 1, "0111101001": 18, "0110110111": 67, "1110100110": 4, "0110101011": 50, "0110100100": 7, "1111101010": 53, "0000000100": 3, "1000011110": 1, "1110101001": 43, "1110111101": 168, "1111110010": 2, "0110111000": 130, "1011100111": 1, "0110110110": 8, "1110110111": 15, "0100000000": 55, "1111101001": 185, "1110101111": 16, "1011110101": 6, "0111101100": 17, "1000001010": 3, "0100010100": 8, "0111111101": 93, "0110101010": 18, "0100000101": 6, "0011100011": 2, "1110100010": 59, "1111110100": 15, "1111101000": 109, "0110111110": 9, "1110111001": 26, "0111010101": 3, "1111111011": 413, "1111111101": 77, "1111101100": 36, "1101001101": 4, "1111110000": 3, "1110101011": 45, "0110100110": 18, "0111100100": 99, "1111100000": 23, "1100010011": 9, "0100011100": 20, "1010110101": 1, "1000010010": 2, "0011110001": 3, "1100000001": 61, "1110100011": 9, "0111111011": 70, "0100001100": 46, "0111101110": 117, "1100011011": 2, "1100000101": 161, "0111000101": 5, "1011100001": 1, "0111111010": 104, "0111110101": 38, "1100010101": 79, "1100010100": 2, "0111001101": 1, "1100000110": 12, "1111111100": 26, "0100001111": 32, "0000001110": 1, "0110111011": 25, "0111110111": 147, "1110100001": 98, "0110100001": 1, "1110110011": 20, "1000011010": 1, "1111100011": 485, "0110110001": 3, "1111111000": 156, "0111111100": 125, "1100011100": 1, "0110111111": 10, "1100001101": 75, "0111111110": 12, "0110110010": 60, "0111101011": 152, "1111100110": 18, "0111111001": 185, "0111100110": 30, "1111110101": 79, "1111110111": 191, "1111111001": 101, "1100010010": 5, "0101000001": 1, "0111110100": 41, "0110101001": 8, "1110101010": 23, "1111110001": 42, "1110111000": 3, "0111100010": 104, "0111110010": 69, "1111101101": 24, "0111101000": 35, "0110111010": 15, "1110101101": 166, "1100000010": 11, "0110101111": 126, "1110110000": 34, "1100000011": 9, "1100010001": 47, "0000000111": 12, "0111110000": 78, "0000010100": 1, "0111100101": 10, "0111110011": 64, "0100001010": 14, "1100011000": 1, "1110111010": 23, "1111100111": 12, "1100011111": 5, "0110111101": 8, "0111101111": 56, "1100001110": 3, "1110110001": 39, "0100010101": 9, "1111111010": 43, "0000011110": 2, "1111111111": 4, "0100011111": 3, "0000010111": 1, "1100001001": 9, "0100000011": 1, "1100011101": 7, "0100001110": 1, "0100010000": 16, "0100011000": 1, "1110110101": 50, "1101001111": 11, "0111100011": 128, "1111101111": 7, "1110000110": 1, "0100000100": 11, "0110101110": 15, "0111011001": 1, "0111111111": 41, "1111101011": 20, "0111101010": 106, "0111100001": 102, "0110110000": 118, "1100000100": 2, "1011100110": 2, "1111110110": 10, "0011110000": 4, "1110101110": 12, "1110111111": 4, "0011101111": 5, "0011111111": 6, "1110111011": 13, "0110111100": 141, "1011100100": 1}, "counts_lsb_right": true, "parsed_states": {"0000000010": {"state": 2.0}, "0011100000": {"state": 224.0}, "0101011011": {"state": 347.0}, "0100000001": {"state": 257.0}, "1011111100": {"state": 764.0}, "1100011010": {"state": 794.0}, "0110101101": {"state": 429.0}, "1110101000": {"state": 936.0}, "0101000011": {"state": 323.0}, "1101010100": {"state": 852.0}, "1100000111": {"state": 775.0}, "1000000101": {"state": 517.0}, "0101011100": {"state": 348.0}, "1101001010": {"state": 842.0}, "1101001011": {"state": 843.0}, "0011101100": {"state": 236.0}, "0011110101": {"state": 245.0}, "1011101010": {"state": 746.0}, "1111011100": {"state": 988.0}, "1011110110": {"state": 758.0}, "1101011101": {"state": 861.0}, "1101011111": {"state": 863.0}, "1101000101": {"state": 837.0}, "1101011011": {"state": 859.0}, "0100001001": {"state": 265.0}, "1100001000": {"state": 776.0}, "0100010011": {"state": 275.0}, "1001000000": {"state": 576.0}, "0100011010": {"state": 282.0}, "0000000001": {"state": 1.0}, "1001001111": {"state": 591.0}, "0101000111": {"state": 327.0}, "0100001011": {"state": 267.0}, "1110100000": {"state": 928.0}, "1011110001": {"state": 753.0}, "0111111000": {"state": 504.0}, "0111010001": {"state": 465.0}, "0011110100": {"state": 244.0}, "1110100111": {"state": 935.0}, "1111100001": {"state": 993.0}, "0111011010": {"state": 474.0}, "1111111110": {"state": 1022.0}, "1100000000": {"state": 768.0}, "0100010001": {"state": 273.0}, "1111000100": {"state": 964.0}, "1000001110": {"state": 526.0}, "1110111100": {"state": 956.0}, "0101011001": {"state": 345.0}, "0101010111": {"state": 343.0}, "1101000000": {"state": 832.0}, "0010110010": {"state": 178.0}, "0110100010": {"state": 418.0}, "1111101110": {"state": 1006.0}, "1110110100": {"state": 948.0}, "0111110110": {"state": 502.0}, "1011110111": {"state": 759.0}, "0100010110": {"state": 278.0}, "0100011011": {"state": 283.0}, "0100011001": {"state": 281.0}, "1111100100": {"state": 996.0}, "0101000110": {"state": 326.0}, "1100011110": {"state": 798.0}, "0110101100": {"state": 428.0}, "1110101100": {"state": 940.0}, "1111100101": {"state": 997.0}, "1110100101": {"state": 933.0}, "1111001100": {"state": 972.0}, "0110100101": {"state": 421.0}, "0101001001": {"state": 329.0}, "0111110001": {"state": 497.0}, "1111110011": {"state": 1011.0}, "0110110101": {"state": 437.0}, "1110111110": {"state": 958.0}, "0110101000": {"state": 424.0}, "0110100000": {"state": 416.0}, "0111100111": {"state": 487.0}, "0111100000": {"state": 480.0}, "1000000001": {"state": 513.0}, "0111101101": {"state": 493.0}, "1100001111": {"state": 783.0}, "0110100111": {"state": 423.0}, "0111101001": {"state": 489.0}, "0110110111": {"state": 439.0}, "1110100110": {"state": 934.0}, "0110101011": {"state": 427.0}, "0110100100": {"state": 420.0}, "1111101010": {"state": 1002.0}, "0000000100": {"state": 4.0}, "1000011110": {"state": 542.0}, "1110101001": {"state": 937.0}, "1110111101": {"state": 957.0}, "1111110010": {"state": 1010.0}, "0110111000": {"state": 440.0}, "1011100111": {"state": 743.0}, "0110110110": {"state": 438.0}, "1110110111": {"state": 951.0}, "0100000000": {"state": 256.0}, "1111101001": {"state": 1001.0}, "1110101111": {"state": 943.0}, "1011110101": {"state": 757.0}, "0111101100": {"state": 492.0}, "1000001010": {"state": 522.0}, "0100010100": {"state": 276.0}, "0111111101": {"state": 509.0}, "0110101010": {"state": 426.0}, "0100000101": {"state": 261.0}, "0011100011": {"state": 227.0}, "1110100010": {"state": 930.0}, "1111110100": {"state": 1012.0}, "1111101000": {"state": 1000.0}, "0110111110": {"state": 446.0}, "1110111001": {"state": 953.0}, "0111010101": {"state": 469.0}, "1111111011": {"state": 1019.0}, "1111111101": {"state": 1021.0}, "1111101100": {"state": 1004.0}, "1101001101": {"state": 845.0}, "1111110000": {"state": 1008.0}, "1110101011": {"state": 939.0}, "0110100110": {"state": 422.0}, "0111100100": {"state": 484.0}, "1111100000": {"state": 992.0}, "1100010011": {"state": 787.0}, "0100011100": {"state": 284.0}, "1010110101": {"state": 693.0}, "1000010010": {"state": 530.0}, "0011110001": {"state": 241.0}, "1100000001": {"state": 769.0}, "1110100011": {"state": 931.0}, "0111111011": {"state": 507.0}, "0100001100": {"state": 268.0}, "0111101110": {"state": 494.0}, "1100011011": {"state": 795.0}, "1100000101": {"state": 773.0}, "0111000101": {"state": 453.0}, "1011100001": {"state": 737.0}, "0111111010": {"state": 506.0}, "0111110101": {"state": 501.0}, "1100010101": {"state": 789.0}, "1100010100": {"state": 788.0}, "0111001101": {"state": 461.0}, "1100000110": {"state": 774.0}, "1111111100": {"state": 1020.0}, "0100001111": {"state": 271.0}, "0000001110": {"state": 14.0}, "0110111011": {"state": 443.0}, "0111110111": {"state": 503.0}, "1110100001": {"state": 929.0}, "0110100001": {"state": 417.0}, "1110110011": {"state": 947.0}, "1000011010": {"state": 538.0}, "1111100011": {"state": 995.0}, "0110110001": {"state": 433.0}, "1111111000": {"state": 1016.0}, "0111111100": {"state": 508.0}, "1100011100": {"state": 796.0}, "0110111111": {"state": 447.0}, "1100001101": {"state": 781.0}, "0111111110": {"state": 510.0}, "0110110010": {"state": 434.0}, "0111101011": {"state": 491.0}, "1111100110": {"state": 998.0}, "0111111001": {"state": 505.0}, "0111100110": {"state": 486.0}, "1111110101": {"state": 1013.0}, "1111110111": {"state": 1015.0}, "1111111001": {"state": 1017.0}, "1100010010": {"state": 786.0}, "0101000001": {"state": 321.0}, "0111110100": {"state": 500.0}, "0110101001": {"state": 425.0}, "1110101010": {"state": 938.0}, "1111110001": {"state": 1009.0}, "1110111000": {"state": 952.0}, "0111100010": {"state": 482.0}, "0111110010": {"state": 498.0}, "1111101101": {"state": 1005.0}, "0111101000": {"state": 488.0}, "0110111010": {"state": 442.0}, "1110101101": {"state": 941.0}, "1100000010": {"state": 770.0}, "0110101111": {"state": 431.0}, "1110110000": {"state": 944.0}, "1100000011": {"state": 771.0}, "1100010001": {"state": 785.0}, "0000000111": {"state": 7.0}, "0111110000": {"state": 496.0}, "0000010100": {"state": 20.0}, "0111100101": {"state": 485.0}, "0111110011": {"state": 499.0}, "0100001010": {"state": 266.0}, "1100011000": {"state": 792.0}, "1110111010": {"state": 954.0}, "1111100111": {"state": 999.0}, "1100011111": {"state": 799.0}, "0110111101": {"state": 445.0}, "0111101111": {"state": 495.0}, "1100001110": {"state": 782.0}, "1110110001": {"state": 945.0}, "0100010101": {"state": 277.0}, "1111111010": {"state": 1018.0}, "0000011110": {"state": 30.0}, "1111111111": {"state": 1023.0}, "0100011111": {"state": 287.0}, "0000010111": {"state": 23.0}, "1100001001": {"state": 777.0}, "0100000011": {"state": 259.0}, "1100011101": {"state": 797.0}, "0100001110": {"state": 270.0}, "0100010000": {"state": 272.0}, "0100011000": {"state": 280.0}, "1110110101": {"state": 949.0}, "1101001111": {"state": 847.0}, "0111100011": {"state": 483.0}, "1111101111": {"state": 1007.0}, "1110000110": {"state": 902.0}, "0100000100": {"state": 260.0}, "0110101110": {"state": 430.0}, "0111011001": {"state": 473.0}, "0111111111": {"state": 511.0}, "1111101011": {"state": 1003.0}, "0111101010": {"state": 490.0}, "0111100001": {"state": 481.0}, "0110110000": {"state": 432.0}, "1100000100": {"state": 772.0}, "1011100110": {"state": 742.0}, "1111110110": {"state": 1014.0}, "0011110000": {"state": 240.0}, "1110101110": {"state": 942.0}, "1110111111": {"state": 959.0}, "0011101111": {"state": 239.0}, "0011111111": {"state": 255.0}, "1110111011": {"state": 955.0}, "0110111100": {"state": 444.0}, "1011100100": {"state": 740.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "0110111001": 1, + "1111000100": 1, + "1000001110": 2, + "1111111111": 1, + "1101001110": 1, + "0000000001": 1, + "1111001100": 1, + "0000010011": 1, + "1011110001": 1, + "1000010011": 1, + "1110100000": 4, + "1000001111": 1, + "1110100110": 2, + "0011110101": 3, + "0100000011": 3, + "1100000111": 3, + "0111110110": 4, + "1101010100": 2, + "1100011101": 2, + "1101010011": 1, + "0101011101": 1, + "1100010111": 1, + "1011100110": 1, + "0100001011": 1, + "0101000011": 1, + "1111101110": 3, + "1100011110": 3, + "1101011101": 1, + "1101011111": 1, + "0000000111": 5, + "1010100011": 1, + "1101000101": 1, + "0011110000": 5, + "0110100010": 10, + "0000000011": 1, + "1110101111": 13, + "1100000110": 11, + "1000010100": 1, + "1110101000": 5, + "0111001001": 1, + "0100010111": 2, + "1110111100": 7, + "1111100111": 8, + "1011111100": 1, + "1110101110": 11, + "1000000010": 6, + "1110111111": 4, + "1110110100": 10, + "1100011100": 2, + "0110111111": 8, + "0111111000": 6, + "1101001011": 2, + "1101010010": 2, + "1100010100": 4, + "1100000000": 2, + "0100010001": 4, + "1100001000": 3, + "0110100100": 10, + "0111111110": 14, + "1101011011": 3, + "0100001001": 2, + "0011111011": 4, + "0111100110": 22, + "0100011011": 2, + "0110101010": 13, + "0100000101": 6, + "0011100000": 5, + "0100010000": 15, + "1100000010": 8, + "0011110111": 2, + "0111100111": 194, + "0111100000": 79, + "1111111110": 7, + "0101001001": 8, + "0111110001": 172, + "1111110011": 414, + "0110100101": 36, + "1100000011": 4, + "1100010001": 47, + "1101001010": 1, + "1100011011": 5, + "1100000101": 146, + "0111111010": 106, + "0111101110": 128, + "0100001100": 41, + "1111110101": 74, + "1111101100": 39, + "0101000110": 4, + "1111101111": 7, + "0111100011": 142, + "1110111101": 182, + "1111101001": 186, + "0100000000": 55, + "1100001101": 97, + "1110111000": 1, + "0111100010": 120, + "0111110000": 88, + "1100000100": 1, + "0110110000": 109, + "0111100001": 113, + "0111101010": 89, + "1110100101": 24, + "0111111101": 68, + "0110110101": 63, + "0000001001": 2, + "1111100011": 481, + "1011110111": 6, + "1110110111": 18, + "1011100111": 1, + "0110110110": 13, + "0110111000": 125, + "1111110100": 16, + "0010110101": 1, + "1110100010": 67, + "1111111101": 66, + "1111111011": 411, + "1111101000": 107, + "1110110110": 1, + "0110101001": 13, + "1100001111": 31, + "0111101101": 142, + "1100010010": 9, + "0110100001": 1, + "1110110011": 24, + "1110101101": 155, + "0111101011": 141, + "1111100110": 17, + "0000011000": 1, + "0110110010": 57, + "0111111100": 131, + "1111111000": 156, + "0110110001": 6, + "1111111100": 25, + "1111110111": 213, + "1111111001": 104, + "0100001111": 30, + "1110100111": 5, + "1111110001": 34, + "0000000101": 1, + "0110111110": 8, + "1110111001": 17, + "1110100011": 14, + "0111111011": 89, + "0011100111": 1, + "1011110110": 4, + "0101001011": 1, + "1000010010": 3, + "1100000001": 60, + "0111110101": 53, + "1111000011": 1, + "0111111001": 175, + "1111011011": 2, + "1111101010": 70, + "0010100010": 1, + "0111110100": 53, + "0110111101": 9, + "1100011111": 9, + "0100011001": 9, + "1110101100": 1, + "1111100101": 24, + "0111010110": 1, + "0000000100": 1, + "1110101001": 40, + "1000011110": 1, + "0110101000": 32, + "1110111110": 63, + "1110100001": 90, + "0110111011": 35, + "0111110111": 111, + "0100010100": 5, + "1011110101": 4, + "0111101100": 13, + "0100011111": 1, + "1100001001": 10, + "0110101011": 42, + "0100010011": 3, + "1100010101": 71, + "1100001110": 6, + "1110110001": 47, + "0100010101": 11, + "0111011001": 2, + "0111111111": 40, + "1111100100": 17, + "0110101111": 118, + "1110110000": 34, + "1111101101": 22, + "0110100000": 16, + "0101010101": 1, + "0110101110": 28, + "0111101111": 48, + "1111111010": 41, + "1100010011": 5, + "1111100000": 17, + "0100011100": 24, + "0111100100": 134, + "0111110010": 46, + "0100011000": 1, + "1101001111": 6, + "1110110101": 48, + "0100011010": 3, + "0111101000": 48, + "0110111010": 12, + "1110110010": 1, + "1100011000": 2, + "1110111010": 21, + "0110111100": 140, + "1100001100": 3, + "0111011010": 1, + "1111100001": 15, + "1111110000": 1, + "0110100110": 13, + "1110101011": 30, + "0101000111": 1, + "0110101100": 13, + "0110110111": 93, + "0111101001": 14, + "0000010100": 1, + "0111110011": 73, + "0111100101": 15, + "0100001010": 9, + "1101011000": 1, + "1111110110": 12, + "1001001100": 2, + "1101000100": 1, + "0011111111": 9, + "1110111011": 8, + "0100000100": 10, + "1110101010": 16, + "1111101011": 30, + "0110101101": 3 + }, + "counts_lsb_right": true, + "parsed_states": { + "0110111001": { "state": 441.0 }, + "1111000100": { "state": 964.0 }, + "1000001110": { "state": 526.0 }, + "1111111111": { "state": 1023.0 }, + "1101001110": { "state": 846.0 }, + "0000000001": { "state": 1.0 }, + "1111001100": { "state": 972.0 }, + "0000010011": { "state": 19.0 }, + "1011110001": { "state": 753.0 }, + "1000010011": { "state": 531.0 }, + "1110100000": { "state": 928.0 }, + "1000001111": { "state": 527.0 }, + "1110100110": { "state": 934.0 }, + "0011110101": { "state": 245.0 }, + "0100000011": { "state": 259.0 }, + "1100000111": { "state": 775.0 }, + "0111110110": { "state": 502.0 }, + "1101010100": { "state": 852.0 }, + "1100011101": { "state": 797.0 }, + "1101010011": { "state": 851.0 }, + "0101011101": { "state": 349.0 }, + "1100010111": { "state": 791.0 }, + "1011100110": { "state": 742.0 }, + "0100001011": { "state": 267.0 }, + "0101000011": { "state": 323.0 }, + "1111101110": { "state": 1006.0 }, + "1100011110": { "state": 798.0 }, + "1101011101": { "state": 861.0 }, + "1101011111": { "state": 863.0 }, + "0000000111": { "state": 7.0 }, + "1010100011": { "state": 675.0 }, + "1101000101": { "state": 837.0 }, + "0011110000": { "state": 240.0 }, + "0110100010": { "state": 418.0 }, + "0000000011": { "state": 3.0 }, + "1110101111": { "state": 943.0 }, + "1100000110": { "state": 774.0 }, + "1000010100": { "state": 532.0 }, + "1110101000": { "state": 936.0 }, + "0111001001": { "state": 457.0 }, + "0100010111": { "state": 279.0 }, + "1110111100": { "state": 956.0 }, + "1111100111": { "state": 999.0 }, + "1011111100": { "state": 764.0 }, + "1110101110": { "state": 942.0 }, + "1000000010": { "state": 514.0 }, + "1110111111": { "state": 959.0 }, + "1110110100": { "state": 948.0 }, + "1100011100": { "state": 796.0 }, + "0110111111": { "state": 447.0 }, + "0111111000": { "state": 504.0 }, + "1101001011": { "state": 843.0 }, + "1101010010": { "state": 850.0 }, + "1100010100": { "state": 788.0 }, + "1100000000": { "state": 768.0 }, + "0100010001": { "state": 273.0 }, + "1100001000": { "state": 776.0 }, + "0110100100": { "state": 420.0 }, + "0111111110": { "state": 510.0 }, + "1101011011": { "state": 859.0 }, + "0100001001": { "state": 265.0 }, + "0011111011": { "state": 251.0 }, + "0111100110": { "state": 486.0 }, + "0100011011": { "state": 283.0 }, + "0110101010": { "state": 426.0 }, + "0100000101": { "state": 261.0 }, + "0011100000": { "state": 224.0 }, + "0100010000": { "state": 272.0 }, + "1100000010": { "state": 770.0 }, + "0011110111": { "state": 247.0 }, + "0111100111": { "state": 487.0 }, + "0111100000": { "state": 480.0 }, + "1111111110": { "state": 1022.0 }, + "0101001001": { "state": 329.0 }, + "0111110001": { "state": 497.0 }, + "1111110011": { "state": 1011.0 }, + "0110100101": { "state": 421.0 }, + "1100000011": { "state": 771.0 }, + "1100010001": { "state": 785.0 }, + "1101001010": { "state": 842.0 }, + "1100011011": { "state": 795.0 }, + "1100000101": { "state": 773.0 }, + "0111111010": { "state": 506.0 }, + "0111101110": { "state": 494.0 }, + "0100001100": { "state": 268.0 }, + "1111110101": { "state": 1013.0 }, + "1111101100": { "state": 1004.0 }, + "0101000110": { "state": 326.0 }, + "1111101111": { "state": 1007.0 }, + "0111100011": { "state": 483.0 }, + "1110111101": { "state": 957.0 }, + "1111101001": { "state": 1001.0 }, + "0100000000": { "state": 256.0 }, + "1100001101": { "state": 781.0 }, + "1110111000": { "state": 952.0 }, + "0111100010": { "state": 482.0 }, + "0111110000": { "state": 496.0 }, + "1100000100": { "state": 772.0 }, + "0110110000": { "state": 432.0 }, + "0111100001": { "state": 481.0 }, + "0111101010": { "state": 490.0 }, + "1110100101": { "state": 933.0 }, + "0111111101": { "state": 509.0 }, + "0110110101": { "state": 437.0 }, + "0000001001": { "state": 9.0 }, + "1111100011": { "state": 995.0 }, + "1011110111": { "state": 759.0 }, + "1110110111": { "state": 951.0 }, + "1011100111": { "state": 743.0 }, + "0110110110": { "state": 438.0 }, + "0110111000": { "state": 440.0 }, + "1111110100": { "state": 1012.0 }, + "0010110101": { "state": 181.0 }, + "1110100010": { "state": 930.0 }, + "1111111101": { "state": 1021.0 }, + "1111111011": { "state": 1019.0 }, + "1111101000": { "state": 1000.0 }, + "1110110110": { "state": 950.0 }, + "0110101001": { "state": 425.0 }, + "1100001111": { "state": 783.0 }, + "0111101101": { "state": 493.0 }, + "1100010010": { "state": 786.0 }, + "0110100001": { "state": 417.0 }, + "1110110011": { "state": 947.0 }, + "1110101101": { "state": 941.0 }, + "0111101011": { "state": 491.0 }, + "1111100110": { "state": 998.0 }, + "0000011000": { "state": 24.0 }, + "0110110010": { "state": 434.0 }, + "0111111100": { "state": 508.0 }, + "1111111000": { "state": 1016.0 }, + "0110110001": { "state": 433.0 }, + "1111111100": { "state": 1020.0 }, + "1111110111": { "state": 1015.0 }, + "1111111001": { "state": 1017.0 }, + "0100001111": { "state": 271.0 }, + "1110100111": { "state": 935.0 }, + "1111110001": { "state": 1009.0 }, + "0000000101": { "state": 5.0 }, + "0110111110": { "state": 446.0 }, + "1110111001": { "state": 953.0 }, + "1110100011": { "state": 931.0 }, + "0111111011": { "state": 507.0 }, + "0011100111": { "state": 231.0 }, + "1011110110": { "state": 758.0 }, + "0101001011": { "state": 331.0 }, + "1000010010": { "state": 530.0 }, + "1100000001": { "state": 769.0 }, + "0111110101": { "state": 501.0 }, + "1111000011": { "state": 963.0 }, + "0111111001": { "state": 505.0 }, + "1111011011": { "state": 987.0 }, + "1111101010": { "state": 1002.0 }, + "0010100010": { "state": 162.0 }, + "0111110100": { "state": 500.0 }, + "0110111101": { "state": 445.0 }, + "1100011111": { "state": 799.0 }, + "0100011001": { "state": 281.0 }, + "1110101100": { "state": 940.0 }, + "1111100101": { "state": 997.0 }, + "0111010110": { "state": 470.0 }, + "0000000100": { "state": 4.0 }, + "1110101001": { "state": 937.0 }, + "1000011110": { "state": 542.0 }, + "0110101000": { "state": 424.0 }, + "1110111110": { "state": 958.0 }, + "1110100001": { "state": 929.0 }, + "0110111011": { "state": 443.0 }, + "0111110111": { "state": 503.0 }, + "0100010100": { "state": 276.0 }, + "1011110101": { "state": 757.0 }, + "0111101100": { "state": 492.0 }, + "0100011111": { "state": 287.0 }, + "1100001001": { "state": 777.0 }, + "0110101011": { "state": 427.0 }, + "0100010011": { "state": 275.0 }, + "1100010101": { "state": 789.0 }, + "1100001110": { "state": 782.0 }, + "1110110001": { "state": 945.0 }, + "0100010101": { "state": 277.0 }, + "0111011001": { "state": 473.0 }, + "0111111111": { "state": 511.0 }, + "1111100100": { "state": 996.0 }, + "0110101111": { "state": 431.0 }, + "1110110000": { "state": 944.0 }, + "1111101101": { "state": 1005.0 }, + "0110100000": { "state": 416.0 }, + "0101010101": { "state": 341.0 }, + "0110101110": { "state": 430.0 }, + "0111101111": { "state": 495.0 }, + "1111111010": { "state": 1018.0 }, + "1100010011": { "state": 787.0 }, + "1111100000": { "state": 992.0 }, + "0100011100": { "state": 284.0 }, + "0111100100": { "state": 484.0 }, + "0111110010": { "state": 498.0 }, + "0100011000": { "state": 280.0 }, + "1101001111": { "state": 847.0 }, + "1110110101": { "state": 949.0 }, + "0100011010": { "state": 282.0 }, + "0111101000": { "state": 488.0 }, + "0110111010": { "state": 442.0 }, + "1110110010": { "state": 946.0 }, + "1100011000": { "state": 792.0 }, + "1110111010": { "state": 954.0 }, + "0110111100": { "state": 444.0 }, + "1100001100": { "state": 780.0 }, + "0111011010": { "state": 474.0 }, + "1111100001": { "state": 993.0 }, + "1111110000": { "state": 1008.0 }, + "0110100110": { "state": 422.0 }, + "1110101011": { "state": 939.0 }, + "0101000111": { "state": 327.0 }, + "0110101100": { "state": 428.0 }, + "0110110111": { "state": 439.0 }, + "0111101001": { "state": 489.0 }, + "0000010100": { "state": 20.0 }, + "0111110011": { "state": 499.0 }, + "0111100101": { "state": 485.0 }, + "0100001010": { "state": 266.0 }, + "1101011000": { "state": 856.0 }, + "1111110110": { "state": 1014.0 }, + "1001001100": { "state": 588.0 }, + "1101000100": { "state": 836.0 }, + "0011111111": { "state": 255.0 }, + "1110111011": { "state": 955.0 }, + "0100000100": { "state": 260.0 }, + "1110101010": { "state": 938.0 }, + "1111101011": { "state": 1003.0 }, + "0110101101": { "state": 429.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n+2.json b/algorithms/glued_trees/results/10-qubits/2n+2.json index 3eb33f7a..e67a985b 100644 --- a/algorithms/glued_trees/results/10-qubits/2n+2.json +++ b/algorithms/glued_trees/results/10-qubits/2n+2.json @@ -1 +1,526 @@ -{"vendor_format_result": {}, "counts": {"0110100011": 1, "0111100100": 1, "1111101000": 1, "0010111001": 1, "1000000111": 1, "1111101100": 1, "1110100110": 3, "1111100111": 1, "1001001100": 1, "0001001110": 2, "0011110110": 5, "1010101011": 1, "0100011010": 2, "0110111100": 3, "1011100100": 2, "1110101101": 7, "0110100100": 2, "0110101101": 3, "1111101011": 6, "1101001100": 2, "0101001101": 3, "0100011101": 1, "1000010000": 1, "1000000011": 2, "1011101010": 2, "0011110101": 1, "0110110010": 5, "0000011000": 6, "0100010001": 2, "1111100011": 9, "0000001001": 3, "1110111111": 2, "0011101111": 4, "0110101111": 1, "1110110000": 5, "1000000101": 2, "1100011101": 4, "0111101011": 4, "1000010101": 1, "0011111100": 1, "0011110010": 5, "1011111011": 1, "0011111011": 1, "1110111100": 7, "0101000000": 1, "1110111101": 4, "1000000000": 2, "0100011000": 5, "0101000110": 3, "0101011010": 1, "1000001111": 9, "0110101001": 1, "1110110001": 4, "0110100010": 4, "0110101011": 16, "1011110010": 2, "1110111011": 13, "0011111111": 19, "1110101011": 2, "0110100110": 10, "1111110000": 43, "0100011100": 1, "1111100000": 20, "0111100111": 3, "0111110000": 133, "0000001010": 2, "1111101010": 66, "1000011110": 1, "1110101001": 36, "0000000100": 13, "0110100001": 5, "1110110011": 6, "1000001100": 4, "1111111100": 382, "1000010110": 73, "0110110000": 2, "0100001000": 1, "0100000111": 17, "0111100001": 15, "0111101111": 10, "1100001000": 14, "1100001100": 30, "0101010110": 1, "0111110100": 71, "0000010000": 1, "0011110100": 3, "0111000001": 1, "0000000111": 50, "1111110011": 76, "1011111101": 1, "0111110001": 111, "1111111110": 514, "1100011110": 5, "0110100101": 2, "1100001010": 43, "0000011111": 1, "1111101001": 119, "1100000001": 246, "1000001000": 9, "0111110110": 170, "0100001111": 20, "0000001000": 9, "1111110101": 10, "1111100100": 17, "1000000001": 1, "0111101101": 5, "1100001011": 15, "0111111111": 13, "0110110110": 4, "0100000010": 2, "1111110100": 79, "0010110101": 1, "1110100010": 4, "1111111010": 122, "0110100111": 2, "0110110111": 30, "1100000010": 42, "1110101111": 1, "0000000011": 17, "1111110111": 7, "1111111001": 284, "0110101000": 41, "1110111110": 22, "1000001001": 13, "1100001001": 11, "0000010111": 17, "0110111101": 2, "1100011111": 4, "1111100010": 1, "1000000110": 161, "1101010100": 2, "0000001100": 10, "0001000010": 1, "0111111110": 309, "1100001101": 38, "0000011110": 4, "1000001011": 5, "1111111111": 553, "0111111000": 699, "0111110010": 195, "1100011011": 5, "1000011111": 3, "1100000101": 10, "1010111011": 1, "0111111010": 14, "1100000110": 49, "1000000010": 5, "0111110101": 72, "0111100101": 1, "0000010100": 7, "0100001101": 3, "0100001010": 2, "0111110011": 64, "1000001010": 4, "0100010100": 10, "1111101110": 144, "1111111011": 237, "1111111101": 96, "0110100000": 15, "1111110001": 50, "1011101101": 8, "0111111101": 108, "0100010000": 40, "0110111010": 5, "0111101000": 287, "0100000011": 33, "0101000101": 5, "0110110011": 13, "0110111000": 67, "1111110010": 38, "1011110110": 5, "1000010111": 1, "0101010101": 2, "0110101110": 4, "0000000000": 21, "0010101110": 1, "1100010001": 121, "0011101011": 2, "0111100110": 25, "0000001101": 5, "0101010001": 1, "1111101101": 32, "0110110001": 1, "1001000011": 1, "1111111000": 502, "0111111100": 23, "1011101110": 22, "0000001110": 1, "0110111011": 3, "0111110111": 66, "1110100001": 51, "0110111110": 23, "1011111110": 69, "0100001001": 19, "0011101000": 5, "0100000000": 75, "1000011100": 9, "0110101010": 2, "0100011110": 1, "1011100101": 1, "0110101100": 5, "1110110010": 1, "1100011000": 11, "1110111010": 30, "0100001110": 6, "1000001110": 5, "1101011000": 2, "1111110110": 24, "0100010011": 13, "1001000000": 2, "1000000100": 1, "1100011010": 16, "0111100010": 32, "1000011001": 2, "1111101111": 1, "0111100011": 2, "0011101100": 2, "0110111001": 3, "1010110100": 1, "1101001000": 8, "0000001111": 14, "1100010010": 15, "1100011100": 9, "0110111111": 32, "0111101110": 1, "1100011001": 5, "0001000101": 4, "1110101110": 12, "1011110111": 1, "1111100001": 13, "1111100110": 5, "0111111001": 10, "1111000011": 1, "1011111010": 18, "1100010110": 18, "0100000100": 29, "1111100101": 2, "1110101100": 8, "0100001011": 24, "1110100011": 1, "0111111011": 16, "0010110001": 2, "0100011001": 5, "0100011011": 1}, "counts_lsb_right": true, "parsed_states": {"0110100011": {"state": 419.0}, "0111100100": {"state": 484.0}, "1111101000": {"state": 1000.0}, "0010111001": {"state": 185.0}, "1000000111": {"state": 519.0}, "1111101100": {"state": 1004.0}, "1110100110": {"state": 934.0}, "1111100111": {"state": 999.0}, "1001001100": {"state": 588.0}, "0001001110": {"state": 78.0}, "0011110110": {"state": 246.0}, "1010101011": {"state": 683.0}, "0100011010": {"state": 282.0}, "0110111100": {"state": 444.0}, "1011100100": {"state": 740.0}, "1110101101": {"state": 941.0}, "0110100100": {"state": 420.0}, "0110101101": {"state": 429.0}, "1111101011": {"state": 1003.0}, "1101001100": {"state": 844.0}, "0101001101": {"state": 333.0}, "0100011101": {"state": 285.0}, "1000010000": {"state": 528.0}, "1000000011": {"state": 515.0}, "1011101010": {"state": 746.0}, "0011110101": {"state": 245.0}, "0110110010": {"state": 434.0}, "0000011000": {"state": 24.0}, "0100010001": {"state": 273.0}, "1111100011": {"state": 995.0}, "0000001001": {"state": 9.0}, "1110111111": {"state": 959.0}, "0011101111": {"state": 239.0}, "0110101111": {"state": 431.0}, "1110110000": {"state": 944.0}, "1000000101": {"state": 517.0}, "1100011101": {"state": 797.0}, "0111101011": {"state": 491.0}, "1000010101": {"state": 533.0}, "0011111100": {"state": 252.0}, "0011110010": {"state": 242.0}, "1011111011": {"state": 763.0}, "0011111011": {"state": 251.0}, "1110111100": {"state": 956.0}, "0101000000": {"state": 320.0}, "1110111101": {"state": 957.0}, "1000000000": {"state": 512.0}, "0100011000": {"state": 280.0}, "0101000110": {"state": 326.0}, "0101011010": {"state": 346.0}, "1000001111": {"state": 527.0}, "0110101001": {"state": 425.0}, "1110110001": {"state": 945.0}, "0110100010": {"state": 418.0}, "0110101011": {"state": 427.0}, "1011110010": {"state": 754.0}, "1110111011": {"state": 955.0}, "0011111111": {"state": 255.0}, "1110101011": {"state": 939.0}, "0110100110": {"state": 422.0}, "1111110000": {"state": 1008.0}, "0100011100": {"state": 284.0}, "1111100000": {"state": 992.0}, "0111100111": {"state": 487.0}, "0111110000": {"state": 496.0}, "0000001010": {"state": 10.0}, "1111101010": {"state": 1002.0}, "1000011110": {"state": 542.0}, "1110101001": {"state": 937.0}, "0000000100": {"state": 4.0}, "0110100001": {"state": 417.0}, "1110110011": {"state": 947.0}, "1000001100": {"state": 524.0}, "1111111100": {"state": 1020.0}, "1000010110": {"state": 534.0}, "0110110000": {"state": 432.0}, "0100001000": {"state": 264.0}, "0100000111": {"state": 263.0}, "0111100001": {"state": 481.0}, "0111101111": {"state": 495.0}, "1100001000": {"state": 776.0}, "1100001100": {"state": 780.0}, "0101010110": {"state": 342.0}, "0111110100": {"state": 500.0}, "0000010000": {"state": 16.0}, "0011110100": {"state": 244.0}, "0111000001": {"state": 449.0}, "0000000111": {"state": 7.0}, "1111110011": {"state": 1011.0}, "1011111101": {"state": 765.0}, "0111110001": {"state": 497.0}, "1111111110": {"state": 1022.0}, "1100011110": {"state": 798.0}, "0110100101": {"state": 421.0}, "1100001010": {"state": 778.0}, "0000011111": {"state": 31.0}, "1111101001": {"state": 1001.0}, "1100000001": {"state": 769.0}, "1000001000": {"state": 520.0}, "0111110110": {"state": 502.0}, "0100001111": {"state": 271.0}, "0000001000": {"state": 8.0}, "1111110101": {"state": 1013.0}, "1111100100": {"state": 996.0}, "1000000001": {"state": 513.0}, "0111101101": {"state": 493.0}, "1100001011": {"state": 779.0}, "0111111111": {"state": 511.0}, "0110110110": {"state": 438.0}, "0100000010": {"state": 258.0}, "1111110100": {"state": 1012.0}, "0010110101": {"state": 181.0}, "1110100010": {"state": 930.0}, "1111111010": {"state": 1018.0}, "0110100111": {"state": 423.0}, "0110110111": {"state": 439.0}, "1100000010": {"state": 770.0}, "1110101111": {"state": 943.0}, "0000000011": {"state": 3.0}, "1111110111": {"state": 1015.0}, "1111111001": {"state": 1017.0}, "0110101000": {"state": 424.0}, "1110111110": {"state": 958.0}, "1000001001": {"state": 521.0}, "1100001001": {"state": 777.0}, "0000010111": {"state": 23.0}, "0110111101": {"state": 445.0}, "1100011111": {"state": 799.0}, "1111100010": {"state": 994.0}, "1000000110": {"state": 518.0}, "1101010100": {"state": 852.0}, "0000001100": {"state": 12.0}, "0001000010": {"state": 66.0}, "0111111110": {"state": 510.0}, "1100001101": {"state": 781.0}, "0000011110": {"state": 30.0}, "1000001011": {"state": 523.0}, "1111111111": {"state": 1023.0}, "0111111000": {"state": 504.0}, "0111110010": {"state": 498.0}, "1100011011": {"state": 795.0}, "1000011111": {"state": 543.0}, "1100000101": {"state": 773.0}, "1010111011": {"state": 699.0}, "0111111010": {"state": 506.0}, "1100000110": {"state": 774.0}, "1000000010": {"state": 514.0}, "0111110101": {"state": 501.0}, "0111100101": {"state": 485.0}, "0000010100": {"state": 20.0}, "0100001101": {"state": 269.0}, "0100001010": {"state": 266.0}, "0111110011": {"state": 499.0}, "1000001010": {"state": 522.0}, "0100010100": {"state": 276.0}, "1111101110": {"state": 1006.0}, "1111111011": {"state": 1019.0}, "1111111101": {"state": 1021.0}, "0110100000": {"state": 416.0}, "1111110001": {"state": 1009.0}, "1011101101": {"state": 749.0}, "0111111101": {"state": 509.0}, "0100010000": {"state": 272.0}, "0110111010": {"state": 442.0}, "0111101000": {"state": 488.0}, "0100000011": {"state": 259.0}, "0101000101": {"state": 325.0}, "0110110011": {"state": 435.0}, "0110111000": {"state": 440.0}, "1111110010": {"state": 1010.0}, "1011110110": {"state": 758.0}, "1000010111": {"state": 535.0}, "0101010101": {"state": 341.0}, "0110101110": {"state": 430.0}, "0000000000": {"state": 0.0}, "0010101110": {"state": 174.0}, "1100010001": {"state": 785.0}, "0011101011": {"state": 235.0}, "0111100110": {"state": 486.0}, "0000001101": {"state": 13.0}, "0101010001": {"state": 337.0}, "1111101101": {"state": 1005.0}, "0110110001": {"state": 433.0}, "1001000011": {"state": 579.0}, "1111111000": {"state": 1016.0}, "0111111100": {"state": 508.0}, "1011101110": {"state": 750.0}, "0000001110": {"state": 14.0}, "0110111011": {"state": 443.0}, "0111110111": {"state": 503.0}, "1110100001": {"state": 929.0}, "0110111110": {"state": 446.0}, "1011111110": {"state": 766.0}, "0100001001": {"state": 265.0}, "0011101000": {"state": 232.0}, "0100000000": {"state": 256.0}, "1000011100": {"state": 540.0}, "0110101010": {"state": 426.0}, "0100011110": {"state": 286.0}, "1011100101": {"state": 741.0}, "0110101100": {"state": 428.0}, "1110110010": {"state": 946.0}, "1100011000": {"state": 792.0}, "1110111010": {"state": 954.0}, "0100001110": {"state": 270.0}, "1000001110": {"state": 526.0}, "1101011000": {"state": 856.0}, "1111110110": {"state": 1014.0}, "0100010011": {"state": 275.0}, "1001000000": {"state": 576.0}, "1000000100": {"state": 516.0}, "1100011010": {"state": 794.0}, "0111100010": {"state": 482.0}, "1000011001": {"state": 537.0}, "1111101111": {"state": 1007.0}, "0111100011": {"state": 483.0}, "0011101100": {"state": 236.0}, "0110111001": {"state": 441.0}, "1010110100": {"state": 692.0}, "1101001000": {"state": 840.0}, "0000001111": {"state": 15.0}, "1100010010": {"state": 786.0}, "1100011100": {"state": 796.0}, "0110111111": {"state": 447.0}, "0111101110": {"state": 494.0}, "1100011001": {"state": 793.0}, "0001000101": {"state": 69.0}, "1110101110": {"state": 942.0}, "1011110111": {"state": 759.0}, "1111100001": {"state": 993.0}, "1111100110": {"state": 998.0}, "0111111001": {"state": 505.0}, "1111000011": {"state": 963.0}, "1011111010": {"state": 762.0}, "1100010110": {"state": 790.0}, "0100000100": {"state": 260.0}, "1111100101": {"state": 997.0}, "1110101100": {"state": 940.0}, "0100001011": {"state": 267.0}, "1110100011": {"state": 931.0}, "0111111011": {"state": 507.0}, "0010110001": {"state": 177.0}, "0100011001": {"state": 281.0}, "0100011011": {"state": 283.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "1000011101": 1, + "1001011100": 1, + "1011110011": 1, + "0011101000": 3, + "0111100100": 2, + "1001010011": 1, + "1110100110": 2, + "0011111010": 1, + "1011110110": 3, + "1001001100": 2, + "1101000100": 2, + "1000000011": 1, + "1111101100": 1, + "0101000110": 2, + "0110100011": 2, + "0110100100": 1, + "0100000110": 2, + "1000000101": 6, + "1111100111": 2, + "0110100010": 2, + "1111100010": 1, + "0110111101": 3, + "0110101001": 2, + "1101010010": 1, + "0011100101": 4, + "0101001101": 2, + "1000010000": 1, + "0110100101": 2, + "1011101001": 2, + "1111101000": 1, + "0110111100": 1, + "1011110010": 3, + "0000000010": 1, + "1111001100": 1, + "0101011101": 1, + "1000000111": 3, + "0111111010": 8, + "1100011101": 3, + "0100010010": 1, + "1111100101": 3, + "1110101100": 7, + "1000000010": 5, + "0100010001": 3, + "0100001110": 10, + "0011100110": 1, + "0100000101": 3, + "0110101010": 4, + "0101000101": 5, + "0110110011": 10, + "0110111001": 7, + "0100011001": 6, + "0000001000": 13, + "1100001000": 10, + "1100011001": 2, + "1100011110": 2, + "1000000001": 1, + "1100001011": 7, + "0111101101": 7, + "0100001111": 20, + "0001011110": 1, + "1110111100": 8, + "0000000110": 1, + "0100001001": 18, + "0110100001": 4, + "1110110011": 5, + "1000001110": 9, + "1100001110": 2, + "1110110001": 5, + "1011111000": 2, + "0110101101": 2, + "1110101110": 8, + "1000001100": 7, + "1100001100": 27, + "0000000111": 48, + "0111111001": 17, + "0000001100": 6, + "1000000110": 145, + "1011111101": 4, + "0111110001": 103, + "0010101001": 1, + "1111111110": 484, + "1111110011": 87, + "1111110001": 59, + "1011101101": 2, + "0111111101": 97, + "0100010110": 1, + "1000001010": 3, + "0100010100": 13, + "1100001001": 14, + "0000010111": 20, + "1000001001": 11, + "1000010110": 81, + "1110111101": 3, + "0000001010": 1, + "1111101010": 55, + "1000011110": 2, + "0000000100": 8, + "1110101001": 40, + "1100000101": 5, + "1100011011": 7, + "1000011111": 2, + "0110101011": 20, + "0100000011": 22, + "0110111010": 5, + "0111101000": 268, + "1110110110": 1, + "1100001010": 56, + "0000011111": 1, + "1111101001": 96, + "0000011101": 2, + "1011111110": 59, + "1111111011": 215, + "1111111101": 96, + "1111101110": 144, + "0000011110": 4, + "1000001011": 5, + "1111111111": 521, + "1111101111": 1, + "1000011001": 4, + "0111100011": 3, + "1100000001": 256, + "1000001000": 8, + "1001001111": 1, + "1111100100": 19, + "0111111111": 8, + "0110101000": 42, + "1110111110": 19, + "1011111001": 1, + "0001000010": 2, + "0111111110": 316, + "1100001101": 47, + "0111110101": 67, + "0000000000": 20, + "0110101110": 4, + "1111110101": 12, + "1110100100": 2, + "1000001101": 1, + "0111110010": 202, + "0111111000": 768, + "0111101011": 7, + "1111100110": 9, + "1111110111": 7, + "1111111001": 286, + "0110100111": 1, + "0110110111": 17, + "1100000010": 32, + "1110101101": 11, + "0000000011": 23, + "1100011100": 6, + "0110111111": 58, + "0000001110": 1, + "0110111011": 4, + "0111110111": 80, + "1110100001": 61, + "0110111110": 15, + "1111101011": 8, + "1111111100": 373, + "0000011010": 1, + "0100000010": 14, + "1111110100": 87, + "1110100010": 6, + "1111111010": 143, + "0111100010": 39, + "1000000100": 2, + "1100011010": 15, + "0111110000": 123, + "1011100111": 1, + "1101010111": 1, + "0110110110": 10, + "1110100111": 1, + "0111110110": 177, + "1100011000": 6, + "1110111010": 20, + "1011101110": 18, + "0100001000": 1, + "1100000100": 1, + "0111101010": 1, + "0111100001": 17, + "0100000111": 17, + "1110101011": 7, + "0110100110": 7, + "1111110000": 42, + "0101010110": 1, + "0111110100": 62, + "0011110100": 3, + "1011110100": 1, + "0111101111": 12, + "0001001001": 1, + "1111101101": 22, + "0000001001": 1, + "1000011010": 2, + "1111100011": 11, + "0110110001": 3, + "1111111000": 510, + "0111111100": 27, + "0100001011": 22, + "0000001101": 4, + "0111100110": 27, + "1110110000": 6, + "0011100010": 5, + "1011101010": 3, + "1110101000": 1, + "1111000111": 2, + "0111001101": 1, + "1100000110": 40, + "1110101010": 12, + "1011111010": 16, + "0000001111": 17, + "1001000000": 4, + "0100010011": 13, + "0110111000": 61, + "1111110010": 38, + "0100000000": 48, + "1000011100": 4, + "1110111111": 4, + "0011101111": 6, + "0100011100": 2, + "1111100000": 25, + "0111100000": 4, + "0011110000": 3, + "0110110010": 4, + "0000011000": 9, + "1100010010": 13, + "1111100001": 17, + "0100011000": 5, + "1000000000": 3, + "0100011110": 4, + "0110101100": 16, + "0001001010": 3, + "0011111111": 18, + "1110111011": 14, + "0011101011": 1, + "1100010001": 110, + "1100000011": 1, + "0011111100": 3, + "0011110010": 1, + "0111111011": 19, + "1110100011": 3, + "1101011000": 2, + "1111110110": 25, + "0101011010": 1, + "1000001111": 6, + "0100010000": 35, + "0110100000": 11, + "0100001101": 8, + "0000010100": 4, + "0111100101": 4, + "0111110011": 58, + "0100001010": 4, + "1100010110": 18, + "0100000100": 27, + "1110100000": 7, + "1101000011": 1, + "1010110100": 2, + "1101001000": 10, + "0011111011": 4 + }, + "counts_lsb_right": true, + "parsed_states": { + "1000011101": { "state": 541.0 }, + "1001011100": { "state": 604.0 }, + "1011110011": { "state": 755.0 }, + "0011101000": { "state": 232.0 }, + "0111100100": { "state": 484.0 }, + "1001010011": { "state": 595.0 }, + "1110100110": { "state": 934.0 }, + "0011111010": { "state": 250.0 }, + "1011110110": { "state": 758.0 }, + "1001001100": { "state": 588.0 }, + "1101000100": { "state": 836.0 }, + "1000000011": { "state": 515.0 }, + "1111101100": { "state": 1004.0 }, + "0101000110": { "state": 326.0 }, + "0110100011": { "state": 419.0 }, + "0110100100": { "state": 420.0 }, + "0100000110": { "state": 262.0 }, + "1000000101": { "state": 517.0 }, + "1111100111": { "state": 999.0 }, + "0110100010": { "state": 418.0 }, + "1111100010": { "state": 994.0 }, + "0110111101": { "state": 445.0 }, + "0110101001": { "state": 425.0 }, + "1101010010": { "state": 850.0 }, + "0011100101": { "state": 229.0 }, + "0101001101": { "state": 333.0 }, + "1000010000": { "state": 528.0 }, + "0110100101": { "state": 421.0 }, + "1011101001": { "state": 745.0 }, + "1111101000": { "state": 1000.0 }, + "0110111100": { "state": 444.0 }, + "1011110010": { "state": 754.0 }, + "0000000010": { "state": 2.0 }, + "1111001100": { "state": 972.0 }, + "0101011101": { "state": 349.0 }, + "1000000111": { "state": 519.0 }, + "0111111010": { "state": 506.0 }, + "1100011101": { "state": 797.0 }, + "0100010010": { "state": 274.0 }, + "1111100101": { "state": 997.0 }, + "1110101100": { "state": 940.0 }, + "1000000010": { "state": 514.0 }, + "0100010001": { "state": 273.0 }, + "0100001110": { "state": 270.0 }, + "0011100110": { "state": 230.0 }, + "0100000101": { "state": 261.0 }, + "0110101010": { "state": 426.0 }, + "0101000101": { "state": 325.0 }, + "0110110011": { "state": 435.0 }, + "0110111001": { "state": 441.0 }, + "0100011001": { "state": 281.0 }, + "0000001000": { "state": 8.0 }, + "1100001000": { "state": 776.0 }, + "1100011001": { "state": 793.0 }, + "1100011110": { "state": 798.0 }, + "1000000001": { "state": 513.0 }, + "1100001011": { "state": 779.0 }, + "0111101101": { "state": 493.0 }, + "0100001111": { "state": 271.0 }, + "0001011110": { "state": 94.0 }, + "1110111100": { "state": 956.0 }, + "0000000110": { "state": 6.0 }, + "0100001001": { "state": 265.0 }, + "0110100001": { "state": 417.0 }, + "1110110011": { "state": 947.0 }, + "1000001110": { "state": 526.0 }, + "1100001110": { "state": 782.0 }, + "1110110001": { "state": 945.0 }, + "1011111000": { "state": 760.0 }, + "0110101101": { "state": 429.0 }, + "1110101110": { "state": 942.0 }, + "1000001100": { "state": 524.0 }, + "1100001100": { "state": 780.0 }, + "0000000111": { "state": 7.0 }, + "0111111001": { "state": 505.0 }, + "0000001100": { "state": 12.0 }, + "1000000110": { "state": 518.0 }, + "1011111101": { "state": 765.0 }, + "0111110001": { "state": 497.0 }, + "0010101001": { "state": 169.0 }, + "1111111110": { "state": 1022.0 }, + "1111110011": { "state": 1011.0 }, + "1111110001": { "state": 1009.0 }, + "1011101101": { "state": 749.0 }, + "0111111101": { "state": 509.0 }, + "0100010110": { "state": 278.0 }, + "1000001010": { "state": 522.0 }, + "0100010100": { "state": 276.0 }, + "1100001001": { "state": 777.0 }, + "0000010111": { "state": 23.0 }, + "1000001001": { "state": 521.0 }, + "1000010110": { "state": 534.0 }, + "1110111101": { "state": 957.0 }, + "0000001010": { "state": 10.0 }, + "1111101010": { "state": 1002.0 }, + "1000011110": { "state": 542.0 }, + "0000000100": { "state": 4.0 }, + "1110101001": { "state": 937.0 }, + "1100000101": { "state": 773.0 }, + "1100011011": { "state": 795.0 }, + "1000011111": { "state": 543.0 }, + "0110101011": { "state": 427.0 }, + "0100000011": { "state": 259.0 }, + "0110111010": { "state": 442.0 }, + "0111101000": { "state": 488.0 }, + "1110110110": { "state": 950.0 }, + "1100001010": { "state": 778.0 }, + "0000011111": { "state": 31.0 }, + "1111101001": { "state": 1001.0 }, + "0000011101": { "state": 29.0 }, + "1011111110": { "state": 766.0 }, + "1111111011": { "state": 1019.0 }, + "1111111101": { "state": 1021.0 }, + "1111101110": { "state": 1006.0 }, + "0000011110": { "state": 30.0 }, + "1000001011": { "state": 523.0 }, + "1111111111": { "state": 1023.0 }, + "1111101111": { "state": 1007.0 }, + "1000011001": { "state": 537.0 }, + "0111100011": { "state": 483.0 }, + "1100000001": { "state": 769.0 }, + "1000001000": { "state": 520.0 }, + "1001001111": { "state": 591.0 }, + "1111100100": { "state": 996.0 }, + "0111111111": { "state": 511.0 }, + "0110101000": { "state": 424.0 }, + "1110111110": { "state": 958.0 }, + "1011111001": { "state": 761.0 }, + "0001000010": { "state": 66.0 }, + "0111111110": { "state": 510.0 }, + "1100001101": { "state": 781.0 }, + "0111110101": { "state": 501.0 }, + "0000000000": { "state": 0.0 }, + "0110101110": { "state": 430.0 }, + "1111110101": { "state": 1013.0 }, + "1110100100": { "state": 932.0 }, + "1000001101": { "state": 525.0 }, + "0111110010": { "state": 498.0 }, + "0111111000": { "state": 504.0 }, + "0111101011": { "state": 491.0 }, + "1111100110": { "state": 998.0 }, + "1111110111": { "state": 1015.0 }, + "1111111001": { "state": 1017.0 }, + "0110100111": { "state": 423.0 }, + "0110110111": { "state": 439.0 }, + "1100000010": { "state": 770.0 }, + "1110101101": { "state": 941.0 }, + "0000000011": { "state": 3.0 }, + "1100011100": { "state": 796.0 }, + "0110111111": { "state": 447.0 }, + "0000001110": { "state": 14.0 }, + "0110111011": { "state": 443.0 }, + "0111110111": { "state": 503.0 }, + "1110100001": { "state": 929.0 }, + "0110111110": { "state": 446.0 }, + "1111101011": { "state": 1003.0 }, + "1111111100": { "state": 1020.0 }, + "0000011010": { "state": 26.0 }, + "0100000010": { "state": 258.0 }, + "1111110100": { "state": 1012.0 }, + "1110100010": { "state": 930.0 }, + "1111111010": { "state": 1018.0 }, + "0111100010": { "state": 482.0 }, + "1000000100": { "state": 516.0 }, + "1100011010": { "state": 794.0 }, + "0111110000": { "state": 496.0 }, + "1011100111": { "state": 743.0 }, + "1101010111": { "state": 855.0 }, + "0110110110": { "state": 438.0 }, + "1110100111": { "state": 935.0 }, + "0111110110": { "state": 502.0 }, + "1100011000": { "state": 792.0 }, + "1110111010": { "state": 954.0 }, + "1011101110": { "state": 750.0 }, + "0100001000": { "state": 264.0 }, + "1100000100": { "state": 772.0 }, + "0111101010": { "state": 490.0 }, + "0111100001": { "state": 481.0 }, + "0100000111": { "state": 263.0 }, + "1110101011": { "state": 939.0 }, + "0110100110": { "state": 422.0 }, + "1111110000": { "state": 1008.0 }, + "0101010110": { "state": 342.0 }, + "0111110100": { "state": 500.0 }, + "0011110100": { "state": 244.0 }, + "1011110100": { "state": 756.0 }, + "0111101111": { "state": 495.0 }, + "0001001001": { "state": 73.0 }, + "1111101101": { "state": 1005.0 }, + "0000001001": { "state": 9.0 }, + "1000011010": { "state": 538.0 }, + "1111100011": { "state": 995.0 }, + "0110110001": { "state": 433.0 }, + "1111111000": { "state": 1016.0 }, + "0111111100": { "state": 508.0 }, + "0100001011": { "state": 267.0 }, + "0000001101": { "state": 13.0 }, + "0111100110": { "state": 486.0 }, + "1110110000": { "state": 944.0 }, + "0011100010": { "state": 226.0 }, + "1011101010": { "state": 746.0 }, + "1110101000": { "state": 936.0 }, + "1111000111": { "state": 967.0 }, + "0111001101": { "state": 461.0 }, + "1100000110": { "state": 774.0 }, + "1110101010": { "state": 938.0 }, + "1011111010": { "state": 762.0 }, + "0000001111": { "state": 15.0 }, + "1001000000": { "state": 576.0 }, + "0100010011": { "state": 275.0 }, + "0110111000": { "state": 440.0 }, + "1111110010": { "state": 1010.0 }, + "0100000000": { "state": 256.0 }, + "1000011100": { "state": 540.0 }, + "1110111111": { "state": 959.0 }, + "0011101111": { "state": 239.0 }, + "0100011100": { "state": 284.0 }, + "1111100000": { "state": 992.0 }, + "0111100000": { "state": 480.0 }, + "0011110000": { "state": 240.0 }, + "0110110010": { "state": 434.0 }, + "0000011000": { "state": 24.0 }, + "1100010010": { "state": 786.0 }, + "1111100001": { "state": 993.0 }, + "0100011000": { "state": 280.0 }, + "1000000000": { "state": 512.0 }, + "0100011110": { "state": 286.0 }, + "0110101100": { "state": 428.0 }, + "0001001010": { "state": 74.0 }, + "0011111111": { "state": 255.0 }, + "1110111011": { "state": 955.0 }, + "0011101011": { "state": 235.0 }, + "1100010001": { "state": 785.0 }, + "1100000011": { "state": 771.0 }, + "0011111100": { "state": 252.0 }, + "0011110010": { "state": 242.0 }, + "0111111011": { "state": 507.0 }, + "1110100011": { "state": 931.0 }, + "1101011000": { "state": 856.0 }, + "1111110110": { "state": 1014.0 }, + "0101011010": { "state": 346.0 }, + "1000001111": { "state": 527.0 }, + "0100010000": { "state": 272.0 }, + "0110100000": { "state": 416.0 }, + "0100001101": { "state": 269.0 }, + "0000010100": { "state": 20.0 }, + "0111100101": { "state": 485.0 }, + "0111110011": { "state": 499.0 }, + "0100001010": { "state": 266.0 }, + "1100010110": { "state": 790.0 }, + "0100000100": { "state": 260.0 }, + "1110100000": { "state": 928.0 }, + "1101000011": { "state": 835.0 }, + "1010110100": { "state": 692.0 }, + "1101001000": { "state": 840.0 }, + "0011111011": { "state": 251.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n+4.json b/algorithms/glued_trees/results/10-qubits/2n+4.json index 0c5ecf26..8a4a82ea 100644 --- a/algorithms/glued_trees/results/10-qubits/2n+4.json +++ b/algorithms/glued_trees/results/10-qubits/2n+4.json @@ -1 +1,512 @@ -{"vendor_format_result": {}, "counts": {"0000010100": 1, "1001011011": 1, "0101000100": 1, "0011111000": 6, "0111110111": 174, "1011101010": 3, "0011110101": 1, "0010110110": 1, "0100010000": 8, "0000000100": 7, "1110101001": 1, "0110110011": 1, "0101000101": 2, "1111111011": 28, "0100001110": 24, "0110100100": 9, "0100000100": 32, "1100010110": 119, "0011110111": 1, "0001001110": 1, "0110110101": 1, "1110110010": 12, "1110110111": 1, "1100011000": 1, "1111100001": 33, "1110101011": 18, "0110100110": 1, "0000011100": 1, "1110110000": 9, "1100011100": 11, "0110111111": 4, "0011111011": 12, "0111000010": 1, "0000001111": 11, "1100010001": 8, "0011101011": 3, "1100000011": 1, "1111110111": 38, "1111111001": 155, "0100001101": 9, "0111110011": 16, "0000001110": 4, "0111100101": 14, "0111101111": 66, "1000001001": 17, "0110111011": 13, "0111101101": 11, "1000010001": 24, "1000000001": 35, "1100001011": 2, "1101000100": 10, "0110101101": 8, "0100000010": 7, "1110101110": 24, "1100001001": 1, "1110111000": 2, "0111100010": 59, "1101011000": 1, "1110111101": 23, "0011101111": 7, "1000010110": 1, "0110111110": 10, "1100000000": 5, "0110101111": 51, "1110110101": 8, "0100011000": 4, "0111101000": 262, "0110111010": 5, "0100010011": 2, "1111110010": 38, "0111110101": 34, "0110100011": 21, "1100000101": 16, "1100001111": 1, "1100011011": 1, "0111110000": 68, "0111111010": 269, "1011100001": 1, "0101010001": 8, "1111101101": 4, "1111110101": 153, "1110100100": 3, "1000000110": 21, "0100010101": 1, "1111111111": 189, "1000001011": 4, "1111110001": 489, "1100011010": 43, "0111001001": 1, "1000000100": 4, "1111111010": 83, "1111111000": 755, "0111111100": 91, "1001000011": 1, "0111101001": 19, "1110100001": 82, "0110110111": 1, "0100000111": 88, "0100001000": 13, "0111100001": 4, "1111100111": 24, "0110110000": 1, "0111101010": 4, "0111111011": 73, "1110111111": 2, "1110100111": 7, "0111110110": 199, "1111101001": 37, "0000011111": 1, "1101011100": 1, "1100001010": 26, "1110110110": 24, "0000001001": 2, "0110110010": 25, "0000011000": 4, "0100010010": 5, "1111100101": 2, "0111101011": 26, "0111100100": 23, "0101000001": 3, "0101010110": 3, "1101001011": 3, "0111110100": 1, "0111110010": 158, "1111110000": 283, "0110111100": 26, "1111101010": 38, "0101000010": 2, "0111101100": 8, "0101001101": 2, "0100001100": 96, "1111111110": 5, "0111110001": 240, "0101001001": 2, "1111110011": 125, "1101010100": 3, "1110110001": 70, "1000001101": 8, "0111111111": 330, "1111100100": 10, "1111111100": 13, "1111110100": 122, "1100000001": 49, "0111111110": 21, "1011111001": 1, "1100011101": 14, "0100000110": 7, "0110100010": 18, "1111101111": 4, "1110111001": 1, "1000011001": 3, "0111101110": 5, "0111111101": 574, "1000000000": 1, "1110101010": 3, "0111111001": 103, "1100001110": 39, "0110101100": 42, "0100011110": 12, "1100000100": 43, "1110110011": 13, "1110111100": 3, "0110111101": 6, "1110111011": 5, "0100001111": 7, "0011111111": 34, "1000011110": 4, "1101001000": 2, "1110100101": 2, "1100001101": 74, "0000011001": 6, "0100010111": 20, "0000000001": 2, "1110111110": 3, "0100000000": 1, "0110100101": 3, "1111111101": 102, "0110110100": 18, "1101000110": 2, "0000010011": 2, "1000001110": 7, "0110110110": 10, "1011100111": 3, "1100010111": 2, "1110101101": 7, "0111100000": 47, "0110001011": 1, "0110111001": 2, "0000010000": 4, "0011110100": 3, "1111100000": 7, "1111101100": 4, "0110101001": 6, "1011110110": 1, "1111110110": 91, "0100000101": 5, "1111100010": 6, "0110101010": 1, "1100010100": 6, "1111100011": 20, "1111100110": 9, "0110100000": 7, "1010110000": 1, "0110101011": 6, "0101001100": 2, "1111101011": 8, "0000000000": 5, "0110101110": 1, "0110111000": 16, "1100010011": 4, "0000001000": 2, "1000001100": 3, "1111101000": 1, "0100000011": 2, "1000010100": 1, "1110101000": 1, "1011111000": 1, "1100001000": 3, "0010111111": 1, "0011101000": 2, "1001001011": 2, "1000010101": 3, "1101001001": 1, "0111111000": 256, "0000000011": 2, "1110101111": 1, "1101011011": 2, "0100001001": 1, "1011110111": 5, "0100001011": 1, "0100011001": 3, "1101000101": 1, "0100010110": 1, "1000000010": 2, "1111101110": 14, "1101001110": 1, "0101001110": 1, "0000000111": 1, "1010100000": 1, "0001011110": 1, "1110100000": 2, "0101011110": 1, "0111100011": 7, "1000000101": 1, "0111100111": 19, "1100010000": 2, "0000001101": 4, "1000010000": 1, "0111100110": 19, "0000001010": 1, "1011101110": 1, "1100011110": 4, "1100001100": 45, "1101001100": 6, "0100011010": 1, "1110100010": 26, "0011100000": 1, "0000000010": 1, "1100000110": 203, "0011110011": 1, "1011110010": 1, "1000011011": 1}, "counts_lsb_right": true, "parsed_states": {"0000010100": {"state": 20.0}, "1001011011": {"state": 603.0}, "0101000100": {"state": 324.0}, "0011111000": {"state": 248.0}, "0111110111": {"state": 503.0}, "1011101010": {"state": 746.0}, "0011110101": {"state": 245.0}, "0010110110": {"state": 182.0}, "0100010000": {"state": 272.0}, "0000000100": {"state": 4.0}, "1110101001": {"state": 937.0}, "0110110011": {"state": 435.0}, "0101000101": {"state": 325.0}, "1111111011": {"state": 1019.0}, "0100001110": {"state": 270.0}, "0110100100": {"state": 420.0}, "0100000100": {"state": 260.0}, "1100010110": {"state": 790.0}, "0011110111": {"state": 247.0}, "0001001110": {"state": 78.0}, "0110110101": {"state": 437.0}, "1110110010": {"state": 946.0}, "1110110111": {"state": 951.0}, "1100011000": {"state": 792.0}, "1111100001": {"state": 993.0}, "1110101011": {"state": 939.0}, "0110100110": {"state": 422.0}, "0000011100": {"state": 28.0}, "1110110000": {"state": 944.0}, "1100011100": {"state": 796.0}, "0110111111": {"state": 447.0}, "0011111011": {"state": 251.0}, "0111000010": {"state": 450.0}, "0000001111": {"state": 15.0}, "1100010001": {"state": 785.0}, "0011101011": {"state": 235.0}, "1100000011": {"state": 771.0}, "1111110111": {"state": 1015.0}, "1111111001": {"state": 1017.0}, "0100001101": {"state": 269.0}, "0111110011": {"state": 499.0}, "0000001110": {"state": 14.0}, "0111100101": {"state": 485.0}, "0111101111": {"state": 495.0}, "1000001001": {"state": 521.0}, "0110111011": {"state": 443.0}, "0111101101": {"state": 493.0}, "1000010001": {"state": 529.0}, "1000000001": {"state": 513.0}, "1100001011": {"state": 779.0}, "1101000100": {"state": 836.0}, "0110101101": {"state": 429.0}, "0100000010": {"state": 258.0}, "1110101110": {"state": 942.0}, "1100001001": {"state": 777.0}, "1110111000": {"state": 952.0}, "0111100010": {"state": 482.0}, "1101011000": {"state": 856.0}, "1110111101": {"state": 957.0}, "0011101111": {"state": 239.0}, "1000010110": {"state": 534.0}, "0110111110": {"state": 446.0}, "1100000000": {"state": 768.0}, "0110101111": {"state": 431.0}, "1110110101": {"state": 949.0}, "0100011000": {"state": 280.0}, "0111101000": {"state": 488.0}, "0110111010": {"state": 442.0}, "0100010011": {"state": 275.0}, "1111110010": {"state": 1010.0}, "0111110101": {"state": 501.0}, "0110100011": {"state": 419.0}, "1100000101": {"state": 773.0}, "1100001111": {"state": 783.0}, "1100011011": {"state": 795.0}, "0111110000": {"state": 496.0}, "0111111010": {"state": 506.0}, "1011100001": {"state": 737.0}, "0101010001": {"state": 337.0}, "1111101101": {"state": 1005.0}, "1111110101": {"state": 1013.0}, "1110100100": {"state": 932.0}, "1000000110": {"state": 518.0}, "0100010101": {"state": 277.0}, "1111111111": {"state": 1023.0}, "1000001011": {"state": 523.0}, "1111110001": {"state": 1009.0}, "1100011010": {"state": 794.0}, "0111001001": {"state": 457.0}, "1000000100": {"state": 516.0}, "1111111010": {"state": 1018.0}, "1111111000": {"state": 1016.0}, "0111111100": {"state": 508.0}, "1001000011": {"state": 579.0}, "0111101001": {"state": 489.0}, "1110100001": {"state": 929.0}, "0110110111": {"state": 439.0}, "0100000111": {"state": 263.0}, "0100001000": {"state": 264.0}, "0111100001": {"state": 481.0}, "1111100111": {"state": 999.0}, "0110110000": {"state": 432.0}, "0111101010": {"state": 490.0}, "0111111011": {"state": 507.0}, "1110111111": {"state": 959.0}, "1110100111": {"state": 935.0}, "0111110110": {"state": 502.0}, "1111101001": {"state": 1001.0}, "0000011111": {"state": 31.0}, "1101011100": {"state": 860.0}, "1100001010": {"state": 778.0}, "1110110110": {"state": 950.0}, "0000001001": {"state": 9.0}, "0110110010": {"state": 434.0}, "0000011000": {"state": 24.0}, "0100010010": {"state": 274.0}, "1111100101": {"state": 997.0}, "0111101011": {"state": 491.0}, "0111100100": {"state": 484.0}, "0101000001": {"state": 321.0}, "0101010110": {"state": 342.0}, "1101001011": {"state": 843.0}, "0111110100": {"state": 500.0}, "0111110010": {"state": 498.0}, "1111110000": {"state": 1008.0}, "0110111100": {"state": 444.0}, "1111101010": {"state": 1002.0}, "0101000010": {"state": 322.0}, "0111101100": {"state": 492.0}, "0101001101": {"state": 333.0}, "0100001100": {"state": 268.0}, "1111111110": {"state": 1022.0}, "0111110001": {"state": 497.0}, "0101001001": {"state": 329.0}, "1111110011": {"state": 1011.0}, "1101010100": {"state": 852.0}, "1110110001": {"state": 945.0}, "1000001101": {"state": 525.0}, "0111111111": {"state": 511.0}, "1111100100": {"state": 996.0}, "1111111100": {"state": 1020.0}, "1111110100": {"state": 1012.0}, "1100000001": {"state": 769.0}, "0111111110": {"state": 510.0}, "1011111001": {"state": 761.0}, "1100011101": {"state": 797.0}, "0100000110": {"state": 262.0}, "0110100010": {"state": 418.0}, "1111101111": {"state": 1007.0}, "1110111001": {"state": 953.0}, "1000011001": {"state": 537.0}, "0111101110": {"state": 494.0}, "0111111101": {"state": 509.0}, "1000000000": {"state": 512.0}, "1110101010": {"state": 938.0}, "0111111001": {"state": 505.0}, "1100001110": {"state": 782.0}, "0110101100": {"state": 428.0}, "0100011110": {"state": 286.0}, "1100000100": {"state": 772.0}, "1110110011": {"state": 947.0}, "1110111100": {"state": 956.0}, "0110111101": {"state": 445.0}, "1110111011": {"state": 955.0}, "0100001111": {"state": 271.0}, "0011111111": {"state": 255.0}, "1000011110": {"state": 542.0}, "1101001000": {"state": 840.0}, "1110100101": {"state": 933.0}, "1100001101": {"state": 781.0}, "0000011001": {"state": 25.0}, "0100010111": {"state": 279.0}, "0000000001": {"state": 1.0}, "1110111110": {"state": 958.0}, "0100000000": {"state": 256.0}, "0110100101": {"state": 421.0}, "1111111101": {"state": 1021.0}, "0110110100": {"state": 436.0}, "1101000110": {"state": 838.0}, "0000010011": {"state": 19.0}, "1000001110": {"state": 526.0}, "0110110110": {"state": 438.0}, "1011100111": {"state": 743.0}, "1100010111": {"state": 791.0}, "1110101101": {"state": 941.0}, "0111100000": {"state": 480.0}, "0110001011": {"state": 395.0}, "0110111001": {"state": 441.0}, "0000010000": {"state": 16.0}, "0011110100": {"state": 244.0}, "1111100000": {"state": 992.0}, "1111101100": {"state": 1004.0}, "0110101001": {"state": 425.0}, "1011110110": {"state": 758.0}, "1111110110": {"state": 1014.0}, "0100000101": {"state": 261.0}, "1111100010": {"state": 994.0}, "0110101010": {"state": 426.0}, "1100010100": {"state": 788.0}, "1111100011": {"state": 995.0}, "1111100110": {"state": 998.0}, "0110100000": {"state": 416.0}, "1010110000": {"state": 688.0}, "0110101011": {"state": 427.0}, "0101001100": {"state": 332.0}, "1111101011": {"state": 1003.0}, "0000000000": {"state": 0.0}, "0110101110": {"state": 430.0}, "0110111000": {"state": 440.0}, "1100010011": {"state": 787.0}, "0000001000": {"state": 8.0}, "1000001100": {"state": 524.0}, "1111101000": {"state": 1000.0}, "0100000011": {"state": 259.0}, "1000010100": {"state": 532.0}, "1110101000": {"state": 936.0}, "1011111000": {"state": 760.0}, "1100001000": {"state": 776.0}, "0010111111": {"state": 191.0}, "0011101000": {"state": 232.0}, "1001001011": {"state": 587.0}, "1000010101": {"state": 533.0}, "1101001001": {"state": 841.0}, "0111111000": {"state": 504.0}, "0000000011": {"state": 3.0}, "1110101111": {"state": 943.0}, "1101011011": {"state": 859.0}, "0100001001": {"state": 265.0}, "1011110111": {"state": 759.0}, "0100001011": {"state": 267.0}, "0100011001": {"state": 281.0}, "1101000101": {"state": 837.0}, "0100010110": {"state": 278.0}, "1000000010": {"state": 514.0}, "1111101110": {"state": 1006.0}, "1101001110": {"state": 846.0}, "0101001110": {"state": 334.0}, "0000000111": {"state": 7.0}, "1010100000": {"state": 672.0}, "0001011110": {"state": 94.0}, "1110100000": {"state": 928.0}, "0101011110": {"state": 350.0}, "0111100011": {"state": 483.0}, "1000000101": {"state": 517.0}, "0111100111": {"state": 487.0}, "1100010000": {"state": 784.0}, "0000001101": {"state": 13.0}, "1000010000": {"state": 528.0}, "0111100110": {"state": 486.0}, "0000001010": {"state": 10.0}, "1011101110": {"state": 750.0}, "1100011110": {"state": 798.0}, "1100001100": {"state": 780.0}, "1101001100": {"state": 844.0}, "0100011010": {"state": 282.0}, "1110100010": {"state": 930.0}, "0011100000": {"state": 224.0}, "0000000010": {"state": 2.0}, "1100000110": {"state": 774.0}, "0011110011": {"state": 243.0}, "1011110010": {"state": 754.0}, "1000011011": {"state": 539.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "0000001000": 1, + "1110110111": 1, + "1001001111": 1, + "0000010010": 1, + "0101011110": 1, + "0100000011": 1, + "1000001111": 1, + "1010100000": 1, + "1101001110": 2, + "0101001110": 1, + "0000000111": 1, + "1011110111": 1, + "1010101110": 1, + "0011110111": 1, + "0100000000": 2, + "0100000110": 5, + "0111010011": 1, + "1101011011": 2, + "1000001100": 1, + "0000000001": 1, + "1011101110": 2, + "1111101100": 6, + "1101001010": 1, + "0011110100": 3, + "0000010000": 6, + "1011100010": 3, + "0110110101": 3, + "1000010110": 2, + "1111101000": 3, + "1010111000": 1, + "0000001111": 6, + "1101010100": 1, + "1000010100": 1, + "1101000100": 3, + "1111100000": 5, + "1100010011": 4, + "0011110010": 1, + "0011111100": 1, + "0110101001": 2, + "1100000010": 1, + "1100011101": 8, + "1100000000": 3, + "0100010001": 1, + "0000000010": 1, + "1110111110": 3, + "1111101011": 6, + "1100001111": 2, + "0100010010": 2, + "1011100111": 1, + "0110110110": 6, + "0100010000": 6, + "0000010011": 1, + "1111100110": 12, + "0000000100": 7, + "1000011110": 2, + "1110101001": 2, + "0110101101": 13, + "1101001100": 4, + "0111110100": 2, + "0101000001": 8, + "0101010110": 1, + "0110111110": 2, + "1110111001": 3, + "0000000101": 1, + "0101010001": 4, + "1000000010": 1, + "1110100000": 7, + "0100001111": 7, + "1100010001": 4, + "0011101011": 1, + "1100001001": 2, + "0000010111": 1, + "0101001101": 1, + "0111101100": 4, + "0000000011": 8, + "1011100100": 1, + "0110111100": 18, + "1100011000": 1, + "1110111010": 3, + "1110110010": 27, + "0100000101": 3, + "0110101010": 1, + "0110101110": 1, + "0000000000": 15, + "0100001011": 10, + "1101001011": 2, + "1000001101": 2, + "0111110010": 149, + "0101000110": 4, + "0110111010": 13, + "0111101000": 280, + "1110100111": 7, + "0111110110": 219, + "1100001101": 53, + "1011111001": 1, + "0111111110": 14, + "0111101110": 6, + "0100001100": 89, + "1011101010": 3, + "0111111001": 91, + "1111100111": 30, + "0111110101": 58, + "1111000111": 1, + "1100000110": 241, + "1100011100": 3, + "0110111111": 7, + "1111110011": 124, + "0011111000": 6, + "1100011110": 3, + "0110100101": 2, + "1111111110": 6, + "0111101111": 73, + "1000000000": 1, + "1110110101": 10, + "0100011000": 7, + "1111111100": 13, + "0111101011": 25, + "0110100001": 1, + "1110110011": 23, + "1110111100": 3, + "0100010111": 12, + "1110100011": 3, + "0111111011": 75, + "0000001010": 1, + "1111101010": 42, + "1110101110": 31, + "1100001100": 36, + "0111111000": 280, + "0111100100": 31, + "0000011001": 4, + "0111100111": 11, + "0111100000": 46, + "1111111001": 173, + "1111110111": 50, + "1000010001": 17, + "1100000001": 56, + "0000001101": 4, + "0111100110": 11, + "0101000010": 1, + "1111100001": 57, + "0011111110": 1, + "1000001011": 1, + "1111111111": 224, + "1111101001": 32, + "1110110110": 26, + "1100001010": 22, + "0110100000": 18, + "0111111101": 566, + "1111111010": 82, + "0100000010": 9, + "1111110100": 130, + "1110100010": 27, + "1000000100": 4, + "1100011010": 40, + "0111100010": 38, + "0111000101": 1, + "0111111010": 302, + "1100000101": 18, + "0110110001": 1, + "0111111100": 77, + "1111111000": 706, + "0110110111": 5, + "0111101001": 12, + "1111110001": 464, + "1100010110": 139, + "0100000100": 31, + "1000011001": 2, + "0111100011": 6, + "1111101111": 4, + "0111110000": 93, + "1111111101": 93, + "1111111011": 46, + "0111111111": 301, + "1111100100": 8, + "0100001110": 15, + "1000001110": 8, + "1101011000": 2, + "1111110110": 104, + "0110100011": 17, + "0110111101": 10, + "1111100010": 3, + "1111110010": 35, + "0110111000": 15, + "1110110100": 1, + "1000001001": 22, + "0101010010": 1, + "1111100011": 20, + "0000001001": 5, + "1110101101": 8, + "0111101101": 9, + "1100001011": 1, + "1000000001": 34, + "0100001010": 1, + "0100001101": 4, + "0111100101": 10, + "1101011110": 1, + "0111110011": 12, + "1100010100": 13, + "0110110100": 9, + "0101000101": 3, + "0110110011": 2, + "1001001011": 1, + "1011111100": 1, + "0110110010": 28, + "0000011000": 6, + "0110100010": 19, + "1111101110": 15, + "0110101111": 65, + "1110110000": 5, + "1011100101": 1, + "0110101100": 43, + "0100011110": 13, + "1110111011": 7, + "0011111111": 27, + "1110100101": 6, + "1101001000": 7, + "0011101111": 7, + "1110111111": 2, + "1000000110": 11, + "1111110000": 244, + "1110101011": 7, + "0110100110": 3, + "1110110001": 43, + "1100001110": 48, + "0110101011": 3, + "0110111011": 5, + "0111110111": 165, + "1110100001": 68, + "0000001110": 3, + "0100011011": 1, + "1000000101": 2, + "0111000010": 1, + "0011111011": 10, + "1111110101": 144, + "1110100100": 5, + "1100010000": 3, + "0111110001": 259, + "0101001001": 5, + "0011101100": 2, + "0110111001": 7, + "1100001000": 3, + "0110100100": 12, + "1100010111": 1, + "0111101010": 14, + "0111100001": 3, + "0100000111": 93, + "1100000100": 40, + "0100001000": 9, + "1110111101": 21 + }, + "counts_lsb_right": true, + "parsed_states": { + "0000001000": { "state": 8.0 }, + "1110110111": { "state": 951.0 }, + "1001001111": { "state": 591.0 }, + "0000010010": { "state": 18.0 }, + "0101011110": { "state": 350.0 }, + "0100000011": { "state": 259.0 }, + "1000001111": { "state": 527.0 }, + "1010100000": { "state": 672.0 }, + "1101001110": { "state": 846.0 }, + "0101001110": { "state": 334.0 }, + "0000000111": { "state": 7.0 }, + "1011110111": { "state": 759.0 }, + "1010101110": { "state": 686.0 }, + "0011110111": { "state": 247.0 }, + "0100000000": { "state": 256.0 }, + "0100000110": { "state": 262.0 }, + "0111010011": { "state": 467.0 }, + "1101011011": { "state": 859.0 }, + "1000001100": { "state": 524.0 }, + "0000000001": { "state": 1.0 }, + "1011101110": { "state": 750.0 }, + "1111101100": { "state": 1004.0 }, + "1101001010": { "state": 842.0 }, + "0011110100": { "state": 244.0 }, + "0000010000": { "state": 16.0 }, + "1011100010": { "state": 738.0 }, + "0110110101": { "state": 437.0 }, + "1000010110": { "state": 534.0 }, + "1111101000": { "state": 1000.0 }, + "1010111000": { "state": 696.0 }, + "0000001111": { "state": 15.0 }, + "1101010100": { "state": 852.0 }, + "1000010100": { "state": 532.0 }, + "1101000100": { "state": 836.0 }, + "1111100000": { "state": 992.0 }, + "1100010011": { "state": 787.0 }, + "0011110010": { "state": 242.0 }, + "0011111100": { "state": 252.0 }, + "0110101001": { "state": 425.0 }, + "1100000010": { "state": 770.0 }, + "1100011101": { "state": 797.0 }, + "1100000000": { "state": 768.0 }, + "0100010001": { "state": 273.0 }, + "0000000010": { "state": 2.0 }, + "1110111110": { "state": 958.0 }, + "1111101011": { "state": 1003.0 }, + "1100001111": { "state": 783.0 }, + "0100010010": { "state": 274.0 }, + "1011100111": { "state": 743.0 }, + "0110110110": { "state": 438.0 }, + "0100010000": { "state": 272.0 }, + "0000010011": { "state": 19.0 }, + "1111100110": { "state": 998.0 }, + "0000000100": { "state": 4.0 }, + "1000011110": { "state": 542.0 }, + "1110101001": { "state": 937.0 }, + "0110101101": { "state": 429.0 }, + "1101001100": { "state": 844.0 }, + "0111110100": { "state": 500.0 }, + "0101000001": { "state": 321.0 }, + "0101010110": { "state": 342.0 }, + "0110111110": { "state": 446.0 }, + "1110111001": { "state": 953.0 }, + "0000000101": { "state": 5.0 }, + "0101010001": { "state": 337.0 }, + "1000000010": { "state": 514.0 }, + "1110100000": { "state": 928.0 }, + "0100001111": { "state": 271.0 }, + "1100010001": { "state": 785.0 }, + "0011101011": { "state": 235.0 }, + "1100001001": { "state": 777.0 }, + "0000010111": { "state": 23.0 }, + "0101001101": { "state": 333.0 }, + "0111101100": { "state": 492.0 }, + "0000000011": { "state": 3.0 }, + "1011100100": { "state": 740.0 }, + "0110111100": { "state": 444.0 }, + "1100011000": { "state": 792.0 }, + "1110111010": { "state": 954.0 }, + "1110110010": { "state": 946.0 }, + "0100000101": { "state": 261.0 }, + "0110101010": { "state": 426.0 }, + "0110101110": { "state": 430.0 }, + "0000000000": { "state": 0.0 }, + "0100001011": { "state": 267.0 }, + "1101001011": { "state": 843.0 }, + "1000001101": { "state": 525.0 }, + "0111110010": { "state": 498.0 }, + "0101000110": { "state": 326.0 }, + "0110111010": { "state": 442.0 }, + "0111101000": { "state": 488.0 }, + "1110100111": { "state": 935.0 }, + "0111110110": { "state": 502.0 }, + "1100001101": { "state": 781.0 }, + "1011111001": { "state": 761.0 }, + "0111111110": { "state": 510.0 }, + "0111101110": { "state": 494.0 }, + "0100001100": { "state": 268.0 }, + "1011101010": { "state": 746.0 }, + "0111111001": { "state": 505.0 }, + "1111100111": { "state": 999.0 }, + "0111110101": { "state": 501.0 }, + "1111000111": { "state": 967.0 }, + "1100000110": { "state": 774.0 }, + "1100011100": { "state": 796.0 }, + "0110111111": { "state": 447.0 }, + "1111110011": { "state": 1011.0 }, + "0011111000": { "state": 248.0 }, + "1100011110": { "state": 798.0 }, + "0110100101": { "state": 421.0 }, + "1111111110": { "state": 1022.0 }, + "0111101111": { "state": 495.0 }, + "1000000000": { "state": 512.0 }, + "1110110101": { "state": 949.0 }, + "0100011000": { "state": 280.0 }, + "1111111100": { "state": 1020.0 }, + "0111101011": { "state": 491.0 }, + "0110100001": { "state": 417.0 }, + "1110110011": { "state": 947.0 }, + "1110111100": { "state": 956.0 }, + "0100010111": { "state": 279.0 }, + "1110100011": { "state": 931.0 }, + "0111111011": { "state": 507.0 }, + "0000001010": { "state": 10.0 }, + "1111101010": { "state": 1002.0 }, + "1110101110": { "state": 942.0 }, + "1100001100": { "state": 780.0 }, + "0111111000": { "state": 504.0 }, + "0111100100": { "state": 484.0 }, + "0000011001": { "state": 25.0 }, + "0111100111": { "state": 487.0 }, + "0111100000": { "state": 480.0 }, + "1111111001": { "state": 1017.0 }, + "1111110111": { "state": 1015.0 }, + "1000010001": { "state": 529.0 }, + "1100000001": { "state": 769.0 }, + "0000001101": { "state": 13.0 }, + "0111100110": { "state": 486.0 }, + "0101000010": { "state": 322.0 }, + "1111100001": { "state": 993.0 }, + "0011111110": { "state": 254.0 }, + "1000001011": { "state": 523.0 }, + "1111111111": { "state": 1023.0 }, + "1111101001": { "state": 1001.0 }, + "1110110110": { "state": 950.0 }, + "1100001010": { "state": 778.0 }, + "0110100000": { "state": 416.0 }, + "0111111101": { "state": 509.0 }, + "1111111010": { "state": 1018.0 }, + "0100000010": { "state": 258.0 }, + "1111110100": { "state": 1012.0 }, + "1110100010": { "state": 930.0 }, + "1000000100": { "state": 516.0 }, + "1100011010": { "state": 794.0 }, + "0111100010": { "state": 482.0 }, + "0111000101": { "state": 453.0 }, + "0111111010": { "state": 506.0 }, + "1100000101": { "state": 773.0 }, + "0110110001": { "state": 433.0 }, + "0111111100": { "state": 508.0 }, + "1111111000": { "state": 1016.0 }, + "0110110111": { "state": 439.0 }, + "0111101001": { "state": 489.0 }, + "1111110001": { "state": 1009.0 }, + "1100010110": { "state": 790.0 }, + "0100000100": { "state": 260.0 }, + "1000011001": { "state": 537.0 }, + "0111100011": { "state": 483.0 }, + "1111101111": { "state": 1007.0 }, + "0111110000": { "state": 496.0 }, + "1111111101": { "state": 1021.0 }, + "1111111011": { "state": 1019.0 }, + "0111111111": { "state": 511.0 }, + "1111100100": { "state": 996.0 }, + "0100001110": { "state": 270.0 }, + "1000001110": { "state": 526.0 }, + "1101011000": { "state": 856.0 }, + "1111110110": { "state": 1014.0 }, + "0110100011": { "state": 419.0 }, + "0110111101": { "state": 445.0 }, + "1111100010": { "state": 994.0 }, + "1111110010": { "state": 1010.0 }, + "0110111000": { "state": 440.0 }, + "1110110100": { "state": 948.0 }, + "1000001001": { "state": 521.0 }, + "0101010010": { "state": 338.0 }, + "1111100011": { "state": 995.0 }, + "0000001001": { "state": 9.0 }, + "1110101101": { "state": 941.0 }, + "0111101101": { "state": 493.0 }, + "1100001011": { "state": 779.0 }, + "1000000001": { "state": 513.0 }, + "0100001010": { "state": 266.0 }, + "0100001101": { "state": 269.0 }, + "0111100101": { "state": 485.0 }, + "1101011110": { "state": 862.0 }, + "0111110011": { "state": 499.0 }, + "1100010100": { "state": 788.0 }, + "0110110100": { "state": 436.0 }, + "0101000101": { "state": 325.0 }, + "0110110011": { "state": 435.0 }, + "1001001011": { "state": 587.0 }, + "1011111100": { "state": 764.0 }, + "0110110010": { "state": 434.0 }, + "0000011000": { "state": 24.0 }, + "0110100010": { "state": 418.0 }, + "1111101110": { "state": 1006.0 }, + "0110101111": { "state": 431.0 }, + "1110110000": { "state": 944.0 }, + "1011100101": { "state": 741.0 }, + "0110101100": { "state": 428.0 }, + "0100011110": { "state": 286.0 }, + "1110111011": { "state": 955.0 }, + "0011111111": { "state": 255.0 }, + "1110100101": { "state": 933.0 }, + "1101001000": { "state": 840.0 }, + "0011101111": { "state": 239.0 }, + "1110111111": { "state": 959.0 }, + "1000000110": { "state": 518.0 }, + "1111110000": { "state": 1008.0 }, + "1110101011": { "state": 939.0 }, + "0110100110": { "state": 422.0 }, + "1110110001": { "state": 945.0 }, + "1100001110": { "state": 782.0 }, + "0110101011": { "state": 427.0 }, + "0110111011": { "state": 443.0 }, + "0111110111": { "state": 503.0 }, + "1110100001": { "state": 929.0 }, + "0000001110": { "state": 14.0 }, + "0100011011": { "state": 283.0 }, + "1000000101": { "state": 517.0 }, + "0111000010": { "state": 450.0 }, + "0011111011": { "state": 251.0 }, + "1111110101": { "state": 1013.0 }, + "1110100100": { "state": 932.0 }, + "1100010000": { "state": 784.0 }, + "0111110001": { "state": 497.0 }, + "0101001001": { "state": 329.0 }, + "0011101100": { "state": 236.0 }, + "0110111001": { "state": 441.0 }, + "1100001000": { "state": 776.0 }, + "0110100100": { "state": 420.0 }, + "1100010111": { "state": 791.0 }, + "0111101010": { "state": 490.0 }, + "0111100001": { "state": 481.0 }, + "0100000111": { "state": 263.0 }, + "1100000100": { "state": 772.0 }, + "0100001000": { "state": 264.0 }, + "1110111101": { "state": 957.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n+6.json b/algorithms/glued_trees/results/10-qubits/2n+6.json index 21c11e25..ec1b32ad 100644 --- a/algorithms/glued_trees/results/10-qubits/2n+6.json +++ b/algorithms/glued_trees/results/10-qubits/2n+6.json @@ -1 +1,450 @@ -{"vendor_format_result": {}, "counts": {"1000000011": 1, "1111000000": 1, "0101011101": 1, "0100010011": 1, "1100000011": 1, "0101011001": 1, "1011110100": 1, "1100010010": 2, "1101001011": 3, "0110110110": 1, "1110100000": 1, "1111100101": 2, "1110101100": 1, "0100011101": 2, "1011101110": 3, "1101001101": 1, "0110100101": 1, "0101000110": 1, "0110101001": 1, "1101000100": 2, "1011110111": 1, "0000000111": 3, "1110100111": 2, "0000001100": 1, "0110110111": 1, "0111101001": 4, "0100010110": 2, "1000000111": 1, "0101001010": 2, "0000000010": 1, "0100000001": 3, "1110111110": 3, "0110101010": 8, "0100000101": 6, "0111100100": 1, "1100011010": 1, "1000000100": 1, "0101000011": 2, "1110101110": 2, "1100001100": 10, "0100011110": 1, "0110101100": 1, "0100001110": 24, "1111101111": 4, "0011110010": 1, "1000010101": 1, "1101001110": 2, "0101001110": 2, "1110101111": 1, "0100010100": 9, "1101000000": 8, "0110100010": 2, "0110110010": 2, "1011111110": 2, "0110111001": 10, "0111100111": 9, "0111101111": 7, "0100000011": 2, "1100010101": 15, "0011111000": 3, "0000000110": 1, "0101000000": 2, "1110111101": 7, "1100011011": 1, "1100000101": 17, "0101000010": 1, "1111100001": 13, "1111100100": 9, "1100000000": 19, "0011110100": 1, "1111111110": 62, "1111110011": 339, "0101001001": 3, "0111001011": 2, "0111110001": 100, "0100000110": 16, "1110101101": 11, "0110101000": 66, "0101010010": 1, "1111100011": 79, "1011110101": 3, "0111101100": 36, "1110101011": 5, "1111110000": 128, "0111111111": 18, "1110101010": 25, "1111100111": 2, "1110111100": 11, "1111110101": 44, "0111100110": 4, "0000001000": 9, "0001000010": 1, "1011111001": 1, "0111111110": 302, "1100001101": 10, "0110101101": 14, "1110110000": 2, "0110101111": 51, "1111111100": 48, "1111110001": 161, "1111101100": 11, "1111000011": 3, "0111111001": 248, "0111110101": 114, "1111000111": 1, "1100000110": 389, "0010111110": 1, "0100011010": 3, "0100000010": 14, "1111110100": 42, "1110100010": 40, "1111111010": 144, "1000001101": 1, "0111110010": 263, "0111110100": 89, "0101000001": 2, "0111111000": 623, "0111101011": 14, "1111100110": 8, "0111110000": 70, "1001000011": 1, "0111111100": 460, "0110110001": 3, "1111111000": 233, "1110110111": 6, "1000011000": 1, "0100001001": 29, "1111111001": 331, "1111110111": 60, "1111111101": 87, "1111111011": 271, "0100000100": 168, "1100010110": 49, "0111111101": 198, "1101000011": 1, "1110100101": 19, "1110111000": 11, "0111100010": 15, "0110111000": 155, "1111110010": 54, "0111111010": 99, "0111110110": 384, "1000001001": 3, "1110110100": 22, "0100001111": 23, "1101011100": 1, "1111101001": 26, "0100000000": 42, "1100001000": 12, "0110111110": 5, "1110111001": 110, "0000000101": 1, "1110100110": 45, "0011111110": 1, "1000001011": 1, "1111111111": 163, "1000011101": 1, "1000000101": 6, "0000001111": 3, "1100000111": 1, "1000000001": 3, "1100001011": 25, "0111101101": 2, "0110101110": 1, "0000000000": 5, "1101010000": 2, "0011100111": 1, "1011110110": 18, "1100001010": 53, "1110110110": 3, "0100001100": 32, "0111101110": 11, "1100011001": 5, "1000000000": 1, "1101001111": 1, "0100011000": 9, "1110110101": 21, "1100011100": 1, "0110111111": 20, "1111101011": 3, "0110100011": 3, "1101011000": 1, "1111110110": 27, "0110101011": 41, "1000001110": 5, "0011111111": 1, "1110111011": 4, "0100011111": 5, "1100001001": 20, "0110110100": 5, "0110111011": 6, "0111110111": 184, "1110100001": 9, "1111101101": 16, "1111100000": 1, "1100010011": 1, "0100011100": 5, "1110111111": 3, "1111001000": 1, "0100010000": 8, "1000011110": 2, "1110101001": 3, "1111101110": 14, "1100011000": 2, "1110111010": 4, "1110110010": 47, "1111101000": 6, "0111100101": 51, "0100001010": 77, "0111110011": 148, "0100001101": 13, "0011110111": 1, "0111100001": 1, "0111101010": 21, "0100001000": 54, "0110110000": 3, "1100000100": 8, "0110111010": 14, "0111101000": 19, "0111111011": 4, "1100000001": 13, "0100011001": 3, "0110111101": 10, "1100011111": 3, "0110110011": 9, "0101000101": 3, "1110110011": 4, "0110100001": 10, "0110100100": 13, "0111100000": 17, "1101001100": 12, "1110110001": 33, "1100001110": 11, "0100010101": 1}, "counts_lsb_right": true, "parsed_states": {"1000000011": {"state": 515.0}, "1111000000": {"state": 960.0}, "0101011101": {"state": 349.0}, "0100010011": {"state": 275.0}, "1100000011": {"state": 771.0}, "0101011001": {"state": 345.0}, "1011110100": {"state": 756.0}, "1100010010": {"state": 786.0}, "1101001011": {"state": 843.0}, "0110110110": {"state": 438.0}, "1110100000": {"state": 928.0}, "1111100101": {"state": 997.0}, "1110101100": {"state": 940.0}, "0100011101": {"state": 285.0}, "1011101110": {"state": 750.0}, "1101001101": {"state": 845.0}, "0110100101": {"state": 421.0}, "0101000110": {"state": 326.0}, "0110101001": {"state": 425.0}, "1101000100": {"state": 836.0}, "1011110111": {"state": 759.0}, "0000000111": {"state": 7.0}, "1110100111": {"state": 935.0}, "0000001100": {"state": 12.0}, "0110110111": {"state": 439.0}, "0111101001": {"state": 489.0}, "0100010110": {"state": 278.0}, "1000000111": {"state": 519.0}, "0101001010": {"state": 330.0}, "0000000010": {"state": 2.0}, "0100000001": {"state": 257.0}, "1110111110": {"state": 958.0}, "0110101010": {"state": 426.0}, "0100000101": {"state": 261.0}, "0111100100": {"state": 484.0}, "1100011010": {"state": 794.0}, "1000000100": {"state": 516.0}, "0101000011": {"state": 323.0}, "1110101110": {"state": 942.0}, "1100001100": {"state": 780.0}, "0100011110": {"state": 286.0}, "0110101100": {"state": 428.0}, "0100001110": {"state": 270.0}, "1111101111": {"state": 1007.0}, "0011110010": {"state": 242.0}, "1000010101": {"state": 533.0}, "1101001110": {"state": 846.0}, "0101001110": {"state": 334.0}, "1110101111": {"state": 943.0}, "0100010100": {"state": 276.0}, "1101000000": {"state": 832.0}, "0110100010": {"state": 418.0}, "0110110010": {"state": 434.0}, "1011111110": {"state": 766.0}, "0110111001": {"state": 441.0}, "0111100111": {"state": 487.0}, "0111101111": {"state": 495.0}, "0100000011": {"state": 259.0}, "1100010101": {"state": 789.0}, "0011111000": {"state": 248.0}, "0000000110": {"state": 6.0}, "0101000000": {"state": 320.0}, "1110111101": {"state": 957.0}, "1100011011": {"state": 795.0}, "1100000101": {"state": 773.0}, "0101000010": {"state": 322.0}, "1111100001": {"state": 993.0}, "1111100100": {"state": 996.0}, "1100000000": {"state": 768.0}, "0011110100": {"state": 244.0}, "1111111110": {"state": 1022.0}, "1111110011": {"state": 1011.0}, "0101001001": {"state": 329.0}, "0111001011": {"state": 459.0}, "0111110001": {"state": 497.0}, "0100000110": {"state": 262.0}, "1110101101": {"state": 941.0}, "0110101000": {"state": 424.0}, "0101010010": {"state": 338.0}, "1111100011": {"state": 995.0}, "1011110101": {"state": 757.0}, "0111101100": {"state": 492.0}, "1110101011": {"state": 939.0}, "1111110000": {"state": 1008.0}, "0111111111": {"state": 511.0}, "1110101010": {"state": 938.0}, "1111100111": {"state": 999.0}, "1110111100": {"state": 956.0}, "1111110101": {"state": 1013.0}, "0111100110": {"state": 486.0}, "0000001000": {"state": 8.0}, "0001000010": {"state": 66.0}, "1011111001": {"state": 761.0}, "0111111110": {"state": 510.0}, "1100001101": {"state": 781.0}, "0110101101": {"state": 429.0}, "1110110000": {"state": 944.0}, "0110101111": {"state": 431.0}, "1111111100": {"state": 1020.0}, "1111110001": {"state": 1009.0}, "1111101100": {"state": 1004.0}, "1111000011": {"state": 963.0}, "0111111001": {"state": 505.0}, "0111110101": {"state": 501.0}, "1111000111": {"state": 967.0}, "1100000110": {"state": 774.0}, "0010111110": {"state": 190.0}, "0100011010": {"state": 282.0}, "0100000010": {"state": 258.0}, "1111110100": {"state": 1012.0}, "1110100010": {"state": 930.0}, "1111111010": {"state": 1018.0}, "1000001101": {"state": 525.0}, "0111110010": {"state": 498.0}, "0111110100": {"state": 500.0}, "0101000001": {"state": 321.0}, "0111111000": {"state": 504.0}, "0111101011": {"state": 491.0}, "1111100110": {"state": 998.0}, "0111110000": {"state": 496.0}, "1001000011": {"state": 579.0}, "0111111100": {"state": 508.0}, "0110110001": {"state": 433.0}, "1111111000": {"state": 1016.0}, "1110110111": {"state": 951.0}, "1000011000": {"state": 536.0}, "0100001001": {"state": 265.0}, "1111111001": {"state": 1017.0}, "1111110111": {"state": 1015.0}, "1111111101": {"state": 1021.0}, "1111111011": {"state": 1019.0}, "0100000100": {"state": 260.0}, "1100010110": {"state": 790.0}, "0111111101": {"state": 509.0}, "1101000011": {"state": 835.0}, "1110100101": {"state": 933.0}, "1110111000": {"state": 952.0}, "0111100010": {"state": 482.0}, "0110111000": {"state": 440.0}, "1111110010": {"state": 1010.0}, "0111111010": {"state": 506.0}, "0111110110": {"state": 502.0}, "1000001001": {"state": 521.0}, "1110110100": {"state": 948.0}, "0100001111": {"state": 271.0}, "1101011100": {"state": 860.0}, "1111101001": {"state": 1001.0}, "0100000000": {"state": 256.0}, "1100001000": {"state": 776.0}, "0110111110": {"state": 446.0}, "1110111001": {"state": 953.0}, "0000000101": {"state": 5.0}, "1110100110": {"state": 934.0}, "0011111110": {"state": 254.0}, "1000001011": {"state": 523.0}, "1111111111": {"state": 1023.0}, "1000011101": {"state": 541.0}, "1000000101": {"state": 517.0}, "0000001111": {"state": 15.0}, "1100000111": {"state": 775.0}, "1000000001": {"state": 513.0}, "1100001011": {"state": 779.0}, "0111101101": {"state": 493.0}, "0110101110": {"state": 430.0}, "0000000000": {"state": 0.0}, "1101010000": {"state": 848.0}, "0011100111": {"state": 231.0}, "1011110110": {"state": 758.0}, "1100001010": {"state": 778.0}, "1110110110": {"state": 950.0}, "0100001100": {"state": 268.0}, "0111101110": {"state": 494.0}, "1100011001": {"state": 793.0}, "1000000000": {"state": 512.0}, "1101001111": {"state": 847.0}, "0100011000": {"state": 280.0}, "1110110101": {"state": 949.0}, "1100011100": {"state": 796.0}, "0110111111": {"state": 447.0}, "1111101011": {"state": 1003.0}, "0110100011": {"state": 419.0}, "1101011000": {"state": 856.0}, "1111110110": {"state": 1014.0}, "0110101011": {"state": 427.0}, "1000001110": {"state": 526.0}, "0011111111": {"state": 255.0}, "1110111011": {"state": 955.0}, "0100011111": {"state": 287.0}, "1100001001": {"state": 777.0}, "0110110100": {"state": 436.0}, "0110111011": {"state": 443.0}, "0111110111": {"state": 503.0}, "1110100001": {"state": 929.0}, "1111101101": {"state": 1005.0}, "1111100000": {"state": 992.0}, "1100010011": {"state": 787.0}, "0100011100": {"state": 284.0}, "1110111111": {"state": 959.0}, "1111001000": {"state": 968.0}, "0100010000": {"state": 272.0}, "1000011110": {"state": 542.0}, "1110101001": {"state": 937.0}, "1111101110": {"state": 1006.0}, "1100011000": {"state": 792.0}, "1110111010": {"state": 954.0}, "1110110010": {"state": 946.0}, "1111101000": {"state": 1000.0}, "0111100101": {"state": 485.0}, "0100001010": {"state": 266.0}, "0111110011": {"state": 499.0}, "0100001101": {"state": 269.0}, "0011110111": {"state": 247.0}, "0111100001": {"state": 481.0}, "0111101010": {"state": 490.0}, "0100001000": {"state": 264.0}, "0110110000": {"state": 432.0}, "1100000100": {"state": 772.0}, "0110111010": {"state": 442.0}, "0111101000": {"state": 488.0}, "0111111011": {"state": 507.0}, "1100000001": {"state": 769.0}, "0100011001": {"state": 281.0}, "0110111101": {"state": 445.0}, "1100011111": {"state": 799.0}, "0110110011": {"state": 435.0}, "0101000101": {"state": 325.0}, "1110110011": {"state": 947.0}, "0110100001": {"state": 417.0}, "0110100100": {"state": 420.0}, "0111100000": {"state": 480.0}, "1101001100": {"state": 844.0}, "1110110001": {"state": 945.0}, "1100001110": {"state": 782.0}, "0100010101": {"state": 277.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "1100000010": 1, + "0011111010": 1, + "0000000010": 1, + "0101001000": 1, + "1111101011": 1, + "0110101001": 1, + "0110110101": 1, + "1000010111": 1, + "1011110100": 1, + "1100000111": 3, + "0000000111": 1, + "1110100111": 1, + "1011101000": 1, + "1101010111": 1, + "0011101000": 1, + "0011110100": 3, + "0110100011": 1, + "0101000110": 3, + "1101001100": 5, + "0100010110": 2, + "1101001110": 1, + "0101001110": 2, + "0100001011": 1, + "1110111111": 1, + "1111001100": 1, + "1111100111": 4, + "0110111111": 4, + "1110110111": 4, + "0011110010": 1, + "1000010101": 1, + "1011111000": 1, + "1000000101": 3, + "1100001000": 8, + "1000000011": 1, + "1111010111": 1, + "0000000000": 4, + "0010111110": 1, + "0100011010": 6, + "1100011101": 1, + "0000000110": 1, + "0110100010": 2, + "1101000000": 9, + "1111101000": 6, + "1101001000": 2, + "1101000011": 1, + "1110100101": 14, + "1100011111": 1, + "0110111101": 7, + "0000001111": 1, + "0110111001": 11, + "0110000100": 1, + "1000011101": 1, + "1101001011": 3, + "0111100111": 9, + "1100010101": 15, + "0000001010": 1, + "1000001110": 9, + "1111100101": 3, + "1110101100": 3, + "0100011100": 5, + "1111100000": 3, + "1110111101": 5, + "0110100001": 6, + "1110110011": 2, + "0100010111": 1, + "1110111100": 8, + "1110101101": 10, + "1110100110": 45, + "0100000001": 8, + "1110111010": 5, + "1100011000": 2, + "1110110010": 40, + "0100001110": 17, + "0111100011": 3, + "1111101111": 7, + "0100000011": 2, + "0110111010": 18, + "0111101000": 22, + "1000001001": 3, + "1110110100": 13, + "0111110110": 409, + "0100001111": 33, + "1100011010": 1, + "1000000100": 5, + "1111100110": 8, + "0111101011": 14, + "1111111100": 50, + "1101001111": 5, + "1110110101": 18, + "0100011000": 3, + "1111101100": 15, + "1111111110": 46, + "1111110011": 319, + "0101001001": 3, + "0111110001": 100, + "0110101000": 33, + "1110111110": 1, + "1100001100": 7, + "0110100100": 22, + "0111111110": 330, + "1100001101": 10, + "0111110101": 123, + "1100000110": 373, + "0111110100": 84, + "0101000001": 5, + "1110100010": 28, + "1011110000": 1, + "0111111000": 662, + "0011111110": 1, + "1111111111": 192, + "1111111001": 355, + "1111110111": 78, + "1111110001": 177, + "1100000001": 22, + "0110101010": 5, + "0100000101": 6, + "1111111101": 80, + "1111111011": 268, + "1110100011": 1, + "0111111011": 3, + "1110110110": 3, + "1100001010": 50, + "1111101001": 26, + "0100000000": 60, + "1111101110": 15, + "0110111011": 5, + "1110100001": 19, + "0111110111": 215, + "0101001101": 2, + "1011110101": 2, + "0111101100": 47, + "0100010100": 7, + "0000000101": 2, + "0110111110": 11, + "1110111001": 102, + "0111100110": 9, + "1111110101": 39, + "0000001000": 6, + "0111000101": 1, + "0111111010": 114, + "1100011001": 4, + "0100001100": 20, + "0111101110": 11, + "1100000101": 19, + "0111111101": 211, + "0100000100": 140, + "1100010110": 42, + "1111000000": 1, + "0110110001": 6, + "0111111100": 514, + "1111111000": 211, + "0110110111": 2, + "0111101001": 9, + "1011110110": 5, + "1101010000": 1, + "1111110110": 25, + "0111111111": 15, + "1000000001": 1, + "0111101101": 1, + "1100001011": 19, + "1111100100": 3, + "0111110000": 57, + "0100000111": 1, + "1100000100": 6, + "0110110000": 6, + "0111100001": 3, + "0100001000": 43, + "0111101010": 20, + "1110101010": 28, + "1110110001": 41, + "1100001110": 13, + "0110110011": 12, + "0100001001": 34, + "0110111000": 153, + "1111110010": 45, + "1111111010": 99, + "1000000111": 5, + "1111110000": 114, + "1110101011": 1, + "1111100001": 10, + "0110101101": 9, + "1111110100": 46, + "0100000010": 14, + "0110101011": 30, + "1100000000": 20, + "0100010001": 1, + "0100011111": 8, + "1100001001": 19, + "0110110100": 8, + "0111110010": 288, + "1000001101": 1, + "0111100000": 10, + "1110101001": 3, + "0111110011": 146, + "0111100101": 40, + "0100001101": 20, + "0100001010": 54, + "0100011110": 1, + "0110101100": 1, + "1011111110": 5, + "1111100011": 89, + "1000011010": 1, + "0100000110": 11, + "0101001010": 3, + "0001001101": 1, + "1111101101": 11, + "0111101111": 8, + "1110111011": 6, + "0111111001": 248, + "1111000011": 1, + "0111100010": 16, + "1110111000": 15, + "1101000100": 10, + "0000001100": 1, + "0100010000": 7, + "1111001000": 1, + "0110101111": 53, + "1110110000": 2 + }, + "counts_lsb_right": true, + "parsed_states": { + "1100000010": { "state": 770.0 }, + "0011111010": { "state": 250.0 }, + "0000000010": { "state": 2.0 }, + "0101001000": { "state": 328.0 }, + "1111101011": { "state": 1003.0 }, + "0110101001": { "state": 425.0 }, + "0110110101": { "state": 437.0 }, + "1000010111": { "state": 535.0 }, + "1011110100": { "state": 756.0 }, + "1100000111": { "state": 775.0 }, + "0000000111": { "state": 7.0 }, + "1110100111": { "state": 935.0 }, + "1011101000": { "state": 744.0 }, + "1101010111": { "state": 855.0 }, + "0011101000": { "state": 232.0 }, + "0011110100": { "state": 244.0 }, + "0110100011": { "state": 419.0 }, + "0101000110": { "state": 326.0 }, + "1101001100": { "state": 844.0 }, + "0100010110": { "state": 278.0 }, + "1101001110": { "state": 846.0 }, + "0101001110": { "state": 334.0 }, + "0100001011": { "state": 267.0 }, + "1110111111": { "state": 959.0 }, + "1111001100": { "state": 972.0 }, + "1111100111": { "state": 999.0 }, + "0110111111": { "state": 447.0 }, + "1110110111": { "state": 951.0 }, + "0011110010": { "state": 242.0 }, + "1000010101": { "state": 533.0 }, + "1011111000": { "state": 760.0 }, + "1000000101": { "state": 517.0 }, + "1100001000": { "state": 776.0 }, + "1000000011": { "state": 515.0 }, + "1111010111": { "state": 983.0 }, + "0000000000": { "state": 0.0 }, + "0010111110": { "state": 190.0 }, + "0100011010": { "state": 282.0 }, + "1100011101": { "state": 797.0 }, + "0000000110": { "state": 6.0 }, + "0110100010": { "state": 418.0 }, + "1101000000": { "state": 832.0 }, + "1111101000": { "state": 1000.0 }, + "1101001000": { "state": 840.0 }, + "1101000011": { "state": 835.0 }, + "1110100101": { "state": 933.0 }, + "1100011111": { "state": 799.0 }, + "0110111101": { "state": 445.0 }, + "0000001111": { "state": 15.0 }, + "0110111001": { "state": 441.0 }, + "0110000100": { "state": 388.0 }, + "1000011101": { "state": 541.0 }, + "1101001011": { "state": 843.0 }, + "0111100111": { "state": 487.0 }, + "1100010101": { "state": 789.0 }, + "0000001010": { "state": 10.0 }, + "1000001110": { "state": 526.0 }, + "1111100101": { "state": 997.0 }, + "1110101100": { "state": 940.0 }, + "0100011100": { "state": 284.0 }, + "1111100000": { "state": 992.0 }, + "1110111101": { "state": 957.0 }, + "0110100001": { "state": 417.0 }, + "1110110011": { "state": 947.0 }, + "0100010111": { "state": 279.0 }, + "1110111100": { "state": 956.0 }, + "1110101101": { "state": 941.0 }, + "1110100110": { "state": 934.0 }, + "0100000001": { "state": 257.0 }, + "1110111010": { "state": 954.0 }, + "1100011000": { "state": 792.0 }, + "1110110010": { "state": 946.0 }, + "0100001110": { "state": 270.0 }, + "0111100011": { "state": 483.0 }, + "1111101111": { "state": 1007.0 }, + "0100000011": { "state": 259.0 }, + "0110111010": { "state": 442.0 }, + "0111101000": { "state": 488.0 }, + "1000001001": { "state": 521.0 }, + "1110110100": { "state": 948.0 }, + "0111110110": { "state": 502.0 }, + "0100001111": { "state": 271.0 }, + "1100011010": { "state": 794.0 }, + "1000000100": { "state": 516.0 }, + "1111100110": { "state": 998.0 }, + "0111101011": { "state": 491.0 }, + "1111111100": { "state": 1020.0 }, + "1101001111": { "state": 847.0 }, + "1110110101": { "state": 949.0 }, + "0100011000": { "state": 280.0 }, + "1111101100": { "state": 1004.0 }, + "1111111110": { "state": 1022.0 }, + "1111110011": { "state": 1011.0 }, + "0101001001": { "state": 329.0 }, + "0111110001": { "state": 497.0 }, + "0110101000": { "state": 424.0 }, + "1110111110": { "state": 958.0 }, + "1100001100": { "state": 780.0 }, + "0110100100": { "state": 420.0 }, + "0111111110": { "state": 510.0 }, + "1100001101": { "state": 781.0 }, + "0111110101": { "state": 501.0 }, + "1100000110": { "state": 774.0 }, + "0111110100": { "state": 500.0 }, + "0101000001": { "state": 321.0 }, + "1110100010": { "state": 930.0 }, + "1011110000": { "state": 752.0 }, + "0111111000": { "state": 504.0 }, + "0011111110": { "state": 254.0 }, + "1111111111": { "state": 1023.0 }, + "1111111001": { "state": 1017.0 }, + "1111110111": { "state": 1015.0 }, + "1111110001": { "state": 1009.0 }, + "1100000001": { "state": 769.0 }, + "0110101010": { "state": 426.0 }, + "0100000101": { "state": 261.0 }, + "1111111101": { "state": 1021.0 }, + "1111111011": { "state": 1019.0 }, + "1110100011": { "state": 931.0 }, + "0111111011": { "state": 507.0 }, + "1110110110": { "state": 950.0 }, + "1100001010": { "state": 778.0 }, + "1111101001": { "state": 1001.0 }, + "0100000000": { "state": 256.0 }, + "1111101110": { "state": 1006.0 }, + "0110111011": { "state": 443.0 }, + "1110100001": { "state": 929.0 }, + "0111110111": { "state": 503.0 }, + "0101001101": { "state": 333.0 }, + "1011110101": { "state": 757.0 }, + "0111101100": { "state": 492.0 }, + "0100010100": { "state": 276.0 }, + "0000000101": { "state": 5.0 }, + "0110111110": { "state": 446.0 }, + "1110111001": { "state": 953.0 }, + "0111100110": { "state": 486.0 }, + "1111110101": { "state": 1013.0 }, + "0000001000": { "state": 8.0 }, + "0111000101": { "state": 453.0 }, + "0111111010": { "state": 506.0 }, + "1100011001": { "state": 793.0 }, + "0100001100": { "state": 268.0 }, + "0111101110": { "state": 494.0 }, + "1100000101": { "state": 773.0 }, + "0111111101": { "state": 509.0 }, + "0100000100": { "state": 260.0 }, + "1100010110": { "state": 790.0 }, + "1111000000": { "state": 960.0 }, + "0110110001": { "state": 433.0 }, + "0111111100": { "state": 508.0 }, + "1111111000": { "state": 1016.0 }, + "0110110111": { "state": 439.0 }, + "0111101001": { "state": 489.0 }, + "1011110110": { "state": 758.0 }, + "1101010000": { "state": 848.0 }, + "1111110110": { "state": 1014.0 }, + "0111111111": { "state": 511.0 }, + "1000000001": { "state": 513.0 }, + "0111101101": { "state": 493.0 }, + "1100001011": { "state": 779.0 }, + "1111100100": { "state": 996.0 }, + "0111110000": { "state": 496.0 }, + "0100000111": { "state": 263.0 }, + "1100000100": { "state": 772.0 }, + "0110110000": { "state": 432.0 }, + "0111100001": { "state": 481.0 }, + "0100001000": { "state": 264.0 }, + "0111101010": { "state": 490.0 }, + "1110101010": { "state": 938.0 }, + "1110110001": { "state": 945.0 }, + "1100001110": { "state": 782.0 }, + "0110110011": { "state": 435.0 }, + "0100001001": { "state": 265.0 }, + "0110111000": { "state": 440.0 }, + "1111110010": { "state": 1010.0 }, + "1111111010": { "state": 1018.0 }, + "1000000111": { "state": 519.0 }, + "1111110000": { "state": 1008.0 }, + "1110101011": { "state": 939.0 }, + "1111100001": { "state": 993.0 }, + "0110101101": { "state": 429.0 }, + "1111110100": { "state": 1012.0 }, + "0100000010": { "state": 258.0 }, + "0110101011": { "state": 427.0 }, + "1100000000": { "state": 768.0 }, + "0100010001": { "state": 273.0 }, + "0100011111": { "state": 287.0 }, + "1100001001": { "state": 777.0 }, + "0110110100": { "state": 436.0 }, + "0111110010": { "state": 498.0 }, + "1000001101": { "state": 525.0 }, + "0111100000": { "state": 480.0 }, + "1110101001": { "state": 937.0 }, + "0111110011": { "state": 499.0 }, + "0111100101": { "state": 485.0 }, + "0100001101": { "state": 269.0 }, + "0100001010": { "state": 266.0 }, + "0100011110": { "state": 286.0 }, + "0110101100": { "state": 428.0 }, + "1011111110": { "state": 766.0 }, + "1111100011": { "state": 995.0 }, + "1000011010": { "state": 538.0 }, + "0100000110": { "state": 262.0 }, + "0101001010": { "state": 330.0 }, + "0001001101": { "state": 77.0 }, + "1111101101": { "state": 1005.0 }, + "0111101111": { "state": 495.0 }, + "1110111011": { "state": 955.0 }, + "0111111001": { "state": 505.0 }, + "1111000011": { "state": 963.0 }, + "0111100010": { "state": 482.0 }, + "1110111000": { "state": 952.0 }, + "1101000100": { "state": 836.0 }, + "0000001100": { "state": 12.0 }, + "0100010000": { "state": 272.0 }, + "1111001000": { "state": 968.0 }, + "0110101111": { "state": 431.0 }, + "1110110000": { "state": 944.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n+8.json b/algorithms/glued_trees/results/10-qubits/2n+8.json index 89a318de..0e5d4300 100644 --- a/algorithms/glued_trees/results/10-qubits/2n+8.json +++ b/algorithms/glued_trees/results/10-qubits/2n+8.json @@ -1 +1,390 @@ -{"vendor_format_result": {}, "counts": {"1100001101": 1, "1110100000": 2, "1101000000": 1, "1111010000": 1, "1111101001": 3, "0100001001": 1, "1101010000": 1, "0110101101": 8, "0111100111": 3, "0101000111": 1, "0011111000": 1, "0110100101": 2, "0110101000": 4, "0100010000": 2, "0101001110": 1, "1100000011": 1, "1100010001": 2, "1100010011": 6, "0100011100": 1, "1111100000": 14, "1101001011": 3, "1100011101": 3, "1100011010": 4, "1101000101": 1, "0101001010": 3, "1110100111": 5, "0110111100": 2, "1111101100": 2, "0111100100": 1, "0111101011": 4, "1101011001": 1, "0100011011": 3, "0110100100": 7, "0111100000": 1, "0111100011": 10, "1111101111": 3, "1111100111": 16, "0110101100": 13, "0111110010": 580, "0111101111": 3, "0100010001": 1, "1100000000": 41, "1110100110": 59, "1111111100": 32, "1110110000": 9, "0110101111": 51, "1111100100": 151, "0111111111": 124, "1111111110": 76, "1111110011": 3, "0111110001": 23, "1110100011": 2, "0111111011": 25, "0101001011": 4, "1101010001": 1, "0100000000": 9, "1110101111": 7, "1100000001": 182, "0110100111": 7, "0110110111": 130, "0111101001": 97, "0100001011": 103, "1110111011": 2, "1111111111": 353, "1101001010": 2, "0110111101": 17, "1110111100": 15, "0101000000": 1, "1110111101": 42, "0100001111": 28, "0111110110": 28, "1110110100": 5, "1110101110": 3, "0110100011": 102, "1111110110": 143, "0110110011": 31, "1100000010": 38, "1110101101": 5, "0101000010": 10, "1111100001": 14, "1111110000": 49, "1110101011": 6, "0111111110": 671, "1101000100": 3, "1100011001": 1, "0100001100": 3, "0111101110": 34, "1100000101": 45, "1110000010": 1, "0111111010": 77, "0111111001": 595, "1100010100": 2, "0111110101": 183, "1111111000": 4, "0110110001": 26, "0111111100": 68, "1111100011": 9, "0111111101": 38, "0100000100": 36, "1100010110": 7, "0110111111": 166, "0100000001": 5, "0111111000": 211, "1110101000": 4, "1100001000": 15, "0101000001": 13, "0111110100": 148, "0110111011": 2, "1110100001": 16, "0111110111": 103, "0100010100": 6, "0110111110": 16, "1110111001": 307, "1100001110": 3, "1110110001": 13, "1101001001": 7, "1100001100": 9, "1111110001": 108, "0110110100": 8, "1111110100": 710, "1110100010": 12, "1111111010": 129, "1111100101": 4, "0110100000": 8, "1110100100": 11, "1111110101": 29, "0110100001": 9, "1110110011": 10, "1100001011": 1, "0111101101": 11, "1100001111": 28, "1100001001": 11, "0100011111": 12, "0101000110": 2, "0110111010": 30, "0111101000": 24, "1110111111": 4, "0100001110": 39, "1111100110": 19, "1111110010": 62, "0110111000": 20, "1111111101": 157, "1111111011": 2, "0100000101": 15, "1100011000": 1, "1110111010": 42, "1110110010": 5, "1100000110": 52, "0111000010": 4, "1111101011": 15, "1100001010": 24, "1110110110": 22, "0111110000": 1, "1110111000": 6, "1110100101": 15, "1101000011": 7, "1101001000": 15, "0110000000": 1, "0110110000": 7, "1100000100": 11, "0100001000": 268, "0111100001": 13, "0100000111": 43, "0111101010": 8, "1111101110": 15, "0100011000": 8, "1110110101": 3, "1101001111": 2, "0110111001": 20, "1111101000": 17, "1111111001": 342, "1111110111": 13, "0111101100": 10, "0101001101": 5, "0110110101": 11, "0111100101": 1, "0111110011": 49, "0100001101": 6, "1110101001": 21, "1110111110": 2, "1100010010": 5, "1110110111": 16, "1111101101": 12}, "counts_lsb_right": true, "parsed_states": {"1100001101": {"state": 781.0}, "1110100000": {"state": 928.0}, "1101000000": {"state": 832.0}, "1111010000": {"state": 976.0}, "1111101001": {"state": 1001.0}, "0100001001": {"state": 265.0}, "1101010000": {"state": 848.0}, "0110101101": {"state": 429.0}, "0111100111": {"state": 487.0}, "0101000111": {"state": 327.0}, "0011111000": {"state": 248.0}, "0110100101": {"state": 421.0}, "0110101000": {"state": 424.0}, "0100010000": {"state": 272.0}, "0101001110": {"state": 334.0}, "1100000011": {"state": 771.0}, "1100010001": {"state": 785.0}, "1100010011": {"state": 787.0}, "0100011100": {"state": 284.0}, "1111100000": {"state": 992.0}, "1101001011": {"state": 843.0}, "1100011101": {"state": 797.0}, "1100011010": {"state": 794.0}, "1101000101": {"state": 837.0}, "0101001010": {"state": 330.0}, "1110100111": {"state": 935.0}, "0110111100": {"state": 444.0}, "1111101100": {"state": 1004.0}, "0111100100": {"state": 484.0}, "0111101011": {"state": 491.0}, "1101011001": {"state": 857.0}, "0100011011": {"state": 283.0}, "0110100100": {"state": 420.0}, "0111100000": {"state": 480.0}, "0111100011": {"state": 483.0}, "1111101111": {"state": 1007.0}, "1111100111": {"state": 999.0}, "0110101100": {"state": 428.0}, "0111110010": {"state": 498.0}, "0111101111": {"state": 495.0}, "0100010001": {"state": 273.0}, "1100000000": {"state": 768.0}, "1110100110": {"state": 934.0}, "1111111100": {"state": 1020.0}, "1110110000": {"state": 944.0}, "0110101111": {"state": 431.0}, "1111100100": {"state": 996.0}, "0111111111": {"state": 511.0}, "1111111110": {"state": 1022.0}, "1111110011": {"state": 1011.0}, "0111110001": {"state": 497.0}, "1110100011": {"state": 931.0}, "0111111011": {"state": 507.0}, "0101001011": {"state": 331.0}, "1101010001": {"state": 849.0}, "0100000000": {"state": 256.0}, "1110101111": {"state": 943.0}, "1100000001": {"state": 769.0}, "0110100111": {"state": 423.0}, "0110110111": {"state": 439.0}, "0111101001": {"state": 489.0}, "0100001011": {"state": 267.0}, "1110111011": {"state": 955.0}, "1111111111": {"state": 1023.0}, "1101001010": {"state": 842.0}, "0110111101": {"state": 445.0}, "1110111100": {"state": 956.0}, "0101000000": {"state": 320.0}, "1110111101": {"state": 957.0}, "0100001111": {"state": 271.0}, "0111110110": {"state": 502.0}, "1110110100": {"state": 948.0}, "1110101110": {"state": 942.0}, "0110100011": {"state": 419.0}, "1111110110": {"state": 1014.0}, "0110110011": {"state": 435.0}, "1100000010": {"state": 770.0}, "1110101101": {"state": 941.0}, "0101000010": {"state": 322.0}, "1111100001": {"state": 993.0}, "1111110000": {"state": 1008.0}, "1110101011": {"state": 939.0}, "0111111110": {"state": 510.0}, "1101000100": {"state": 836.0}, "1100011001": {"state": 793.0}, "0100001100": {"state": 268.0}, "0111101110": {"state": 494.0}, "1100000101": {"state": 773.0}, "1110000010": {"state": 898.0}, "0111111010": {"state": 506.0}, "0111111001": {"state": 505.0}, "1100010100": {"state": 788.0}, "0111110101": {"state": 501.0}, "1111111000": {"state": 1016.0}, "0110110001": {"state": 433.0}, "0111111100": {"state": 508.0}, "1111100011": {"state": 995.0}, "0111111101": {"state": 509.0}, "0100000100": {"state": 260.0}, "1100010110": {"state": 790.0}, "0110111111": {"state": 447.0}, "0100000001": {"state": 257.0}, "0111111000": {"state": 504.0}, "1110101000": {"state": 936.0}, "1100001000": {"state": 776.0}, "0101000001": {"state": 321.0}, "0111110100": {"state": 500.0}, "0110111011": {"state": 443.0}, "1110100001": {"state": 929.0}, "0111110111": {"state": 503.0}, "0100010100": {"state": 276.0}, "0110111110": {"state": 446.0}, "1110111001": {"state": 953.0}, "1100001110": {"state": 782.0}, "1110110001": {"state": 945.0}, "1101001001": {"state": 841.0}, "1100001100": {"state": 780.0}, "1111110001": {"state": 1009.0}, "0110110100": {"state": 436.0}, "1111110100": {"state": 1012.0}, "1110100010": {"state": 930.0}, "1111111010": {"state": 1018.0}, "1111100101": {"state": 997.0}, "0110100000": {"state": 416.0}, "1110100100": {"state": 932.0}, "1111110101": {"state": 1013.0}, "0110100001": {"state": 417.0}, "1110110011": {"state": 947.0}, "1100001011": {"state": 779.0}, "0111101101": {"state": 493.0}, "1100001111": {"state": 783.0}, "1100001001": {"state": 777.0}, "0100011111": {"state": 287.0}, "0101000110": {"state": 326.0}, "0110111010": {"state": 442.0}, "0111101000": {"state": 488.0}, "1110111111": {"state": 959.0}, "0100001110": {"state": 270.0}, "1111100110": {"state": 998.0}, "1111110010": {"state": 1010.0}, "0110111000": {"state": 440.0}, "1111111101": {"state": 1021.0}, "1111111011": {"state": 1019.0}, "0100000101": {"state": 261.0}, "1100011000": {"state": 792.0}, "1110111010": {"state": 954.0}, "1110110010": {"state": 946.0}, "1100000110": {"state": 774.0}, "0111000010": {"state": 450.0}, "1111101011": {"state": 1003.0}, "1100001010": {"state": 778.0}, "1110110110": {"state": 950.0}, "0111110000": {"state": 496.0}, "1110111000": {"state": 952.0}, "1110100101": {"state": 933.0}, "1101000011": {"state": 835.0}, "1101001000": {"state": 840.0}, "0110000000": {"state": 384.0}, "0110110000": {"state": 432.0}, "1100000100": {"state": 772.0}, "0100001000": {"state": 264.0}, "0111100001": {"state": 481.0}, "0100000111": {"state": 263.0}, "0111101010": {"state": 490.0}, "1111101110": {"state": 1006.0}, "0100011000": {"state": 280.0}, "1110110101": {"state": 949.0}, "1101001111": {"state": 847.0}, "0110111001": {"state": 441.0}, "1111101000": {"state": 1000.0}, "1111111001": {"state": 1017.0}, "1111110111": {"state": 1015.0}, "0111101100": {"state": 492.0}, "0101001101": {"state": 333.0}, "0110110101": {"state": 437.0}, "0111100101": {"state": 485.0}, "0111110011": {"state": 499.0}, "0100001101": {"state": 269.0}, "1110101001": {"state": 937.0}, "1110111110": {"state": 958.0}, "1100010010": {"state": 786.0}, "1110110111": {"state": 951.0}, "1111101101": {"state": 1005.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "1111011001": 1, + "0110101000": 1, + "1000000011": 1, + "0100010000": 1, + "1101011001": 1, + "1100010010": 1, + "0101000110": 1, + "1101000110": 1, + "1100000111": 1, + "0101001100": 1, + "1111010111": 1, + "1111001111": 1, + "1101001010": 4, + "1101000000": 2, + "0101001000": 2, + "1101001011": 1, + "1101001001": 3, + "1100011010": 3, + "0000001000": 1, + "1100011101": 4, + "1100001110": 4, + "1110110001": 7, + "0100000001": 7, + "0111100110": 2, + "0101001011": 4, + "0110110100": 7, + "0111100000": 3, + "0100010110": 1, + "1111110011": 7, + "1110100010": 16, + "1100010101": 1, + "1111100111": 12, + "0111110000": 1, + "0100011011": 3, + "0111101011": 2, + "0100010100": 6, + "0111000111": 1, + "1100001111": 31, + "0111101101": 8, + "0100011110": 1, + "0110101100": 10, + "0101000000": 1, + "1110111101": 33, + "1110101001": 12, + "1111101010": 1, + "1100010110": 11, + "0100000100": 31, + "0100001011": 92, + "1111110110": 129, + "0110100011": 102, + "0111100100": 3, + "1100010011": 3, + "1111100000": 18, + "0111100111": 5, + "0111111111": 139, + "1111100100": 124, + "1111110001": 108, + "1110100111": 10, + "0111110110": 33, + "0100001111": 31, + "1110110100": 4, + "1111111110": 84, + "0111110001": 20, + "1111111111": 337, + "1111111010": 126, + "1111110100": 688, + "0111110010": 510, + "0111111001": 642, + "0111111110": 686, + "1100001101": 5, + "0100010001": 1, + "1100000000": 44, + "0100000000": 16, + "1110101111": 5, + "1111101001": 10, + "0101001101": 6, + "0111101100": 14, + "1110110111": 13, + "1110100011": 3, + "0111111011": 32, + "1100000001": 200, + "0110111111": 228, + "0100001110": 41, + "0101010001": 1, + "1111101101": 20, + "0101001010": 3, + "0110100111": 6, + "0111101001": 95, + "0110110111": 131, + "1110100110": 53, + "1100000010": 41, + "1110101101": 9, + "1111100110": 19, + "0101000001": 14, + "0111110100": 155, + "0111111000": 178, + "1101000010": 2, + "1110111001": 290, + "0110111110": 25, + "0111111010": 65, + "1100000101": 48, + "0111111101": 46, + "1101000011": 4, + "1101001000": 9, + "1110100101": 18, + "1100000110": 53, + "0100010011": 2, + "0110110011": 15, + "0111110101": 209, + "0100001101": 10, + "0111110011": 60, + "1101001111": 3, + "1110110101": 1, + "0100011000": 10, + "1111111100": 31, + "1111110111": 8, + "1111111001": 316, + "1100001100": 12, + "1111101000": 15, + "0101000010": 14, + "1111100001": 21, + "0110100000": 10, + "1110101011": 5, + "1111110000": 47, + "1111110010": 47, + "0110111000": 10, + "0110101010": 1, + "0100000101": 14, + "1111111101": 171, + "1111111011": 3, + "1101000100": 8, + "1110111110": 10, + "1111101110": 15, + "0110101101": 3, + "1110101110": 4, + "0110100100": 14, + "1111101011": 10, + "0110101111": 53, + "1110110000": 5, + "1111100011": 9, + "1111111000": 6, + "0110110001": 33, + "0111111100": 71, + "0111110111": 118, + "1110100001": 8, + "0110111011": 2, + "0111101110": 25, + "0100001100": 2, + "0110111001": 20, + "1110101000": 10, + "1100001000": 15, + "0110100001": 4, + "1110110011": 6, + "0111101000": 27, + "0110111010": 19, + "1110100000": 3, + "1100001010": 14, + "1110110110": 18, + "1110100100": 7, + "1111110101": 26, + "1110111010": 50, + "1110110010": 7, + "0110000000": 1, + "1100000100": 4, + "0111100001": 17, + "0100001000": 286, + "0110110000": 5, + "0100000111": 38, + "0111101010": 10, + "0110110101": 15, + "1111101111": 8, + "0111100011": 6, + "1110111111": 9, + "1100000011": 1, + "1100010001": 5, + "1110111000": 6, + "0111100010": 3, + "0111101111": 4, + "0100011111": 10, + "1100001001": 6, + "1110111100": 20, + "1111100010": 1, + "0110111101": 16, + "0100010010": 2, + "1111100101": 3, + "1110101100": 2, + "0111000010": 4, + "1101011010": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "1111011001": { "state": 985.0 }, + "0110101000": { "state": 424.0 }, + "1000000011": { "state": 515.0 }, + "0100010000": { "state": 272.0 }, + "1101011001": { "state": 857.0 }, + "1100010010": { "state": 786.0 }, + "0101000110": { "state": 326.0 }, + "1101000110": { "state": 838.0 }, + "1100000111": { "state": 775.0 }, + "0101001100": { "state": 332.0 }, + "1111010111": { "state": 983.0 }, + "1111001111": { "state": 975.0 }, + "1101001010": { "state": 842.0 }, + "1101000000": { "state": 832.0 }, + "0101001000": { "state": 328.0 }, + "1101001011": { "state": 843.0 }, + "1101001001": { "state": 841.0 }, + "1100011010": { "state": 794.0 }, + "0000001000": { "state": 8.0 }, + "1100011101": { "state": 797.0 }, + "1100001110": { "state": 782.0 }, + "1110110001": { "state": 945.0 }, + "0100000001": { "state": 257.0 }, + "0111100110": { "state": 486.0 }, + "0101001011": { "state": 331.0 }, + "0110110100": { "state": 436.0 }, + "0111100000": { "state": 480.0 }, + "0100010110": { "state": 278.0 }, + "1111110011": { "state": 1011.0 }, + "1110100010": { "state": 930.0 }, + "1100010101": { "state": 789.0 }, + "1111100111": { "state": 999.0 }, + "0111110000": { "state": 496.0 }, + "0100011011": { "state": 283.0 }, + "0111101011": { "state": 491.0 }, + "0100010100": { "state": 276.0 }, + "0111000111": { "state": 455.0 }, + "1100001111": { "state": 783.0 }, + "0111101101": { "state": 493.0 }, + "0100011110": { "state": 286.0 }, + "0110101100": { "state": 428.0 }, + "0101000000": { "state": 320.0 }, + "1110111101": { "state": 957.0 }, + "1110101001": { "state": 937.0 }, + "1111101010": { "state": 1002.0 }, + "1100010110": { "state": 790.0 }, + "0100000100": { "state": 260.0 }, + "0100001011": { "state": 267.0 }, + "1111110110": { "state": 1014.0 }, + "0110100011": { "state": 419.0 }, + "0111100100": { "state": 484.0 }, + "1100010011": { "state": 787.0 }, + "1111100000": { "state": 992.0 }, + "0111100111": { "state": 487.0 }, + "0111111111": { "state": 511.0 }, + "1111100100": { "state": 996.0 }, + "1111110001": { "state": 1009.0 }, + "1110100111": { "state": 935.0 }, + "0111110110": { "state": 502.0 }, + "0100001111": { "state": 271.0 }, + "1110110100": { "state": 948.0 }, + "1111111110": { "state": 1022.0 }, + "0111110001": { "state": 497.0 }, + "1111111111": { "state": 1023.0 }, + "1111111010": { "state": 1018.0 }, + "1111110100": { "state": 1012.0 }, + "0111110010": { "state": 498.0 }, + "0111111001": { "state": 505.0 }, + "0111111110": { "state": 510.0 }, + "1100001101": { "state": 781.0 }, + "0100010001": { "state": 273.0 }, + "1100000000": { "state": 768.0 }, + "0100000000": { "state": 256.0 }, + "1110101111": { "state": 943.0 }, + "1111101001": { "state": 1001.0 }, + "0101001101": { "state": 333.0 }, + "0111101100": { "state": 492.0 }, + "1110110111": { "state": 951.0 }, + "1110100011": { "state": 931.0 }, + "0111111011": { "state": 507.0 }, + "1100000001": { "state": 769.0 }, + "0110111111": { "state": 447.0 }, + "0100001110": { "state": 270.0 }, + "0101010001": { "state": 337.0 }, + "1111101101": { "state": 1005.0 }, + "0101001010": { "state": 330.0 }, + "0110100111": { "state": 423.0 }, + "0111101001": { "state": 489.0 }, + "0110110111": { "state": 439.0 }, + "1110100110": { "state": 934.0 }, + "1100000010": { "state": 770.0 }, + "1110101101": { "state": 941.0 }, + "1111100110": { "state": 998.0 }, + "0101000001": { "state": 321.0 }, + "0111110100": { "state": 500.0 }, + "0111111000": { "state": 504.0 }, + "1101000010": { "state": 834.0 }, + "1110111001": { "state": 953.0 }, + "0110111110": { "state": 446.0 }, + "0111111010": { "state": 506.0 }, + "1100000101": { "state": 773.0 }, + "0111111101": { "state": 509.0 }, + "1101000011": { "state": 835.0 }, + "1101001000": { "state": 840.0 }, + "1110100101": { "state": 933.0 }, + "1100000110": { "state": 774.0 }, + "0100010011": { "state": 275.0 }, + "0110110011": { "state": 435.0 }, + "0111110101": { "state": 501.0 }, + "0100001101": { "state": 269.0 }, + "0111110011": { "state": 499.0 }, + "1101001111": { "state": 847.0 }, + "1110110101": { "state": 949.0 }, + "0100011000": { "state": 280.0 }, + "1111111100": { "state": 1020.0 }, + "1111110111": { "state": 1015.0 }, + "1111111001": { "state": 1017.0 }, + "1100001100": { "state": 780.0 }, + "1111101000": { "state": 1000.0 }, + "0101000010": { "state": 322.0 }, + "1111100001": { "state": 993.0 }, + "0110100000": { "state": 416.0 }, + "1110101011": { "state": 939.0 }, + "1111110000": { "state": 1008.0 }, + "1111110010": { "state": 1010.0 }, + "0110111000": { "state": 440.0 }, + "0110101010": { "state": 426.0 }, + "0100000101": { "state": 261.0 }, + "1111111101": { "state": 1021.0 }, + "1111111011": { "state": 1019.0 }, + "1101000100": { "state": 836.0 }, + "1110111110": { "state": 958.0 }, + "1111101110": { "state": 1006.0 }, + "0110101101": { "state": 429.0 }, + "1110101110": { "state": 942.0 }, + "0110100100": { "state": 420.0 }, + "1111101011": { "state": 1003.0 }, + "0110101111": { "state": 431.0 }, + "1110110000": { "state": 944.0 }, + "1111100011": { "state": 995.0 }, + "1111111000": { "state": 1016.0 }, + "0110110001": { "state": 433.0 }, + "0111111100": { "state": 508.0 }, + "0111110111": { "state": 503.0 }, + "1110100001": { "state": 929.0 }, + "0110111011": { "state": 443.0 }, + "0111101110": { "state": 494.0 }, + "0100001100": { "state": 268.0 }, + "0110111001": { "state": 441.0 }, + "1110101000": { "state": 936.0 }, + "1100001000": { "state": 776.0 }, + "0110100001": { "state": 417.0 }, + "1110110011": { "state": 947.0 }, + "0111101000": { "state": 488.0 }, + "0110111010": { "state": 442.0 }, + "1110100000": { "state": 928.0 }, + "1100001010": { "state": 778.0 }, + "1110110110": { "state": 950.0 }, + "1110100100": { "state": 932.0 }, + "1111110101": { "state": 1013.0 }, + "1110111010": { "state": 954.0 }, + "1110110010": { "state": 946.0 }, + "0110000000": { "state": 384.0 }, + "1100000100": { "state": 772.0 }, + "0111100001": { "state": 481.0 }, + "0100001000": { "state": 264.0 }, + "0110110000": { "state": 432.0 }, + "0100000111": { "state": 263.0 }, + "0111101010": { "state": 490.0 }, + "0110110101": { "state": 437.0 }, + "1111101111": { "state": 1007.0 }, + "0111100011": { "state": 483.0 }, + "1110111111": { "state": 959.0 }, + "1100000011": { "state": 771.0 }, + "1100010001": { "state": 785.0 }, + "1110111000": { "state": 952.0 }, + "0111100010": { "state": 482.0 }, + "0111101111": { "state": 495.0 }, + "0100011111": { "state": 287.0 }, + "1100001001": { "state": 777.0 }, + "1110111100": { "state": 956.0 }, + "1111100010": { "state": 994.0 }, + "0110111101": { "state": 445.0 }, + "0100010010": { "state": 274.0 }, + "1111100101": { "state": 997.0 }, + "1110101100": { "state": 940.0 }, + "0111000010": { "state": 450.0 }, + "1101011010": { "state": 858.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n-10.json b/algorithms/glued_trees/results/10-qubits/2n-10.json index d2741bdf..e071a3e6 100644 --- a/algorithms/glued_trees/results/10-qubits/2n-10.json +++ b/algorithms/glued_trees/results/10-qubits/2n-10.json @@ -1 +1,206 @@ -{"vendor_format_result": {}, "counts": {"1111101110": 1, "1110111110": 1, "1110101110": 1, "0011111100": 1, "1111111000": 2, "1000011010": 3, "1000000100": 2, "1111111111": 2, "0100001000": 4, "0111111001": 6, "1111101011": 1, "1111100000": 1, "1100001000": 1, "0000011100": 5, "0001000101": 6, "1111110010": 1, "0100001010": 1, "1001000011": 3, "1001001000": 1, "0111111101": 2, "0111111010": 1, "1111111101": 3, "1111101100": 5, "1111111110": 756, "1111110011": 3, "1011110110": 44, "1000000001": 28, "0111110101": 34, "1000000010": 47, "1000001000": 18, "0111110011": 5, "1000001010": 7, "0011111111": 1, "1111111100": 340, "1011111110": 132, "0001000010": 1, "1111101001": 1, "0100000000": 19, "0000000011": 138, "0000000111": 166, "1001000111": 1, "1000001110": 73, "1000001011": 1, "1111111001": 30, "0000001010": 14, "1111100001": 1, "1110111100": 3, "1011101110": 1, "0111110111": 26, "0000000100": 128, "0000001110": 3, "0000000000": 4198, "0111111111": 38, "1000010101": 2, "1110100110": 3, "0011111011": 16, "1011100010": 1, "0000001011": 115, "0000011000": 13, "1000001001": 27, "1000000110": 38, "0000001100": 39, "1011110101": 6, "0000010000": 4, "1000001111": 7, "1111110100": 4, "1111110110": 211, "1001000000": 12, "0111111000": 8, "1111111011": 27, "0000000110": 13, "0111110110": 10, "0000001000": 1174, "1111110101": 6, "0011110110": 5, "0111111100": 1, "1111100011": 1, "0011110000": 5, "1000000101": 29, "0000001111": 28, "0001001110": 5, "1000001101": 32, "0111110100": 13, "0110110000": 1, "0111111011": 24, "1011111101": 1}, "counts_lsb_right": true, "parsed_states": {"1111101110": {"state": 1006.0}, "1110111110": {"state": 958.0}, "1110101110": {"state": 942.0}, "0011111100": {"state": 252.0}, "1111111000": {"state": 1016.0}, "1000011010": {"state": 538.0}, "1000000100": {"state": 516.0}, "1111111111": {"state": 1023.0}, "0100001000": {"state": 264.0}, "0111111001": {"state": 505.0}, "1111101011": {"state": 1003.0}, "1111100000": {"state": 992.0}, "1100001000": {"state": 776.0}, "0000011100": {"state": 28.0}, "0001000101": {"state": 69.0}, "1111110010": {"state": 1010.0}, "0100001010": {"state": 266.0}, "1001000011": {"state": 579.0}, "1001001000": {"state": 584.0}, "0111111101": {"state": 509.0}, "0111111010": {"state": 506.0}, "1111111101": {"state": 1021.0}, "1111101100": {"state": 1004.0}, "1111111110": {"state": 1022.0}, "1111110011": {"state": 1011.0}, "1011110110": {"state": 758.0}, "1000000001": {"state": 513.0}, "0111110101": {"state": 501.0}, "1000000010": {"state": 514.0}, "1000001000": {"state": 520.0}, "0111110011": {"state": 499.0}, "1000001010": {"state": 522.0}, "0011111111": {"state": 255.0}, "1111111100": {"state": 1020.0}, "1011111110": {"state": 766.0}, "0001000010": {"state": 66.0}, "1111101001": {"state": 1001.0}, "0100000000": {"state": 256.0}, "0000000011": {"state": 3.0}, "0000000111": {"state": 7.0}, "1001000111": {"state": 583.0}, "1000001110": {"state": 526.0}, "1000001011": {"state": 523.0}, "1111111001": {"state": 1017.0}, "0000001010": {"state": 10.0}, "1111100001": {"state": 993.0}, "1110111100": {"state": 956.0}, "1011101110": {"state": 750.0}, "0111110111": {"state": 503.0}, "0000000100": {"state": 4.0}, "0000001110": {"state": 14.0}, "0000000000": {"state": 0.0}, "0111111111": {"state": 511.0}, "1000010101": {"state": 533.0}, "1110100110": {"state": 934.0}, "0011111011": {"state": 251.0}, "1011100010": {"state": 738.0}, "0000001011": {"state": 11.0}, "0000011000": {"state": 24.0}, "1000001001": {"state": 521.0}, "1000000110": {"state": 518.0}, "0000001100": {"state": 12.0}, "1011110101": {"state": 757.0}, "0000010000": {"state": 16.0}, "1000001111": {"state": 527.0}, "1111110100": {"state": 1012.0}, "1111110110": {"state": 1014.0}, "1001000000": {"state": 576.0}, "0111111000": {"state": 504.0}, "1111111011": {"state": 1019.0}, "0000000110": {"state": 6.0}, "0111110110": {"state": 502.0}, "0000001000": {"state": 8.0}, "1111110101": {"state": 1013.0}, "0011110110": {"state": 246.0}, "0111111100": {"state": 508.0}, "1111100011": {"state": 995.0}, "0011110000": {"state": 240.0}, "1000000101": {"state": 517.0}, "0000001111": {"state": 15.0}, "0001001110": {"state": 78.0}, "1000001101": {"state": 525.0}, "0111110100": {"state": 500.0}, "0110110000": {"state": 432.0}, "0111111011": {"state": 507.0}, "1011111101": {"state": 765.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "1111110000": 1, + "1110111100": 2, + "1110101110": 1, + "0111111101": 2, + "1000000000": 2, + "1110111110": 1, + "1111100010": 1, + "0111110000": 3, + "0011110000": 2, + "1111101110": 1, + "1000010110": 1, + "0100001011": 1, + "0000001110": 1, + "0011100100": 1, + "0000000001": 1, + "1111101011": 2, + "0111111010": 4, + "1100000101": 3, + "1000010101": 1, + "1110100110": 2, + "1100001000": 1, + "1000001010": 9, + "0010111110": 1, + "0001000101": 4, + "0000001101": 3, + "0111111000": 3, + "1011111101": 2, + "0111111011": 22, + "0011111110": 1, + "0111110110": 8, + "1010110011": 1, + "0000011100": 6, + "1100000010": 1, + "1000011010": 4, + "0110110010": 1, + "1111100110": 3, + "1000001110": 90, + "0000000111": 180, + "1111111011": 23, + "0000000100": 117, + "1001000000": 14, + "1111110110": 183, + "0111110111": 35, + "1111101100": 18, + "1111111101": 2, + "0111111111": 30, + "0000000000": 4237, + "1111111110": 742, + "1111110011": 7, + "1000001101": 36, + "0100001000": 6, + "1100000110": 2, + "1000000010": 72, + "0111110101": 54, + "1000001000": 17, + "0000001010": 9, + "0111110011": 3, + "1111111100": 334, + "0111110100": 9, + "0011110100": 1, + "0000000011": 138, + "1011110110": 34, + "1000000001": 24, + "0111111100": 5, + "0011110110": 3, + "1111110101": 7, + "0000001000": 1104, + "1011110101": 15, + "1000000110": 38, + "0000001100": 26, + "0000000110": 9, + "0001001110": 3, + "1000000101": 37, + "0000001111": 24, + "1011111110": 142, + "0001000010": 3, + "0100000000": 28, + "1000001001": 27, + "1000001011": 1, + "1111111001": 26, + "0111111001": 2, + "0011111011": 16, + "1111111010": 2, + "0001000110": 1, + "1111110100": 3, + "1000000011": 3, + "0000001011": 108, + "0000011000": 19, + "0111101000": 2, + "1001000011": 3, + "1110100001": 1, + "0110110000": 1, + "1011101110": 1, + "1000011101": 1, + "1000001111": 9, + "0000010000": 2 + }, + "counts_lsb_right": true, + "parsed_states": { + "1111110000": { "state": 1008.0 }, + "1110111100": { "state": 956.0 }, + "1110101110": { "state": 942.0 }, + "0111111101": { "state": 509.0 }, + "1000000000": { "state": 512.0 }, + "1110111110": { "state": 958.0 }, + "1111100010": { "state": 994.0 }, + "0111110000": { "state": 496.0 }, + "0011110000": { "state": 240.0 }, + "1111101110": { "state": 1006.0 }, + "1000010110": { "state": 534.0 }, + "0100001011": { "state": 267.0 }, + "0000001110": { "state": 14.0 }, + "0011100100": { "state": 228.0 }, + "0000000001": { "state": 1.0 }, + "1111101011": { "state": 1003.0 }, + "0111111010": { "state": 506.0 }, + "1100000101": { "state": 773.0 }, + "1000010101": { "state": 533.0 }, + "1110100110": { "state": 934.0 }, + "1100001000": { "state": 776.0 }, + "1000001010": { "state": 522.0 }, + "0010111110": { "state": 190.0 }, + "0001000101": { "state": 69.0 }, + "0000001101": { "state": 13.0 }, + "0111111000": { "state": 504.0 }, + "1011111101": { "state": 765.0 }, + "0111111011": { "state": 507.0 }, + "0011111110": { "state": 254.0 }, + "0111110110": { "state": 502.0 }, + "1010110011": { "state": 691.0 }, + "0000011100": { "state": 28.0 }, + "1100000010": { "state": 770.0 }, + "1000011010": { "state": 538.0 }, + "0110110010": { "state": 434.0 }, + "1111100110": { "state": 998.0 }, + "1000001110": { "state": 526.0 }, + "0000000111": { "state": 7.0 }, + "1111111011": { "state": 1019.0 }, + "0000000100": { "state": 4.0 }, + "1001000000": { "state": 576.0 }, + "1111110110": { "state": 1014.0 }, + "0111110111": { "state": 503.0 }, + "1111101100": { "state": 1004.0 }, + "1111111101": { "state": 1021.0 }, + "0111111111": { "state": 511.0 }, + "0000000000": { "state": 0.0 }, + "1111111110": { "state": 1022.0 }, + "1111110011": { "state": 1011.0 }, + "1000001101": { "state": 525.0 }, + "0100001000": { "state": 264.0 }, + "1100000110": { "state": 774.0 }, + "1000000010": { "state": 514.0 }, + "0111110101": { "state": 501.0 }, + "1000001000": { "state": 520.0 }, + "0000001010": { "state": 10.0 }, + "0111110011": { "state": 499.0 }, + "1111111100": { "state": 1020.0 }, + "0111110100": { "state": 500.0 }, + "0011110100": { "state": 244.0 }, + "0000000011": { "state": 3.0 }, + "1011110110": { "state": 758.0 }, + "1000000001": { "state": 513.0 }, + "0111111100": { "state": 508.0 }, + "0011110110": { "state": 246.0 }, + "1111110101": { "state": 1013.0 }, + "0000001000": { "state": 8.0 }, + "1011110101": { "state": 757.0 }, + "1000000110": { "state": 518.0 }, + "0000001100": { "state": 12.0 }, + "0000000110": { "state": 6.0 }, + "0001001110": { "state": 78.0 }, + "1000000101": { "state": 517.0 }, + "0000001111": { "state": 15.0 }, + "1011111110": { "state": 766.0 }, + "0001000010": { "state": 66.0 }, + "0100000000": { "state": 256.0 }, + "1000001001": { "state": 521.0 }, + "1000001011": { "state": 523.0 }, + "1111111001": { "state": 1017.0 }, + "0111111001": { "state": 505.0 }, + "0011111011": { "state": 251.0 }, + "1111111010": { "state": 1018.0 }, + "0001000110": { "state": 70.0 }, + "1111110100": { "state": 1012.0 }, + "1000000011": { "state": 515.0 }, + "0000001011": { "state": 11.0 }, + "0000011000": { "state": 24.0 }, + "0111101000": { "state": 488.0 }, + "1001000011": { "state": 579.0 }, + "1110100001": { "state": 929.0 }, + "0110110000": { "state": 432.0 }, + "1011101110": { "state": 750.0 }, + "1000011101": { "state": 541.0 }, + "1000001111": { "state": 527.0 }, + "0000010000": { "state": 16.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n-12.json b/algorithms/glued_trees/results/10-qubits/2n-12.json index ef49d009..5e0c2f11 100644 --- a/algorithms/glued_trees/results/10-qubits/2n-12.json +++ b/algorithms/glued_trees/results/10-qubits/2n-12.json @@ -1 +1,116 @@ -{"vendor_format_result": {}, "counts": {"0011111100": 1, "1110100110": 1, "0011111000": 1, "1000000000": 1, "1111111010": 1, "1011110101": 1, "1000000011": 2, "0000000110": 2, "0000011000": 3, "0000001101": 2, "0001000101": 1, "0001001110": 3, "0111101110": 1, "1111111011": 4, "0000010000": 1, "1111110000": 2, "1000010001": 1, "0000000100": 5, "0111111100": 1, "1000000001": 15, "0111110111": 6, "1111111101": 11, "0000001010": 2, "1000001000": 4, "0111110101": 11, "1000000010": 42, "1111111100": 130, "0000001100": 2, "1001000000": 1, "0111111000": 12, "1000001001": 2, "1000001110": 4, "0000000111": 40, "0000000011": 194, "1111110101": 4, "0000001011": 44, "0111111110": 41, "0000000000": 6622, "0111111111": 13, "1011111110": 114, "0100000000": 9, "0111111011": 7, "0000011100": 3, "1111111110": 461, "1000000110": 322, "1000000101": 28, "1000001011": 1, "1011111101": 4, "0001000010": 1, "0111111010": 2, "0111111101": 1, "1111110110": 1, "0000001110": 1, "0011111011": 3}, "counts_lsb_right": true, "parsed_states": {"0011111100": {"state": 252.0}, "1110100110": {"state": 934.0}, "0011111000": {"state": 248.0}, "1000000000": {"state": 512.0}, "1111111010": {"state": 1018.0}, "1011110101": {"state": 757.0}, "1000000011": {"state": 515.0}, "0000000110": {"state": 6.0}, "0000011000": {"state": 24.0}, "0000001101": {"state": 13.0}, "0001000101": {"state": 69.0}, "0001001110": {"state": 78.0}, "0111101110": {"state": 494.0}, "1111111011": {"state": 1019.0}, "0000010000": {"state": 16.0}, "1111110000": {"state": 1008.0}, "1000010001": {"state": 529.0}, "0000000100": {"state": 4.0}, "0111111100": {"state": 508.0}, "1000000001": {"state": 513.0}, "0111110111": {"state": 503.0}, "1111111101": {"state": 1021.0}, "0000001010": {"state": 10.0}, "1000001000": {"state": 520.0}, "0111110101": {"state": 501.0}, "1000000010": {"state": 514.0}, "1111111100": {"state": 1020.0}, "0000001100": {"state": 12.0}, "1001000000": {"state": 576.0}, "0111111000": {"state": 504.0}, "1000001001": {"state": 521.0}, "1000001110": {"state": 526.0}, "0000000111": {"state": 7.0}, "0000000011": {"state": 3.0}, "1111110101": {"state": 1013.0}, "0000001011": {"state": 11.0}, "0111111110": {"state": 510.0}, "0000000000": {"state": 0.0}, "0111111111": {"state": 511.0}, "1011111110": {"state": 766.0}, "0100000000": {"state": 256.0}, "0111111011": {"state": 507.0}, "0000011100": {"state": 28.0}, "1111111110": {"state": 1022.0}, "1000000110": {"state": 518.0}, "1000000101": {"state": 517.0}, "1000001011": {"state": 523.0}, "1011111101": {"state": 765.0}, "0001000010": {"state": 66.0}, "0111111010": {"state": 506.0}, "0111111101": {"state": 509.0}, "1111110110": {"state": 1014.0}, "0000001110": {"state": 14.0}, "0011111011": {"state": 251.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "1011110101": 1, + "1111110010": 1, + "0111110000": 1, + "0000001100": 1, + "0111110100": 2, + "0000001110": 1, + "1111111011": 2, + "0111110111": 4, + "1111111101": 5, + "1001000000": 4, + "0111111000": 13, + "0111111011": 3, + "1100001001": 1, + "1111111010": 2, + "0000000011": 170, + "1000001110": 9, + "0000000111": 36, + "1111111000": 2, + "0111111111": 14, + "1001001011": 1, + "0000000000": 6645, + "1011111110": 93, + "0100000000": 10, + "1111111100": 127, + "1111100010": 1, + "0000011100": 3, + "1000000101": 25, + "1111111110": 469, + "1000000110": 303, + "0111110011": 1, + "1000001000": 3, + "1000000010": 58, + "0111110101": 17, + "1111110111": 1, + "1000000001": 10, + "0000000110": 2, + "0011111000": 2, + "0000011000": 2, + "0111101110": 2, + "0001001110": 7, + "0001000101": 1, + "0000001101": 5, + "1000001001": 6, + "0011111011": 1, + "0111111001": 1, + "1011111101": 7, + "1000001010": 1, + "0000000100": 11, + "0111111110": 40, + "0000001011": 58, + "1111110101": 7 + }, + "counts_lsb_right": true, + "parsed_states": { + "1011110101": { "state": 757.0 }, + "1111110010": { "state": 1010.0 }, + "0111110000": { "state": 496.0 }, + "0000001100": { "state": 12.0 }, + "0111110100": { "state": 500.0 }, + "0000001110": { "state": 14.0 }, + "1111111011": { "state": 1019.0 }, + "0111110111": { "state": 503.0 }, + "1111111101": { "state": 1021.0 }, + "1001000000": { "state": 576.0 }, + "0111111000": { "state": 504.0 }, + "0111111011": { "state": 507.0 }, + "1100001001": { "state": 777.0 }, + "1111111010": { "state": 1018.0 }, + "0000000011": { "state": 3.0 }, + "1000001110": { "state": 526.0 }, + "0000000111": { "state": 7.0 }, + "1111111000": { "state": 1016.0 }, + "0111111111": { "state": 511.0 }, + "1001001011": { "state": 587.0 }, + "0000000000": { "state": 0.0 }, + "1011111110": { "state": 766.0 }, + "0100000000": { "state": 256.0 }, + "1111111100": { "state": 1020.0 }, + "1111100010": { "state": 994.0 }, + "0000011100": { "state": 28.0 }, + "1000000101": { "state": 517.0 }, + "1111111110": { "state": 1022.0 }, + "1000000110": { "state": 518.0 }, + "0111110011": { "state": 499.0 }, + "1000001000": { "state": 520.0 }, + "1000000010": { "state": 514.0 }, + "0111110101": { "state": 501.0 }, + "1111110111": { "state": 1015.0 }, + "1000000001": { "state": 513.0 }, + "0000000110": { "state": 6.0 }, + "0011111000": { "state": 248.0 }, + "0000011000": { "state": 24.0 }, + "0111101110": { "state": 494.0 }, + "0001001110": { "state": 78.0 }, + "0001000101": { "state": 69.0 }, + "0000001101": { "state": 13.0 }, + "1000001001": { "state": 521.0 }, + "0011111011": { "state": 251.0 }, + "0111111001": { "state": 505.0 }, + "1011111101": { "state": 765.0 }, + "1000001010": { "state": 522.0 }, + "0000000100": { "state": 4.0 }, + "0111111110": { "state": 510.0 }, + "0000001011": { "state": 11.0 }, + "1111110101": { "state": 1013.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n-2.json b/algorithms/glued_trees/results/10-qubits/2n-2.json index 69951117..d576d991 100644 --- a/algorithms/glued_trees/results/10-qubits/2n-2.json +++ b/algorithms/glued_trees/results/10-qubits/2n-2.json @@ -1 +1,376 @@ -{"vendor_format_result": {}, "counts": {"0001000111": 1, "0011111010": 1, "0011111000": 1, "1110101101": 1, "0100000011": 1, "1110111000": 1, "0100001011": 1, "0000001100": 1, "1111101010": 1, "0101000110": 1, "1001001111": 1, "0000001001": 1, "1111100011": 1, "0011101011": 1, "0010111110": 1, "1110111100": 1, "0100010111": 2, "0011111100": 3, "1111100001": 7, "1101000100": 1, "0000000001": 3, "1111101110": 1, "1100010110": 1, "0110111100": 3, "1110101010": 5, "1011110001": 1, "1111100010": 3, "1110111010": 1, "1110110010": 1, "1111101011": 1, "1011111100": 1, "1001001011": 1, "1110110111": 4, "0110100011": 10, "1111110110": 418, "1100001000": 19, "0000000101": 1, "1000001100": 10, "1111111100": 414, "1100001110": 49, "0111101000": 6, "0111111111": 115, "1111100100": 2, "1111111111": 27, "1000001011": 9, "0100001100": 5, "1110111110": 24, "0110101000": 28, "0100001111": 19, "0111110110": 240, "0110110110": 11, "0111101001": 17, "0110101110": 2, "0000000000": 272, "1011110010": 28, "0110111000": 2, "1111110010": 76, "1110110100": 4, "1000001001": 191, "0101001110": 3, "1111110011": 214, "1111111110": 1514, "0110100101": 2, "1011110101": 1, "0101001101": 1, "0111101100": 2, "1111101100": 4, "0111111010": 212, "1100000101": 33, "0111110101": 299, "1000001101": 1, "0111110010": 15, "1110100010": 4, "1011110000": 2, "1100001101": 7, "0111111110": 189, "0100000110": 11, "0000000111": 343, "0111110000": 124, "1110100011": 1, "0111111011": 87, "0101001001": 2, "0111110001": 27, "1011111101": 22, "0100000000": 334, "1111111010": 115, "0100000010": 4, "1111110100": 167, "0110110001": 1, "1111111000": 37, "0111111100": 63, "1000000001": 407, "1111111001": 67, "1111110111": 78, "0011110000": 78, "0011111011": 13, "1111110101": 119, "0011110110": 5, "0000001000": 1, "0111111001": 161, "0111110111": 23, "0000001110": 4, "1000000110": 45, "1000000101": 79, "0000001111": 5, "1010111000": 1, "1000001010": 118, "1011111010": 8, "1111110001": 78, "1100001010": 2, "1110110110": 8, "0011100111": 1, "1011110110": 18, "1100000110": 2, "1000000010": 5, "1110100110": 1, "1000001000": 12, "1000010010": 9, "1100000001": 28, "0110110010": 5, "0111101011": 2, "1111110000": 7, "0000000010": 51, "1000000011": 4, "0111111101": 23, "1011111000": 5, "0111110100": 24, "0011110100": 14, "0110101011": 3, "1000011110": 4, "0000000100": 261, "1110101001": 16, "1111101111": 2, "0111100011": 7, "0000010011": 1, "1011111110": 124, "0001000000": 1, "0110101111": 11, "1110110000": 10, "1111111101": 71, "1111111011": 30, "0000010111": 1, "1100001001": 10, "0111111000": 11, "0111100100": 4, "1110110101": 12, "1000000000": 1, "0110111001": 1, "0111100101": 6, "0111110011": 23, "0100001010": 8, "1110111111": 1, "1000001111": 17, "1101000111": 1, "1011101010": 2, "0011110101": 4, "0111100110": 16, "0000001101": 1, "1110101111": 1, "0000000011": 5, "0111001010": 2, "1100000111": 2, "1011100101": 1, "0110101100": 12, "0000000110": 3, "1110100101": 4, "1101000011": 1, "0011110011": 24, "1111101000": 1, "0100000111": 3, "0100001000": 44, "1100000100": 10, "0111101010": 3, "0111100001": 4, "0110110000": 2, "0001001101": 1, "1111101101": 2, "0110110101": 1}, "counts_lsb_right": true, "parsed_states": {"0001000111": {"state": 71.0}, "0011111010": {"state": 250.0}, "0011111000": {"state": 248.0}, "1110101101": {"state": 941.0}, "0100000011": {"state": 259.0}, "1110111000": {"state": 952.0}, "0100001011": {"state": 267.0}, "0000001100": {"state": 12.0}, "1111101010": {"state": 1002.0}, "0101000110": {"state": 326.0}, "1001001111": {"state": 591.0}, "0000001001": {"state": 9.0}, "1111100011": {"state": 995.0}, "0011101011": {"state": 235.0}, "0010111110": {"state": 190.0}, "1110111100": {"state": 956.0}, "0100010111": {"state": 279.0}, "0011111100": {"state": 252.0}, "1111100001": {"state": 993.0}, "1101000100": {"state": 836.0}, "0000000001": {"state": 1.0}, "1111101110": {"state": 1006.0}, "1100010110": {"state": 790.0}, "0110111100": {"state": 444.0}, "1110101010": {"state": 938.0}, "1011110001": {"state": 753.0}, "1111100010": {"state": 994.0}, "1110111010": {"state": 954.0}, "1110110010": {"state": 946.0}, "1111101011": {"state": 1003.0}, "1011111100": {"state": 764.0}, "1001001011": {"state": 587.0}, "1110110111": {"state": 951.0}, "0110100011": {"state": 419.0}, "1111110110": {"state": 1014.0}, "1100001000": {"state": 776.0}, "0000000101": {"state": 5.0}, "1000001100": {"state": 524.0}, "1111111100": {"state": 1020.0}, "1100001110": {"state": 782.0}, "0111101000": {"state": 488.0}, "0111111111": {"state": 511.0}, "1111100100": {"state": 996.0}, "1111111111": {"state": 1023.0}, "1000001011": {"state": 523.0}, "0100001100": {"state": 268.0}, "1110111110": {"state": 958.0}, "0110101000": {"state": 424.0}, "0100001111": {"state": 271.0}, "0111110110": {"state": 502.0}, "0110110110": {"state": 438.0}, "0111101001": {"state": 489.0}, "0110101110": {"state": 430.0}, "0000000000": {"state": 0.0}, "1011110010": {"state": 754.0}, "0110111000": {"state": 440.0}, "1111110010": {"state": 1010.0}, "1110110100": {"state": 948.0}, "1000001001": {"state": 521.0}, "0101001110": {"state": 334.0}, "1111110011": {"state": 1011.0}, "1111111110": {"state": 1022.0}, "0110100101": {"state": 421.0}, "1011110101": {"state": 757.0}, "0101001101": {"state": 333.0}, "0111101100": {"state": 492.0}, "1111101100": {"state": 1004.0}, "0111111010": {"state": 506.0}, "1100000101": {"state": 773.0}, "0111110101": {"state": 501.0}, "1000001101": {"state": 525.0}, "0111110010": {"state": 498.0}, "1110100010": {"state": 930.0}, "1011110000": {"state": 752.0}, "1100001101": {"state": 781.0}, "0111111110": {"state": 510.0}, "0100000110": {"state": 262.0}, "0000000111": {"state": 7.0}, "0111110000": {"state": 496.0}, "1110100011": {"state": 931.0}, "0111111011": {"state": 507.0}, "0101001001": {"state": 329.0}, "0111110001": {"state": 497.0}, "1011111101": {"state": 765.0}, "0100000000": {"state": 256.0}, "1111111010": {"state": 1018.0}, "0100000010": {"state": 258.0}, "1111110100": {"state": 1012.0}, "0110110001": {"state": 433.0}, "1111111000": {"state": 1016.0}, "0111111100": {"state": 508.0}, "1000000001": {"state": 513.0}, "1111111001": {"state": 1017.0}, "1111110111": {"state": 1015.0}, "0011110000": {"state": 240.0}, "0011111011": {"state": 251.0}, "1111110101": {"state": 1013.0}, "0011110110": {"state": 246.0}, "0000001000": {"state": 8.0}, "0111111001": {"state": 505.0}, "0111110111": {"state": 503.0}, "0000001110": {"state": 14.0}, "1000000110": {"state": 518.0}, "1000000101": {"state": 517.0}, "0000001111": {"state": 15.0}, "1010111000": {"state": 696.0}, "1000001010": {"state": 522.0}, "1011111010": {"state": 762.0}, "1111110001": {"state": 1009.0}, "1100001010": {"state": 778.0}, "1110110110": {"state": 950.0}, "0011100111": {"state": 231.0}, "1011110110": {"state": 758.0}, "1100000110": {"state": 774.0}, "1000000010": {"state": 514.0}, "1110100110": {"state": 934.0}, "1000001000": {"state": 520.0}, "1000010010": {"state": 530.0}, "1100000001": {"state": 769.0}, "0110110010": {"state": 434.0}, "0111101011": {"state": 491.0}, "1111110000": {"state": 1008.0}, "0000000010": {"state": 2.0}, "1000000011": {"state": 515.0}, "0111111101": {"state": 509.0}, "1011111000": {"state": 760.0}, "0111110100": {"state": 500.0}, "0011110100": {"state": 244.0}, "0110101011": {"state": 427.0}, "1000011110": {"state": 542.0}, "0000000100": {"state": 4.0}, "1110101001": {"state": 937.0}, "1111101111": {"state": 1007.0}, "0111100011": {"state": 483.0}, "0000010011": {"state": 19.0}, "1011111110": {"state": 766.0}, "0001000000": {"state": 64.0}, "0110101111": {"state": 431.0}, "1110110000": {"state": 944.0}, "1111111101": {"state": 1021.0}, "1111111011": {"state": 1019.0}, "0000010111": {"state": 23.0}, "1100001001": {"state": 777.0}, "0111111000": {"state": 504.0}, "0111100100": {"state": 484.0}, "1110110101": {"state": 949.0}, "1000000000": {"state": 512.0}, "0110111001": {"state": 441.0}, "0111100101": {"state": 485.0}, "0111110011": {"state": 499.0}, "0100001010": {"state": 266.0}, "1110111111": {"state": 959.0}, "1000001111": {"state": 527.0}, "1101000111": {"state": 839.0}, "1011101010": {"state": 746.0}, "0011110101": {"state": 245.0}, "0111100110": {"state": 486.0}, "0000001101": {"state": 13.0}, "1110101111": {"state": 943.0}, "0000000011": {"state": 3.0}, "0111001010": {"state": 458.0}, "1100000111": {"state": 775.0}, "1011100101": {"state": 741.0}, "0110101100": {"state": 428.0}, "0000000110": {"state": 6.0}, "1110100101": {"state": 933.0}, "1101000011": {"state": 835.0}, "0011110011": {"state": 243.0}, "1111101000": {"state": 1000.0}, "0100000111": {"state": 263.0}, "0100001000": {"state": 264.0}, "1100000100": {"state": 772.0}, "0111101010": {"state": 490.0}, "0111100001": {"state": 481.0}, "0110110000": {"state": 432.0}, "0001001101": {"state": 77.0}, "1111101101": {"state": 1005.0}, "0110110101": {"state": 437.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "0011111001": 1, + "1111100000": 1, + "0101001110": 1, + "0110100010": 1, + "0100000011": 1, + "0100010111": 1, + "1111101011": 1, + "1110110111": 2, + "0000010011": 1, + "1100010110": 1, + "1111100111": 2, + "0000000110": 3, + "1001001000": 1, + "0111101100": 1, + "0101001101": 1, + "1011110101": 3, + "1000000010": 4, + "1110111111": 2, + "0011111000": 2, + "1100011110": 1, + "1110101101": 1, + "1110100101": 6, + "1110101010": 3, + "1110100111": 1, + "1110110010": 1, + "1110111010": 2, + "0110111110": 1, + "0000000101": 2, + "0110110011": 1, + "1111101010": 2, + "0011111010": 2, + "1111100001": 6, + "1101000100": 1, + "1111101110": 1, + "0101000100": 1, + "1011111010": 6, + "0100000110": 10, + "1010111100": 1, + "1100001101": 4, + "0111111110": 205, + "0100000000": 354, + "1110111110": 16, + "0110101000": 23, + "1111101100": 7, + "1110100011": 2, + "0111111011": 100, + "0110101011": 2, + "0011110000": 84, + "1111110001": 89, + "0111110000": 141, + "0100001111": 12, + "0111110110": 238, + "1111101001": 2, + "0000011111": 1, + "1011110000": 2, + "1110100010": 4, + "0000001101": 2, + "0111100110": 12, + "1111110101": 129, + "0000001000": 3, + "0011110110": 6, + "0000011000": 3, + "0110110010": 8, + "0111111001": 158, + "0100001100": 3, + "1101001011": 1, + "1011111110": 125, + "1100010100": 1, + "0111110101": 301, + "1000011000": 1, + "0100001001": 2, + "0000000010": 35, + "1000000011": 6, + "1011110110": 25, + "1100001010": 1, + "1110110110": 7, + "1111111001": 86, + "1111110111": 73, + "1000000001": 397, + "0111111101": 10, + "1011111000": 2, + "0111111010": 183, + "1100000101": 28, + "1000000101": 78, + "0000001111": 9, + "0110111100": 2, + "1111111110": 1546, + "1111110011": 205, + "1011111101": 16, + "0111110001": 31, + "0011110100": 11, + "0101000001": 1, + "0111110100": 32, + "1111111100": 401, + "1000001100": 19, + "1110110000": 19, + "0110101111": 13, + "0000000111": 340, + "1111111101": 78, + "1111111011": 33, + "1000010010": 9, + "1100000001": 27, + "1000001000": 15, + "0000000000": 267, + "0111101001": 19, + "1011110010": 23, + "0111111111": 111, + "1111100100": 4, + "1110110100": 1, + "1000001001": 185, + "1111110110": 417, + "0110100011": 5, + "0011111110": 1, + "1000001011": 9, + "1111111111": 19, + "1110110001": 1, + "1100001110": 48, + "0110111000": 1, + "1111110010": 75, + "0110101100": 13, + "0111111000": 24, + "0111100100": 2, + "0110110001": 2, + "0111111100": 59, + "1111111000": 26, + "0110110110": 6, + "1100001000": 13, + "1000001111": 14, + "0100011011": 2, + "0111100011": 6, + "1111111010": 117, + "1111101000": 3, + "0011110011": 19, + "0111101000": 3, + "0110100110": 2, + "0000011100": 2, + "1110101011": 1, + "1111110000": 10, + "0111100111": 1, + "0111100000": 1, + "0100001010": 9, + "0111110011": 17, + "0111100101": 6, + "1000001010": 121, + "0100010100": 3, + "0011111011": 11, + "1011101110": 1, + "0000000001": 7, + "1000000110": 38, + "1011101001": 1, + "0000000011": 5, + "1011101010": 3, + "0011110101": 3, + "1011110100": 2, + "0111101111": 3, + "0111110010": 25, + "1000001101": 3, + "1111110100": 183, + "0100000010": 5, + "0000010111": 1, + "1100001001": 14, + "0000000100": 245, + "1110101001": 9, + "0100001011": 1, + "0011111100": 1, + "1110110101": 18, + "0100000111": 1, + "0100001000": 40, + "1100000100": 13, + "0110110000": 2, + "0111101010": 1, + "0111100001": 3, + "1000010110": 1, + "1110100110": 4, + "1111101101": 5, + "1110111000": 1, + "0110100001": 2, + "0110111011": 1, + "1110100001": 1, + "0111110111": 11, + "0000001110": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "0011111001": { "state": 249.0 }, + "1111100000": { "state": 992.0 }, + "0101001110": { "state": 334.0 }, + "0110100010": { "state": 418.0 }, + "0100000011": { "state": 259.0 }, + "0100010111": { "state": 279.0 }, + "1111101011": { "state": 1003.0 }, + "1110110111": { "state": 951.0 }, + "0000010011": { "state": 19.0 }, + "1100010110": { "state": 790.0 }, + "1111100111": { "state": 999.0 }, + "0000000110": { "state": 6.0 }, + "1001001000": { "state": 584.0 }, + "0111101100": { "state": 492.0 }, + "0101001101": { "state": 333.0 }, + "1011110101": { "state": 757.0 }, + "1000000010": { "state": 514.0 }, + "1110111111": { "state": 959.0 }, + "0011111000": { "state": 248.0 }, + "1100011110": { "state": 798.0 }, + "1110101101": { "state": 941.0 }, + "1110100101": { "state": 933.0 }, + "1110101010": { "state": 938.0 }, + "1110100111": { "state": 935.0 }, + "1110110010": { "state": 946.0 }, + "1110111010": { "state": 954.0 }, + "0110111110": { "state": 446.0 }, + "0000000101": { "state": 5.0 }, + "0110110011": { "state": 435.0 }, + "1111101010": { "state": 1002.0 }, + "0011111010": { "state": 250.0 }, + "1111100001": { "state": 993.0 }, + "1101000100": { "state": 836.0 }, + "1111101110": { "state": 1006.0 }, + "0101000100": { "state": 324.0 }, + "1011111010": { "state": 762.0 }, + "0100000110": { "state": 262.0 }, + "1010111100": { "state": 700.0 }, + "1100001101": { "state": 781.0 }, + "0111111110": { "state": 510.0 }, + "0100000000": { "state": 256.0 }, + "1110111110": { "state": 958.0 }, + "0110101000": { "state": 424.0 }, + "1111101100": { "state": 1004.0 }, + "1110100011": { "state": 931.0 }, + "0111111011": { "state": 507.0 }, + "0110101011": { "state": 427.0 }, + "0011110000": { "state": 240.0 }, + "1111110001": { "state": 1009.0 }, + "0111110000": { "state": 496.0 }, + "0100001111": { "state": 271.0 }, + "0111110110": { "state": 502.0 }, + "1111101001": { "state": 1001.0 }, + "0000011111": { "state": 31.0 }, + "1011110000": { "state": 752.0 }, + "1110100010": { "state": 930.0 }, + "0000001101": { "state": 13.0 }, + "0111100110": { "state": 486.0 }, + "1111110101": { "state": 1013.0 }, + "0000001000": { "state": 8.0 }, + "0011110110": { "state": 246.0 }, + "0000011000": { "state": 24.0 }, + "0110110010": { "state": 434.0 }, + "0111111001": { "state": 505.0 }, + "0100001100": { "state": 268.0 }, + "1101001011": { "state": 843.0 }, + "1011111110": { "state": 766.0 }, + "1100010100": { "state": 788.0 }, + "0111110101": { "state": 501.0 }, + "1000011000": { "state": 536.0 }, + "0100001001": { "state": 265.0 }, + "0000000010": { "state": 2.0 }, + "1000000011": { "state": 515.0 }, + "1011110110": { "state": 758.0 }, + "1100001010": { "state": 778.0 }, + "1110110110": { "state": 950.0 }, + "1111111001": { "state": 1017.0 }, + "1111110111": { "state": 1015.0 }, + "1000000001": { "state": 513.0 }, + "0111111101": { "state": 509.0 }, + "1011111000": { "state": 760.0 }, + "0111111010": { "state": 506.0 }, + "1100000101": { "state": 773.0 }, + "1000000101": { "state": 517.0 }, + "0000001111": { "state": 15.0 }, + "0110111100": { "state": 444.0 }, + "1111111110": { "state": 1022.0 }, + "1111110011": { "state": 1011.0 }, + "1011111101": { "state": 765.0 }, + "0111110001": { "state": 497.0 }, + "0011110100": { "state": 244.0 }, + "0101000001": { "state": 321.0 }, + "0111110100": { "state": 500.0 }, + "1111111100": { "state": 1020.0 }, + "1000001100": { "state": 524.0 }, + "1110110000": { "state": 944.0 }, + "0110101111": { "state": 431.0 }, + "0000000111": { "state": 7.0 }, + "1111111101": { "state": 1021.0 }, + "1111111011": { "state": 1019.0 }, + "1000010010": { "state": 530.0 }, + "1100000001": { "state": 769.0 }, + "1000001000": { "state": 520.0 }, + "0000000000": { "state": 0.0 }, + "0111101001": { "state": 489.0 }, + "1011110010": { "state": 754.0 }, + "0111111111": { "state": 511.0 }, + "1111100100": { "state": 996.0 }, + "1110110100": { "state": 948.0 }, + "1000001001": { "state": 521.0 }, + "1111110110": { "state": 1014.0 }, + "0110100011": { "state": 419.0 }, + "0011111110": { "state": 254.0 }, + "1000001011": { "state": 523.0 }, + "1111111111": { "state": 1023.0 }, + "1110110001": { "state": 945.0 }, + "1100001110": { "state": 782.0 }, + "0110111000": { "state": 440.0 }, + "1111110010": { "state": 1010.0 }, + "0110101100": { "state": 428.0 }, + "0111111000": { "state": 504.0 }, + "0111100100": { "state": 484.0 }, + "0110110001": { "state": 433.0 }, + "0111111100": { "state": 508.0 }, + "1111111000": { "state": 1016.0 }, + "0110110110": { "state": 438.0 }, + "1100001000": { "state": 776.0 }, + "1000001111": { "state": 527.0 }, + "0100011011": { "state": 283.0 }, + "0111100011": { "state": 483.0 }, + "1111111010": { "state": 1018.0 }, + "1111101000": { "state": 1000.0 }, + "0011110011": { "state": 243.0 }, + "0111101000": { "state": 488.0 }, + "0110100110": { "state": 422.0 }, + "0000011100": { "state": 28.0 }, + "1110101011": { "state": 939.0 }, + "1111110000": { "state": 1008.0 }, + "0111100111": { "state": 487.0 }, + "0111100000": { "state": 480.0 }, + "0100001010": { "state": 266.0 }, + "0111110011": { "state": 499.0 }, + "0111100101": { "state": 485.0 }, + "1000001010": { "state": 522.0 }, + "0100010100": { "state": 276.0 }, + "0011111011": { "state": 251.0 }, + "1011101110": { "state": 750.0 }, + "0000000001": { "state": 1.0 }, + "1000000110": { "state": 518.0 }, + "1011101001": { "state": 745.0 }, + "0000000011": { "state": 3.0 }, + "1011101010": { "state": 746.0 }, + "0011110101": { "state": 245.0 }, + "1011110100": { "state": 756.0 }, + "0111101111": { "state": 495.0 }, + "0111110010": { "state": 498.0 }, + "1000001101": { "state": 525.0 }, + "1111110100": { "state": 1012.0 }, + "0100000010": { "state": 258.0 }, + "0000010111": { "state": 23.0 }, + "1100001001": { "state": 777.0 }, + "0000000100": { "state": 4.0 }, + "1110101001": { "state": 937.0 }, + "0100001011": { "state": 267.0 }, + "0011111100": { "state": 252.0 }, + "1110110101": { "state": 949.0 }, + "0100000111": { "state": 263.0 }, + "0100001000": { "state": 264.0 }, + "1100000100": { "state": 772.0 }, + "0110110000": { "state": 432.0 }, + "0111101010": { "state": 490.0 }, + "0111100001": { "state": 481.0 }, + "1000010110": { "state": 534.0 }, + "1110100110": { "state": 934.0 }, + "1111101101": { "state": 1005.0 }, + "1110111000": { "state": 952.0 }, + "0110100001": { "state": 417.0 }, + "0110111011": { "state": 443.0 }, + "1110100001": { "state": 929.0 }, + "0111110111": { "state": 503.0 }, + "0000001110": { "state": 14.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n-4.json b/algorithms/glued_trees/results/10-qubits/2n-4.json index bda72173..a6537404 100644 --- a/algorithms/glued_trees/results/10-qubits/2n-4.json +++ b/algorithms/glued_trees/results/10-qubits/2n-4.json @@ -1 +1,400 @@ -{"vendor_format_result": {}, "counts": {"0110110111": 1, "0111101001": 1, "1111100100": 1, "0110110101": 1, "0100001001": 1, "0000001111": 1, "0100011101": 1, "1110111110": 1, "1100001010": 1, "1001000000": 1, "1100000110": 1, "0000000010": 1, "1110100101": 1, "0000010010": 1, "1001001100": 1, "1000011101": 1, "0100000110": 1, "1000001000": 3, "0111100100": 4, "0111101111": 2, "0110110100": 3, "1010110000": 1, "0000000110": 1, "0110111001": 1, "1001000100": 3, "1000000100": 3, "1100000101": 5, "1000001100": 2, "1111101010": 5, "0000001010": 1, "0110101001": 1, "1111110101": 5, "0011111100": 4, "1111101100": 3, "0100000100": 6, "1011110010": 7, "1000000011": 1, "0110111100": 4, "0011100100": 2, "1111110011": 10, "0110101010": 1, "0010110010": 1, "0110100010": 1, "0100011100": 3, "1110100000": 2, "0110101100": 3, "0111110110": 3, "0100001111": 2, "1011110111": 2, "0010110110": 1, "0011111111": 22, "1111100011": 1, "0000001001": 6, "1000011010": 7, "1111110110": 121, "1111111100": 33, "1111101111": 2, "1000011001": 24, "1000010010": 42, "1100000001": 27, "1111111001": 84, "1111110111": 189, "1000010001": 4, "1110110111": 1, "0111111001": 15, "0111000010": 1, "0011111011": 34, "0111110100": 62, "0010100010": 1, "0110111000": 1, "1111110010": 15, "0000000100": 50, "0111111011": 147, "1110100011": 1, "0111111010": 9, "0111111101": 103, "1001001000": 3, "0111101100": 6, "0111110000": 443, "1011111110": 121, "1110101100": 1, "1111100101": 2, "1011100000": 1, "0100000000": 148, "0000011111": 8, "1111101001": 18, "1111101110": 41, "0111110101": 13, "1000000010": 885, "1011110001": 12, "1000000110": 51, "0111111111": 15, "0011101000": 4, "1001001011": 4, "0110101110": 1, "0000000000": 653, "1011110110": 22, "1100001011": 2, "0111101101": 1, "1000000001": 38, "0011111110": 5, "1000001011": 7, "1111111111": 37, "1111101000": 1, "0011110011": 23, "0001001001": 1, "0001001101": 1, "1111101101": 3, "1011110100": 7, "0000000111": 547, "1000001110": 98, "1111111101": 221, "1111111011": 250, "1111110001": 20, "1000000101": 115, "1111111110": 691, "1011111101": 2, "0111110001": 32, "0000001100": 87, "1101010100": 1, "1100011110": 1, "0011111000": 90, "1111111010": 537, "0000010111": 10, "1100001001": 66, "0111101000": 30, "0001000100": 2, "1101001011": 1, "0111111000": 146, "1110110100": 5, "1000001001": 64, "0000001000": 19, "0011110110": 1, "0110101000": 28, "0111101011": 5, "1100001110": 30, "0110101011": 3, "0111111110": 200, "0001000010": 7, "1011111001": 3, "0100001011": 7, "1110111100": 1, "0100010111": 4, "0111100000": 9, "0111100111": 8, "1011101110": 16, "1111100111": 3, "0010110001": 1, "1111110000": 232, "0000011100": 7, "1001000011": 1, "1111111000": 53, "0111111100": 19, "0000011011": 18, "0111100110": 4, "0000001101": 22, "1001010100": 1, "1100010001": 5, "1100000011": 5, "0110111110": 1, "0000000101": 2, "0000001011": 50, "0110111101": 4, "1111100010": 13, "1110100110": 12, "0100010000": 9, "0000010000": 21, "0110100000": 3, "0111110010": 354, "1000001101": 15, "0001001110": 12, "0011110111": 5, "1110111010": 8, "1110110010": 2, "0000010011": 9, "0100001100": 2, "0111100101": 9, "0111110011": 71, "0100001101": 2, "0100001010": 7, "1011110011": 2, "0011111101": 3, "1011110000": 1, "0010110101": 1, "1111110100": 17, "1110111000": 2, "0111100010": 3, "1100010101": 9, "0111100001": 1, "0100000111": 6, "0100001000": 2, "1100000100": 3, "1110100001": 6, "0110111011": 2, "0111110111": 93, "0000001110": 2, "0110101111": 4, "1110110000": 3}, "counts_lsb_right": true, "parsed_states": {"0110110111": {"state": 439.0}, "0111101001": {"state": 489.0}, "1111100100": {"state": 996.0}, "0110110101": {"state": 437.0}, "0100001001": {"state": 265.0}, "0000001111": {"state": 15.0}, "0100011101": {"state": 285.0}, "1110111110": {"state": 958.0}, "1100001010": {"state": 778.0}, "1001000000": {"state": 576.0}, "1100000110": {"state": 774.0}, "0000000010": {"state": 2.0}, "1110100101": {"state": 933.0}, "0000010010": {"state": 18.0}, "1001001100": {"state": 588.0}, "1000011101": {"state": 541.0}, "0100000110": {"state": 262.0}, "1000001000": {"state": 520.0}, "0111100100": {"state": 484.0}, "0111101111": {"state": 495.0}, "0110110100": {"state": 436.0}, "1010110000": {"state": 688.0}, "0000000110": {"state": 6.0}, "0110111001": {"state": 441.0}, "1001000100": {"state": 580.0}, "1000000100": {"state": 516.0}, "1100000101": {"state": 773.0}, "1000001100": {"state": 524.0}, "1111101010": {"state": 1002.0}, "0000001010": {"state": 10.0}, "0110101001": {"state": 425.0}, "1111110101": {"state": 1013.0}, "0011111100": {"state": 252.0}, "1111101100": {"state": 1004.0}, "0100000100": {"state": 260.0}, "1011110010": {"state": 754.0}, "1000000011": {"state": 515.0}, "0110111100": {"state": 444.0}, "0011100100": {"state": 228.0}, "1111110011": {"state": 1011.0}, "0110101010": {"state": 426.0}, "0010110010": {"state": 178.0}, "0110100010": {"state": 418.0}, "0100011100": {"state": 284.0}, "1110100000": {"state": 928.0}, "0110101100": {"state": 428.0}, "0111110110": {"state": 502.0}, "0100001111": {"state": 271.0}, "1011110111": {"state": 759.0}, "0010110110": {"state": 182.0}, "0011111111": {"state": 255.0}, "1111100011": {"state": 995.0}, "0000001001": {"state": 9.0}, "1000011010": {"state": 538.0}, "1111110110": {"state": 1014.0}, "1111111100": {"state": 1020.0}, "1111101111": {"state": 1007.0}, "1000011001": {"state": 537.0}, "1000010010": {"state": 530.0}, "1100000001": {"state": 769.0}, "1111111001": {"state": 1017.0}, "1111110111": {"state": 1015.0}, "1000010001": {"state": 529.0}, "1110110111": {"state": 951.0}, "0111111001": {"state": 505.0}, "0111000010": {"state": 450.0}, "0011111011": {"state": 251.0}, "0111110100": {"state": 500.0}, "0010100010": {"state": 162.0}, "0110111000": {"state": 440.0}, "1111110010": {"state": 1010.0}, "0000000100": {"state": 4.0}, "0111111011": {"state": 507.0}, "1110100011": {"state": 931.0}, "0111111010": {"state": 506.0}, "0111111101": {"state": 509.0}, "1001001000": {"state": 584.0}, "0111101100": {"state": 492.0}, "0111110000": {"state": 496.0}, "1011111110": {"state": 766.0}, "1110101100": {"state": 940.0}, "1111100101": {"state": 997.0}, "1011100000": {"state": 736.0}, "0100000000": {"state": 256.0}, "0000011111": {"state": 31.0}, "1111101001": {"state": 1001.0}, "1111101110": {"state": 1006.0}, "0111110101": {"state": 501.0}, "1000000010": {"state": 514.0}, "1011110001": {"state": 753.0}, "1000000110": {"state": 518.0}, "0111111111": {"state": 511.0}, "0011101000": {"state": 232.0}, "1001001011": {"state": 587.0}, "0110101110": {"state": 430.0}, "0000000000": {"state": 0.0}, "1011110110": {"state": 758.0}, "1100001011": {"state": 779.0}, "0111101101": {"state": 493.0}, "1000000001": {"state": 513.0}, "0011111110": {"state": 254.0}, "1000001011": {"state": 523.0}, "1111111111": {"state": 1023.0}, "1111101000": {"state": 1000.0}, "0011110011": {"state": 243.0}, "0001001001": {"state": 73.0}, "0001001101": {"state": 77.0}, "1111101101": {"state": 1005.0}, "1011110100": {"state": 756.0}, "0000000111": {"state": 7.0}, "1000001110": {"state": 526.0}, "1111111101": {"state": 1021.0}, "1111111011": {"state": 1019.0}, "1111110001": {"state": 1009.0}, "1000000101": {"state": 517.0}, "1111111110": {"state": 1022.0}, "1011111101": {"state": 765.0}, "0111110001": {"state": 497.0}, "0000001100": {"state": 12.0}, "1101010100": {"state": 852.0}, "1100011110": {"state": 798.0}, "0011111000": {"state": 248.0}, "1111111010": {"state": 1018.0}, "0000010111": {"state": 23.0}, "1100001001": {"state": 777.0}, "0111101000": {"state": 488.0}, "0001000100": {"state": 68.0}, "1101001011": {"state": 843.0}, "0111111000": {"state": 504.0}, "1110110100": {"state": 948.0}, "1000001001": {"state": 521.0}, "0000001000": {"state": 8.0}, "0011110110": {"state": 246.0}, "0110101000": {"state": 424.0}, "0111101011": {"state": 491.0}, "1100001110": {"state": 782.0}, "0110101011": {"state": 427.0}, "0111111110": {"state": 510.0}, "0001000010": {"state": 66.0}, "1011111001": {"state": 761.0}, "0100001011": {"state": 267.0}, "1110111100": {"state": 956.0}, "0100010111": {"state": 279.0}, "0111100000": {"state": 480.0}, "0111100111": {"state": 487.0}, "1011101110": {"state": 750.0}, "1111100111": {"state": 999.0}, "0010110001": {"state": 177.0}, "1111110000": {"state": 1008.0}, "0000011100": {"state": 28.0}, "1001000011": {"state": 579.0}, "1111111000": {"state": 1016.0}, "0111111100": {"state": 508.0}, "0000011011": {"state": 27.0}, "0111100110": {"state": 486.0}, "0000001101": {"state": 13.0}, "1001010100": {"state": 596.0}, "1100010001": {"state": 785.0}, "1100000011": {"state": 771.0}, "0110111110": {"state": 446.0}, "0000000101": {"state": 5.0}, "0000001011": {"state": 11.0}, "0110111101": {"state": 445.0}, "1111100010": {"state": 994.0}, "1110100110": {"state": 934.0}, "0100010000": {"state": 272.0}, "0000010000": {"state": 16.0}, "0110100000": {"state": 416.0}, "0111110010": {"state": 498.0}, "1000001101": {"state": 525.0}, "0001001110": {"state": 78.0}, "0011110111": {"state": 247.0}, "1110111010": {"state": 954.0}, "1110110010": {"state": 946.0}, "0000010011": {"state": 19.0}, "0100001100": {"state": 268.0}, "0111100101": {"state": 485.0}, "0111110011": {"state": 499.0}, "0100001101": {"state": 269.0}, "0100001010": {"state": 266.0}, "1011110011": {"state": 755.0}, "0011111101": {"state": 253.0}, "1011110000": {"state": 752.0}, "0010110101": {"state": 181.0}, "1111110100": {"state": 1012.0}, "1110111000": {"state": 952.0}, "0111100010": {"state": 482.0}, "1100010101": {"state": 789.0}, "0111100001": {"state": 481.0}, "0100000111": {"state": 263.0}, "0100001000": {"state": 264.0}, "1100000100": {"state": 772.0}, "1110100001": {"state": 929.0}, "0110111011": {"state": 443.0}, "0111110111": {"state": 503.0}, "0000001110": {"state": 14.0}, "0110101111": {"state": 431.0}, "1110110000": {"state": 944.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "0110101010": 1, + "0001000101": 1, + "1011111000": 1, + "0110110100": 1, + "0110111111": 1, + "1110111111": 1, + "1001000111": 1, + "0011110110": 1, + "1100010010": 1, + "0100000110": 2, + "1000011101": 1, + "0100000011": 1, + "0111101111": 2, + "0111101011": 3, + "0111101001": 4, + "0100011100": 1, + "1111100000": 2, + "0110110010": 4, + "1110101110": 1, + "1111100110": 1, + "1010111000": 1, + "1111100100": 2, + "1011110011": 2, + "0111110110": 5, + "1011110010": 2, + "1011111010": 1, + "0110100010": 1, + "1000000011": 1, + "1000001000": 1, + "1110101000": 1, + "1111100101": 5, + "0110111100": 3, + "0011111101": 5, + "1111100001": 1, + "0101000010": 1, + "0100010111": 3, + "0110101100": 3, + "1100000010": 4, + "1100011001": 1, + "0100001100": 4, + "1011110100": 3, + "1000001100": 2, + "0000000110": 2, + "1111111110": 643, + "1111110011": 6, + "1011110111": 4, + "0011111111": 22, + "0110110110": 3, + "0110111000": 1, + "1111110010": 27, + "1111110001": 15, + "0100011101": 1, + "1111101010": 8, + "1010111011": 1, + "1011100001": 1, + "0111111010": 9, + "1100000101": 6, + "1011100011": 1, + "0100010000": 8, + "0111111101": 109, + "1001001000": 3, + "1110101001": 3, + "0000000100": 58, + "0100000000": 170, + "1000010001": 1, + "1111110111": 158, + "1111111001": 67, + "1011110110": 30, + "0111101101": 1, + "1100001011": 1, + "1000000001": 40, + "1000000101": 92, + "0000001111": 3, + "1111110110": 114, + "0000010000": 22, + "0111000010": 1, + "0011111011": 46, + "0111111001": 18, + "1111101001": 10, + "0000011111": 5, + "1111110100": 13, + "0110110001": 1, + "1001000011": 2, + "1111111000": 66, + "0111111100": 25, + "0000011011": 16, + "0000001100": 87, + "1000000110": 43, + "1111111100": 36, + "0110101111": 3, + "1100010101": 7, + "1000000010": 1019, + "1100000110": 4, + "0111110000": 433, + "0000010111": 16, + "1100001001": 94, + "1111111010": 523, + "1000001110": 87, + "0000000111": 530, + "0111111000": 166, + "0111100100": 7, + "1110100010": 1, + "1011110000": 5, + "0111101100": 3, + "1111101110": 44, + "1111101100": 2, + "0000000000": 636, + "0111111111": 19, + "1011110001": 2, + "1011100010": 1, + "0011110011": 26, + "0111101000": 35, + "1000001011": 6, + "1111111111": 40, + "1011111110": 116, + "1000010010": 47, + "1100000001": 18, + "0111111011": 122, + "0111110001": 35, + "1011111101": 3, + "1111111101": 243, + "1111111011": 236, + "1001001100": 4, + "0011111000": 99, + "0110101000": 16, + "1110111110": 6, + "0100001011": 8, + "1001001011": 4, + "0011101000": 3, + "1011101110": 11, + "0111110011": 52, + "0111100101": 4, + "0100001010": 5, + "0100001101": 1, + "1110111101": 3, + "0000001011": 43, + "1111100010": 9, + "1110100000": 3, + "1100001110": 36, + "1000000100": 5, + "1001000100": 1, + "0111110100": 48, + "0111100111": 6, + "0111100000": 6, + "0100000100": 6, + "1100001000": 2, + "0000001101": 27, + "0111100110": 9, + "0000001000": 21, + "0111100011": 1, + "1000011001": 16, + "1111101111": 2, + "0000010001": 2, + "0110101011": 3, + "0011110101": 1, + "1111110101": 10, + "1110100100": 1, + "0011111100": 3, + "0110111011": 1, + "0111110111": 90, + "1110100001": 5, + "0111110010": 372, + "1000001101": 14, + "0001000010": 3, + "0111111110": 211, + "1011111001": 6, + "1110110101": 1, + "0001001001": 1, + "1111101101": 5, + "0111100001": 1, + "0100000111": 7, + "0100001000": 9, + "1101000110": 1, + "0000010011": 8, + "0000001001": 4, + "1000011010": 7, + "1000001001": 68, + "1110110100": 4, + "1100000011": 1, + "1100010001": 4, + "0011100100": 2, + "0110100001": 1, + "1110100110": 19, + "1111110000": 221, + "0000011100": 3, + "1110101011": 1, + "0111100010": 3, + "1111100111": 1, + "0001001110": 10, + "0011110111": 6, + "0111110101": 6, + "1110111010": 6, + "1110110010": 2 + }, + "counts_lsb_right": true, + "parsed_states": { + "0110101010": { "state": 426.0 }, + "0001000101": { "state": 69.0 }, + "1011111000": { "state": 760.0 }, + "0110110100": { "state": 436.0 }, + "0110111111": { "state": 447.0 }, + "1110111111": { "state": 959.0 }, + "1001000111": { "state": 583.0 }, + "0011110110": { "state": 246.0 }, + "1100010010": { "state": 786.0 }, + "0100000110": { "state": 262.0 }, + "1000011101": { "state": 541.0 }, + "0100000011": { "state": 259.0 }, + "0111101111": { "state": 495.0 }, + "0111101011": { "state": 491.0 }, + "0111101001": { "state": 489.0 }, + "0100011100": { "state": 284.0 }, + "1111100000": { "state": 992.0 }, + "0110110010": { "state": 434.0 }, + "1110101110": { "state": 942.0 }, + "1111100110": { "state": 998.0 }, + "1010111000": { "state": 696.0 }, + "1111100100": { "state": 996.0 }, + "1011110011": { "state": 755.0 }, + "0111110110": { "state": 502.0 }, + "1011110010": { "state": 754.0 }, + "1011111010": { "state": 762.0 }, + "0110100010": { "state": 418.0 }, + "1000000011": { "state": 515.0 }, + "1000001000": { "state": 520.0 }, + "1110101000": { "state": 936.0 }, + "1111100101": { "state": 997.0 }, + "0110111100": { "state": 444.0 }, + "0011111101": { "state": 253.0 }, + "1111100001": { "state": 993.0 }, + "0101000010": { "state": 322.0 }, + "0100010111": { "state": 279.0 }, + "0110101100": { "state": 428.0 }, + "1100000010": { "state": 770.0 }, + "1100011001": { "state": 793.0 }, + "0100001100": { "state": 268.0 }, + "1011110100": { "state": 756.0 }, + "1000001100": { "state": 524.0 }, + "0000000110": { "state": 6.0 }, + "1111111110": { "state": 1022.0 }, + "1111110011": { "state": 1011.0 }, + "1011110111": { "state": 759.0 }, + "0011111111": { "state": 255.0 }, + "0110110110": { "state": 438.0 }, + "0110111000": { "state": 440.0 }, + "1111110010": { "state": 1010.0 }, + "1111110001": { "state": 1009.0 }, + "0100011101": { "state": 285.0 }, + "1111101010": { "state": 1002.0 }, + "1010111011": { "state": 699.0 }, + "1011100001": { "state": 737.0 }, + "0111111010": { "state": 506.0 }, + "1100000101": { "state": 773.0 }, + "1011100011": { "state": 739.0 }, + "0100010000": { "state": 272.0 }, + "0111111101": { "state": 509.0 }, + "1001001000": { "state": 584.0 }, + "1110101001": { "state": 937.0 }, + "0000000100": { "state": 4.0 }, + "0100000000": { "state": 256.0 }, + "1000010001": { "state": 529.0 }, + "1111110111": { "state": 1015.0 }, + "1111111001": { "state": 1017.0 }, + "1011110110": { "state": 758.0 }, + "0111101101": { "state": 493.0 }, + "1100001011": { "state": 779.0 }, + "1000000001": { "state": 513.0 }, + "1000000101": { "state": 517.0 }, + "0000001111": { "state": 15.0 }, + "1111110110": { "state": 1014.0 }, + "0000010000": { "state": 16.0 }, + "0111000010": { "state": 450.0 }, + "0011111011": { "state": 251.0 }, + "0111111001": { "state": 505.0 }, + "1111101001": { "state": 1001.0 }, + "0000011111": { "state": 31.0 }, + "1111110100": { "state": 1012.0 }, + "0110110001": { "state": 433.0 }, + "1001000011": { "state": 579.0 }, + "1111111000": { "state": 1016.0 }, + "0111111100": { "state": 508.0 }, + "0000011011": { "state": 27.0 }, + "0000001100": { "state": 12.0 }, + "1000000110": { "state": 518.0 }, + "1111111100": { "state": 1020.0 }, + "0110101111": { "state": 431.0 }, + "1100010101": { "state": 789.0 }, + "1000000010": { "state": 514.0 }, + "1100000110": { "state": 774.0 }, + "0111110000": { "state": 496.0 }, + "0000010111": { "state": 23.0 }, + "1100001001": { "state": 777.0 }, + "1111111010": { "state": 1018.0 }, + "1000001110": { "state": 526.0 }, + "0000000111": { "state": 7.0 }, + "0111111000": { "state": 504.0 }, + "0111100100": { "state": 484.0 }, + "1110100010": { "state": 930.0 }, + "1011110000": { "state": 752.0 }, + "0111101100": { "state": 492.0 }, + "1111101110": { "state": 1006.0 }, + "1111101100": { "state": 1004.0 }, + "0000000000": { "state": 0.0 }, + "0111111111": { "state": 511.0 }, + "1011110001": { "state": 753.0 }, + "1011100010": { "state": 738.0 }, + "0011110011": { "state": 243.0 }, + "0111101000": { "state": 488.0 }, + "1000001011": { "state": 523.0 }, + "1111111111": { "state": 1023.0 }, + "1011111110": { "state": 766.0 }, + "1000010010": { "state": 530.0 }, + "1100000001": { "state": 769.0 }, + "0111111011": { "state": 507.0 }, + "0111110001": { "state": 497.0 }, + "1011111101": { "state": 765.0 }, + "1111111101": { "state": 1021.0 }, + "1111111011": { "state": 1019.0 }, + "1001001100": { "state": 588.0 }, + "0011111000": { "state": 248.0 }, + "0110101000": { "state": 424.0 }, + "1110111110": { "state": 958.0 }, + "0100001011": { "state": 267.0 }, + "1001001011": { "state": 587.0 }, + "0011101000": { "state": 232.0 }, + "1011101110": { "state": 750.0 }, + "0111110011": { "state": 499.0 }, + "0111100101": { "state": 485.0 }, + "0100001010": { "state": 266.0 }, + "0100001101": { "state": 269.0 }, + "1110111101": { "state": 957.0 }, + "0000001011": { "state": 11.0 }, + "1111100010": { "state": 994.0 }, + "1110100000": { "state": 928.0 }, + "1100001110": { "state": 782.0 }, + "1000000100": { "state": 516.0 }, + "1001000100": { "state": 580.0 }, + "0111110100": { "state": 500.0 }, + "0111100111": { "state": 487.0 }, + "0111100000": { "state": 480.0 }, + "0100000100": { "state": 260.0 }, + "1100001000": { "state": 776.0 }, + "0000001101": { "state": 13.0 }, + "0111100110": { "state": 486.0 }, + "0000001000": { "state": 8.0 }, + "0111100011": { "state": 483.0 }, + "1000011001": { "state": 537.0 }, + "1111101111": { "state": 1007.0 }, + "0000010001": { "state": 17.0 }, + "0110101011": { "state": 427.0 }, + "0011110101": { "state": 245.0 }, + "1111110101": { "state": 1013.0 }, + "1110100100": { "state": 932.0 }, + "0011111100": { "state": 252.0 }, + "0110111011": { "state": 443.0 }, + "0111110111": { "state": 503.0 }, + "1110100001": { "state": 929.0 }, + "0111110010": { "state": 498.0 }, + "1000001101": { "state": 525.0 }, + "0001000010": { "state": 66.0 }, + "0111111110": { "state": 510.0 }, + "1011111001": { "state": 761.0 }, + "1110110101": { "state": 949.0 }, + "0001001001": { "state": 73.0 }, + "1111101101": { "state": 1005.0 }, + "0111100001": { "state": 481.0 }, + "0100000111": { "state": 263.0 }, + "0100001000": { "state": 264.0 }, + "1101000110": { "state": 838.0 }, + "0000010011": { "state": 19.0 }, + "0000001001": { "state": 9.0 }, + "1000011010": { "state": 538.0 }, + "1000001001": { "state": 521.0 }, + "1110110100": { "state": 948.0 }, + "1100000011": { "state": 771.0 }, + "1100010001": { "state": 785.0 }, + "0011100100": { "state": 228.0 }, + "0110100001": { "state": 417.0 }, + "1110100110": { "state": 934.0 }, + "1111110000": { "state": 1008.0 }, + "0000011100": { "state": 28.0 }, + "1110101011": { "state": 939.0 }, + "0111100010": { "state": 482.0 }, + "1111100111": { "state": 999.0 }, + "0001001110": { "state": 78.0 }, + "0011110111": { "state": 247.0 }, + "0111110101": { "state": 501.0 }, + "1110111010": { "state": 954.0 }, + "1110110010": { "state": 946.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n-6.json b/algorithms/glued_trees/results/10-qubits/2n-6.json index 49a293b8..1a895441 100644 --- a/algorithms/glued_trees/results/10-qubits/2n-6.json +++ b/algorithms/glued_trees/results/10-qubits/2n-6.json @@ -1 +1,378 @@ -{"vendor_format_result": {}, "counts": {"1011111010": 1, "0110111100": 1, "0100000011": 1, "0110100100": 1, "1100010110": 1, "0110110110": 1, "1111100000": 1, "1011110100": 1, "0000001100": 2, "1011101110": 2, "1100011101": 1, "1110100010": 1, "1011110000": 1, "1111111010": 3, "1011110001": 1, "1000001100": 3, "1100001101": 2, "0110101000": 3, "0110101100": 1, "1000000111": 1, "0001000101": 2, "0001000110": 2, "1101001100": 1, "0011101100": 1, "0110111001": 1, "1110110010": 2, "0100011011": 2, "1011110101": 3, "1100011001": 1, "0111101110": 1, "1101001000": 1, "1101000011": 1, "1111100101": 1, "0011101011": 3, "0101000101": 1, "0100000101": 1, "0100011000": 2, "1000000000": 4, "1100001010": 2, "1111100110": 6, "1011100110": 6, "0011110000": 4, "0110110100": 3, "0000000110": 18, "0000001111": 175, "1000000101": 64, "1111101110": 92, "1000001111": 70, "1000011101": 4, "0111111111": 137, "1111100100": 3, "1100001000": 7, "0111111011": 6, "1111100001": 6, "0101000010": 2, "0100000000": 60, "0011111000": 24, "1100000001": 2, "1011110011": 2, "0111110110": 147, "0100001111": 7, "1110101010": 4, "1000001011": 2, "1111111111": 30, "1001001101": 1, "0010111101": 1, "0011110110": 17, "0000001000": 455, "1111110101": 17, "1000001010": 246, "0111110101": 62, "1000000010": 8, "1100000110": 12, "1000000110": 309, "0110110010": 1, "0000011000": 13, "1111100010": 1, "0000001011": 68, "1111110111": 1, "1111111001": 315, "1000001001": 186, "1100001001": 14, "0000010111": 97, "0111111000": 194, "1000001110": 68, "0011100110": 1, "1001000111": 1, "0000000111": 800, "0000011010": 1, "1111111100": 123, "0110101111": 1, "0000010001": 1, "1000011001": 9, "0000000000": 640, "1000000001": 110, "1011110110": 65, "0111111101": 9, "1011100001": 1, "0111111010": 7, "0011111011": 23, "0111111001": 20, "1111111110": 1004, "1111110011": 16, "1011111101": 61, "0111110001": 17, "1100011010": 1, "1000000100": 3, "1001000100": 4, "0110100111": 4, "1111110110": 289, "1001000000": 12, "0110100011": 1, "1110101110": 9, "0000011101": 1, "1011111110": 120, "1110100110": 11, "0000011011": 6, "1111111000": 99, "0111111100": 56, "0111101000": 11, "0111110100": 11, "0000010000": 95, "0011110100": 6, "0110100110": 1, "0000011100": 7, "1111110000": 14, "0111110000": 49, "1111101010": 2, "0000001010": 15, "0001000010": 2, "0111111110": 382, "1011111001": 4, "0011110101": 3, "0111100001": 1, "1100000100": 1, "0110110000": 1, "0100000111": 21, "0100001000": 35, "0000000011": 17, "1000010101": 3, "0011111100": 6, "0100001101": 1, "0111110011": 51, "0000010100": 20, "0100001010": 3, "0001001010": 1, "0011111111": 19, "1111111011": 210, "1111111101": 19, "1111101100": 2, "1000010110": 15, "1110111001": 1, "0000000101": 1, "0110111110": 3, "1001010000": 1, "0100010111": 1, "1110111100": 8, "1111110001": 3, "1011101101": 1, "0111100110": 11, "0000001101": 14, "1001010100": 1, "0110110101": 2, "1111101001": 17, "0000011111": 7, "1100001110": 2, "0111100000": 10, "0111101111": 5, "0000010010": 4, "1100000101": 18, "1000011111": 5, "0000000100": 315, "1110101001": 1, "0000000010": 42, "1110111110": 4, "1111110010": 20, "0100010000": 2, "1000001101": 70, "0111110010": 5, "0011101000": 4, "0001001110": 6, "0011110111": 2, "0000001001": 1, "1111100011": 6, "1000011010": 5, "0100001011": 4, "0000000001": 6, "1110100001": 1, "0111110111": 1}, "counts_lsb_right": true, "parsed_states": {"1011111010": {"state": 762.0}, "0110111100": {"state": 444.0}, "0100000011": {"state": 259.0}, "0110100100": {"state": 420.0}, "1100010110": {"state": 790.0}, "0110110110": {"state": 438.0}, "1111100000": {"state": 992.0}, "1011110100": {"state": 756.0}, "0000001100": {"state": 12.0}, "1011101110": {"state": 750.0}, "1100011101": {"state": 797.0}, "1110100010": {"state": 930.0}, "1011110000": {"state": 752.0}, "1111111010": {"state": 1018.0}, "1011110001": {"state": 753.0}, "1000001100": {"state": 524.0}, "1100001101": {"state": 781.0}, "0110101000": {"state": 424.0}, "0110101100": {"state": 428.0}, "1000000111": {"state": 519.0}, "0001000101": {"state": 69.0}, "0001000110": {"state": 70.0}, "1101001100": {"state": 844.0}, "0011101100": {"state": 236.0}, "0110111001": {"state": 441.0}, "1110110010": {"state": 946.0}, "0100011011": {"state": 283.0}, "1011110101": {"state": 757.0}, "1100011001": {"state": 793.0}, "0111101110": {"state": 494.0}, "1101001000": {"state": 840.0}, "1101000011": {"state": 835.0}, "1111100101": {"state": 997.0}, "0011101011": {"state": 235.0}, "0101000101": {"state": 325.0}, "0100000101": {"state": 261.0}, "0100011000": {"state": 280.0}, "1000000000": {"state": 512.0}, "1100001010": {"state": 778.0}, "1111100110": {"state": 998.0}, "1011100110": {"state": 742.0}, "0011110000": {"state": 240.0}, "0110110100": {"state": 436.0}, "0000000110": {"state": 6.0}, "0000001111": {"state": 15.0}, "1000000101": {"state": 517.0}, "1111101110": {"state": 1006.0}, "1000001111": {"state": 527.0}, "1000011101": {"state": 541.0}, "0111111111": {"state": 511.0}, "1111100100": {"state": 996.0}, "1100001000": {"state": 776.0}, "0111111011": {"state": 507.0}, "1111100001": {"state": 993.0}, "0101000010": {"state": 322.0}, "0100000000": {"state": 256.0}, "0011111000": {"state": 248.0}, "1100000001": {"state": 769.0}, "1011110011": {"state": 755.0}, "0111110110": {"state": 502.0}, "0100001111": {"state": 271.0}, "1110101010": {"state": 938.0}, "1000001011": {"state": 523.0}, "1111111111": {"state": 1023.0}, "1001001101": {"state": 589.0}, "0010111101": {"state": 189.0}, "0011110110": {"state": 246.0}, "0000001000": {"state": 8.0}, "1111110101": {"state": 1013.0}, "1000001010": {"state": 522.0}, "0111110101": {"state": 501.0}, "1000000010": {"state": 514.0}, "1100000110": {"state": 774.0}, "1000000110": {"state": 518.0}, "0110110010": {"state": 434.0}, "0000011000": {"state": 24.0}, "1111100010": {"state": 994.0}, "0000001011": {"state": 11.0}, "1111110111": {"state": 1015.0}, "1111111001": {"state": 1017.0}, "1000001001": {"state": 521.0}, "1100001001": {"state": 777.0}, "0000010111": {"state": 23.0}, "0111111000": {"state": 504.0}, "1000001110": {"state": 526.0}, "0011100110": {"state": 230.0}, "1001000111": {"state": 583.0}, "0000000111": {"state": 7.0}, "0000011010": {"state": 26.0}, "1111111100": {"state": 1020.0}, "0110101111": {"state": 431.0}, "0000010001": {"state": 17.0}, "1000011001": {"state": 537.0}, "0000000000": {"state": 0.0}, "1000000001": {"state": 513.0}, "1011110110": {"state": 758.0}, "0111111101": {"state": 509.0}, "1011100001": {"state": 737.0}, "0111111010": {"state": 506.0}, "0011111011": {"state": 251.0}, "0111111001": {"state": 505.0}, "1111111110": {"state": 1022.0}, "1111110011": {"state": 1011.0}, "1011111101": {"state": 765.0}, "0111110001": {"state": 497.0}, "1100011010": {"state": 794.0}, "1000000100": {"state": 516.0}, "1001000100": {"state": 580.0}, "0110100111": {"state": 423.0}, "1111110110": {"state": 1014.0}, "1001000000": {"state": 576.0}, "0110100011": {"state": 419.0}, "1110101110": {"state": 942.0}, "0000011101": {"state": 29.0}, "1011111110": {"state": 766.0}, "1110100110": {"state": 934.0}, "0000011011": {"state": 27.0}, "1111111000": {"state": 1016.0}, "0111111100": {"state": 508.0}, "0111101000": {"state": 488.0}, "0111110100": {"state": 500.0}, "0000010000": {"state": 16.0}, "0011110100": {"state": 244.0}, "0110100110": {"state": 422.0}, "0000011100": {"state": 28.0}, "1111110000": {"state": 1008.0}, "0111110000": {"state": 496.0}, "1111101010": {"state": 1002.0}, "0000001010": {"state": 10.0}, "0001000010": {"state": 66.0}, "0111111110": {"state": 510.0}, "1011111001": {"state": 761.0}, "0011110101": {"state": 245.0}, "0111100001": {"state": 481.0}, "1100000100": {"state": 772.0}, "0110110000": {"state": 432.0}, "0100000111": {"state": 263.0}, "0100001000": {"state": 264.0}, "0000000011": {"state": 3.0}, "1000010101": {"state": 533.0}, "0011111100": {"state": 252.0}, "0100001101": {"state": 269.0}, "0111110011": {"state": 499.0}, "0000010100": {"state": 20.0}, "0100001010": {"state": 266.0}, "0001001010": {"state": 74.0}, "0011111111": {"state": 255.0}, "1111111011": {"state": 1019.0}, "1111111101": {"state": 1021.0}, "1111101100": {"state": 1004.0}, "1000010110": {"state": 534.0}, "1110111001": {"state": 953.0}, "0000000101": {"state": 5.0}, "0110111110": {"state": 446.0}, "1001010000": {"state": 592.0}, "0100010111": {"state": 279.0}, "1110111100": {"state": 956.0}, "1111110001": {"state": 1009.0}, "1011101101": {"state": 749.0}, "0111100110": {"state": 486.0}, "0000001101": {"state": 13.0}, "1001010100": {"state": 596.0}, "0110110101": {"state": 437.0}, "1111101001": {"state": 1001.0}, "0000011111": {"state": 31.0}, "1100001110": {"state": 782.0}, "0111100000": {"state": 480.0}, "0111101111": {"state": 495.0}, "0000010010": {"state": 18.0}, "1100000101": {"state": 773.0}, "1000011111": {"state": 543.0}, "0000000100": {"state": 4.0}, "1110101001": {"state": 937.0}, "0000000010": {"state": 2.0}, "1110111110": {"state": 958.0}, "1111110010": {"state": 1010.0}, "0100010000": {"state": 272.0}, "1000001101": {"state": 525.0}, "0111110010": {"state": 498.0}, "0011101000": {"state": 232.0}, "0001001110": {"state": 78.0}, "0011110111": {"state": 247.0}, "0000001001": {"state": 9.0}, "1111100011": {"state": 995.0}, "1000011010": {"state": 538.0}, "0100001011": {"state": 267.0}, "0000000001": {"state": 1.0}, "1110100001": {"state": 929.0}, "0111110111": {"state": 503.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "0001000110": 1, + "0110101001": 1, + "0110101011": 1, + "1011101001": 1, + "1001010001": 1, + "0110110110": 1, + "1011101110": 1, + "0110101000": 1, + "1001001100": 1, + "0110100011": 1, + "0110101100": 2, + "1111100000": 1, + "0110110101": 2, + "0000001010": 1, + "1111101010": 1, + "1110100110": 3, + "0100010000": 2, + "1111110001": 1, + "1100001110": 6, + "0100011011": 1, + "1100011101": 2, + "1111100101": 2, + "0100000010": 1, + "1111110100": 3, + "0000010010": 3, + "0110111110": 1, + "0000000101": 3, + "0111111011": 2, + "1110111110": 6, + "0001001001": 1, + "1111101101": 2, + "1010110100": 1, + "0111101011": 1, + "0111111101": 10, + "1000000010": 1, + "0010110101": 1, + "0001000101": 3, + "0000000001": 2, + "0000001011": 58, + "0100000000": 54, + "0100001011": 6, + "1010111011": 1, + "0111111010": 8, + "0100001100": 1, + "1100011001": 2, + "0111101110": 3, + "0111111001": 13, + "0000001000": 497, + "1111110101": 9, + "0011110110": 16, + "1111110011": 11, + "1111111110": 1006, + "0000011010": 2, + "1111111100": 126, + "1000001100": 4, + "0111110001": 27, + "1011111101": 47, + "1111111111": 16, + "1000001011": 4, + "1111111001": 248, + "1100000101": 15, + "1000011111": 2, + "0111110000": 44, + "1000011101": 9, + "1000001111": 62, + "1000010101": 5, + "0011111100": 4, + "1000010110": 17, + "1111110010": 18, + "0000000010": 59, + "1000000011": 1, + "0000001111": 158, + "1000000101": 61, + "0001001110": 7, + "1111100111": 2, + "0111111111": 112, + "1111100100": 3, + "0000000000": 693, + "1111101110": 103, + "0111110110": 147, + "0100001111": 8, + "0011111000": 27, + "0111110101": 76, + "0111101101": 1, + "1000000001": 112, + "1100001101": 3, + "0011101011": 5, + "1000001110": 71, + "0000000111": 831, + "1000001001": 187, + "0000010110": 1, + "1100001001": 9, + "0000010111": 87, + "0100011111": 2, + "1000001101": 69, + "0111110010": 13, + "0111111000": 220, + "1111110110": 283, + "1001000000": 13, + "0111101010": 1, + "0111100001": 2, + "0100001000": 51, + "0100000111": 8, + "0011110101": 6, + "0001011110": 1, + "1001010000": 1, + "1110111100": 11, + "0100010111": 1, + "1110101001": 2, + "0000000100": 353, + "1000000110": 311, + "1011110101": 2, + "0000001100": 2, + "0100000101": 2, + "1011111110": 114, + "0000010000": 101, + "0011110100": 6, + "0111110100": 8, + "1110101110": 7, + "1011110110": 62, + "1110110110": 2, + "1000010010": 1, + "1111100110": 6, + "0000011000": 12, + "0110110010": 3, + "0001001010": 2, + "0011111111": 14, + "1100000110": 10, + "0011111011": 24, + "1100001000": 5, + "0000000011": 14, + "0111101111": 10, + "0011100000": 3, + "1000011001": 6, + "0111100110": 5, + "0000001101": 7, + "0011110000": 6, + "1111111010": 4, + "0000011100": 4, + "0110100110": 2, + "1111110000": 14, + "1111111011": 198, + "1111111101": 25, + "1111101100": 1, + "1110110010": 2, + "1110111010": 1, + "0011101000": 2, + "1001001011": 2, + "0111101000": 7, + "0101000110": 1, + "1110100001": 1, + "0000001110": 3, + "0111110111": 5, + "1000001010": 220, + "0100010100": 1, + "0111111110": 409, + "1011111001": 3, + "1011100110": 10, + "1110101010": 4, + "1111111000": 120, + "0111111100": 41, + "0000011011": 1, + "0111100000": 8, + "1011100100": 1, + "0110111100": 2, + "0110100111": 2, + "1000000100": 2, + "1001000100": 6, + "1111101001": 13, + "0000011111": 11, + "1111100011": 7, + "1000011010": 4, + "0100011000": 7, + "1000000000": 4, + "1011101101": 5, + "0111110011": 43, + "0000010100": 18, + "0100001010": 3, + "0011101100": 4, + "0110111001": 2, + "0000000110": 9, + "1111100001": 4 + }, + "counts_lsb_right": true, + "parsed_states": { + "0001000110": { "state": 70.0 }, + "0110101001": { "state": 425.0 }, + "0110101011": { "state": 427.0 }, + "1011101001": { "state": 745.0 }, + "1001010001": { "state": 593.0 }, + "0110110110": { "state": 438.0 }, + "1011101110": { "state": 750.0 }, + "0110101000": { "state": 424.0 }, + "1001001100": { "state": 588.0 }, + "0110100011": { "state": 419.0 }, + "0110101100": { "state": 428.0 }, + "1111100000": { "state": 992.0 }, + "0110110101": { "state": 437.0 }, + "0000001010": { "state": 10.0 }, + "1111101010": { "state": 1002.0 }, + "1110100110": { "state": 934.0 }, + "0100010000": { "state": 272.0 }, + "1111110001": { "state": 1009.0 }, + "1100001110": { "state": 782.0 }, + "0100011011": { "state": 283.0 }, + "1100011101": { "state": 797.0 }, + "1111100101": { "state": 997.0 }, + "0100000010": { "state": 258.0 }, + "1111110100": { "state": 1012.0 }, + "0000010010": { "state": 18.0 }, + "0110111110": { "state": 446.0 }, + "0000000101": { "state": 5.0 }, + "0111111011": { "state": 507.0 }, + "1110111110": { "state": 958.0 }, + "0001001001": { "state": 73.0 }, + "1111101101": { "state": 1005.0 }, + "1010110100": { "state": 692.0 }, + "0111101011": { "state": 491.0 }, + "0111111101": { "state": 509.0 }, + "1000000010": { "state": 514.0 }, + "0010110101": { "state": 181.0 }, + "0001000101": { "state": 69.0 }, + "0000000001": { "state": 1.0 }, + "0000001011": { "state": 11.0 }, + "0100000000": { "state": 256.0 }, + "0100001011": { "state": 267.0 }, + "1010111011": { "state": 699.0 }, + "0111111010": { "state": 506.0 }, + "0100001100": { "state": 268.0 }, + "1100011001": { "state": 793.0 }, + "0111101110": { "state": 494.0 }, + "0111111001": { "state": 505.0 }, + "0000001000": { "state": 8.0 }, + "1111110101": { "state": 1013.0 }, + "0011110110": { "state": 246.0 }, + "1111110011": { "state": 1011.0 }, + "1111111110": { "state": 1022.0 }, + "0000011010": { "state": 26.0 }, + "1111111100": { "state": 1020.0 }, + "1000001100": { "state": 524.0 }, + "0111110001": { "state": 497.0 }, + "1011111101": { "state": 765.0 }, + "1111111111": { "state": 1023.0 }, + "1000001011": { "state": 523.0 }, + "1111111001": { "state": 1017.0 }, + "1100000101": { "state": 773.0 }, + "1000011111": { "state": 543.0 }, + "0111110000": { "state": 496.0 }, + "1000011101": { "state": 541.0 }, + "1000001111": { "state": 527.0 }, + "1000010101": { "state": 533.0 }, + "0011111100": { "state": 252.0 }, + "1000010110": { "state": 534.0 }, + "1111110010": { "state": 1010.0 }, + "0000000010": { "state": 2.0 }, + "1000000011": { "state": 515.0 }, + "0000001111": { "state": 15.0 }, + "1000000101": { "state": 517.0 }, + "0001001110": { "state": 78.0 }, + "1111100111": { "state": 999.0 }, + "0111111111": { "state": 511.0 }, + "1111100100": { "state": 996.0 }, + "0000000000": { "state": 0.0 }, + "1111101110": { "state": 1006.0 }, + "0111110110": { "state": 502.0 }, + "0100001111": { "state": 271.0 }, + "0011111000": { "state": 248.0 }, + "0111110101": { "state": 501.0 }, + "0111101101": { "state": 493.0 }, + "1000000001": { "state": 513.0 }, + "1100001101": { "state": 781.0 }, + "0011101011": { "state": 235.0 }, + "1000001110": { "state": 526.0 }, + "0000000111": { "state": 7.0 }, + "1000001001": { "state": 521.0 }, + "0000010110": { "state": 22.0 }, + "1100001001": { "state": 777.0 }, + "0000010111": { "state": 23.0 }, + "0100011111": { "state": 287.0 }, + "1000001101": { "state": 525.0 }, + "0111110010": { "state": 498.0 }, + "0111111000": { "state": 504.0 }, + "1111110110": { "state": 1014.0 }, + "1001000000": { "state": 576.0 }, + "0111101010": { "state": 490.0 }, + "0111100001": { "state": 481.0 }, + "0100001000": { "state": 264.0 }, + "0100000111": { "state": 263.0 }, + "0011110101": { "state": 245.0 }, + "0001011110": { "state": 94.0 }, + "1001010000": { "state": 592.0 }, + "1110111100": { "state": 956.0 }, + "0100010111": { "state": 279.0 }, + "1110101001": { "state": 937.0 }, + "0000000100": { "state": 4.0 }, + "1000000110": { "state": 518.0 }, + "1011110101": { "state": 757.0 }, + "0000001100": { "state": 12.0 }, + "0100000101": { "state": 261.0 }, + "1011111110": { "state": 766.0 }, + "0000010000": { "state": 16.0 }, + "0011110100": { "state": 244.0 }, + "0111110100": { "state": 500.0 }, + "1110101110": { "state": 942.0 }, + "1011110110": { "state": 758.0 }, + "1110110110": { "state": 950.0 }, + "1000010010": { "state": 530.0 }, + "1111100110": { "state": 998.0 }, + "0000011000": { "state": 24.0 }, + "0110110010": { "state": 434.0 }, + "0001001010": { "state": 74.0 }, + "0011111111": { "state": 255.0 }, + "1100000110": { "state": 774.0 }, + "0011111011": { "state": 251.0 }, + "1100001000": { "state": 776.0 }, + "0000000011": { "state": 3.0 }, + "0111101111": { "state": 495.0 }, + "0011100000": { "state": 224.0 }, + "1000011001": { "state": 537.0 }, + "0111100110": { "state": 486.0 }, + "0000001101": { "state": 13.0 }, + "0011110000": { "state": 240.0 }, + "1111111010": { "state": 1018.0 }, + "0000011100": { "state": 28.0 }, + "0110100110": { "state": 422.0 }, + "1111110000": { "state": 1008.0 }, + "1111111011": { "state": 1019.0 }, + "1111111101": { "state": 1021.0 }, + "1111101100": { "state": 1004.0 }, + "1110110010": { "state": 946.0 }, + "1110111010": { "state": 954.0 }, + "0011101000": { "state": 232.0 }, + "1001001011": { "state": 587.0 }, + "0111101000": { "state": 488.0 }, + "0101000110": { "state": 326.0 }, + "1110100001": { "state": 929.0 }, + "0000001110": { "state": 14.0 }, + "0111110111": { "state": 503.0 }, + "1000001010": { "state": 522.0 }, + "0100010100": { "state": 276.0 }, + "0111111110": { "state": 510.0 }, + "1011111001": { "state": 761.0 }, + "1011100110": { "state": 742.0 }, + "1110101010": { "state": 938.0 }, + "1111111000": { "state": 1016.0 }, + "0111111100": { "state": 508.0 }, + "0000011011": { "state": 27.0 }, + "0111100000": { "state": 480.0 }, + "1011100100": { "state": 740.0 }, + "0110111100": { "state": 444.0 }, + "0110100111": { "state": 423.0 }, + "1000000100": { "state": 516.0 }, + "1001000100": { "state": 580.0 }, + "1111101001": { "state": 1001.0 }, + "0000011111": { "state": 31.0 }, + "1111100011": { "state": 995.0 }, + "1000011010": { "state": 538.0 }, + "0100011000": { "state": 280.0 }, + "1000000000": { "state": 512.0 }, + "1011101101": { "state": 749.0 }, + "0111110011": { "state": 499.0 }, + "0000010100": { "state": 20.0 }, + "0100001010": { "state": 266.0 }, + "0011101100": { "state": 236.0 }, + "0110111001": { "state": 441.0 }, + "0000000110": { "state": 6.0 }, + "1111100001": { "state": 993.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/10-qubits/2n-8.json b/algorithms/glued_trees/results/10-qubits/2n-8.json index 223d0024..e043e42e 100644 --- a/algorithms/glued_trees/results/10-qubits/2n-8.json +++ b/algorithms/glued_trees/results/10-qubits/2n-8.json @@ -1 +1,302 @@ -{"vendor_format_result": {}, "counts": {"1111100100": 1, "1000001100": 1, "0111100111": 1, "0010111001": 1, "0111110100": 1, "0001000110": 1, "0100001110": 1, "1011110001": 1, "0111100010": 1, "1000001010": 4, "0010111110": 1, "0000001111": 35, "0001001110": 1, "1000000101": 101, "1000010110": 23, "0100001000": 3, "1111111110": 846, "1111110011": 12, "0111111111": 12, "0111101000": 10, "0100000011": 4, "0000011000": 23, "1111101100": 10, "1111101110": 22, "1111111101": 15, "1111111011": 61, "1000010010": 5, "1111110110": 38, "1001000000": 32, "0111110111": 52, "0000001110": 88, "1000000111": 2, "0000010111": 25, "0000000011": 27, "1011110110": 13, "1000000001": 250, "0110111101": 1, "0000001100": 6, "1000000110": 1475, "0000000100": 401, "1000011110": 4, "0111101100": 1, "1011110101": 2, "0000001000": 347, "0011111000": 60, "1111111100": 182, "0000000010": 4, "1000000011": 6, "0110111000": 3, "1111110010": 7, "1011111110": 144, "0100000000": 38, "0111110110": 8, "1000001001": 4, "1110110100": 1, "0111111011": 65, "0111110001": 1, "1011111101": 6, "1111110100": 41, "0000011111": 5, "1110100110": 4, "1110111100": 3, "1001010000": 1, "1111100110": 11, "0111101011": 3, "0000000111": 611, "0111111000": 487, "0000010000": 31, "1000011101": 3, "1000001111": 3, "1000001000": 25, "1111111001": 79, "1000010001": 2, "1100000110": 31, "1000000010": 42, "0000001010": 23, "1111100001": 3, "0111111001": 49, "1000010000": 2, "1111110001": 6, "1001000111": 1, "1000001110": 12, "1110111110": 4, "1111101101": 1, "0001001101": 5, "0111111101": 26, "0111100110": 2, "0000001101": 14, "1110111011": 3, "1000010101": 10, "0011111100": 4, "0000000000": 1554, "0110101110": 1, "1000011000": 3, "1111111010": 10, "1000000000": 10, "0111110000": 1, "0111110101": 1, "0111101110": 3, "1100000101": 2, "1010111011": 1, "0111111010": 1, "1000000100": 4, "1001000100": 2, "0111101001": 2, "0110100111": 1, "1111110000": 14, "0000011100": 1, "0110101100": 2, "1111100011": 1, "0000001001": 6, "1011111010": 1, "0001000101": 7, "0110100000": 3, "0011111110": 1, "1111111111": 1, "0111100000": 5, "1111100000": 1, "1011101110": 3, "0011111011": 42, "0111000010": 1, "0111101111": 1, "0001001000": 1, "0001000010": 3, "0111111110": 368, "1011111001": 1, "1000001101": 3, "0111110010": 3, "1110111001": 1, "0000000101": 13, "0110111110": 1, "0000011011": 1, "0111111100": 52, "1001000011": 2, "0000010100": 12, "0111110011": 2, "0100001010": 1, "0011110000": 1, "0011101000": 3, "1011111100": 1}, "counts_lsb_right": true, "parsed_states": {"1111100100": {"state": 996.0}, "1000001100": {"state": 524.0}, "0111100111": {"state": 487.0}, "0010111001": {"state": 185.0}, "0111110100": {"state": 500.0}, "0001000110": {"state": 70.0}, "0100001110": {"state": 270.0}, "1011110001": {"state": 753.0}, "0111100010": {"state": 482.0}, "1000001010": {"state": 522.0}, "0010111110": {"state": 190.0}, "0000001111": {"state": 15.0}, "0001001110": {"state": 78.0}, "1000000101": {"state": 517.0}, "1000010110": {"state": 534.0}, "0100001000": {"state": 264.0}, "1111111110": {"state": 1022.0}, "1111110011": {"state": 1011.0}, "0111111111": {"state": 511.0}, "0111101000": {"state": 488.0}, "0100000011": {"state": 259.0}, "0000011000": {"state": 24.0}, "1111101100": {"state": 1004.0}, "1111101110": {"state": 1006.0}, "1111111101": {"state": 1021.0}, "1111111011": {"state": 1019.0}, "1000010010": {"state": 530.0}, "1111110110": {"state": 1014.0}, "1001000000": {"state": 576.0}, "0111110111": {"state": 503.0}, "0000001110": {"state": 14.0}, "1000000111": {"state": 519.0}, "0000010111": {"state": 23.0}, "0000000011": {"state": 3.0}, "1011110110": {"state": 758.0}, "1000000001": {"state": 513.0}, "0110111101": {"state": 445.0}, "0000001100": {"state": 12.0}, "1000000110": {"state": 518.0}, "0000000100": {"state": 4.0}, "1000011110": {"state": 542.0}, "0111101100": {"state": 492.0}, "1011110101": {"state": 757.0}, "0000001000": {"state": 8.0}, "0011111000": {"state": 248.0}, "1111111100": {"state": 1020.0}, "0000000010": {"state": 2.0}, "1000000011": {"state": 515.0}, "0110111000": {"state": 440.0}, "1111110010": {"state": 1010.0}, "1011111110": {"state": 766.0}, "0100000000": {"state": 256.0}, "0111110110": {"state": 502.0}, "1000001001": {"state": 521.0}, "1110110100": {"state": 948.0}, "0111111011": {"state": 507.0}, "0111110001": {"state": 497.0}, "1011111101": {"state": 765.0}, "1111110100": {"state": 1012.0}, "0000011111": {"state": 31.0}, "1110100110": {"state": 934.0}, "1110111100": {"state": 956.0}, "1001010000": {"state": 592.0}, "1111100110": {"state": 998.0}, "0111101011": {"state": 491.0}, "0000000111": {"state": 7.0}, "0111111000": {"state": 504.0}, "0000010000": {"state": 16.0}, "1000011101": {"state": 541.0}, "1000001111": {"state": 527.0}, "1000001000": {"state": 520.0}, "1111111001": {"state": 1017.0}, "1000010001": {"state": 529.0}, "1100000110": {"state": 774.0}, "1000000010": {"state": 514.0}, "0000001010": {"state": 10.0}, "1111100001": {"state": 993.0}, "0111111001": {"state": 505.0}, "1000010000": {"state": 528.0}, "1111110001": {"state": 1009.0}, "1001000111": {"state": 583.0}, "1000001110": {"state": 526.0}, "1110111110": {"state": 958.0}, "1111101101": {"state": 1005.0}, "0001001101": {"state": 77.0}, "0111111101": {"state": 509.0}, "0111100110": {"state": 486.0}, "0000001101": {"state": 13.0}, "1110111011": {"state": 955.0}, "1000010101": {"state": 533.0}, "0011111100": {"state": 252.0}, "0000000000": {"state": 0.0}, "0110101110": {"state": 430.0}, "1000011000": {"state": 536.0}, "1111111010": {"state": 1018.0}, "1000000000": {"state": 512.0}, "0111110000": {"state": 496.0}, "0111110101": {"state": 501.0}, "0111101110": {"state": 494.0}, "1100000101": {"state": 773.0}, "1010111011": {"state": 699.0}, "0111111010": {"state": 506.0}, "1000000100": {"state": 516.0}, "1001000100": {"state": 580.0}, "0111101001": {"state": 489.0}, "0110100111": {"state": 423.0}, "1111110000": {"state": 1008.0}, "0000011100": {"state": 28.0}, "0110101100": {"state": 428.0}, "1111100011": {"state": 995.0}, "0000001001": {"state": 9.0}, "1011111010": {"state": 762.0}, "0001000101": {"state": 69.0}, "0110100000": {"state": 416.0}, "0011111110": {"state": 254.0}, "1111111111": {"state": 1023.0}, "0111100000": {"state": 480.0}, "1111100000": {"state": 992.0}, "1011101110": {"state": 750.0}, "0011111011": {"state": 251.0}, "0111000010": {"state": 450.0}, "0111101111": {"state": 495.0}, "0001001000": {"state": 72.0}, "0001000010": {"state": 66.0}, "0111111110": {"state": 510.0}, "1011111001": {"state": 761.0}, "1000001101": {"state": 525.0}, "0111110010": {"state": 498.0}, "1110111001": {"state": 953.0}, "0000000101": {"state": 5.0}, "0110111110": {"state": 446.0}, "0000011011": {"state": 27.0}, "0111111100": {"state": 508.0}, "1001000011": {"state": 579.0}, "0000010100": {"state": 20.0}, "0111110011": {"state": 499.0}, "0100001010": {"state": 266.0}, "0011110000": {"state": 240.0}, "0011101000": {"state": 232.0}, "1011111100": {"state": 764.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "0110111101": 1, + "0001000110": 1, + "0110101011": 1, + "1000011000": 1, + "1011110000": 1, + "0110100100": 1, + "1110100110": 3, + "1100010101": 1, + "0000001100": 4, + "1000010110": 25, + "0000000011": 29, + "0111111011": 47, + "1011110011": 1, + "0000010000": 37, + "1000001111": 2, + "0111111111": 8, + "1111100100": 3, + "1111111011": 50, + "1111111101": 22, + "1111101100": 6, + "1111101110": 21, + "0000000010": 3, + "1000000011": 1, + "1100010110": 2, + "0111111101": 32, + "1001001000": 1, + "0000001111": 45, + "1000000101": 107, + "1000010010": 5, + "0111101110": 7, + "1100000101": 8, + "1111111100": 158, + "1000001100": 3, + "1111111010": 12, + "1011101101": 2, + "1111110001": 5, + "1000000000": 10, + "1111110100": 37, + "0000011111": 3, + "0000001000": 366, + "0011110110": 4, + "0011111000": 64, + "0000000111": 574, + "0000010101": 1, + "0111111010": 1, + "1010111011": 2, + "0000000000": 1654, + "0001000101": 7, + "0111100110": 4, + "0000001101": 15, + "1110111011": 3, + "1000010101": 9, + "0111101001": 1, + "0110110111": 2, + "1001000011": 1, + "0111111100": 43, + "0111101101": 1, + "1000000001": 233, + "1011110110": 19, + "0000011000": 37, + "1000000110": 1512, + "1111111110": 884, + "1111110011": 9, + "1011111101": 19, + "0111110001": 2, + "0011111011": 43, + "1111100101": 1, + "0100000000": 37, + "0111111000": 425, + "1001000000": 23, + "1111110110": 50, + "1011111110": 137, + "0000011101": 1, + "0001011101": 1, + "0000010111": 25, + "1000001001": 2, + "1000001000": 25, + "1111111001": 93, + "1111110111": 1, + "1000010001": 5, + "0000001010": 19, + "1111100001": 2, + "1100000110": 18, + "1000000010": 21, + "0001001101": 3, + "1000000111": 2, + "0111101000": 8, + "0100000011": 6, + "0110100000": 2, + "0000010100": 9, + "0111110011": 2, + "0111100101": 1, + "0111101100": 1, + "0100000111": 2, + "0100001000": 6, + "0111111001": 51, + "1000001101": 4, + "0111110010": 4, + "1000001110": 11, + "0100001110": 1, + "0110110100": 1, + "0011110000": 6, + "0000010010": 1, + "0110111000": 3, + "1111110010": 4, + "1110111100": 2, + "1000000100": 3, + "0111101011": 2, + "1111100110": 5, + "0111110110": 8, + "0011100000": 1, + "1110111001": 1, + "0000000101": 8, + "0110111110": 2, + "0000001110": 74, + "0111110111": 38, + "0110111011": 1, + "1110100001": 2, + "0011101000": 6, + "1001001011": 1, + "0111100000": 1, + "0111100111": 2, + "1011101110": 4, + "0111110000": 2, + "1111110000": 16, + "0000011100": 2, + "1111100011": 2, + "0000001001": 7, + "0000011110": 2, + "0011111110": 3, + "1111111111": 3, + "0111111110": 330, + "0001000010": 9, + "1011111001": 4, + "0000010011": 1, + "0110111001": 2, + "0001001110": 1, + "0011110111": 1, + "0111100010": 1, + "1110111110": 2, + "1110101110": 1, + "1000011110": 7, + "0000000100": 404, + "1110101001": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "0110111101": { "state": 445.0 }, + "0001000110": { "state": 70.0 }, + "0110101011": { "state": 427.0 }, + "1000011000": { "state": 536.0 }, + "1011110000": { "state": 752.0 }, + "0110100100": { "state": 420.0 }, + "1110100110": { "state": 934.0 }, + "1100010101": { "state": 789.0 }, + "0000001100": { "state": 12.0 }, + "1000010110": { "state": 534.0 }, + "0000000011": { "state": 3.0 }, + "0111111011": { "state": 507.0 }, + "1011110011": { "state": 755.0 }, + "0000010000": { "state": 16.0 }, + "1000001111": { "state": 527.0 }, + "0111111111": { "state": 511.0 }, + "1111100100": { "state": 996.0 }, + "1111111011": { "state": 1019.0 }, + "1111111101": { "state": 1021.0 }, + "1111101100": { "state": 1004.0 }, + "1111101110": { "state": 1006.0 }, + "0000000010": { "state": 2.0 }, + "1000000011": { "state": 515.0 }, + "1100010110": { "state": 790.0 }, + "0111111101": { "state": 509.0 }, + "1001001000": { "state": 584.0 }, + "0000001111": { "state": 15.0 }, + "1000000101": { "state": 517.0 }, + "1000010010": { "state": 530.0 }, + "0111101110": { "state": 494.0 }, + "1100000101": { "state": 773.0 }, + "1111111100": { "state": 1020.0 }, + "1000001100": { "state": 524.0 }, + "1111111010": { "state": 1018.0 }, + "1011101101": { "state": 749.0 }, + "1111110001": { "state": 1009.0 }, + "1000000000": { "state": 512.0 }, + "1111110100": { "state": 1012.0 }, + "0000011111": { "state": 31.0 }, + "0000001000": { "state": 8.0 }, + "0011110110": { "state": 246.0 }, + "0011111000": { "state": 248.0 }, + "0000000111": { "state": 7.0 }, + "0000010101": { "state": 21.0 }, + "0111111010": { "state": 506.0 }, + "1010111011": { "state": 699.0 }, + "0000000000": { "state": 0.0 }, + "0001000101": { "state": 69.0 }, + "0111100110": { "state": 486.0 }, + "0000001101": { "state": 13.0 }, + "1110111011": { "state": 955.0 }, + "1000010101": { "state": 533.0 }, + "0111101001": { "state": 489.0 }, + "0110110111": { "state": 439.0 }, + "1001000011": { "state": 579.0 }, + "0111111100": { "state": 508.0 }, + "0111101101": { "state": 493.0 }, + "1000000001": { "state": 513.0 }, + "1011110110": { "state": 758.0 }, + "0000011000": { "state": 24.0 }, + "1000000110": { "state": 518.0 }, + "1111111110": { "state": 1022.0 }, + "1111110011": { "state": 1011.0 }, + "1011111101": { "state": 765.0 }, + "0111110001": { "state": 497.0 }, + "0011111011": { "state": 251.0 }, + "1111100101": { "state": 997.0 }, + "0100000000": { "state": 256.0 }, + "0111111000": { "state": 504.0 }, + "1001000000": { "state": 576.0 }, + "1111110110": { "state": 1014.0 }, + "1011111110": { "state": 766.0 }, + "0000011101": { "state": 29.0 }, + "0001011101": { "state": 93.0 }, + "0000010111": { "state": 23.0 }, + "1000001001": { "state": 521.0 }, + "1000001000": { "state": 520.0 }, + "1111111001": { "state": 1017.0 }, + "1111110111": { "state": 1015.0 }, + "1000010001": { "state": 529.0 }, + "0000001010": { "state": 10.0 }, + "1111100001": { "state": 993.0 }, + "1100000110": { "state": 774.0 }, + "1000000010": { "state": 514.0 }, + "0001001101": { "state": 77.0 }, + "1000000111": { "state": 519.0 }, + "0111101000": { "state": 488.0 }, + "0100000011": { "state": 259.0 }, + "0110100000": { "state": 416.0 }, + "0000010100": { "state": 20.0 }, + "0111110011": { "state": 499.0 }, + "0111100101": { "state": 485.0 }, + "0111101100": { "state": 492.0 }, + "0100000111": { "state": 263.0 }, + "0100001000": { "state": 264.0 }, + "0111111001": { "state": 505.0 }, + "1000001101": { "state": 525.0 }, + "0111110010": { "state": 498.0 }, + "1000001110": { "state": 526.0 }, + "0100001110": { "state": 270.0 }, + "0110110100": { "state": 436.0 }, + "0011110000": { "state": 240.0 }, + "0000010010": { "state": 18.0 }, + "0110111000": { "state": 440.0 }, + "1111110010": { "state": 1010.0 }, + "1110111100": { "state": 956.0 }, + "1000000100": { "state": 516.0 }, + "0111101011": { "state": 491.0 }, + "1111100110": { "state": 998.0 }, + "0111110110": { "state": 502.0 }, + "0011100000": { "state": 224.0 }, + "1110111001": { "state": 953.0 }, + "0000000101": { "state": 5.0 }, + "0110111110": { "state": 446.0 }, + "0000001110": { "state": 14.0 }, + "0111110111": { "state": 503.0 }, + "0110111011": { "state": 443.0 }, + "1110100001": { "state": 929.0 }, + "0011101000": { "state": 232.0 }, + "1001001011": { "state": 587.0 }, + "0111100000": { "state": 480.0 }, + "0111100111": { "state": 487.0 }, + "1011101110": { "state": 750.0 }, + "0111110000": { "state": 496.0 }, + "1111110000": { "state": 1008.0 }, + "0000011100": { "state": 28.0 }, + "1111100011": { "state": 995.0 }, + "0000001001": { "state": 9.0 }, + "0000011110": { "state": 30.0 }, + "0011111110": { "state": 254.0 }, + "1111111111": { "state": 1023.0 }, + "0111111110": { "state": 510.0 }, + "0001000010": { "state": 66.0 }, + "1011111001": { "state": 761.0 }, + "0000010011": { "state": 19.0 }, + "0110111001": { "state": 441.0 }, + "0001001110": { "state": 78.0 }, + "0011110111": { "state": 247.0 }, + "0111100010": { "state": 482.0 }, + "1110111110": { "state": 958.0 }, + "1110101110": { "state": 942.0 }, + "1000011110": { "state": 542.0 }, + "0000000100": { "state": 4.0 }, + "1110101001": { "state": 937.0 } + }, + "histogram": null, + "output_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { "state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n+0.json b/algorithms/glued_trees/results/20-qubits/2n+0.json index ed5a8710..f197514c 100644 --- a/algorithms/glued_trees/results/20-qubits/2n+0.json +++ b/algorithms/glued_trees/results/20-qubits/2n+0.json @@ -1 +1,286 @@ -{"vendor_format_result": {}, "counts": {"00000000011111110100": 1, "10000000000011110010": 1, "01111111111100111010": 1, "00000000000100001111": 1, "10000000001100000101": 1, "11111111111011111010": 1, "01111111111111111101": 1, "11111111111100001000": 1, "01111111110110010101": 1, "10000000001100001010": 1, "00000000000011111001": 1, "00000000000011111011": 1, "10000000000111110010": 1, "01111111111000110101": 1, "10000000011111110001": 2, "00000000000011111010": 1, "11111111110110011111": 1, "11111111111000110011": 1, "01111111111100000100": 1, "11111111101001101011": 1, "01111111110000000010": 1, "10000000000111111001": 1, "11111111110011111111": 1, "00000000000111110100": 2, "00000000000011110100": 2, "01111111111011111001": 1, "11111111111100001111": 1, "01111111110110011101": 7, "10000000000011111101": 3, "01111111111111001101": 2, "11111111110110010100": 3, "11111111110011111101": 1, "01111111111001100010": 2, "11111111111010101010": 1, "01111111110110011010": 3, "11111111111001100011": 2, "11111111110110011000": 2, "01111111111111110010": 2, "01111111111011111110": 2, "01111111110110010001": 1, "01111111111100001110": 2, "01111111111011110101": 1, "10000000000011111001": 2, "11111111111100001101": 7, "11111111111111111111": 5, "00000000000000001011": 222, "11111111111011111100": 1, "00000000000000001000": 18, "00000000011000000000": 1, "11111111110100000010": 1, "10000000000000000010": 35, "00000000000000001100": 4, "11111111111100000010": 2, "01111111111100001101": 10, "00000000000111111100": 5, "10000000011111111110": 17, "11111111111010011110": 9, "10000000000000001100": 1, "00000000000011111100": 8, "11111111111011111000": 2, "00000000000000000011": 14, "10000000000000001001": 183, "00000000000000000100": 13, "01111111111100000110": 2, "01111111111011111010": 4, "10000000000000001010": 673, "11111111111111111010": 1, "00000000000000001111": 919, "11111111110011111011": 1, "10000000000011111010": 2, "11111111110011110010": 2, "11111111111100000100": 15, "11111111111100000000": 16, "00000000011111111011": 2, "00000000001011111100": 1, "01111111111101110010": 1, "11111111111100001011": 4, "01111111110011111010": 1, "10000000000011110110": 1, "00000000000000000000": 3745, "01111111111100000111": 2, "01111111111011110010": 2, "10000000000000000001": 95, "10000000000011110100": 1, "10000000000000000101": 1293, "01111111111100000101": 16, "11111111111100001100": 7, "00000000011111110011": 2, "11111111111100001010": 3, "10000000000111110001": 106, "01111111111000111110": 1, "10000000000100000001": 1, "11111111111010010001": 2, "11111111111100000011": 13, "01111111111111110101": 1, "11111111110110010010": 2, "00000000000011111111": 5, "10000000000000001101": 10, "01111111111000110011": 1, "10000000001100000010": 1, "11111111110011110011": 1, "10000000011111110110": 1, "11111111111100000101": 6, "11111111110110010000": 1, "11111111111100000110": 2, "00000000000100000100": 1, "10000000000000000110": 207, "10000000011111110010": 2, "10000000000011110101": 2, "11111111111100000111": 12, "01111111111010010011": 1, "00000000011111111100": 6, "01111111111100000001": 1, "11111111110110011010": 1, "10000000000111111110": 285, "01111111111010011100": 3, "01111111110110011110": 2, "10000000000000001110": 66, "01111111111100001010": 8, "11111111110110010101": 3, "00000000000011110011": 3}, "counts_lsb_right": true, "parsed_states": {"00000000011111110100": {"state": 2036.0}, "10000000000011110010": {"state": 524530.0}, "01111111111100111010": {"state": 524090.0}, "00000000000100001111": {"state": 271.0}, "10000000001100000101": {"state": 525061.0}, "11111111111011111010": {"state": 1048314.0}, "01111111111111111101": {"state": 524285.0}, "11111111111100001000": {"state": 1048328.0}, "01111111110110010101": {"state": 523669.0}, "10000000001100001010": {"state": 525066.0}, "00000000000011111001": {"state": 249.0}, "00000000000011111011": {"state": 251.0}, "10000000000111110010": {"state": 524786.0}, "01111111111000110101": {"state": 523829.0}, "10000000011111110001": {"state": 526321.0}, "00000000000011111010": {"state": 250.0}, "11111111110110011111": {"state": 1047967.0}, "11111111111000110011": {"state": 1048115.0}, "01111111111100000100": {"state": 524036.0}, "11111111101001101011": {"state": 1047147.0}, "01111111110000000010": {"state": 523266.0}, "10000000000111111001": {"state": 524793.0}, "11111111110011111111": {"state": 1047807.0}, "00000000000111110100": {"state": 500.0}, "00000000000011110100": {"state": 244.0}, "01111111111011111001": {"state": 524025.0}, "11111111111100001111": {"state": 1048335.0}, "01111111110110011101": {"state": 523677.0}, "10000000000011111101": {"state": 524541.0}, "01111111111111001101": {"state": 524237.0}, "11111111110110010100": {"state": 1047956.0}, "11111111110011111101": {"state": 1047805.0}, "01111111111001100010": {"state": 523874.0}, "11111111111010101010": {"state": 1048234.0}, "01111111110110011010": {"state": 523674.0}, "11111111111001100011": {"state": 1048163.0}, "11111111110110011000": {"state": 1047960.0}, "01111111111111110010": {"state": 524274.0}, "01111111111011111110": {"state": 524030.0}, "01111111110110010001": {"state": 523665.0}, "01111111111100001110": {"state": 524046.0}, "01111111111011110101": {"state": 524021.0}, "10000000000011111001": {"state": 524537.0}, "11111111111100001101": {"state": 1048333.0}, "11111111111111111111": {"state": 1048575.0}, "00000000000000001011": {"state": 11.0}, "11111111111011111100": {"state": 1048316.0}, "00000000000000001000": {"state": 8.0}, "00000000011000000000": {"state": 1536.0}, "11111111110100000010": {"state": 1047810.0}, "10000000000000000010": {"state": 524290.0}, "00000000000000001100": {"state": 12.0}, "11111111111100000010": {"state": 1048322.0}, "01111111111100001101": {"state": 524045.0}, "00000000000111111100": {"state": 508.0}, "10000000011111111110": {"state": 526334.0}, "11111111111010011110": {"state": 1048222.0}, "10000000000000001100": {"state": 524300.0}, "00000000000011111100": {"state": 252.0}, "11111111111011111000": {"state": 1048312.0}, "00000000000000000011": {"state": 3.0}, "10000000000000001001": {"state": 524297.0}, "00000000000000000100": {"state": 4.0}, "01111111111100000110": {"state": 524038.0}, "01111111111011111010": {"state": 524026.0}, "10000000000000001010": {"state": 524298.0}, "11111111111111111010": {"state": 1048570.0}, "00000000000000001111": {"state": 15.0}, "11111111110011111011": {"state": 1047803.0}, "10000000000011111010": {"state": 524538.0}, "11111111110011110010": {"state": 1047794.0}, "11111111111100000100": {"state": 1048324.0}, "11111111111100000000": {"state": 1048320.0}, "00000000011111111011": {"state": 2043.0}, "00000000001011111100": {"state": 764.0}, "01111111111101110010": {"state": 524146.0}, "11111111111100001011": {"state": 1048331.0}, "01111111110011111010": {"state": 523514.0}, "10000000000011110110": {"state": 524534.0}, "00000000000000000000": {"state": 0.0}, "01111111111100000111": {"state": 524039.0}, "01111111111011110010": {"state": 524018.0}, "10000000000000000001": {"state": 524289.0}, "10000000000011110100": {"state": 524532.0}, "10000000000000000101": {"state": 524293.0}, "01111111111100000101": {"state": 524037.0}, "11111111111100001100": {"state": 1048332.0}, "00000000011111110011": {"state": 2035.0}, "11111111111100001010": {"state": 1048330.0}, "10000000000111110001": {"state": 524785.0}, "01111111111000111110": {"state": 523838.0}, "10000000000100000001": {"state": 524545.0}, "11111111111010010001": {"state": 1048209.0}, "11111111111100000011": {"state": 1048323.0}, "01111111111111110101": {"state": 524277.0}, "11111111110110010010": {"state": 1047954.0}, "00000000000011111111": {"state": 255.0}, "10000000000000001101": {"state": 524301.0}, "01111111111000110011": {"state": 523827.0}, "10000000001100000010": {"state": 525058.0}, "11111111110011110011": {"state": 1047795.0}, "10000000011111110110": {"state": 526326.0}, "11111111111100000101": {"state": 1048325.0}, "11111111110110010000": {"state": 1047952.0}, "11111111111100000110": {"state": 1048326.0}, "00000000000100000100": {"state": 260.0}, "10000000000000000110": {"state": 524294.0}, "10000000011111110010": {"state": 526322.0}, "10000000000011110101": {"state": 524533.0}, "11111111111100000111": {"state": 1048327.0}, "01111111111010010011": {"state": 523923.0}, "00000000011111111100": {"state": 2044.0}, "01111111111100000001": {"state": 524033.0}, "11111111110110011010": {"state": 1047962.0}, "10000000000111111110": {"state": 524798.0}, "01111111111010011100": {"state": 523932.0}, "01111111110110011110": {"state": 523678.0}, "10000000000000001110": {"state": 524302.0}, "01111111111100001010": {"state": 524042.0}, "11111111110110010101": {"state": 1047957.0}, "00000000000011110011": {"state": 243.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "11111111111001101010": 1, + "10000000001100001011": 1, + "00000000011111111100": 5, + "00000000000000000011": 8, + "10000000000000001001": 185, + "11111111111100001011": 1, + "00000000001100000011": 1, + "01111111111100001101": 12, + "01111111111101100000": 3, + "10000000000000001110": 77, + "01111111110110011110": 9, + "01111111110110011010": 2, + "00000000000011111000": 1, + "00000000011111111111": 1, + "10000000000000001101": 12, + "11111111111000110011": 2, + "11111111111010101010": 1, + "01111111111101111000": 1, + "11111111111100000101": 7, + "10000000000011111110": 1, + "10000000000011111010": 4, + "11111111111100000100": 8, + "11111111110011111011": 1, + "11111111110110011101": 4, + "00000000011111111011": 1, + "01111111110110010001": 5, + "01111111110011111101": 1, + "01111111111100001110": 4, + "01111111111011110101": 4, + "10000000000100000001": 1, + "11111111111100000011": 22, + "11111111111100000110": 3, + "11111111110110010000": 2, + "10000000000111111110": 314, + "01111111111100000001": 1, + "11111111110110011010": 1, + "10000000000111110001": 89, + "01111111111100001010": 5, + "00000000000000001111": 958, + "11111111111111111010": 1, + "00000000000000000000": 3628, + "01111111110011111010": 2, + "10000000000111110101": 1, + "11111111111100001100": 10, + "10000000000000000101": 1282, + "00000000011111110011": 5, + "11111111110110011000": 3, + "00000000000011111011": 5, + "00000000000100000011": 1, + "01111111110110011101": 5, + "11111111111100001111": 2, + "11111111111100001001": 1, + "00000000000111111000": 1, + "11111111111100000000": 11, + "01111111111111110011": 1, + "00000000000000001011": 241, + "11111111111100000111": 16, + "00000000000111111100": 5, + "11111111111010011110": 10, + "01111111111100000101": 9, + "10000000011111111110": 17, + "00000000000011111100": 5, + "10000000000000001100": 1, + "10000000000000000000": 1, + "01111111111011111110": 6, + "10000000000000000110": 171, + "11111111110110010011": 2, + "00000000000111111010": 1, + "01111111101001100101": 2, + "10000000011111110010": 1, + "11111111111011110010": 1, + "00000000000011110100": 1, + "00000000000111110100": 2, + "01111111110110010101": 2, + "10000000011111110001": 5, + "00000000000011110011": 4, + "01111111111001100010": 1, + "11111111111100000010": 3, + "00000000000000001100": 6, + "01111111111111111111": 1, + "10000000000000000010": 24, + "10000000000110100011": 1, + "10000000000011111101": 4, + "11111111110110010100": 2, + "01111111110011111110": 1, + "10000000000011110010": 5, + "11111111111100001000": 3, + "00000000000000001000": 22, + "11111111111100000001": 1, + "10000000000011111000": 1, + "01111111111111111001": 1, + "10000000000000000001": 108, + "01111111111010010011": 2, + "11111111110011111010": 2, + "00000000011111110100": 3, + "10000000000111110010": 1, + "11111111111010010001": 5, + "11111111111100001101": 4, + "01111111101001100010": 2, + "01111111111011111001": 3, + "00000000000011111111": 2, + "01111111111100000000": 1, + "11111111110110010010": 1, + "01111111111111110010": 1, + "00000000011111111000": 2, + "01111111111000110011": 1, + "01111111110110011001": 1, + "00000000000000001001": 1, + "01111111110011111001": 1, + "11111111111010010010": 3, + "11111111101100001100": 1, + "11111111111111111001": 1, + "00000000011000001011": 1, + "01111111111011110111": 1, + "01111111111111000001": 1, + "11111111110110011111": 1, + "11111111111011110000": 1, + "10000000000100001010": 1, + "11111111111101011110": 1, + "01111111111001100011": 1, + "01111111100011110101": 1, + "01111111111101101111": 1, + "01111111110110011111": 1, + "10000000000000001010": 715, + "00000000000011111010": 1, + "00000000000000000100": 15, + "01111111111011111000": 1, + "01111111111010010100": 1, + "11111111111100001010": 2, + "00000000011000000000": 1, + "10000000001100000101": 1, + "01111111111111110101": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "11111111111001101010": { "state": 1048170.0 }, + "10000000001100001011": { "state": 525067.0 }, + "00000000011111111100": { "state": 2044.0 }, + "00000000000000000011": { "state": 3.0 }, + "10000000000000001001": { "state": 524297.0 }, + "11111111111100001011": { "state": 1048331.0 }, + "00000000001100000011": { "state": 771.0 }, + "01111111111100001101": { "state": 524045.0 }, + "01111111111101100000": { "state": 524128.0 }, + "10000000000000001110": { "state": 524302.0 }, + "01111111110110011110": { "state": 523678.0 }, + "01111111110110011010": { "state": 523674.0 }, + "00000000000011111000": { "state": 248.0 }, + "00000000011111111111": { "state": 2047.0 }, + "10000000000000001101": { "state": 524301.0 }, + "11111111111000110011": { "state": 1048115.0 }, + "11111111111010101010": { "state": 1048234.0 }, + "01111111111101111000": { "state": 524152.0 }, + "11111111111100000101": { "state": 1048325.0 }, + "10000000000011111110": { "state": 524542.0 }, + "10000000000011111010": { "state": 524538.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "11111111110011111011": { "state": 1047803.0 }, + "11111111110110011101": { "state": 1047965.0 }, + "00000000011111111011": { "state": 2043.0 }, + "01111111110110010001": { "state": 523665.0 }, + "01111111110011111101": { "state": 523517.0 }, + "01111111111100001110": { "state": 524046.0 }, + "01111111111011110101": { "state": 524021.0 }, + "10000000000100000001": { "state": 524545.0 }, + "11111111111100000011": { "state": 1048323.0 }, + "11111111111100000110": { "state": 1048326.0 }, + "11111111110110010000": { "state": 1047952.0 }, + "10000000000111111110": { "state": 524798.0 }, + "01111111111100000001": { "state": 524033.0 }, + "11111111110110011010": { "state": 1047962.0 }, + "10000000000111110001": { "state": 524785.0 }, + "01111111111100001010": { "state": 524042.0 }, + "00000000000000001111": { "state": 15.0 }, + "11111111111111111010": { "state": 1048570.0 }, + "00000000000000000000": { "state": 0.0 }, + "01111111110011111010": { "state": 523514.0 }, + "10000000000111110101": { "state": 524789.0 }, + "11111111111100001100": { "state": 1048332.0 }, + "10000000000000000101": { "state": 524293.0 }, + "00000000011111110011": { "state": 2035.0 }, + "11111111110110011000": { "state": 1047960.0 }, + "00000000000011111011": { "state": 251.0 }, + "00000000000100000011": { "state": 259.0 }, + "01111111110110011101": { "state": 523677.0 }, + "11111111111100001111": { "state": 1048335.0 }, + "11111111111100001001": { "state": 1048329.0 }, + "00000000000111111000": { "state": 504.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "01111111111111110011": { "state": 524275.0 }, + "00000000000000001011": { "state": 11.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "00000000000111111100": { "state": 508.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "01111111111100000101": { "state": 524037.0 }, + "10000000011111111110": { "state": 526334.0 }, + "00000000000011111100": { "state": 252.0 }, + "10000000000000001100": { "state": 524300.0 }, + "10000000000000000000": { "state": 524288.0 }, + "01111111111011111110": { "state": 524030.0 }, + "10000000000000000110": { "state": 524294.0 }, + "11111111110110010011": { "state": 1047955.0 }, + "00000000000111111010": { "state": 506.0 }, + "01111111101001100101": { "state": 522853.0 }, + "10000000011111110010": { "state": 526322.0 }, + "11111111111011110010": { "state": 1048306.0 }, + "00000000000011110100": { "state": 244.0 }, + "00000000000111110100": { "state": 500.0 }, + "01111111110110010101": { "state": 523669.0 }, + "10000000011111110001": { "state": 526321.0 }, + "00000000000011110011": { "state": 243.0 }, + "01111111111001100010": { "state": 523874.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "00000000000000001100": { "state": 12.0 }, + "01111111111111111111": { "state": 524287.0 }, + "10000000000000000010": { "state": 524290.0 }, + "10000000000110100011": { "state": 524707.0 }, + "10000000000011111101": { "state": 524541.0 }, + "11111111110110010100": { "state": 1047956.0 }, + "01111111110011111110": { "state": 523518.0 }, + "10000000000011110010": { "state": 524530.0 }, + "11111111111100001000": { "state": 1048328.0 }, + "00000000000000001000": { "state": 8.0 }, + "11111111111100000001": { "state": 1048321.0 }, + "10000000000011111000": { "state": 524536.0 }, + "01111111111111111001": { "state": 524281.0 }, + "10000000000000000001": { "state": 524289.0 }, + "01111111111010010011": { "state": 523923.0 }, + "11111111110011111010": { "state": 1047802.0 }, + "00000000011111110100": { "state": 2036.0 }, + "10000000000111110010": { "state": 524786.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "11111111111100001101": { "state": 1048333.0 }, + "01111111101001100010": { "state": 522850.0 }, + "01111111111011111001": { "state": 524025.0 }, + "00000000000011111111": { "state": 255.0 }, + "01111111111100000000": { "state": 524032.0 }, + "11111111110110010010": { "state": 1047954.0 }, + "01111111111111110010": { "state": 524274.0 }, + "00000000011111111000": { "state": 2040.0 }, + "01111111111000110011": { "state": 523827.0 }, + "01111111110110011001": { "state": 523673.0 }, + "00000000000000001001": { "state": 9.0 }, + "01111111110011111001": { "state": 523513.0 }, + "11111111111010010010": { "state": 1048210.0 }, + "11111111101100001100": { "state": 1047308.0 }, + "11111111111111111001": { "state": 1048569.0 }, + "00000000011000001011": { "state": 1547.0 }, + "01111111111011110111": { "state": 524023.0 }, + "01111111111111000001": { "state": 524225.0 }, + "11111111110110011111": { "state": 1047967.0 }, + "11111111111011110000": { "state": 1048304.0 }, + "10000000000100001010": { "state": 524554.0 }, + "11111111111101011110": { "state": 1048414.0 }, + "01111111111001100011": { "state": 523875.0 }, + "01111111100011110101": { "state": 522485.0 }, + "01111111111101101111": { "state": 524143.0 }, + "01111111110110011111": { "state": 523679.0 }, + "10000000000000001010": { "state": 524298.0 }, + "00000000000011111010": { "state": 250.0 }, + "00000000000000000100": { "state": 4.0 }, + "01111111111011111000": { "state": 524024.0 }, + "01111111111010010100": { "state": 523924.0 }, + "11111111111100001010": { "state": 1048330.0 }, + "00000000011000000000": { "state": 1536.0 }, + "10000000001100000101": { "state": 525061.0 }, + "01111111111111110101": { "state": 524277.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n+10.json b/algorithms/glued_trees/results/20-qubits/2n+10.json index 9c3683aa..bc4dca52 100644 --- a/algorithms/glued_trees/results/20-qubits/2n+10.json +++ b/algorithms/glued_trees/results/20-qubits/2n+10.json @@ -1 +1,354 @@ -{"vendor_format_result": {}, "counts": {"01111111111000000111": 1, "01111111111100001011": 1, "00000000001111000100": 1, "11111111111000111101": 1, "01111111111000000101": 1, "10000000000011110010": 1, "10000000000011111101": 1, "11111111111111100100": 1, "01111111110110010101": 1, "00000000001100001000": 1, "11111111111111111001": 1, "11111111111010010101": 1, "11111111110000001011": 1, "00000000001111000110": 1, "01111111110011111110": 1, "10000000000011110100": 1, "11111111111000111010": 1, "01111111111011111010": 2, "01111111110000000010": 1, "01111111111001100100": 2, "11111111110110010011": 1, "01111111111010101111": 1, "01111111111000110101": 1, "10000000011000001101": 1, "01111111111100000010": 1, "01111111110000000110": 1, "01111111110110011111": 1, "11111111110110010001": 1, "00000000011111110100": 2, "01111111110111111111": 1, "00000000001100001100": 1, "11111111111011110000": 1, "01111111111111110100": 1, "11111111110100001101": 1, "00000000000111110111": 5, "11111111111001101011": 1, "01111111110001101001": 4, "10000000011111111110": 23, "11111111111110000100": 1, "00000000000000000010": 4, "01111111110001100110": 1, "11111111111100000111": 9, "11111111110011111000": 1, "00000000000111110011": 45, "11111111110000000111": 1, "00000000000000001011": 214, "11111111111000000101": 2, "01111111111111110110": 7, "00000000011000000000": 3, "11111111111000000000": 1, "11111111111000111000": 1, "10000000000011110110": 2, "00000000000000000000": 3668, "01111111110011111010": 1, "00000000000000000011": 31, "10000000000000001001": 279, "01111111111111001101": 1, "11111111110110011010": 4, "01111111110001100010": 2, "11111111111010101101": 3, "10000000000000001011": 3, "00000000011111110011": 11, "11111111110110010000": 6, "01111111111100001100": 3, "11111111111100000110": 3, "11111111110001101000": 1, "01111111110110011110": 4, "10000000001000001101": 2, "10000000000100000010": 1, "01111111111000001101": 2, "11111111111100001011": 9, "01111111111100000000": 1, "11111111110001101001": 1, "11111111111100001001": 1, "10000000000000001101": 711, "10000000000000000101": 59, "11111111111111110101": 5, "00000000000000001111": 1627, "11111111111111111010": 5, "10000000000111110101": 7, "11111111111100000000": 5, "11111111101001100101": 1, "10000000000000001010": 230, "01111111111111110000": 4, "01111111111001100111": 1, "11111111111110011000": 1, "01111111111011111110": 1, "01111111111010100000": 6, "01111111110110010100": 1, "11111111111111110010": 1, "10000000000000000000": 3, "10000000000000000110": 49, "00000000000000000100": 90, "00000000000111110100": 12, "00000000000011110100": 2, "10000000011111110101": 4, "01111111111101111010": 1, "10000000000111110001": 204, "01111111110001100101": 5, "00000000000000000111": 15, "01111111111100001001": 10, "11111111111001101101": 2, "11111111111000110110": 1, "01111111111100111001": 1, "10000000000011111001": 1, "11111111111100000101": 1, "11111111110111110001": 1, "11111111111000000111": 5, "11111111110110011011": 5, "01111111110110010001": 2, "11111111111111111100": 36, "11111111110011110111": 1, "10000000000100001101": 3, "01111111111111110001": 48, "10000000000000000010": 44, "01111111111000001111": 1, "00000000000000001100": 30, "11111111110001100100": 1, "11111111111100000010": 5, "01111111110000001001": 1, "10000000000111111110": 345, "01111111110110010110": 2, "01111111111000001110": 2, "11111111111100000100": 11, "01111111111001010011": 1, "01111111110110011001": 3, "01111111111111110111": 7, "01111111110000001101": 1, "11111111111111110001": 1, "11111111110001100111": 4, "11111111110110011100": 2, "00000000000000001101": 2, "00000000001001010111": 1, "01111111111100001101": 6, "11111111111000000010": 1, "01111111110110011010": 3, "11111111111001011110": 2, "01111111110001101111": 2, "11111111110111111011": 1, "11111111111000001001": 1, "11111111110011110100": 1, "00000000000111111100": 6, "11111111111111110111": 4, "01111111111111110101": 3, "01111111111111111010": 40, "01111111110001101011": 1, "01111111111111111001": 6, "01111111110000000111": 1, "01111111111001100000": 2, "00000000000011111000": 2, "01111111111000000010": 4, "00000000010000110101": 1, "01111111111111111000": 1, "11111111111100000011": 1, "11111111111010011110": 4, "11111111111110011110": 2, "10000000001111001011": 1, "11111111111000001110": 1, "01111111110110010111": 5, "10000000000111111010": 3, "00000000000000001000": 14, "11111111111011110001": 2, "10000000011111110001": 3, "11111111111000001111": 3, "01111111100000001001": 1, "10000000000111110010": 1, "01111111110011110111": 1, "11111111111111110011": 7, "11111111111111111011": 1, "10000000000000000001": 4, "01111111111010010011": 6, "11111111110001101011": 2, "10000000000100001100": 1, "10000000000000001110": 9, "01111111111111111011": 2}, "counts_lsb_right": true, "parsed_states": {"01111111111000000111": {"state": 523783.0}, "01111111111100001011": {"state": 524043.0}, "00000000001111000100": {"state": 964.0}, "11111111111000111101": {"state": 1048125.0}, "01111111111000000101": {"state": 523781.0}, "10000000000011110010": {"state": 524530.0}, "10000000000011111101": {"state": 524541.0}, "11111111111111100100": {"state": 1048548.0}, "01111111110110010101": {"state": 523669.0}, "00000000001100001000": {"state": 776.0}, "11111111111111111001": {"state": 1048569.0}, "11111111111010010101": {"state": 1048213.0}, "11111111110000001011": {"state": 1047563.0}, "00000000001111000110": {"state": 966.0}, "01111111110011111110": {"state": 523518.0}, "10000000000011110100": {"state": 524532.0}, "11111111111000111010": {"state": 1048122.0}, "01111111111011111010": {"state": 524026.0}, "01111111110000000010": {"state": 523266.0}, "01111111111001100100": {"state": 523876.0}, "11111111110110010011": {"state": 1047955.0}, "01111111111010101111": {"state": 523951.0}, "01111111111000110101": {"state": 523829.0}, "10000000011000001101": {"state": 525837.0}, "01111111111100000010": {"state": 524034.0}, "01111111110000000110": {"state": 523270.0}, "01111111110110011111": {"state": 523679.0}, "11111111110110010001": {"state": 1047953.0}, "00000000011111110100": {"state": 2036.0}, "01111111110111111111": {"state": 523775.0}, "00000000001100001100": {"state": 780.0}, "11111111111011110000": {"state": 1048304.0}, "01111111111111110100": {"state": 524276.0}, "11111111110100001101": {"state": 1047821.0}, "00000000000111110111": {"state": 503.0}, "11111111111001101011": {"state": 1048171.0}, "01111111110001101001": {"state": 523369.0}, "10000000011111111110": {"state": 526334.0}, "11111111111110000100": {"state": 1048452.0}, "00000000000000000010": {"state": 2.0}, "01111111110001100110": {"state": 523366.0}, "11111111111100000111": {"state": 1048327.0}, "11111111110011111000": {"state": 1047800.0}, "00000000000111110011": {"state": 499.0}, "11111111110000000111": {"state": 1047559.0}, "00000000000000001011": {"state": 11.0}, "11111111111000000101": {"state": 1048069.0}, "01111111111111110110": {"state": 524278.0}, "00000000011000000000": {"state": 1536.0}, "11111111111000000000": {"state": 1048064.0}, "11111111111000111000": {"state": 1048120.0}, "10000000000011110110": {"state": 524534.0}, "00000000000000000000": {"state": 0.0}, "01111111110011111010": {"state": 523514.0}, "00000000000000000011": {"state": 3.0}, "10000000000000001001": {"state": 524297.0}, "01111111111111001101": {"state": 524237.0}, "11111111110110011010": {"state": 1047962.0}, "01111111110001100010": {"state": 523362.0}, "11111111111010101101": {"state": 1048237.0}, "10000000000000001011": {"state": 524299.0}, "00000000011111110011": {"state": 2035.0}, "11111111110110010000": {"state": 1047952.0}, "01111111111100001100": {"state": 524044.0}, "11111111111100000110": {"state": 1048326.0}, "11111111110001101000": {"state": 1047656.0}, "01111111110110011110": {"state": 523678.0}, "10000000001000001101": {"state": 524813.0}, "10000000000100000010": {"state": 524546.0}, "01111111111000001101": {"state": 523789.0}, "11111111111100001011": {"state": 1048331.0}, "01111111111100000000": {"state": 524032.0}, "11111111110001101001": {"state": 1047657.0}, "11111111111100001001": {"state": 1048329.0}, "10000000000000001101": {"state": 524301.0}, "10000000000000000101": {"state": 524293.0}, "11111111111111110101": {"state": 1048565.0}, "00000000000000001111": {"state": 15.0}, "11111111111111111010": {"state": 1048570.0}, "10000000000111110101": {"state": 524789.0}, "11111111111100000000": {"state": 1048320.0}, "11111111101001100101": {"state": 1047141.0}, "10000000000000001010": {"state": 524298.0}, "01111111111111110000": {"state": 524272.0}, "01111111111001100111": {"state": 523879.0}, "11111111111110011000": {"state": 1048472.0}, "01111111111011111110": {"state": 524030.0}, "01111111111010100000": {"state": 523936.0}, "01111111110110010100": {"state": 523668.0}, "11111111111111110010": {"state": 1048562.0}, "10000000000000000000": {"state": 524288.0}, "10000000000000000110": {"state": 524294.0}, "00000000000000000100": {"state": 4.0}, "00000000000111110100": {"state": 500.0}, "00000000000011110100": {"state": 244.0}, "10000000011111110101": {"state": 526325.0}, "01111111111101111010": {"state": 524154.0}, "10000000000111110001": {"state": 524785.0}, "01111111110001100101": {"state": 523365.0}, "00000000000000000111": {"state": 7.0}, "01111111111100001001": {"state": 524041.0}, "11111111111001101101": {"state": 1048173.0}, "11111111111000110110": {"state": 1048118.0}, "01111111111100111001": {"state": 524089.0}, "10000000000011111001": {"state": 524537.0}, "11111111111100000101": {"state": 1048325.0}, "11111111110111110001": {"state": 1048049.0}, "11111111111000000111": {"state": 1048071.0}, "11111111110110011011": {"state": 1047963.0}, "01111111110110010001": {"state": 523665.0}, "11111111111111111100": {"state": 1048572.0}, "11111111110011110111": {"state": 1047799.0}, "10000000000100001101": {"state": 524557.0}, "01111111111111110001": {"state": 524273.0}, "10000000000000000010": {"state": 524290.0}, "01111111111000001111": {"state": 523791.0}, "00000000000000001100": {"state": 12.0}, "11111111110001100100": {"state": 1047652.0}, "11111111111100000010": {"state": 1048322.0}, "01111111110000001001": {"state": 523273.0}, "10000000000111111110": {"state": 524798.0}, "01111111110110010110": {"state": 523670.0}, "01111111111000001110": {"state": 523790.0}, "11111111111100000100": {"state": 1048324.0}, "01111111111001010011": {"state": 523859.0}, "01111111110110011001": {"state": 523673.0}, "01111111111111110111": {"state": 524279.0}, "01111111110000001101": {"state": 523277.0}, "11111111111111110001": {"state": 1048561.0}, "11111111110001100111": {"state": 1047655.0}, "11111111110110011100": {"state": 1047964.0}, "00000000000000001101": {"state": 13.0}, "00000000001001010111": {"state": 599.0}, "01111111111100001101": {"state": 524045.0}, "11111111111000000010": {"state": 1048066.0}, "01111111110110011010": {"state": 523674.0}, "11111111111001011110": {"state": 1048158.0}, "01111111110001101111": {"state": 523375.0}, "11111111110111111011": {"state": 1048059.0}, "11111111111000001001": {"state": 1048073.0}, "11111111110011110100": {"state": 1047796.0}, "00000000000111111100": {"state": 508.0}, "11111111111111110111": {"state": 1048567.0}, "01111111111111110101": {"state": 524277.0}, "01111111111111111010": {"state": 524282.0}, "01111111110001101011": {"state": 523371.0}, "01111111111111111001": {"state": 524281.0}, "01111111110000000111": {"state": 523271.0}, "01111111111001100000": {"state": 523872.0}, "00000000000011111000": {"state": 248.0}, "01111111111000000010": {"state": 523778.0}, "00000000010000110101": {"state": 1077.0}, "01111111111111111000": {"state": 524280.0}, "11111111111100000011": {"state": 1048323.0}, "11111111111010011110": {"state": 1048222.0}, "11111111111110011110": {"state": 1048478.0}, "10000000001111001011": {"state": 525259.0}, "11111111111000001110": {"state": 1048078.0}, "01111111110110010111": {"state": 523671.0}, "10000000000111111010": {"state": 524794.0}, "00000000000000001000": {"state": 8.0}, "11111111111011110001": {"state": 1048305.0}, "10000000011111110001": {"state": 526321.0}, "11111111111000001111": {"state": 1048079.0}, "01111111100000001001": {"state": 522249.0}, "10000000000111110010": {"state": 524786.0}, "01111111110011110111": {"state": 523511.0}, "11111111111111110011": {"state": 1048563.0}, "11111111111111111011": {"state": 1048571.0}, "10000000000000000001": {"state": 524289.0}, "01111111111010010011": {"state": 523923.0}, "11111111110001101011": {"state": 1047659.0}, "10000000000100001100": {"state": 524556.0}, "10000000000000001110": {"state": 524302.0}, "01111111111111111011": {"state": 524283.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "01111111111011111010": 1, + "10000000011111110010": 1, + "11111111111111110100": 1, + "10000000000011110110": 1, + "11111111110110010100": 1, + "10000000001111001011": 1, + "01111111111000000010": 4, + "11111111110011111011": 1, + "01111111111100111001": 1, + "01111111111001101100": 1, + "10000000000001100100": 1, + "11111111111111111110": 1, + "00000000000000001010": 1, + "01111111111000001101": 1, + "01111111111000111111": 1, + "11111111100111001100": 1, + "10000000011111110101": 3, + "11111111100010000111": 1, + "11111111111011110111": 1, + "00000000000111111101": 1, + "01111111110000001010": 1, + "00000000000011110100": 2, + "10000000000111111010": 1, + "01111111111101100000": 1, + "10000000001100001101": 1, + "11111111111111111010": 6, + "10000000011000001101": 4, + "00000000000000001111": 1681, + "11111111111000110101": 1, + "10000000011111111001": 1, + "01111111110110011011": 1, + "01111111111100011010": 1, + "11111111111001011110": 2, + "11111111110110011100": 2, + "00000000000000000010": 6, + "11111111111100000110": 1, + "01111111111100001100": 4, + "00000000001001011110": 1, + "01111111111000001001": 1, + "11111111111111111100": 37, + "01111111111110100000": 2, + "01111111111111110011": 1, + "11111111111100000000": 8, + "01111111111001100000": 4, + "11111111111001101101": 4, + "10000000001111110010": 1, + "01111111111001010011": 1, + "01111111110110011001": 5, + "01111111111111110111": 2, + "11111111111000001111": 5, + "10000000000111110010": 2, + "00000000000000000011": 30, + "01111111111110000010": 1, + "10000000000000001001": 302, + "00000000011111110100": 3, + "01111111111100001101": 11, + "01111111111001101101": 1, + "10000000000000000101": 62, + "00000000001111001001": 1, + "11111111110001100011": 1, + "11111111110110010000": 12, + "00000000000000001100": 41, + "10000000000100001101": 6, + "11111111110011110001": 2, + "11111111110110010001": 1, + "11111111110110011010": 3, + "11111111100000001111": 1, + "10000000000000000001": 7, + "01111111111010010011": 5, + "10000000000011110011": 1, + "01111111110001100110": 3, + "11111111111100000111": 7, + "10000000000000001101": 689, + "11111111111111110111": 1, + "11111111110011110100": 1, + "00000000000111111100": 8, + "10000000011111111110": 33, + "01111111100000000010": 1, + "00000000000000001011": 216, + "00000000000000000100": 125, + "01111111111011110010": 1, + "00000000000111110100": 16, + "01111111111111111010": 34, + "00000000000111110011": 45, + "00000000011111110011": 5, + "10000000000000001011": 1, + "01111111111100000111": 1, + "00000000000000000000": 3633, + "01111111111011111111": 1, + "11111111111111111001": 4, + "01111111111100001001": 8, + "10000000000000001010": 206, + "00000000000000000111": 14, + "01111111110001100101": 2, + "10000000000000000010": 37, + "01111111111111110001": 39, + "01111111110100000110": 1, + "11111111110110011011": 9, + "01111111110110010001": 2, + "01111111111111110101": 1, + "11111111111001101111": 1, + "11111111111011111000": 1, + "01111111111111110000": 3, + "01111111111101111001": 1, + "01111111111001111001": 1, + "11111111110110010010": 1, + "01111111110100001110": 1, + "01111111111100001111": 1, + "11111111111000001000": 2, + "11111111111100001011": 1, + "01111111110110011110": 3, + "11111111111000000100": 4, + "11111111111001101011": 1, + "01111111110001101001": 3, + "11111111111010101010": 1, + "01111111110001100010": 1, + "11111111111000111100": 1, + "11111111111100000010": 2, + "11111111110001100100": 1, + "01111111111011111110": 1, + "10000000000000000110": 52, + "01111111111010100000": 3, + "11111111111100000100": 7, + "01111111111001011100": 1, + "10000000000001100110": 1, + "01111111111111001101": 2, + "01111111110110010010": 3, + "10000000000000001110": 3, + "01111111111111111011": 2, + "00000000000000001000": 9, + "11111111111011110001": 2, + "11111111111100000001": 2, + "10000000000111110001": 215, + "11111111111000000001": 2, + "01111111110000001001": 1, + "10000000000111111110": 346, + "01111111110110010110": 4, + "11111111110001100001": 1, + "11111111111010011110": 5, + "11111111111000000011": 1, + "10000000011111110001": 3, + "01111111110011110101": 1, + "11111111111001101100": 1, + "10000000000111111011": 1, + "01111111111111111101": 2, + "11111111111101110111": 1, + "11111111110000000110": 1, + "11111111111000000000": 1, + "11111111111000000101": 1, + "01111111111001100110": 1, + "01111111111111110110": 3, + "00000000011000000000": 1, + "01111111110000000010": 1, + "11111111111111001011": 1, + "00000000000111110111": 6, + "11111111111111000000": 4, + "11111111110001100111": 2, + "01111111110110010101": 1, + "11111111111111110011": 3, + "11111111111111111011": 1, + "01111111111111111001": 4, + "10000000000111110101": 5, + "11111111111010101001": 1, + "01111111110110011101": 1, + "00000000000000001101": 1, + "00000000000110100010": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "01111111111011111010": { "state": 524026.0 }, + "10000000011111110010": { "state": 526322.0 }, + "11111111111111110100": { "state": 1048564.0 }, + "10000000000011110110": { "state": 524534.0 }, + "11111111110110010100": { "state": 1047956.0 }, + "10000000001111001011": { "state": 525259.0 }, + "01111111111000000010": { "state": 523778.0 }, + "11111111110011111011": { "state": 1047803.0 }, + "01111111111100111001": { "state": 524089.0 }, + "01111111111001101100": { "state": 523884.0 }, + "10000000000001100100": { "state": 524388.0 }, + "11111111111111111110": { "state": 1048574.0 }, + "00000000000000001010": { "state": 10.0 }, + "01111111111000001101": { "state": 523789.0 }, + "01111111111000111111": { "state": 523839.0 }, + "11111111100111001100": { "state": 1046988.0 }, + "10000000011111110101": { "state": 526325.0 }, + "11111111100010000111": { "state": 1046663.0 }, + "11111111111011110111": { "state": 1048311.0 }, + "00000000000111111101": { "state": 509.0 }, + "01111111110000001010": { "state": 523274.0 }, + "00000000000011110100": { "state": 244.0 }, + "10000000000111111010": { "state": 524794.0 }, + "01111111111101100000": { "state": 524128.0 }, + "10000000001100001101": { "state": 525069.0 }, + "11111111111111111010": { "state": 1048570.0 }, + "10000000011000001101": { "state": 525837.0 }, + "00000000000000001111": { "state": 15.0 }, + "11111111111000110101": { "state": 1048117.0 }, + "10000000011111111001": { "state": 526329.0 }, + "01111111110110011011": { "state": 523675.0 }, + "01111111111100011010": { "state": 524058.0 }, + "11111111111001011110": { "state": 1048158.0 }, + "11111111110110011100": { "state": 1047964.0 }, + "00000000000000000010": { "state": 2.0 }, + "11111111111100000110": { "state": 1048326.0 }, + "01111111111100001100": { "state": 524044.0 }, + "00000000001001011110": { "state": 606.0 }, + "01111111111000001001": { "state": 523785.0 }, + "11111111111111111100": { "state": 1048572.0 }, + "01111111111110100000": { "state": 524192.0 }, + "01111111111111110011": { "state": 524275.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "01111111111001100000": { "state": 523872.0 }, + "11111111111001101101": { "state": 1048173.0 }, + "10000000001111110010": { "state": 525298.0 }, + "01111111111001010011": { "state": 523859.0 }, + "01111111110110011001": { "state": 523673.0 }, + "01111111111111110111": { "state": 524279.0 }, + "11111111111000001111": { "state": 1048079.0 }, + "10000000000111110010": { "state": 524786.0 }, + "00000000000000000011": { "state": 3.0 }, + "01111111111110000010": { "state": 524162.0 }, + "10000000000000001001": { "state": 524297.0 }, + "00000000011111110100": { "state": 2036.0 }, + "01111111111100001101": { "state": 524045.0 }, + "01111111111001101101": { "state": 523885.0 }, + "10000000000000000101": { "state": 524293.0 }, + "00000000001111001001": { "state": 969.0 }, + "11111111110001100011": { "state": 1047651.0 }, + "11111111110110010000": { "state": 1047952.0 }, + "00000000000000001100": { "state": 12.0 }, + "10000000000100001101": { "state": 524557.0 }, + "11111111110011110001": { "state": 1047793.0 }, + "11111111110110010001": { "state": 1047953.0 }, + "11111111110110011010": { "state": 1047962.0 }, + "11111111100000001111": { "state": 1046543.0 }, + "10000000000000000001": { "state": 524289.0 }, + "01111111111010010011": { "state": 523923.0 }, + "10000000000011110011": { "state": 524531.0 }, + "01111111110001100110": { "state": 523366.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "10000000000000001101": { "state": 524301.0 }, + "11111111111111110111": { "state": 1048567.0 }, + "11111111110011110100": { "state": 1047796.0 }, + "00000000000111111100": { "state": 508.0 }, + "10000000011111111110": { "state": 526334.0 }, + "01111111100000000010": { "state": 522242.0 }, + "00000000000000001011": { "state": 11.0 }, + "00000000000000000100": { "state": 4.0 }, + "01111111111011110010": { "state": 524018.0 }, + "00000000000111110100": { "state": 500.0 }, + "01111111111111111010": { "state": 524282.0 }, + "00000000000111110011": { "state": 499.0 }, + "00000000011111110011": { "state": 2035.0 }, + "10000000000000001011": { "state": 524299.0 }, + "01111111111100000111": { "state": 524039.0 }, + "00000000000000000000": { "state": 0.0 }, + "01111111111011111111": { "state": 524031.0 }, + "11111111111111111001": { "state": 1048569.0 }, + "01111111111100001001": { "state": 524041.0 }, + "10000000000000001010": { "state": 524298.0 }, + "00000000000000000111": { "state": 7.0 }, + "01111111110001100101": { "state": 523365.0 }, + "10000000000000000010": { "state": 524290.0 }, + "01111111111111110001": { "state": 524273.0 }, + "01111111110100000110": { "state": 523526.0 }, + "11111111110110011011": { "state": 1047963.0 }, + "01111111110110010001": { "state": 523665.0 }, + "01111111111111110101": { "state": 524277.0 }, + "11111111111001101111": { "state": 1048175.0 }, + "11111111111011111000": { "state": 1048312.0 }, + "01111111111111110000": { "state": 524272.0 }, + "01111111111101111001": { "state": 524153.0 }, + "01111111111001111001": { "state": 523897.0 }, + "11111111110110010010": { "state": 1047954.0 }, + "01111111110100001110": { "state": 523534.0 }, + "01111111111100001111": { "state": 524047.0 }, + "11111111111000001000": { "state": 1048072.0 }, + "11111111111100001011": { "state": 1048331.0 }, + "01111111110110011110": { "state": 523678.0 }, + "11111111111000000100": { "state": 1048068.0 }, + "11111111111001101011": { "state": 1048171.0 }, + "01111111110001101001": { "state": 523369.0 }, + "11111111111010101010": { "state": 1048234.0 }, + "01111111110001100010": { "state": 523362.0 }, + "11111111111000111100": { "state": 1048124.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "11111111110001100100": { "state": 1047652.0 }, + "01111111111011111110": { "state": 524030.0 }, + "10000000000000000110": { "state": 524294.0 }, + "01111111111010100000": { "state": 523936.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "01111111111001011100": { "state": 523868.0 }, + "10000000000001100110": { "state": 524390.0 }, + "01111111111111001101": { "state": 524237.0 }, + "01111111110110010010": { "state": 523666.0 }, + "10000000000000001110": { "state": 524302.0 }, + "01111111111111111011": { "state": 524283.0 }, + "00000000000000001000": { "state": 8.0 }, + "11111111111011110001": { "state": 1048305.0 }, + "11111111111100000001": { "state": 1048321.0 }, + "10000000000111110001": { "state": 524785.0 }, + "11111111111000000001": { "state": 1048065.0 }, + "01111111110000001001": { "state": 523273.0 }, + "10000000000111111110": { "state": 524798.0 }, + "01111111110110010110": { "state": 523670.0 }, + "11111111110001100001": { "state": 1047649.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "11111111111000000011": { "state": 1048067.0 }, + "10000000011111110001": { "state": 526321.0 }, + "01111111110011110101": { "state": 523509.0 }, + "11111111111001101100": { "state": 1048172.0 }, + "10000000000111111011": { "state": 524795.0 }, + "01111111111111111101": { "state": 524285.0 }, + "11111111111101110111": { "state": 1048439.0 }, + "11111111110000000110": { "state": 1047558.0 }, + "11111111111000000000": { "state": 1048064.0 }, + "11111111111000000101": { "state": 1048069.0 }, + "01111111111001100110": { "state": 523878.0 }, + "01111111111111110110": { "state": 524278.0 }, + "00000000011000000000": { "state": 1536.0 }, + "01111111110000000010": { "state": 523266.0 }, + "11111111111111001011": { "state": 1048523.0 }, + "00000000000111110111": { "state": 503.0 }, + "11111111111111000000": { "state": 1048512.0 }, + "11111111110001100111": { "state": 1047655.0 }, + "01111111110110010101": { "state": 523669.0 }, + "11111111111111110011": { "state": 1048563.0 }, + "11111111111111111011": { "state": 1048571.0 }, + "01111111111111111001": { "state": 524281.0 }, + "10000000000111110101": { "state": 524789.0 }, + "11111111111010101001": { "state": 1048233.0 }, + "01111111110110011101": { "state": 523677.0 }, + "00000000000000001101": { "state": 13.0 }, + "00000000000110100010": { "state": 418.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n+12.json b/algorithms/glued_trees/results/20-qubits/2n+12.json index 99abee7e..d091e114 100644 --- a/algorithms/glued_trees/results/20-qubits/2n+12.json +++ b/algorithms/glued_trees/results/20-qubits/2n+12.json @@ -1 +1,422 @@ -{"vendor_format_result": {}, "counts": {"11111111111100001100": 1, "00000000000111110100": 1, "01111111111111110100": 1, "01111111110011111001": 2, "10000000001100000010": 1, "01111111100000000110": 1, "11111111110001101111": 1, "01111111100111110010": 1, "11111111111001011110": 1, "11111111111111111011": 1, "10000000000000001111": 1, "10000000000011111001": 1, "01111111111110000000": 1, "11111111110110011001": 1, "11111111110111110001": 1, "01111111111010101111": 2, "11111111111011110000": 1, "10000000000100001010": 1, "11111111111100001001": 1, "11111111111010010101": 1, "00000000011000001111": 1, "11111111110110010001": 1, "11111111111010101101": 1, "01111111110110010010": 2, "10000000000100000100": 1, "11111111111000110101": 1, "11111111111010011110": 2, "11111111111101111100": 1, "01111111111111001101": 1, "10000000011111110010": 1, "01111111111000111000": 1, "10000000000100001111": 1, "10000000000011110010": 1, "01111111110110010000": 1, "11111111111111000000": 1, "11111111111010011010": 2, "11111111111000110100": 1, "10000000011111111000": 1, "01111111100000001001": 1, "11111111111100010111": 1, "01111111111010100100": 1, "11111111111111110000": 3, "01111111110001101010": 1, "11111111111011110111": 2, "01111111110111110101": 1, "01111111110011111111": 1, "01111111111011111100": 4, "00000000000000001011": 8, "11111111111011110001": 2, "11111111111000111010": 1, "11111111111111111000": 6, "11111111110001100000": 1, "00000000000011111010": 1, "10000000000000001010": 12, "11111111111111111101": 1, "00000000000000000010": 6, "10000000000111111101": 1, "00000000011111111000": 5, "00000000000000000111": 14, "11111111110110010111": 7, "00000000000001011110": 1, "11111111111111111010": 1, "00000000000000001111": 1131, "01111111111001101111": 2, "10000000011000001101": 4, "01111111111111111101": 7, "11111111111110101101": 2, "01111111111110010111": 1, "11111111110110011101": 1, "10000000000111111010": 43, "01111111110110010111": 4, "00000000000111110111": 25, "10000000011111110101": 10, "01111111111111111010": 49, "00000000000111110011": 124, "10000000000111110001": 170, "00000000011111110011": 13, "01111111111011110100": 1, "10000000011111111110": 5, "01111111110110001110": 1, "11111111110000001011": 1, "11111111111110010001": 1, "01111111110110010011": 1, "11111111111111110110": 4, "00000000000111111100": 1, "11111111111111110111": 48, "10000000000011111111": 1, "01111111111000110001": 2, "10000000000000001110": 2, "01111111111111111011": 1, "01111111111001110101": 1, "10000000000111110101": 17, "00000000011111111111": 1, "01111111110011110101": 2, "00000000000000000000": 501, "00000000000000000011": 77, "10000000011111111010": 9, "01111111110001100010": 3, "10000000000111111110": 300, "11111111110110010010": 1, "11111111111001100100": 3, "11111111111011111110": 1, "01111111110001101101": 1, "01111111111111110111": 5, "01111111111001010011": 5, "01111111110110011001": 4, "11111111111001011010": 2, "00000000000000000100": 2266, "11111111111000001111": 6, "11111111100011111101": 1, "01111111111000001011": 1, "00000000000111111111": 3, "11111111110011110111": 1, "10000000000100001101": 1, "11111111111000000010": 3, "11111111111111001111": 1, "01111111111100001110": 1, "01111111111101111110": 1, "10000000000011110101": 1, "10000000000000001101": 340, "01111111111111110101": 5, "01111111110110011010": 3, "00000000000000001100": 83, "01111111111000001111": 3, "10000000000000000010": 47, "01111111111111110001": 24, "11111111111001101101": 4, "10000000000111110100": 1, "11111111110000001001": 2, "01111111111000110101": 1, "11111111111011111100": 1, "01111111111110011010": 1, "01111111110110011110": 11, "11111111111000000110": 1, "00000000000100000000": 1, "10000000001111001100": 1, "11111111111100000100": 2, "11111111111100000010": 2, "00000000000011110011": 2, "11111111110001100100": 8, "01111111111000000100": 2, "11111111111001101011": 1, "01111111110001101001": 3, "01111111111100001001": 8, "00000000000100000100": 1, "01111111111001100000": 9, "01111111111011110110": 1, "01111111111000000010": 5, "00000000000000001101": 1, "11111111111100000011": 1, "11111111111110000111": 2, "00000000000100001111": 3, "11111111110110011111": 1, "11111111111111111110": 8, "00000000000110101010": 1, "01111111111000001101": 1, "10000000000000001001": 1780, "00000000001111000010": 1, "11111111111000110000": 1, "01111111111111111110": 47, "11111111110110011110": 1, "11111111100000001111": 1, "10000000000000000001": 96, "01111111111010010011": 3, "01111111111010100000": 4, "10000000000000000110": 597, "10000000000000000000": 3, "01111111111110101011": 1, "00000000011000000000": 1, "10000000000000000100": 2, "11111111111000000000": 2, "11111111111010011101": 1, "01111111110110010101": 3, "01111111110001100110": 5, "11111111111100000111": 5, "00000000001000111110": 1, "10000000000101010000": 1, "11111111111111110001": 2, "01111111111011111101": 1, "11111111110001100111": 3, "10000000011111110001": 3, "11111111110001100011": 1, "11111111110110010000": 1, "11111111111000111000": 1, "10000000001000111110": 1, "01111111111010101011": 1, "10000000000011111110": 1, "11111111111111111100": 15, "01111111111000001001": 1, "11111111111000001110": 2, "01111111110110011111": 1, "01111111111100000011": 1, "01111111111111111100": 5, "01111111111001100110": 1, "01111111110111001101": 1, "01111111111111110011": 2, "11111111111100000000": 2}, "counts_lsb_right": true, "parsed_states": {"11111111111100001100": {"state": 1048332.0}, "00000000000111110100": {"state": 500.0}, "01111111111111110100": {"state": 524276.0}, "01111111110011111001": {"state": 523513.0}, "10000000001100000010": {"state": 525058.0}, "01111111100000000110": {"state": 522246.0}, "11111111110001101111": {"state": 1047663.0}, "01111111100111110010": {"state": 522738.0}, "11111111111001011110": {"state": 1048158.0}, "11111111111111111011": {"state": 1048571.0}, "10000000000000001111": {"state": 524303.0}, "10000000000011111001": {"state": 524537.0}, "01111111111110000000": {"state": 524160.0}, "11111111110110011001": {"state": 1047961.0}, "11111111110111110001": {"state": 1048049.0}, "01111111111010101111": {"state": 523951.0}, "11111111111011110000": {"state": 1048304.0}, "10000000000100001010": {"state": 524554.0}, "11111111111100001001": {"state": 1048329.0}, "11111111111010010101": {"state": 1048213.0}, "00000000011000001111": {"state": 1551.0}, "11111111110110010001": {"state": 1047953.0}, "11111111111010101101": {"state": 1048237.0}, "01111111110110010010": {"state": 523666.0}, "10000000000100000100": {"state": 524548.0}, "11111111111000110101": {"state": 1048117.0}, "11111111111010011110": {"state": 1048222.0}, "11111111111101111100": {"state": 1048444.0}, "01111111111111001101": {"state": 524237.0}, "10000000011111110010": {"state": 526322.0}, "01111111111000111000": {"state": 523832.0}, "10000000000100001111": {"state": 524559.0}, "10000000000011110010": {"state": 524530.0}, "01111111110110010000": {"state": 523664.0}, "11111111111111000000": {"state": 1048512.0}, "11111111111010011010": {"state": 1048218.0}, "11111111111000110100": {"state": 1048116.0}, "10000000011111111000": {"state": 526328.0}, "01111111100000001001": {"state": 522249.0}, "11111111111100010111": {"state": 1048343.0}, "01111111111010100100": {"state": 523940.0}, "11111111111111110000": {"state": 1048560.0}, "01111111110001101010": {"state": 523370.0}, "11111111111011110111": {"state": 1048311.0}, "01111111110111110101": {"state": 523765.0}, "01111111110011111111": {"state": 523519.0}, "01111111111011111100": {"state": 524028.0}, "00000000000000001011": {"state": 11.0}, "11111111111011110001": {"state": 1048305.0}, "11111111111000111010": {"state": 1048122.0}, "11111111111111111000": {"state": 1048568.0}, "11111111110001100000": {"state": 1047648.0}, "00000000000011111010": {"state": 250.0}, "10000000000000001010": {"state": 524298.0}, "11111111111111111101": {"state": 1048573.0}, "00000000000000000010": {"state": 2.0}, "10000000000111111101": {"state": 524797.0}, "00000000011111111000": {"state": 2040.0}, "00000000000000000111": {"state": 7.0}, "11111111110110010111": {"state": 1047959.0}, "00000000000001011110": {"state": 94.0}, "11111111111111111010": {"state": 1048570.0}, "00000000000000001111": {"state": 15.0}, "01111111111001101111": {"state": 523887.0}, "10000000011000001101": {"state": 525837.0}, "01111111111111111101": {"state": 524285.0}, "11111111111110101101": {"state": 1048493.0}, "01111111111110010111": {"state": 524183.0}, "11111111110110011101": {"state": 1047965.0}, "10000000000111111010": {"state": 524794.0}, "01111111110110010111": {"state": 523671.0}, "00000000000111110111": {"state": 503.0}, "10000000011111110101": {"state": 526325.0}, "01111111111111111010": {"state": 524282.0}, "00000000000111110011": {"state": 499.0}, "10000000000111110001": {"state": 524785.0}, "00000000011111110011": {"state": 2035.0}, "01111111111011110100": {"state": 524020.0}, "10000000011111111110": {"state": 526334.0}, "01111111110110001110": {"state": 523662.0}, "11111111110000001011": {"state": 1047563.0}, "11111111111110010001": {"state": 1048465.0}, "01111111110110010011": {"state": 523667.0}, "11111111111111110110": {"state": 1048566.0}, "00000000000111111100": {"state": 508.0}, "11111111111111110111": {"state": 1048567.0}, "10000000000011111111": {"state": 524543.0}, "01111111111000110001": {"state": 523825.0}, "10000000000000001110": {"state": 524302.0}, "01111111111111111011": {"state": 524283.0}, "01111111111001110101": {"state": 523893.0}, "10000000000111110101": {"state": 524789.0}, "00000000011111111111": {"state": 2047.0}, "01111111110011110101": {"state": 523509.0}, "00000000000000000000": {"state": 0.0}, "00000000000000000011": {"state": 3.0}, "10000000011111111010": {"state": 526330.0}, "01111111110001100010": {"state": 523362.0}, "10000000000111111110": {"state": 524798.0}, "11111111110110010010": {"state": 1047954.0}, "11111111111001100100": {"state": 1048164.0}, "11111111111011111110": {"state": 1048318.0}, "01111111110001101101": {"state": 523373.0}, "01111111111111110111": {"state": 524279.0}, "01111111111001010011": {"state": 523859.0}, "01111111110110011001": {"state": 523673.0}, "11111111111001011010": {"state": 1048154.0}, "00000000000000000100": {"state": 4.0}, "11111111111000001111": {"state": 1048079.0}, "11111111100011111101": {"state": 1046781.0}, "01111111111000001011": {"state": 523787.0}, "00000000000111111111": {"state": 511.0}, "11111111110011110111": {"state": 1047799.0}, "10000000000100001101": {"state": 524557.0}, "11111111111000000010": {"state": 1048066.0}, "11111111111111001111": {"state": 1048527.0}, "01111111111100001110": {"state": 524046.0}, "01111111111101111110": {"state": 524158.0}, "10000000000011110101": {"state": 524533.0}, "10000000000000001101": {"state": 524301.0}, "01111111111111110101": {"state": 524277.0}, "01111111110110011010": {"state": 523674.0}, "00000000000000001100": {"state": 12.0}, "01111111111000001111": {"state": 523791.0}, "10000000000000000010": {"state": 524290.0}, "01111111111111110001": {"state": 524273.0}, "11111111111001101101": {"state": 1048173.0}, "10000000000111110100": {"state": 524788.0}, "11111111110000001001": {"state": 1047561.0}, "01111111111000110101": {"state": 523829.0}, "11111111111011111100": {"state": 1048316.0}, "01111111111110011010": {"state": 524186.0}, "01111111110110011110": {"state": 523678.0}, "11111111111000000110": {"state": 1048070.0}, "00000000000100000000": {"state": 256.0}, "10000000001111001100": {"state": 525260.0}, "11111111111100000100": {"state": 1048324.0}, "11111111111100000010": {"state": 1048322.0}, "00000000000011110011": {"state": 243.0}, "11111111110001100100": {"state": 1047652.0}, "01111111111000000100": {"state": 523780.0}, "11111111111001101011": {"state": 1048171.0}, "01111111110001101001": {"state": 523369.0}, "01111111111100001001": {"state": 524041.0}, "00000000000100000100": {"state": 260.0}, "01111111111001100000": {"state": 523872.0}, "01111111111011110110": {"state": 524022.0}, "01111111111000000010": {"state": 523778.0}, "00000000000000001101": {"state": 13.0}, "11111111111100000011": {"state": 1048323.0}, "11111111111110000111": {"state": 1048455.0}, "00000000000100001111": {"state": 271.0}, "11111111110110011111": {"state": 1047967.0}, "11111111111111111110": {"state": 1048574.0}, "00000000000110101010": {"state": 426.0}, "01111111111000001101": {"state": 523789.0}, "10000000000000001001": {"state": 524297.0}, "00000000001111000010": {"state": 962.0}, "11111111111000110000": {"state": 1048112.0}, "01111111111111111110": {"state": 524286.0}, "11111111110110011110": {"state": 1047966.0}, "11111111100000001111": {"state": 1046543.0}, "10000000000000000001": {"state": 524289.0}, "01111111111010010011": {"state": 523923.0}, "01111111111010100000": {"state": 523936.0}, "10000000000000000110": {"state": 524294.0}, "10000000000000000000": {"state": 524288.0}, "01111111111110101011": {"state": 524203.0}, "00000000011000000000": {"state": 1536.0}, "10000000000000000100": {"state": 524292.0}, "11111111111000000000": {"state": 1048064.0}, "11111111111010011101": {"state": 1048221.0}, "01111111110110010101": {"state": 523669.0}, "01111111110001100110": {"state": 523366.0}, "11111111111100000111": {"state": 1048327.0}, "00000000001000111110": {"state": 574.0}, "10000000000101010000": {"state": 524624.0}, "11111111111111110001": {"state": 1048561.0}, "01111111111011111101": {"state": 524029.0}, "11111111110001100111": {"state": 1047655.0}, "10000000011111110001": {"state": 526321.0}, "11111111110001100011": {"state": 1047651.0}, "11111111110110010000": {"state": 1047952.0}, "11111111111000111000": {"state": 1048120.0}, "10000000001000111110": {"state": 524862.0}, "01111111111010101011": {"state": 523947.0}, "10000000000011111110": {"state": 524542.0}, "11111111111111111100": {"state": 1048572.0}, "01111111111000001001": {"state": 523785.0}, "11111111111000001110": {"state": 1048078.0}, "01111111110110011111": {"state": 523679.0}, "01111111111100000011": {"state": 524035.0}, "01111111111111111100": {"state": 524284.0}, "01111111111001100110": {"state": 523878.0}, "01111111110111001101": {"state": 523725.0}, "01111111111111110011": {"state": 524275.0}, "11111111111100000000": {"state": 1048320.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "11111111110110011101": 1, + "11111111111101110011": 1, + "01111111111001011000": 1, + "11111111101001100100": 1, + "01111111111100001110": 1, + "11111111110110010001": 2, + "00000000000000110001": 1, + "11111111111010010101": 1, + "11111111111001010101": 1, + "10000000000011111101": 1, + "01111111110110011100": 1, + "10000000011111110001": 1, + "01111111111100001111": 1, + "01111111111011111010": 1, + "01111111111010100100": 1, + "11111111111100000100": 1, + "01111111110001101111": 1, + "10000000000011110101": 1, + "10000000000111111101": 1, + "01111111111000000110": 1, + "10000000001000001101": 1, + "11111111110110011100": 1, + "01111111111000000111": 1, + "11111111111111000100": 3, + "00000000001111000100": 1, + "11111111111110011000": 1, + "01111111111111001101": 1, + "10000000001000000101": 1, + "11111111111000000010": 4, + "00000000011111111111": 1, + "01111111110110010001": 2, + "11111111110110011010": 4, + "11111111111100000011": 1, + "11111111111111111101": 1, + "01111111111001100110": 2, + "10000000001001010011": 2, + "01111111101001100101": 1, + "11111111111010011110": 4, + "01111111111111110100": 5, + "00000000000000000111": 15, + "11111111110001100000": 2, + "00000000011111111110": 1, + "00000000000111111111": 4, + "10000000000111110010": 2, + "11111111111000001111": 9, + "10000000000000001110": 2, + "01111111111111111011": 4, + "11111111101001101100": 1, + "10000000011111110101": 10, + "01111111111111111010": 35, + "01111111110000001111": 1, + "11111111111100000111": 10, + "01111111110001100110": 3, + "10000000000000001001": 1755, + "00000000000000000011": 78, + "11111111111010010001": 1, + "01111111111000000010": 4, + "01111111111011110110": 2, + "00000000000000000000": 505, + "00000000001011110011": 1, + "11111111100000001010": 1, + "01111111111000001110": 1, + "01111111111011111100": 5, + "10000000000011111110": 1, + "11111111111111111100": 28, + "01111111111000001001": 3, + "00000000000111110111": 24, + "10000000001111001011": 2, + "00000000000100001111": 1, + "01111111111000110111": 2, + "01111111111100001001": 7, + "10000000000011111001": 1, + "11111111111111111111": 3, + "00000000000000001011": 17, + "11111111110100001011": 1, + "00000000000000001101": 5, + "01111111111010101111": 2, + "01111111111000110101": 2, + "11111111111011111100": 2, + "10000000000000001101": 352, + "00000000000000001111": 1024, + "01111111111001101111": 2, + "10000000011000001101": 4, + "11111111110011110111": 2, + "01111111110110010111": 4, + "10000000000111111010": 32, + "11111111110110010111": 6, + "01111111111001100000": 2, + "00000000000100000100": 1, + "11111111110011111000": 2, + "00000000000111110011": 137, + "00000000011000001111": 2, + "01111111110000001001": 1, + "10000000000111111110": 313, + "11111111111010101101": 4, + "10000000000000001010": 9, + "10000000000111110101": 9, + "01111111111100000010": 2, + "10000000000111110001": 157, + "01111111111011111101": 1, + "11111111110001100111": 5, + "11111111111111110001": 3, + "10000000000001100000": 1, + "00000000001111000110": 2, + "01111111110000000100": 1, + "00000000011111110011": 11, + "11111111110110011000": 3, + "11111111111001011110": 6, + "11111111100000001011": 1, + "11111111111011110111": 3, + "10000000000100000110": 2, + "00000000000000000100": 2351, + "01111111110110011110": 12, + "01111111111111110001": 28, + "10000000000000000010": 55, + "11111111110001101001": 1, + "11111111110100000010": 1, + "01111111111000001111": 2, + "00000000000000001100": 78, + "01111111111000110000": 1, + "11111111110001101010": 1, + "01111111111000110010": 1, + "01111111110110010011": 2, + "01111111111111111100": 4, + "01111111111110001001": 1, + "11111111111111110111": 45, + "00000000000111111100": 1, + "01111111111111111101": 3, + "01111111111111001111": 1, + "00000000011000000000": 2, + "10000000000000000100": 2, + "11111111111000000000": 4, + "01111111110111111010": 1, + "00000000000011110011": 1, + "11111111111100000010": 3, + "11111111110001100100": 7, + "01111111110111001001": 1, + "10000000000000000110": 563, + "01111111111010100000": 1, + "00000000000000001000": 2, + "11111111111011110001": 5, + "01111111110001101101": 1, + "01111111111111110111": 3, + "11111111111011111110": 1, + "11111111111111110100": 4, + "11111111111111110000": 4, + "11111111110110010000": 1, + "10000000000111001001": 1, + "11111111110110010010": 1, + "01111111111101111100": 1, + "01111111110110010010": 4, + "01111111111100000101": 2, + "10000000011111111110": 8, + "00000000000011111100": 1, + "01111111110110011010": 5, + "11111111111001101101": 3, + "01111111111111110101": 6, + "11111111111111110011": 2, + "01111111111000000011": 1, + "01111111110000001010": 1, + "11111111110001101111": 2, + "11111111111010011010": 2, + "00000000010000001111": 1, + "00000000000000001001": 1, + "01111111111001010011": 3, + "01111111110110011001": 1, + "11111111111101011010": 1, + "11111111110001101011": 2, + "10000000000000000001": 103, + "01111111111010010011": 1, + "10000000000000001111": 6, + "01111111110001100010": 4, + "10000000011111111010": 16, + "11111111110000000100": 1, + "01111111101001101010": 2, + "11111111111001010001": 1, + "00000000000000000010": 2, + "01111111111000001011": 1, + "01111111110000000110": 1, + "11111111111100000000": 2, + "01111111111111110011": 1, + "11111111111000111010": 2, + "11111111111111111000": 5, + "11111111110110011110": 1, + "01111111111000111100": 1, + "11111111110000000111": 2, + "01111111111111111110": 35, + "11111111111000110000": 1, + "01111111111010101011": 2, + "01111111111000001101": 4, + "01111111111010011000": 1, + "01111111110011111001": 2, + "00000000011111111000": 6, + "11111111111001101011": 2, + "01111111110001101001": 10, + "01111111110110100010": 1, + "11111111111111111110": 14, + "11111111110110011111": 2, + "11111111111111110110": 1, + "11111111111111001011": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "11111111110110011101": { "state": 1047965.0 }, + "11111111111101110011": { "state": 1048435.0 }, + "01111111111001011000": { "state": 523864.0 }, + "11111111101001100100": { "state": 1047140.0 }, + "01111111111100001110": { "state": 524046.0 }, + "11111111110110010001": { "state": 1047953.0 }, + "00000000000000110001": { "state": 49.0 }, + "11111111111010010101": { "state": 1048213.0 }, + "11111111111001010101": { "state": 1048149.0 }, + "10000000000011111101": { "state": 524541.0 }, + "01111111110110011100": { "state": 523676.0 }, + "10000000011111110001": { "state": 526321.0 }, + "01111111111100001111": { "state": 524047.0 }, + "01111111111011111010": { "state": 524026.0 }, + "01111111111010100100": { "state": 523940.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "01111111110001101111": { "state": 523375.0 }, + "10000000000011110101": { "state": 524533.0 }, + "10000000000111111101": { "state": 524797.0 }, + "01111111111000000110": { "state": 523782.0 }, + "10000000001000001101": { "state": 524813.0 }, + "11111111110110011100": { "state": 1047964.0 }, + "01111111111000000111": { "state": 523783.0 }, + "11111111111111000100": { "state": 1048516.0 }, + "00000000001111000100": { "state": 964.0 }, + "11111111111110011000": { "state": 1048472.0 }, + "01111111111111001101": { "state": 524237.0 }, + "10000000001000000101": { "state": 524805.0 }, + "11111111111000000010": { "state": 1048066.0 }, + "00000000011111111111": { "state": 2047.0 }, + "01111111110110010001": { "state": 523665.0 }, + "11111111110110011010": { "state": 1047962.0 }, + "11111111111100000011": { "state": 1048323.0 }, + "11111111111111111101": { "state": 1048573.0 }, + "01111111111001100110": { "state": 523878.0 }, + "10000000001001010011": { "state": 524883.0 }, + "01111111101001100101": { "state": 522853.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "01111111111111110100": { "state": 524276.0 }, + "00000000000000000111": { "state": 7.0 }, + "11111111110001100000": { "state": 1047648.0 }, + "00000000011111111110": { "state": 2046.0 }, + "00000000000111111111": { "state": 511.0 }, + "10000000000111110010": { "state": 524786.0 }, + "11111111111000001111": { "state": 1048079.0 }, + "10000000000000001110": { "state": 524302.0 }, + "01111111111111111011": { "state": 524283.0 }, + "11111111101001101100": { "state": 1047148.0 }, + "10000000011111110101": { "state": 526325.0 }, + "01111111111111111010": { "state": 524282.0 }, + "01111111110000001111": { "state": 523279.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "01111111110001100110": { "state": 523366.0 }, + "10000000000000001001": { "state": 524297.0 }, + "00000000000000000011": { "state": 3.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "01111111111000000010": { "state": 523778.0 }, + "01111111111011110110": { "state": 524022.0 }, + "00000000000000000000": { "state": 0.0 }, + "00000000001011110011": { "state": 755.0 }, + "11111111100000001010": { "state": 1046538.0 }, + "01111111111000001110": { "state": 523790.0 }, + "01111111111011111100": { "state": 524028.0 }, + "10000000000011111110": { "state": 524542.0 }, + "11111111111111111100": { "state": 1048572.0 }, + "01111111111000001001": { "state": 523785.0 }, + "00000000000111110111": { "state": 503.0 }, + "10000000001111001011": { "state": 525259.0 }, + "00000000000100001111": { "state": 271.0 }, + "01111111111000110111": { "state": 523831.0 }, + "01111111111100001001": { "state": 524041.0 }, + "10000000000011111001": { "state": 524537.0 }, + "11111111111111111111": { "state": 1048575.0 }, + "00000000000000001011": { "state": 11.0 }, + "11111111110100001011": { "state": 1047819.0 }, + "00000000000000001101": { "state": 13.0 }, + "01111111111010101111": { "state": 523951.0 }, + "01111111111000110101": { "state": 523829.0 }, + "11111111111011111100": { "state": 1048316.0 }, + "10000000000000001101": { "state": 524301.0 }, + "00000000000000001111": { "state": 15.0 }, + "01111111111001101111": { "state": 523887.0 }, + "10000000011000001101": { "state": 525837.0 }, + "11111111110011110111": { "state": 1047799.0 }, + "01111111110110010111": { "state": 523671.0 }, + "10000000000111111010": { "state": 524794.0 }, + "11111111110110010111": { "state": 1047959.0 }, + "01111111111001100000": { "state": 523872.0 }, + "00000000000100000100": { "state": 260.0 }, + "11111111110011111000": { "state": 1047800.0 }, + "00000000000111110011": { "state": 499.0 }, + "00000000011000001111": { "state": 1551.0 }, + "01111111110000001001": { "state": 523273.0 }, + "10000000000111111110": { "state": 524798.0 }, + "11111111111010101101": { "state": 1048237.0 }, + "10000000000000001010": { "state": 524298.0 }, + "10000000000111110101": { "state": 524789.0 }, + "01111111111100000010": { "state": 524034.0 }, + "10000000000111110001": { "state": 524785.0 }, + "01111111111011111101": { "state": 524029.0 }, + "11111111110001100111": { "state": 1047655.0 }, + "11111111111111110001": { "state": 1048561.0 }, + "10000000000001100000": { "state": 524384.0 }, + "00000000001111000110": { "state": 966.0 }, + "01111111110000000100": { "state": 523268.0 }, + "00000000011111110011": { "state": 2035.0 }, + "11111111110110011000": { "state": 1047960.0 }, + "11111111111001011110": { "state": 1048158.0 }, + "11111111100000001011": { "state": 1046539.0 }, + "11111111111011110111": { "state": 1048311.0 }, + "10000000000100000110": { "state": 524550.0 }, + "00000000000000000100": { "state": 4.0 }, + "01111111110110011110": { "state": 523678.0 }, + "01111111111111110001": { "state": 524273.0 }, + "10000000000000000010": { "state": 524290.0 }, + "11111111110001101001": { "state": 1047657.0 }, + "11111111110100000010": { "state": 1047810.0 }, + "01111111111000001111": { "state": 523791.0 }, + "00000000000000001100": { "state": 12.0 }, + "01111111111000110000": { "state": 523824.0 }, + "11111111110001101010": { "state": 1047658.0 }, + "01111111111000110010": { "state": 523826.0 }, + "01111111110110010011": { "state": 523667.0 }, + "01111111111111111100": { "state": 524284.0 }, + "01111111111110001001": { "state": 524169.0 }, + "11111111111111110111": { "state": 1048567.0 }, + "00000000000111111100": { "state": 508.0 }, + "01111111111111111101": { "state": 524285.0 }, + "01111111111111001111": { "state": 524239.0 }, + "00000000011000000000": { "state": 1536.0 }, + "10000000000000000100": { "state": 524292.0 }, + "11111111111000000000": { "state": 1048064.0 }, + "01111111110111111010": { "state": 523770.0 }, + "00000000000011110011": { "state": 243.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "11111111110001100100": { "state": 1047652.0 }, + "01111111110111001001": { "state": 523721.0 }, + "10000000000000000110": { "state": 524294.0 }, + "01111111111010100000": { "state": 523936.0 }, + "00000000000000001000": { "state": 8.0 }, + "11111111111011110001": { "state": 1048305.0 }, + "01111111110001101101": { "state": 523373.0 }, + "01111111111111110111": { "state": 524279.0 }, + "11111111111011111110": { "state": 1048318.0 }, + "11111111111111110100": { "state": 1048564.0 }, + "11111111111111110000": { "state": 1048560.0 }, + "11111111110110010000": { "state": 1047952.0 }, + "10000000000111001001": { "state": 524745.0 }, + "11111111110110010010": { "state": 1047954.0 }, + "01111111111101111100": { "state": 524156.0 }, + "01111111110110010010": { "state": 523666.0 }, + "01111111111100000101": { "state": 524037.0 }, + "10000000011111111110": { "state": 526334.0 }, + "00000000000011111100": { "state": 252.0 }, + "01111111110110011010": { "state": 523674.0 }, + "11111111111001101101": { "state": 1048173.0 }, + "01111111111111110101": { "state": 524277.0 }, + "11111111111111110011": { "state": 1048563.0 }, + "01111111111000000011": { "state": 523779.0 }, + "01111111110000001010": { "state": 523274.0 }, + "11111111110001101111": { "state": 1047663.0 }, + "11111111111010011010": { "state": 1048218.0 }, + "00000000010000001111": { "state": 1039.0 }, + "00000000000000001001": { "state": 9.0 }, + "01111111111001010011": { "state": 523859.0 }, + "01111111110110011001": { "state": 523673.0 }, + "11111111111101011010": { "state": 1048410.0 }, + "11111111110001101011": { "state": 1047659.0 }, + "10000000000000000001": { "state": 524289.0 }, + "01111111111010010011": { "state": 523923.0 }, + "10000000000000001111": { "state": 524303.0 }, + "01111111110001100010": { "state": 523362.0 }, + "10000000011111111010": { "state": 526330.0 }, + "11111111110000000100": { "state": 1047556.0 }, + "01111111101001101010": { "state": 522858.0 }, + "11111111111001010001": { "state": 1048145.0 }, + "00000000000000000010": { "state": 2.0 }, + "01111111111000001011": { "state": 523787.0 }, + "01111111110000000110": { "state": 523270.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "01111111111111110011": { "state": 524275.0 }, + "11111111111000111010": { "state": 1048122.0 }, + "11111111111111111000": { "state": 1048568.0 }, + "11111111110110011110": { "state": 1047966.0 }, + "01111111111000111100": { "state": 523836.0 }, + "11111111110000000111": { "state": 1047559.0 }, + "01111111111111111110": { "state": 524286.0 }, + "11111111111000110000": { "state": 1048112.0 }, + "01111111111010101011": { "state": 523947.0 }, + "01111111111000001101": { "state": 523789.0 }, + "01111111111010011000": { "state": 523928.0 }, + "01111111110011111001": { "state": 523513.0 }, + "00000000011111111000": { "state": 2040.0 }, + "11111111111001101011": { "state": 1048171.0 }, + "01111111110001101001": { "state": 523369.0 }, + "01111111110110100010": { "state": 523682.0 }, + "11111111111111111110": { "state": 1048574.0 }, + "11111111110110011111": { "state": 1047967.0 }, + "11111111111111110110": { "state": 1048566.0 }, + "11111111111111001011": { "state": 1048523.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n+2.json b/algorithms/glued_trees/results/20-qubits/2n+2.json index 8bc954a2..56935c7f 100644 --- a/algorithms/glued_trees/results/20-qubits/2n+2.json +++ b/algorithms/glued_trees/results/20-qubits/2n+2.json @@ -1 +1,316 @@ -{"vendor_format_result": {}, "counts": {"11111111111001100011": 1, "11111111111010101101": 1, "11111111111010010010": 1, "01111111111011110110": 1, "01111111111010000010": 1, "11111111111011110100": 1, "00000000000000000010": 1, "11111111111000110101": 1, "10000000000111110010": 4, "01111111111000110101": 1, "11111111110110011100": 3, "10000000000000001110": 13, "01111111111101100000": 1, "11111111110110010101": 2, "11111111110011111010": 2, "00000000000111110011": 17, "01111111111111111110": 6, "11111111111100001011": 21, "11111111101001100000": 1, "10000000001111001010": 1, "10000000000111110001": 114, "00000000011000000000": 1, "11111111111100001010": 5, "00000000000000000011": 16, "10000000000000001001": 150, "01111111111100000100": 2, "01111111111011110010": 2, "00000000000111110100": 8, "11111111111011110010": 1, "00000000000011110100": 6, "11111111110110010000": 8, "00000000000000001101": 2, "01111111111011110111": 1, "00000000011000001111": 1, "11111111111111001001": 1, "00000000011111111100": 9, "11111111111011110000": 1, "01111111111100000001": 1, "10000000000111111110": 287, "11111111110110011010": 1, "01111111111100001101": 18, "00000000000000001011": 356, "01111111110110010101": 2, "00000000000111111100": 8, "11111111110011110100": 1, "11111111111100000000": 43, "00000000000000000000": 4026, "01111111111100000111": 1, "01111111111100001111": 1, "01111111110011111010": 1, "10000000000011110110": 1, "00000000000011111010": 1, "10000000000000001010": 435, "10000000011111111110": 21, "01111111111100000101": 17, "10000000000000000101": 863, "00000000000000001111": 981, "01111111110011110010": 2, "10000000000011111010": 4, "11111111111100000100": 14, "11111111110011111011": 1, "01111111110110011101": 15, "10000000000111110101": 1, "11111111111111110001": 1, "01111111111011111101": 1, "11111111111100000111": 10, "11111111111111110100": 2, "10000000000000001101": 267, "01111111110011110110": 1, "00000000000011111111": 3, "11111111110110010010": 1, "11111111111010011110": 9, "01111111111010100000": 1, "01111111111011111110": 2, "10000000000000000110": 52, "11111111111000111011": 1, "11111111110110010011": 3, "01111111101001100101": 1, "10000000011111110010": 3, "10000000011111110001": 1, "00000000000000000100": 20, "01111111101001100010": 1, "11111111111111001101": 1, "01111111111100000110": 2, "11111111111100011011": 1, "00000000000000001100": 47, "01111111111010011100": 1, "01111111110011111110": 1, "10000000000011111101": 1, "11111111110110010100": 2, "01111111111111001101": 1, "11111111110011111100": 2, "00000000000000001000": 87, "01111111110110010010": 1, "10000000000011110010": 3, "11111111111100001000": 5, "01111111111001100000": 4, "01111111110100000101": 1, "00000000011111110100": 3, "11111111111100001101": 5, "11111111111010010001": 2, "11111111111100000011": 2, "11111111110011110101": 1, "10000000000111111010": 1, "11111111110110010111": 2, "01111111111000110010": 3, "01111111111111111111": 1, "10000000000011111100": 1, "11111111111100000101": 5, "00000000000011111101": 1, "11111111111000110100": 1, "10000000000011111001": 1, "00000000000011111011": 2, "11111111111111001011": 1, "00000000000100000101": 1, "01111111100011111010": 1, "01111111111001101111": 1, "01111111111111111010": 4, "11111111111111001100": 1, "01111111111100000011": 1, "01111111101001100100": 1, "11111111110110011000": 2, "00000000011111110011": 2, "11111111111100001100": 7, "01111111111100001100": 2, "11111111110110011101": 2, "01111111110011111101": 2, "01111111111100001110": 2, "11111111110110011011": 2, "01111111110110010001": 1, "01111111111100000010": 4, "01111111111011110101": 1, "11111111110001100100": 2, "11111111111100000010": 6, "00000000000011110011": 1, "10000000000000000001": 50, "01111111111010010011": 1, "10000000000000000010": 9, "11111111100011110011": 1, "01111111110110010000": 1, "00000000001100001111": 1, "00000000000100001111": 1}, "counts_lsb_right": true, "parsed_states": {"11111111111001100011": {"state": 1048163.0}, "11111111111010101101": {"state": 1048237.0}, "11111111111010010010": {"state": 1048210.0}, "01111111111011110110": {"state": 524022.0}, "01111111111010000010": {"state": 523906.0}, "11111111111011110100": {"state": 1048308.0}, "00000000000000000010": {"state": 2.0}, "11111111111000110101": {"state": 1048117.0}, "10000000000111110010": {"state": 524786.0}, "01111111111000110101": {"state": 523829.0}, "11111111110110011100": {"state": 1047964.0}, "10000000000000001110": {"state": 524302.0}, "01111111111101100000": {"state": 524128.0}, "11111111110110010101": {"state": 1047957.0}, "11111111110011111010": {"state": 1047802.0}, "00000000000111110011": {"state": 499.0}, "01111111111111111110": {"state": 524286.0}, "11111111111100001011": {"state": 1048331.0}, "11111111101001100000": {"state": 1047136.0}, "10000000001111001010": {"state": 525258.0}, "10000000000111110001": {"state": 524785.0}, "00000000011000000000": {"state": 1536.0}, "11111111111100001010": {"state": 1048330.0}, "00000000000000000011": {"state": 3.0}, "10000000000000001001": {"state": 524297.0}, "01111111111100000100": {"state": 524036.0}, "01111111111011110010": {"state": 524018.0}, "00000000000111110100": {"state": 500.0}, "11111111111011110010": {"state": 1048306.0}, "00000000000011110100": {"state": 244.0}, "11111111110110010000": {"state": 1047952.0}, "00000000000000001101": {"state": 13.0}, "01111111111011110111": {"state": 524023.0}, "00000000011000001111": {"state": 1551.0}, "11111111111111001001": {"state": 1048521.0}, "00000000011111111100": {"state": 2044.0}, "11111111111011110000": {"state": 1048304.0}, "01111111111100000001": {"state": 524033.0}, "10000000000111111110": {"state": 524798.0}, "11111111110110011010": {"state": 1047962.0}, "01111111111100001101": {"state": 524045.0}, "00000000000000001011": {"state": 11.0}, "01111111110110010101": {"state": 523669.0}, "00000000000111111100": {"state": 508.0}, "11111111110011110100": {"state": 1047796.0}, "11111111111100000000": {"state": 1048320.0}, "00000000000000000000": {"state": 0.0}, "01111111111100000111": {"state": 524039.0}, "01111111111100001111": {"state": 524047.0}, "01111111110011111010": {"state": 523514.0}, "10000000000011110110": {"state": 524534.0}, "00000000000011111010": {"state": 250.0}, "10000000000000001010": {"state": 524298.0}, "10000000011111111110": {"state": 526334.0}, "01111111111100000101": {"state": 524037.0}, "10000000000000000101": {"state": 524293.0}, "00000000000000001111": {"state": 15.0}, "01111111110011110010": {"state": 523506.0}, "10000000000011111010": {"state": 524538.0}, "11111111111100000100": {"state": 1048324.0}, "11111111110011111011": {"state": 1047803.0}, "01111111110110011101": {"state": 523677.0}, "10000000000111110101": {"state": 524789.0}, "11111111111111110001": {"state": 1048561.0}, "01111111111011111101": {"state": 524029.0}, "11111111111100000111": {"state": 1048327.0}, "11111111111111110100": {"state": 1048564.0}, "10000000000000001101": {"state": 524301.0}, "01111111110011110110": {"state": 523510.0}, "00000000000011111111": {"state": 255.0}, "11111111110110010010": {"state": 1047954.0}, "11111111111010011110": {"state": 1048222.0}, "01111111111010100000": {"state": 523936.0}, "01111111111011111110": {"state": 524030.0}, "10000000000000000110": {"state": 524294.0}, "11111111111000111011": {"state": 1048123.0}, "11111111110110010011": {"state": 1047955.0}, "01111111101001100101": {"state": 522853.0}, "10000000011111110010": {"state": 526322.0}, "10000000011111110001": {"state": 526321.0}, "00000000000000000100": {"state": 4.0}, "01111111101001100010": {"state": 522850.0}, "11111111111111001101": {"state": 1048525.0}, "01111111111100000110": {"state": 524038.0}, "11111111111100011011": {"state": 1048347.0}, "00000000000000001100": {"state": 12.0}, "01111111111010011100": {"state": 523932.0}, "01111111110011111110": {"state": 523518.0}, "10000000000011111101": {"state": 524541.0}, "11111111110110010100": {"state": 1047956.0}, "01111111111111001101": {"state": 524237.0}, "11111111110011111100": {"state": 1047804.0}, "00000000000000001000": {"state": 8.0}, "01111111110110010010": {"state": 523666.0}, "10000000000011110010": {"state": 524530.0}, "11111111111100001000": {"state": 1048328.0}, "01111111111001100000": {"state": 523872.0}, "01111111110100000101": {"state": 523525.0}, "00000000011111110100": {"state": 2036.0}, "11111111111100001101": {"state": 1048333.0}, "11111111111010010001": {"state": 1048209.0}, "11111111111100000011": {"state": 1048323.0}, "11111111110011110101": {"state": 1047797.0}, "10000000000111111010": {"state": 524794.0}, "11111111110110010111": {"state": 1047959.0}, "01111111111000110010": {"state": 523826.0}, "01111111111111111111": {"state": 524287.0}, "10000000000011111100": {"state": 524540.0}, "11111111111100000101": {"state": 1048325.0}, "00000000000011111101": {"state": 253.0}, "11111111111000110100": {"state": 1048116.0}, "10000000000011111001": {"state": 524537.0}, "00000000000011111011": {"state": 251.0}, "11111111111111001011": {"state": 1048523.0}, "00000000000100000101": {"state": 261.0}, "01111111100011111010": {"state": 522490.0}, "01111111111001101111": {"state": 523887.0}, "01111111111111111010": {"state": 524282.0}, "11111111111111001100": {"state": 1048524.0}, "01111111111100000011": {"state": 524035.0}, "01111111101001100100": {"state": 522852.0}, "11111111110110011000": {"state": 1047960.0}, "00000000011111110011": {"state": 2035.0}, "11111111111100001100": {"state": 1048332.0}, "01111111111100001100": {"state": 524044.0}, "11111111110110011101": {"state": 1047965.0}, "01111111110011111101": {"state": 523517.0}, "01111111111100001110": {"state": 524046.0}, "11111111110110011011": {"state": 1047963.0}, "01111111110110010001": {"state": 523665.0}, "01111111111100000010": {"state": 524034.0}, "01111111111011110101": {"state": 524021.0}, "11111111110001100100": {"state": 1047652.0}, "11111111111100000010": {"state": 1048322.0}, "00000000000011110011": {"state": 243.0}, "10000000000000000001": {"state": 524289.0}, "01111111111010010011": {"state": 523923.0}, "10000000000000000010": {"state": 524290.0}, "11111111100011110011": {"state": 1046771.0}, "01111111110110010000": {"state": 523664.0}, "00000000001100001111": {"state": 783.0}, "00000000000100001111": {"state": 271.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "11111111101001100000": 1, + "10000000001111001111": 1, + "11111111111100001110": 1, + "10000000000110100111": 1, + "11111111110110101111": 1, + "11111111110100001011": 1, + "00000000000100000100": 1, + "11111111110110010111": 1, + "11111111110110011011": 3, + "01111111111001101110": 1, + "01111111111111110110": 1, + "10000000000011111101": 7, + "01111111111111001101": 1, + "11111111110110010100": 3, + "01111111110011111110": 1, + "10000000000111110010": 6, + "11111111110110010101": 2, + "10000000000000001110": 24, + "01111111111101100000": 1, + "01111111111011110010": 1, + "00000000000111110100": 5, + "00000000000011110100": 2, + "00000000000111110011": 13, + "00000000000111110101": 1, + "11111111110110010000": 2, + "11111111110000000100": 1, + "10000000001100001010": 1, + "11111111111100000110": 2, + "01111111111100000110": 2, + "00000000000000000100": 14, + "11111111110011111011": 1, + "11111111111100000100": 12, + "11111111111001100101": 1, + "11111111111010011110": 13, + "10000000000000001101": 278, + "10000000000000000101": 876, + "10000000000011110100": 1, + "01111111110001101010": 1, + "11111111110110011100": 3, + "10000000000111110001": 106, + "10000000000011111010": 2, + "01111111110011110010": 2, + "11111111101001101101": 1, + "11111111111100000101": 6, + "00000000000000001011": 372, + "01111111111111111110": 5, + "11111111110000000111": 1, + "11111111111100000111": 7, + "11111111111100001011": 18, + "10000000000011110101": 2, + "10000000000110010001": 1, + "11111111111000001100": 1, + "01111111111100001010": 1, + "00000000000000001111": 933, + "10000000000000001001": 145, + "00000000000000000011": 24, + "10000000011111110010": 2, + "01111111111011110101": 1, + "01111111111100000010": 9, + "11111111110110010010": 2, + "00000000000011111111": 3, + "11111111111111111011": 2, + "10000000011111111110": 22, + "01111111111100000101": 14, + "00000000000011110010": 1, + "01111111111010010100": 2, + "10000000000111111110": 304, + "11111111111100000000": 40, + "00000000000000000000": 4031, + "01111111111100001111": 2, + "01111111110011111010": 1, + "00000000000100000011": 1, + "01111111110110011101": 11, + "11111111110110010011": 2, + "11111111111100111010": 1, + "00000000000011111011": 3, + "10000000000000001011": 2, + "00000000011111110100": 6, + "01111111111100001011": 2, + "01111111111100001101": 18, + "11111111111111000100": 1, + "11111111111101101010": 1, + "01111111111100000011": 2, + "00000000000000000101": 1, + "11111111111100000001": 1, + "00000000000000001000": 65, + "00000000000000001100": 32, + "10000000000000000010": 14, + "11111111110001100100": 1, + "00000000000011110011": 3, + "11111111111100000010": 3, + "11111111111111000000": 2, + "01111111111111001110": 1, + "11111111111100000011": 2, + "10000000011111110001": 3, + "10000000000011111001": 2, + "00000000000111111100": 5, + "11111111101001101011": 2, + "10000000001111000100": 1, + "10000000000011110010": 4, + "11111111111100001000": 4, + "11111111111011100010": 1, + "01111111111100001110": 2, + "01111111110011111101": 1, + "11111111101001100100": 1, + "11111111111111001001": 1, + "00000000011111111100": 1, + "01111111111111111111": 1, + "10000000000011111100": 3, + "01111111111011111010": 1, + "01111111111000110011": 1, + "11111111111011110100": 2, + "11111111111100001100": 5, + "01111111111111001001": 1, + "11111111111111001011": 1, + "01111111110000001101": 2, + "01111111110110010101": 1, + "10000000000000000001": 49, + "01111111111010010011": 2, + "01111111111000110010": 1, + "00000000001111001010": 1, + "10000000001111000011": 1, + "10000000000111111010": 2, + "01111111101001101010": 1, + "01111111110110010010": 2, + "01111111111010100000": 1, + "10000000000000000110": 66, + "01111111111011111110": 2, + "10000000000100001010": 1, + "01111111111000111110": 1, + "11111111110110011111": 1, + "00000000011111110011": 5, + "11111111110110011000": 1, + "11111111111001101101": 2, + "11111111111010010001": 2, + "11111111111100001101": 4, + "11111111111111000011": 1, + "01111111111100110110": 1, + "01111111111111110010": 2, + "01111111111000110101": 1, + "11111111111111001110": 1, + "11111111111111000001": 1, + "10000000000000001010": 464, + "11111111111101011001": 1, + "00000000000011111010": 1, + "11111111111011111011": 1, + "01111111101001101110": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "11111111101001100000": { "state": 1047136.0 }, + "10000000001111001111": { "state": 525263.0 }, + "11111111111100001110": { "state": 1048334.0 }, + "10000000000110100111": { "state": 524711.0 }, + "11111111110110101111": { "state": 1047983.0 }, + "11111111110100001011": { "state": 1047819.0 }, + "00000000000100000100": { "state": 260.0 }, + "11111111110110010111": { "state": 1047959.0 }, + "11111111110110011011": { "state": 1047963.0 }, + "01111111111001101110": { "state": 523886.0 }, + "01111111111111110110": { "state": 524278.0 }, + "10000000000011111101": { "state": 524541.0 }, + "01111111111111001101": { "state": 524237.0 }, + "11111111110110010100": { "state": 1047956.0 }, + "01111111110011111110": { "state": 523518.0 }, + "10000000000111110010": { "state": 524786.0 }, + "11111111110110010101": { "state": 1047957.0 }, + "10000000000000001110": { "state": 524302.0 }, + "01111111111101100000": { "state": 524128.0 }, + "01111111111011110010": { "state": 524018.0 }, + "00000000000111110100": { "state": 500.0 }, + "00000000000011110100": { "state": 244.0 }, + "00000000000111110011": { "state": 499.0 }, + "00000000000111110101": { "state": 501.0 }, + "11111111110110010000": { "state": 1047952.0 }, + "11111111110000000100": { "state": 1047556.0 }, + "10000000001100001010": { "state": 525066.0 }, + "11111111111100000110": { "state": 1048326.0 }, + "01111111111100000110": { "state": 524038.0 }, + "00000000000000000100": { "state": 4.0 }, + "11111111110011111011": { "state": 1047803.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "11111111111001100101": { "state": 1048165.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "10000000000000001101": { "state": 524301.0 }, + "10000000000000000101": { "state": 524293.0 }, + "10000000000011110100": { "state": 524532.0 }, + "01111111110001101010": { "state": 523370.0 }, + "11111111110110011100": { "state": 1047964.0 }, + "10000000000111110001": { "state": 524785.0 }, + "10000000000011111010": { "state": 524538.0 }, + "01111111110011110010": { "state": 523506.0 }, + "11111111101001101101": { "state": 1047149.0 }, + "11111111111100000101": { "state": 1048325.0 }, + "00000000000000001011": { "state": 11.0 }, + "01111111111111111110": { "state": 524286.0 }, + "11111111110000000111": { "state": 1047559.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "11111111111100001011": { "state": 1048331.0 }, + "10000000000011110101": { "state": 524533.0 }, + "10000000000110010001": { "state": 524689.0 }, + "11111111111000001100": { "state": 1048076.0 }, + "01111111111100001010": { "state": 524042.0 }, + "00000000000000001111": { "state": 15.0 }, + "10000000000000001001": { "state": 524297.0 }, + "00000000000000000011": { "state": 3.0 }, + "10000000011111110010": { "state": 526322.0 }, + "01111111111011110101": { "state": 524021.0 }, + "01111111111100000010": { "state": 524034.0 }, + "11111111110110010010": { "state": 1047954.0 }, + "00000000000011111111": { "state": 255.0 }, + "11111111111111111011": { "state": 1048571.0 }, + "10000000011111111110": { "state": 526334.0 }, + "01111111111100000101": { "state": 524037.0 }, + "00000000000011110010": { "state": 242.0 }, + "01111111111010010100": { "state": 523924.0 }, + "10000000000111111110": { "state": 524798.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "00000000000000000000": { "state": 0.0 }, + "01111111111100001111": { "state": 524047.0 }, + "01111111110011111010": { "state": 523514.0 }, + "00000000000100000011": { "state": 259.0 }, + "01111111110110011101": { "state": 523677.0 }, + "11111111110110010011": { "state": 1047955.0 }, + "11111111111100111010": { "state": 1048378.0 }, + "00000000000011111011": { "state": 251.0 }, + "10000000000000001011": { "state": 524299.0 }, + "00000000011111110100": { "state": 2036.0 }, + "01111111111100001011": { "state": 524043.0 }, + "01111111111100001101": { "state": 524045.0 }, + "11111111111111000100": { "state": 1048516.0 }, + "11111111111101101010": { "state": 1048426.0 }, + "01111111111100000011": { "state": 524035.0 }, + "00000000000000000101": { "state": 5.0 }, + "11111111111100000001": { "state": 1048321.0 }, + "00000000000000001000": { "state": 8.0 }, + "00000000000000001100": { "state": 12.0 }, + "10000000000000000010": { "state": 524290.0 }, + "11111111110001100100": { "state": 1047652.0 }, + "00000000000011110011": { "state": 243.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "11111111111111000000": { "state": 1048512.0 }, + "01111111111111001110": { "state": 524238.0 }, + "11111111111100000011": { "state": 1048323.0 }, + "10000000011111110001": { "state": 526321.0 }, + "10000000000011111001": { "state": 524537.0 }, + "00000000000111111100": { "state": 508.0 }, + "11111111101001101011": { "state": 1047147.0 }, + "10000000001111000100": { "state": 525252.0 }, + "10000000000011110010": { "state": 524530.0 }, + "11111111111100001000": { "state": 1048328.0 }, + "11111111111011100010": { "state": 1048290.0 }, + "01111111111100001110": { "state": 524046.0 }, + "01111111110011111101": { "state": 523517.0 }, + "11111111101001100100": { "state": 1047140.0 }, + "11111111111111001001": { "state": 1048521.0 }, + "00000000011111111100": { "state": 2044.0 }, + "01111111111111111111": { "state": 524287.0 }, + "10000000000011111100": { "state": 524540.0 }, + "01111111111011111010": { "state": 524026.0 }, + "01111111111000110011": { "state": 523827.0 }, + "11111111111011110100": { "state": 1048308.0 }, + "11111111111100001100": { "state": 1048332.0 }, + "01111111111111001001": { "state": 524233.0 }, + "11111111111111001011": { "state": 1048523.0 }, + "01111111110000001101": { "state": 523277.0 }, + "01111111110110010101": { "state": 523669.0 }, + "10000000000000000001": { "state": 524289.0 }, + "01111111111010010011": { "state": 523923.0 }, + "01111111111000110010": { "state": 523826.0 }, + "00000000001111001010": { "state": 970.0 }, + "10000000001111000011": { "state": 525251.0 }, + "10000000000111111010": { "state": 524794.0 }, + "01111111101001101010": { "state": 522858.0 }, + "01111111110110010010": { "state": 523666.0 }, + "01111111111010100000": { "state": 523936.0 }, + "10000000000000000110": { "state": 524294.0 }, + "01111111111011111110": { "state": 524030.0 }, + "10000000000100001010": { "state": 524554.0 }, + "01111111111000111110": { "state": 523838.0 }, + "11111111110110011111": { "state": 1047967.0 }, + "00000000011111110011": { "state": 2035.0 }, + "11111111110110011000": { "state": 1047960.0 }, + "11111111111001101101": { "state": 1048173.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "11111111111100001101": { "state": 1048333.0 }, + "11111111111111000011": { "state": 1048515.0 }, + "01111111111100110110": { "state": 524086.0 }, + "01111111111111110010": { "state": 524274.0 }, + "01111111111000110101": { "state": 523829.0 }, + "11111111111111001110": { "state": 1048526.0 }, + "11111111111111000001": { "state": 1048513.0 }, + "10000000000000001010": { "state": 524298.0 }, + "11111111111101011001": { "state": 1048409.0 }, + "00000000000011111010": { "state": 250.0 }, + "11111111111011111011": { "state": 1048315.0 }, + "01111111101001101110": { "state": 522862.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n+4.json b/algorithms/glued_trees/results/20-qubits/2n+4.json index 73cbddab..2e0f5123 100644 --- a/algorithms/glued_trees/results/20-qubits/2n+4.json +++ b/algorithms/glued_trees/results/20-qubits/2n+4.json @@ -1 +1,358 @@ -{"vendor_format_result": {}, "counts": {"10000000000000001111": 1, "11111111110110010001": 1, "10000000011111110101": 1, "01111111111111000001": 1, "11111111111000001100": 1, "00000000000011100111": 1, "01111111110110011010": 2, "01111111110100001010": 1, "00000000001100001100": 1, "11111111101001101100": 1, "00000000011111111000": 2, "00000000001111111100": 1, "01111111111111001100": 1, "01111111111100001011": 1, "00000000011000001111": 1, "01111111111011111010": 2, "01111111111001101111": 1, "10000000000111110010": 3, "10000000000111111010": 7, "10000000000100000110": 1, "11111111111011110111": 1, "11111111110110011010": 1, "11111111111100001001": 2, "11111111111001101101": 1, "11111111110110011111": 1, "11111111111111001100": 2, "10000000000011110100": 1, "10000000000000000101": 5, "11111111111111110101": 1, "10000000000111111001": 1, "01111111110000000010": 1, "00000000000000001011": 29, "11111111111000000101": 1, "00000000000111111111": 2, "10000000000000001110": 102, "01111111110110011110": 4, "01111111111101100000": 3, "10000000011111110001": 9, "11111111110001100011": 1, "00000000000111110111": 2, "11111111111100001100": 16, "10000000000111111110": 302, "01111111110110010110": 2, "01111111110001100011": 1, "01111111111100001001": 11, "11111111111100000111": 13, "11111111111100001011": 2, "10000000000011110101": 3, "01111111111010010011": 3, "10000000000000000001": 651, "01111111110001101010": 1, "11111111110110011100": 3, "00000000000000000011": 769, "11111111111000111011": 1, "11111111111111110010": 2, "10000000000000000110": 271, "00000000000011111101": 2, "11111111111100000101": 4, "10000000001111001101": 1, "10000000011111110110": 1, "00000000000011111011": 1, "10000000000111111101": 10, "00000000000000000010": 1, "00000000000000000100": 1414, "00000000000011111100": 1, "01111111111100000101": 17, "10000000011111111110": 7, "11111111111111001011": 1, "11111111111111110110": 1, "11111111111010011110": 11, "10000000000011111011": 2, "01111111111100001010": 10, "00000000000000001111": 1178, "00000000000000000000": 1257, "01111111111101100100": 1, "01111111111100000111": 3, "01111111110011111010": 2, "10000000000000001010": 66, "00000000000000000111": 91, "01111111110001100101": 1, "01111111111101101111": 3, "01111111110110010101": 7, "11111111101001101011": 1, "11111111111111110111": 7, "00000000000000001100": 585, "01111111111111111111": 1, "10000000000000000010": 313, "10000000000111110001": 129, "00000000011000000000": 3, "11111111111100001010": 4, "01111111111000100001": 1, "00000000000111110011": 30, "11111111111000110000": 1, "11111111110000000111": 1, "01111111111111111110": 9, "11111111110110010010": 2, "10000000000000000100": 1, "01111111111100000010": 13, "10000000000111110101": 4, "00000000011111111111": 7, "01111111110011110101": 1, "01111111111011111101": 4, "01111111110110010001": 1, "11111111110110011011": 3, "01111111110001100010": 1, "10000000011111111010": 6, "01111111110110010000": 2, "11111111111000110011": 1, "11111111111100001110": 1, "10000000011111111101": 5, "10000000000000001101": 312, "00000000000011110000": 1, "11111111111100001111": 4, "01111111110110011101": 1, "00000000000100000011": 1, "01111111111001100010": 1, "11111111111100000010": 3, "00000000000011110011": 2, "01111111111111111001": 1, "11111111111100000000": 8, "01111111111010011000": 1, "01111111110011111001": 2, "10000000000011110001": 2, "11111111100000000000": 1, "11111111111111110011": 2, "11111111111111111011": 2, "01111111110110011111": 2, "01111111111111000101": 2, "01111111111111111101": 12, "00000000000011110101": 1, "11111111110011111100": 2, "00000000000000001000": 8, "11111111111100000001": 3, "10000000000011111101": 5, "10000000000000001001": 270, "01111111111100001000": 4, "01111111111100000001": 1, "11111111110011111101": 1, "11111111110000000010": 1, "11111111111010010001": 3, "11111111111100001101": 2, "11111111111100000100": 4, "10000000000011111010": 4, "01111111100000000101": 1, "01111111110110101101": 1, "11111111111100000011": 14, "11111111101001100010": 1, "01111111111100000110": 1, "01111111101001100010": 2, "01111111111001100000": 4, "00000000000111111011": 1, "00000000011111110011": 3, "00000000001100000100": 1, "01111111101001101010": 1, "11111111101001100011": 1, "11111111110001101011": 1, "11111111111010011010": 1, "01111111111111110101": 1, "10000000001100000001": 1, "01111111101001100001": 1, "11111111111010010101": 1, "11111111100011111000": 1, "11111111111000111001": 1, "11111111110110011101": 1, "11111111111111001111": 1}, "counts_lsb_right": true, "parsed_states": {"10000000000000001111": {"state": 524303.0}, "11111111110110010001": {"state": 1047953.0}, "10000000011111110101": {"state": 526325.0}, "01111111111111000001": {"state": 524225.0}, "11111111111000001100": {"state": 1048076.0}, "00000000000011100111": {"state": 231.0}, "01111111110110011010": {"state": 523674.0}, "01111111110100001010": {"state": 523530.0}, "00000000001100001100": {"state": 780.0}, "11111111101001101100": {"state": 1047148.0}, "00000000011111111000": {"state": 2040.0}, "00000000001111111100": {"state": 1020.0}, "01111111111111001100": {"state": 524236.0}, "01111111111100001011": {"state": 524043.0}, "00000000011000001111": {"state": 1551.0}, "01111111111011111010": {"state": 524026.0}, "01111111111001101111": {"state": 523887.0}, "10000000000111110010": {"state": 524786.0}, "10000000000111111010": {"state": 524794.0}, "10000000000100000110": {"state": 524550.0}, "11111111111011110111": {"state": 1048311.0}, "11111111110110011010": {"state": 1047962.0}, "11111111111100001001": {"state": 1048329.0}, "11111111111001101101": {"state": 1048173.0}, "11111111110110011111": {"state": 1047967.0}, "11111111111111001100": {"state": 1048524.0}, "10000000000011110100": {"state": 524532.0}, "10000000000000000101": {"state": 524293.0}, "11111111111111110101": {"state": 1048565.0}, "10000000000111111001": {"state": 524793.0}, "01111111110000000010": {"state": 523266.0}, "00000000000000001011": {"state": 11.0}, "11111111111000000101": {"state": 1048069.0}, "00000000000111111111": {"state": 511.0}, "10000000000000001110": {"state": 524302.0}, "01111111110110011110": {"state": 523678.0}, "01111111111101100000": {"state": 524128.0}, "10000000011111110001": {"state": 526321.0}, "11111111110001100011": {"state": 1047651.0}, "00000000000111110111": {"state": 503.0}, "11111111111100001100": {"state": 1048332.0}, "10000000000111111110": {"state": 524798.0}, "01111111110110010110": {"state": 523670.0}, "01111111110001100011": {"state": 523363.0}, "01111111111100001001": {"state": 524041.0}, "11111111111100000111": {"state": 1048327.0}, "11111111111100001011": {"state": 1048331.0}, "10000000000011110101": {"state": 524533.0}, "01111111111010010011": {"state": 523923.0}, "10000000000000000001": {"state": 524289.0}, "01111111110001101010": {"state": 523370.0}, "11111111110110011100": {"state": 1047964.0}, "00000000000000000011": {"state": 3.0}, "11111111111000111011": {"state": 1048123.0}, "11111111111111110010": {"state": 1048562.0}, "10000000000000000110": {"state": 524294.0}, "00000000000011111101": {"state": 253.0}, "11111111111100000101": {"state": 1048325.0}, "10000000001111001101": {"state": 525261.0}, "10000000011111110110": {"state": 526326.0}, "00000000000011111011": {"state": 251.0}, "10000000000111111101": {"state": 524797.0}, "00000000000000000010": {"state": 2.0}, "00000000000000000100": {"state": 4.0}, "00000000000011111100": {"state": 252.0}, "01111111111100000101": {"state": 524037.0}, "10000000011111111110": {"state": 526334.0}, "11111111111111001011": {"state": 1048523.0}, "11111111111111110110": {"state": 1048566.0}, "11111111111010011110": {"state": 1048222.0}, "10000000000011111011": {"state": 524539.0}, "01111111111100001010": {"state": 524042.0}, "00000000000000001111": {"state": 15.0}, "00000000000000000000": {"state": 0.0}, "01111111111101100100": {"state": 524132.0}, "01111111111100000111": {"state": 524039.0}, "01111111110011111010": {"state": 523514.0}, "10000000000000001010": {"state": 524298.0}, "00000000000000000111": {"state": 7.0}, "01111111110001100101": {"state": 523365.0}, "01111111111101101111": {"state": 524143.0}, "01111111110110010101": {"state": 523669.0}, "11111111101001101011": {"state": 1047147.0}, "11111111111111110111": {"state": 1048567.0}, "00000000000000001100": {"state": 12.0}, "01111111111111111111": {"state": 524287.0}, "10000000000000000010": {"state": 524290.0}, "10000000000111110001": {"state": 524785.0}, "00000000011000000000": {"state": 1536.0}, "11111111111100001010": {"state": 1048330.0}, "01111111111000100001": {"state": 523809.0}, "00000000000111110011": {"state": 499.0}, "11111111111000110000": {"state": 1048112.0}, "11111111110000000111": {"state": 1047559.0}, "01111111111111111110": {"state": 524286.0}, "11111111110110010010": {"state": 1047954.0}, "10000000000000000100": {"state": 524292.0}, "01111111111100000010": {"state": 524034.0}, "10000000000111110101": {"state": 524789.0}, "00000000011111111111": {"state": 2047.0}, "01111111110011110101": {"state": 523509.0}, "01111111111011111101": {"state": 524029.0}, "01111111110110010001": {"state": 523665.0}, "11111111110110011011": {"state": 1047963.0}, "01111111110001100010": {"state": 523362.0}, "10000000011111111010": {"state": 526330.0}, "01111111110110010000": {"state": 523664.0}, "11111111111000110011": {"state": 1048115.0}, "11111111111100001110": {"state": 1048334.0}, "10000000011111111101": {"state": 526333.0}, "10000000000000001101": {"state": 524301.0}, "00000000000011110000": {"state": 240.0}, "11111111111100001111": {"state": 1048335.0}, "01111111110110011101": {"state": 523677.0}, "00000000000100000011": {"state": 259.0}, "01111111111001100010": {"state": 523874.0}, "11111111111100000010": {"state": 1048322.0}, "00000000000011110011": {"state": 243.0}, "01111111111111111001": {"state": 524281.0}, "11111111111100000000": {"state": 1048320.0}, "01111111111010011000": {"state": 523928.0}, "01111111110011111001": {"state": 523513.0}, "10000000000011110001": {"state": 524529.0}, "11111111100000000000": {"state": 1046528.0}, "11111111111111110011": {"state": 1048563.0}, "11111111111111111011": {"state": 1048571.0}, "01111111110110011111": {"state": 523679.0}, "01111111111111000101": {"state": 524229.0}, "01111111111111111101": {"state": 524285.0}, "00000000000011110101": {"state": 245.0}, "11111111110011111100": {"state": 1047804.0}, "00000000000000001000": {"state": 8.0}, "11111111111100000001": {"state": 1048321.0}, "10000000000011111101": {"state": 524541.0}, "10000000000000001001": {"state": 524297.0}, "01111111111100001000": {"state": 524040.0}, "01111111111100000001": {"state": 524033.0}, "11111111110011111101": {"state": 1047805.0}, "11111111110000000010": {"state": 1047554.0}, "11111111111010010001": {"state": 1048209.0}, "11111111111100001101": {"state": 1048333.0}, "11111111111100000100": {"state": 1048324.0}, "10000000000011111010": {"state": 524538.0}, "01111111100000000101": {"state": 522245.0}, "01111111110110101101": {"state": 523693.0}, "11111111111100000011": {"state": 1048323.0}, "11111111101001100010": {"state": 1047138.0}, "01111111111100000110": {"state": 524038.0}, "01111111101001100010": {"state": 522850.0}, "01111111111001100000": {"state": 523872.0}, "00000000000111111011": {"state": 507.0}, "00000000011111110011": {"state": 2035.0}, "00000000001100000100": {"state": 772.0}, "01111111101001101010": {"state": 522858.0}, "11111111101001100011": {"state": 1047139.0}, "11111111110001101011": {"state": 1047659.0}, "11111111111010011010": {"state": 1048218.0}, "01111111111111110101": {"state": 524277.0}, "10000000001100000001": {"state": 525057.0}, "01111111101001100001": {"state": 522849.0}, "11111111111010010101": {"state": 1048213.0}, "11111111100011111000": {"state": 1046776.0}, "11111111111000111001": {"state": 1048121.0}, "11111111110110011101": {"state": 1047965.0}, "11111111111111001111": {"state": 1048527.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "11111111111100001110": 1, + "01111111101001100101": 1, + "10000000000110010000": 1, + "11111111111011110111": 1, + "01111111110000000110": 1, + "00000000000111111011": 1, + "01111111111111000100": 1, + "01111111111100000011": 1, + "01111111110110011111": 1, + "01111111111001101100": 1, + "01111111111010011111": 1, + "00000000011000001111": 1, + "00000000000000001001": 1, + "11111111110110011001": 1, + "11111111111100001001": 2, + "01111111111100000001": 1, + "11111111110011111101": 1, + "01111111111010100011": 1, + "01111111110100000010": 1, + "01111111110011111001": 1, + "11111111110110011100": 2, + "11111111111010011010": 1, + "01111111110110011010": 10, + "00000000011111111111": 1, + "11111111110110010001": 2, + "10000000000011110100": 3, + "11111111111111110101": 1, + "11111111111100000100": 7, + "01111111110011110010": 1, + "10000000000011111010": 3, + "00000000000000001011": 23, + "11111111110011111000": 1, + "00000000000111110011": 20, + "11111111111000110000": 3, + "11111111110000000111": 1, + "01111111111111111110": 5, + "10000000000111111010": 6, + "11111111111000001011": 1, + "10000000000011111101": 2, + "00000000000000000101": 4, + "01111111111001101101": 1, + "10000000000000000101": 3, + "10000000000000001000": 1, + "01111111111100001101": 3, + "01111111111111110101": 5, + "11111111111100001100": 10, + "11111111110110010010": 2, + "01111111110110010101": 8, + "01111111111100000111": 8, + "00000000000000000000": 1313, + "01111111110100001111": 1, + "11111111111100000011": 11, + "11111111111100001101": 2, + "11111111111010010001": 4, + "11111111110110010000": 5, + "11111111110001100011": 1, + "01111111111000110001": 1, + "10000000000011110001": 2, + "11111111110110011101": 2, + "01111111111010011011": 3, + "00000000000000000011": 756, + "01111111111100001000": 5, + "10000000000000001001": 265, + "00000000000000000100": 1396, + "11111111111100000000": 15, + "00000000011111111011": 1, + "10000000000000001010": 66, + "10000000000000000100": 2, + "11111111111000000000": 2, + "11111111111100000001": 3, + "11111111110011111100": 1, + "00000000000000001000": 12, + "00000000000011111100": 1, + "01111111111100000101": 17, + "10000000011111111110": 13, + "01111111111011110100": 1, + "10000000000000000010": 328, + "00000000000000001100": 635, + "01111111111111111111": 3, + "11111111111111110100": 1, + "00000000001111000110": 1, + "01111111111011111110": 1, + "10000000000000000110": 231, + "11111111111000111011": 2, + "00000000000011111011": 2, + "10000000000111111101": 5, + "01111111110110000101": 1, + "01111111111100000010": 11, + "10000000000111110101": 11, + "00000000000111110100": 1, + "01111111111100011110": 1, + "01111111111111111011": 2, + "10000000000000001110": 101, + "00000000000000001111": 1178, + "01111111111100001010": 7, + "01111111110110011110": 1, + "00000000011111111000": 3, + "11111111111100000101": 5, + "00000000000011110111": 3, + "10000000001111001101": 1, + "10000000000111110001": 132, + "00000000011000000000": 3, + "11111111111100001010": 3, + "10000000000011001110": 1, + "01111111110011111101": 1, + "01111111111100001110": 1, + "11111111111100000111": 7, + "10000000000111110010": 1, + "11111111111010011110": 4, + "11111111111100001000": 1, + "01111111111010100100": 1, + "10000000011111111010": 9, + "10000000000000001101": 310, + "00000000000011110000": 7, + "10000000011111111101": 3, + "00000000000011110011": 1, + "11111111111100000010": 3, + "00000000000111111111": 3, + "00000000000100000100": 1, + "01111111111001100000": 2, + "00000000000100000011": 1, + "11111111111111001110": 1, + "01111111111111001100": 1, + "11111111111000110011": 3, + "10000000000011110101": 3, + "11111111111100001011": 2, + "01111111101001101110": 1, + "01111111110110010001": 1, + "11111111110110011011": 5, + "01111111110000000101": 1, + "01111111111101100011": 1, + "11111111111011111011": 1, + "11111111111111110111": 5, + "11111111101001101011": 1, + "10000000011111110001": 9, + "00000000011111110000": 1, + "11111111101001100011": 2, + "10000000001100001010": 2, + "00000000000000000111": 65, + "01111111111101111101": 2, + "01111111110110010110": 1, + "10000000000111111110": 291, + "11111111110011110011": 2, + "01111111111100001001": 8, + "10000000000110011111": 1, + "11111111111011111101": 1, + "10000000000000000001": 644, + "01111111111010010011": 3, + "00000000001100000011": 2, + "10000000000111111001": 2, + "11111111101110011101": 1, + "01111111111111000101": 2, + "01111111111111111101": 5, + "00000000000011110101": 1, + "10000000011111110101": 4, + "11111111111111110011": 2, + "11111111111111111011": 2, + "01111111111011111010": 3, + "01111111110001101101": 1, + "01111111111111110111": 1, + "01111111110110010010": 3, + "11111111111100001111": 4, + "11111111111111001100": 1, + "11111111110110011111": 2, + "00000000011111110011": 3, + "11111111100011111100": 1, + "11111111111000001100": 3, + "00000000000011110100": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "11111111111100001110": { "state": 1048334.0 }, + "01111111101001100101": { "state": 522853.0 }, + "10000000000110010000": { "state": 524688.0 }, + "11111111111011110111": { "state": 1048311.0 }, + "01111111110000000110": { "state": 523270.0 }, + "00000000000111111011": { "state": 507.0 }, + "01111111111111000100": { "state": 524228.0 }, + "01111111111100000011": { "state": 524035.0 }, + "01111111110110011111": { "state": 523679.0 }, + "01111111111001101100": { "state": 523884.0 }, + "01111111111010011111": { "state": 523935.0 }, + "00000000011000001111": { "state": 1551.0 }, + "00000000000000001001": { "state": 9.0 }, + "11111111110110011001": { "state": 1047961.0 }, + "11111111111100001001": { "state": 1048329.0 }, + "01111111111100000001": { "state": 524033.0 }, + "11111111110011111101": { "state": 1047805.0 }, + "01111111111010100011": { "state": 523939.0 }, + "01111111110100000010": { "state": 523522.0 }, + "01111111110011111001": { "state": 523513.0 }, + "11111111110110011100": { "state": 1047964.0 }, + "11111111111010011010": { "state": 1048218.0 }, + "01111111110110011010": { "state": 523674.0 }, + "00000000011111111111": { "state": 2047.0 }, + "11111111110110010001": { "state": 1047953.0 }, + "10000000000011110100": { "state": 524532.0 }, + "11111111111111110101": { "state": 1048565.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "01111111110011110010": { "state": 523506.0 }, + "10000000000011111010": { "state": 524538.0 }, + "00000000000000001011": { "state": 11.0 }, + "11111111110011111000": { "state": 1047800.0 }, + "00000000000111110011": { "state": 499.0 }, + "11111111111000110000": { "state": 1048112.0 }, + "11111111110000000111": { "state": 1047559.0 }, + "01111111111111111110": { "state": 524286.0 }, + "10000000000111111010": { "state": 524794.0 }, + "11111111111000001011": { "state": 1048075.0 }, + "10000000000011111101": { "state": 524541.0 }, + "00000000000000000101": { "state": 5.0 }, + "01111111111001101101": { "state": 523885.0 }, + "10000000000000000101": { "state": 524293.0 }, + "10000000000000001000": { "state": 524296.0 }, + "01111111111100001101": { "state": 524045.0 }, + "01111111111111110101": { "state": 524277.0 }, + "11111111111100001100": { "state": 1048332.0 }, + "11111111110110010010": { "state": 1047954.0 }, + "01111111110110010101": { "state": 523669.0 }, + "01111111111100000111": { "state": 524039.0 }, + "00000000000000000000": { "state": 0.0 }, + "01111111110100001111": { "state": 523535.0 }, + "11111111111100000011": { "state": 1048323.0 }, + "11111111111100001101": { "state": 1048333.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "11111111110110010000": { "state": 1047952.0 }, + "11111111110001100011": { "state": 1047651.0 }, + "01111111111000110001": { "state": 523825.0 }, + "10000000000011110001": { "state": 524529.0 }, + "11111111110110011101": { "state": 1047965.0 }, + "01111111111010011011": { "state": 523931.0 }, + "00000000000000000011": { "state": 3.0 }, + "01111111111100001000": { "state": 524040.0 }, + "10000000000000001001": { "state": 524297.0 }, + "00000000000000000100": { "state": 4.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "00000000011111111011": { "state": 2043.0 }, + "10000000000000001010": { "state": 524298.0 }, + "10000000000000000100": { "state": 524292.0 }, + "11111111111000000000": { "state": 1048064.0 }, + "11111111111100000001": { "state": 1048321.0 }, + "11111111110011111100": { "state": 1047804.0 }, + "00000000000000001000": { "state": 8.0 }, + "00000000000011111100": { "state": 252.0 }, + "01111111111100000101": { "state": 524037.0 }, + "10000000011111111110": { "state": 526334.0 }, + "01111111111011110100": { "state": 524020.0 }, + "10000000000000000010": { "state": 524290.0 }, + "00000000000000001100": { "state": 12.0 }, + "01111111111111111111": { "state": 524287.0 }, + "11111111111111110100": { "state": 1048564.0 }, + "00000000001111000110": { "state": 966.0 }, + "01111111111011111110": { "state": 524030.0 }, + "10000000000000000110": { "state": 524294.0 }, + "11111111111000111011": { "state": 1048123.0 }, + "00000000000011111011": { "state": 251.0 }, + "10000000000111111101": { "state": 524797.0 }, + "01111111110110000101": { "state": 523653.0 }, + "01111111111100000010": { "state": 524034.0 }, + "10000000000111110101": { "state": 524789.0 }, + "00000000000111110100": { "state": 500.0 }, + "01111111111100011110": { "state": 524062.0 }, + "01111111111111111011": { "state": 524283.0 }, + "10000000000000001110": { "state": 524302.0 }, + "00000000000000001111": { "state": 15.0 }, + "01111111111100001010": { "state": 524042.0 }, + "01111111110110011110": { "state": 523678.0 }, + "00000000011111111000": { "state": 2040.0 }, + "11111111111100000101": { "state": 1048325.0 }, + "00000000000011110111": { "state": 247.0 }, + "10000000001111001101": { "state": 525261.0 }, + "10000000000111110001": { "state": 524785.0 }, + "00000000011000000000": { "state": 1536.0 }, + "11111111111100001010": { "state": 1048330.0 }, + "10000000000011001110": { "state": 524494.0 }, + "01111111110011111101": { "state": 523517.0 }, + "01111111111100001110": { "state": 524046.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "10000000000111110010": { "state": 524786.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "11111111111100001000": { "state": 1048328.0 }, + "01111111111010100100": { "state": 523940.0 }, + "10000000011111111010": { "state": 526330.0 }, + "10000000000000001101": { "state": 524301.0 }, + "00000000000011110000": { "state": 240.0 }, + "10000000011111111101": { "state": 526333.0 }, + "00000000000011110011": { "state": 243.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "00000000000111111111": { "state": 511.0 }, + "00000000000100000100": { "state": 260.0 }, + "01111111111001100000": { "state": 523872.0 }, + "00000000000100000011": { "state": 259.0 }, + "11111111111111001110": { "state": 1048526.0 }, + "01111111111111001100": { "state": 524236.0 }, + "11111111111000110011": { "state": 1048115.0 }, + "10000000000011110101": { "state": 524533.0 }, + "11111111111100001011": { "state": 1048331.0 }, + "01111111101001101110": { "state": 522862.0 }, + "01111111110110010001": { "state": 523665.0 }, + "11111111110110011011": { "state": 1047963.0 }, + "01111111110000000101": { "state": 523269.0 }, + "01111111111101100011": { "state": 524131.0 }, + "11111111111011111011": { "state": 1048315.0 }, + "11111111111111110111": { "state": 1048567.0 }, + "11111111101001101011": { "state": 1047147.0 }, + "10000000011111110001": { "state": 526321.0 }, + "00000000011111110000": { "state": 2032.0 }, + "11111111101001100011": { "state": 1047139.0 }, + "10000000001100001010": { "state": 525066.0 }, + "00000000000000000111": { "state": 7.0 }, + "01111111111101111101": { "state": 524157.0 }, + "01111111110110010110": { "state": 523670.0 }, + "10000000000111111110": { "state": 524798.0 }, + "11111111110011110011": { "state": 1047795.0 }, + "01111111111100001001": { "state": 524041.0 }, + "10000000000110011111": { "state": 524703.0 }, + "11111111111011111101": { "state": 1048317.0 }, + "10000000000000000001": { "state": 524289.0 }, + "01111111111010010011": { "state": 523923.0 }, + "00000000001100000011": { "state": 771.0 }, + "10000000000111111001": { "state": 524793.0 }, + "11111111101110011101": { "state": 1047453.0 }, + "01111111111111000101": { "state": 524229.0 }, + "01111111111111111101": { "state": 524285.0 }, + "00000000000011110101": { "state": 245.0 }, + "10000000011111110101": { "state": 526325.0 }, + "11111111111111110011": { "state": 1048563.0 }, + "11111111111111111011": { "state": 1048571.0 }, + "01111111111011111010": { "state": 524026.0 }, + "01111111110001101101": { "state": 523373.0 }, + "01111111111111110111": { "state": 524279.0 }, + "01111111110110010010": { "state": 523666.0 }, + "11111111111100001111": { "state": 1048335.0 }, + "11111111111111001100": { "state": 1048524.0 }, + "11111111110110011111": { "state": 1047967.0 }, + "00000000011111110011": { "state": 2035.0 }, + "11111111100011111100": { "state": 1046780.0 }, + "11111111111000001100": { "state": 1048076.0 }, + "00000000000011110100": { "state": 244.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n+6.json b/algorithms/glued_trees/results/20-qubits/2n+6.json index ac03fe71..cce4eecb 100644 --- a/algorithms/glued_trees/results/20-qubits/2n+6.json +++ b/algorithms/glued_trees/results/20-qubits/2n+6.json @@ -1 +1,358 @@ -{"vendor_format_result": {}, "counts": {"11111111110111000011": 1, "01111111111111000010": 1, "01111111111000001101": 1, "11111111110110010110": 1, "01111111111001100100": 1, "01111111111000110001": 1, "01111111110011111100": 1, "00000000000111111111": 1, "11111111101001101100": 1, "01111111111111111111": 3, "11111111111111110001": 1, "11111111110001100111": 1, "00000000011000000000": 1, "10000000011111110101": 1, "11111111111001011110": 1, "11111111100100000100": 1, "11111111111000001111": 1, "11111111111000000010": 1, "11111111111000000100": 1, "01111111110011110010": 1, "10000000000110010011": 1, "11111111111010010101": 1, "01111111101001100001": 1, "01111111110110011100": 1, "10000000011111111001": 1, "11111111111100000010": 8, "10000000011111111101": 3, "11111111111000000101": 2, "00000000000000001100": 148, "00000000001111000101": 1, "01111111111100000000": 1, "11111111110110011100": 5, "01111111111010010011": 1, "10000000000000000001": 388, "01111111111111110010": 1, "01111111111100001110": 1, "10000000011111110110": 2, "11111111111100001000": 2, "01111111111010100100": 2, "11111111110110010000": 7, "11111111101001100011": 2, "01111111111100001100": 3, "11111111111100000110": 7, "01111111110110011001": 2, "01111111101001100101": 2, "11111111110001101000": 1, "00000000011111110011": 5, "00000000000111111011": 2, "00000000000000000010": 1, "10000000000111111101": 5, "01111111111100001001": 10, "00000000000111110011": 59, "01111111111111111110": 30, "11111111110110011110": 2, "11111111111001011010": 2, "00000000000000000100": 1302, "10000000000000001001": 43, "11111111110111010001": 1, "01111111111010011011": 2, "00000000000000000011": 359, "11111111111100000111": 16, "01111111110001100110": 2, "10000000000000001010": 19, "00000000000000000000": 451, "10000000000111110001": 140, "00000000000000001111": 1806, "11111111111111111010": 2, "10000000000011111101": 5, "11111111110110010100": 1, "11111111111111110011": 3, "11111111111100001110": 2, "10000000011111110001": 9, "11111111111100001111": 6, "11111111111111111000": 9, "00000000000100000011": 1, "01111111110110011101": 1, "10000000000000000101": 252, "11111111111100111010": 1, "01111111111010101111": 2, "11111111110000001010": 1, "00000000000011110000": 2, "10000000000000001101": 603, "11111111111100001011": 8, "01111111110110010110": 1, "10000000000111111110": 306, "11111111110110011010": 3, "11111111111010101101": 1, "01111111111010011100": 1, "01111111110110010001": 1, "11111111110110011011": 9, "11111111111100000001": 1, "11111111110011111100": 1, "00000000000000001000": 70, "01111111111111001100": 1, "01111111111000110101": 2, "11111111111011111100": 3, "11111111111110110000": 1, "11111111111011111000": 3, "01111111111100000010": 7, "11111111111100001001": 1, "10000000011000000010": 1, "01111111110011111001": 3, "10000000000111111010": 20, "11111111110110010101": 4, "10000000000111111001": 3, "00000000000011110100": 2, "01111111101001101101": 1, "00000000000111110100": 2, "01111111101001101100": 1, "00000000011111111100": 6, "01111111111001100000": 4, "11111111111100000100": 4, "11111111111010011110": 5, "01111111110110011010": 2, "00000000011111111111": 3, "10000000001111111010": 1, "01111111110001100101": 1, "11111111111101101101": 1, "11111111111000001011": 2, "10000000001100001101": 1, "00000000011111111011": 6, "11111111111100000000": 8, "11111111110110011111": 3, "01111111110110010010": 11, "10000000000000001111": 4, "00000000000000001011": 21, "11111111101001101010": 1, "01111111111011111011": 1, "01111111111111110101": 2, "01111111110001100100": 1, "01111111111111110100": 1, "10000000000000000111": 1, "01111111110110010101": 2, "10000000000011110011": 2, "11111111110001101100": 2, "01111111111100000110": 9, "11111111110011110111": 1, "01111111111001101010": 1, "10000000000000000010": 1590, "01111111111111110001": 3, "11111111110100001010": 1, "11111111111000110100": 1, "11111111111111001111": 3, "11111111111010010001": 7, "01111111111011110001": 2, "01111111111101100100": 1, "11111111111100000011": 1, "00000000000011111100": 1, "01111111111100000101": 19, "10000000011111111110": 3, "00000000000111111100": 2, "01111111111000001001": 1, "00000000000110100101": 1, "00000000000100000000": 1, "11111111111111110100": 8, "11111111111111110000": 1, "01111111111010100000": 2, "10000000000000000110": 178, "01111111110110010100": 1, "11111111111111110010": 3, "11111111111111000000": 1, "11111111111010011010": 2, "11111111111101111100": 1, "11111111111111110110": 1, "01111111110000001101": 1, "10000000011111111010": 6, "11111111111000111100": 2, "01111111111100001101": 6, "11111111111011110100": 1, "11111111111000000111": 1, "00000000000011111101": 1, "01111111111111111010": 2}, "counts_lsb_right": true, "parsed_states": {"11111111110111000011": {"state": 1048003.0}, "01111111111111000010": {"state": 524226.0}, "01111111111000001101": {"state": 523789.0}, "11111111110110010110": {"state": 1047958.0}, "01111111111001100100": {"state": 523876.0}, "01111111111000110001": {"state": 523825.0}, "01111111110011111100": {"state": 523516.0}, "00000000000111111111": {"state": 511.0}, "11111111101001101100": {"state": 1047148.0}, "01111111111111111111": {"state": 524287.0}, "11111111111111110001": {"state": 1048561.0}, "11111111110001100111": {"state": 1047655.0}, "00000000011000000000": {"state": 1536.0}, "10000000011111110101": {"state": 526325.0}, "11111111111001011110": {"state": 1048158.0}, "11111111100100000100": {"state": 1046788.0}, "11111111111000001111": {"state": 1048079.0}, "11111111111000000010": {"state": 1048066.0}, "11111111111000000100": {"state": 1048068.0}, "01111111110011110010": {"state": 523506.0}, "10000000000110010011": {"state": 524691.0}, "11111111111010010101": {"state": 1048213.0}, "01111111101001100001": {"state": 522849.0}, "01111111110110011100": {"state": 523676.0}, "10000000011111111001": {"state": 526329.0}, "11111111111100000010": {"state": 1048322.0}, "10000000011111111101": {"state": 526333.0}, "11111111111000000101": {"state": 1048069.0}, "00000000000000001100": {"state": 12.0}, "00000000001111000101": {"state": 965.0}, "01111111111100000000": {"state": 524032.0}, "11111111110110011100": {"state": 1047964.0}, "01111111111010010011": {"state": 523923.0}, "10000000000000000001": {"state": 524289.0}, "01111111111111110010": {"state": 524274.0}, "01111111111100001110": {"state": 524046.0}, "10000000011111110110": {"state": 526326.0}, "11111111111100001000": {"state": 1048328.0}, "01111111111010100100": {"state": 523940.0}, "11111111110110010000": {"state": 1047952.0}, "11111111101001100011": {"state": 1047139.0}, "01111111111100001100": {"state": 524044.0}, "11111111111100000110": {"state": 1048326.0}, "01111111110110011001": {"state": 523673.0}, "01111111101001100101": {"state": 522853.0}, "11111111110001101000": {"state": 1047656.0}, "00000000011111110011": {"state": 2035.0}, "00000000000111111011": {"state": 507.0}, "00000000000000000010": {"state": 2.0}, "10000000000111111101": {"state": 524797.0}, "01111111111100001001": {"state": 524041.0}, "00000000000111110011": {"state": 499.0}, "01111111111111111110": {"state": 524286.0}, "11111111110110011110": {"state": 1047966.0}, "11111111111001011010": {"state": 1048154.0}, "00000000000000000100": {"state": 4.0}, "10000000000000001001": {"state": 524297.0}, "11111111110111010001": {"state": 1048017.0}, "01111111111010011011": {"state": 523931.0}, "00000000000000000011": {"state": 3.0}, "11111111111100000111": {"state": 1048327.0}, "01111111110001100110": {"state": 523366.0}, "10000000000000001010": {"state": 524298.0}, "00000000000000000000": {"state": 0.0}, "10000000000111110001": {"state": 524785.0}, "00000000000000001111": {"state": 15.0}, "11111111111111111010": {"state": 1048570.0}, "10000000000011111101": {"state": 524541.0}, "11111111110110010100": {"state": 1047956.0}, "11111111111111110011": {"state": 1048563.0}, "11111111111100001110": {"state": 1048334.0}, "10000000011111110001": {"state": 526321.0}, "11111111111100001111": {"state": 1048335.0}, "11111111111111111000": {"state": 1048568.0}, "00000000000100000011": {"state": 259.0}, "01111111110110011101": {"state": 523677.0}, "10000000000000000101": {"state": 524293.0}, "11111111111100111010": {"state": 1048378.0}, "01111111111010101111": {"state": 523951.0}, "11111111110000001010": {"state": 1047562.0}, "00000000000011110000": {"state": 240.0}, "10000000000000001101": {"state": 524301.0}, "11111111111100001011": {"state": 1048331.0}, "01111111110110010110": {"state": 523670.0}, "10000000000111111110": {"state": 524798.0}, "11111111110110011010": {"state": 1047962.0}, "11111111111010101101": {"state": 1048237.0}, "01111111111010011100": {"state": 523932.0}, "01111111110110010001": {"state": 523665.0}, "11111111110110011011": {"state": 1047963.0}, "11111111111100000001": {"state": 1048321.0}, "11111111110011111100": {"state": 1047804.0}, "00000000000000001000": {"state": 8.0}, "01111111111111001100": {"state": 524236.0}, "01111111111000110101": {"state": 523829.0}, "11111111111011111100": {"state": 1048316.0}, "11111111111110110000": {"state": 1048496.0}, "11111111111011111000": {"state": 1048312.0}, "01111111111100000010": {"state": 524034.0}, "11111111111100001001": {"state": 1048329.0}, "10000000011000000010": {"state": 525826.0}, "01111111110011111001": {"state": 523513.0}, "10000000000111111010": {"state": 524794.0}, "11111111110110010101": {"state": 1047957.0}, "10000000000111111001": {"state": 524793.0}, "00000000000011110100": {"state": 244.0}, "01111111101001101101": {"state": 522861.0}, "00000000000111110100": {"state": 500.0}, "01111111101001101100": {"state": 522860.0}, "00000000011111111100": {"state": 2044.0}, "01111111111001100000": {"state": 523872.0}, "11111111111100000100": {"state": 1048324.0}, "11111111111010011110": {"state": 1048222.0}, "01111111110110011010": {"state": 523674.0}, "00000000011111111111": {"state": 2047.0}, "10000000001111111010": {"state": 525306.0}, "01111111110001100101": {"state": 523365.0}, "11111111111101101101": {"state": 1048429.0}, "11111111111000001011": {"state": 1048075.0}, "10000000001100001101": {"state": 525069.0}, "00000000011111111011": {"state": 2043.0}, "11111111111100000000": {"state": 1048320.0}, "11111111110110011111": {"state": 1047967.0}, "01111111110110010010": {"state": 523666.0}, "10000000000000001111": {"state": 524303.0}, "00000000000000001011": {"state": 11.0}, "11111111101001101010": {"state": 1047146.0}, "01111111111011111011": {"state": 524027.0}, "01111111111111110101": {"state": 524277.0}, "01111111110001100100": {"state": 523364.0}, "01111111111111110100": {"state": 524276.0}, "10000000000000000111": {"state": 524295.0}, "01111111110110010101": {"state": 523669.0}, "10000000000011110011": {"state": 524531.0}, "11111111110001101100": {"state": 1047660.0}, "01111111111100000110": {"state": 524038.0}, "11111111110011110111": {"state": 1047799.0}, "01111111111001101010": {"state": 523882.0}, "10000000000000000010": {"state": 524290.0}, "01111111111111110001": {"state": 524273.0}, "11111111110100001010": {"state": 1047818.0}, "11111111111000110100": {"state": 1048116.0}, "11111111111111001111": {"state": 1048527.0}, "11111111111010010001": {"state": 1048209.0}, "01111111111011110001": {"state": 524017.0}, "01111111111101100100": {"state": 524132.0}, "11111111111100000011": {"state": 1048323.0}, "00000000000011111100": {"state": 252.0}, "01111111111100000101": {"state": 524037.0}, "10000000011111111110": {"state": 526334.0}, "00000000000111111100": {"state": 508.0}, "01111111111000001001": {"state": 523785.0}, "00000000000110100101": {"state": 421.0}, "00000000000100000000": {"state": 256.0}, "11111111111111110100": {"state": 1048564.0}, "11111111111111110000": {"state": 1048560.0}, "01111111111010100000": {"state": 523936.0}, "10000000000000000110": {"state": 524294.0}, "01111111110110010100": {"state": 523668.0}, "11111111111111110010": {"state": 1048562.0}, "11111111111111000000": {"state": 1048512.0}, "11111111111010011010": {"state": 1048218.0}, "11111111111101111100": {"state": 1048444.0}, "11111111111111110110": {"state": 1048566.0}, "01111111110000001101": {"state": 523277.0}, "10000000011111111010": {"state": 526330.0}, "11111111111000111100": {"state": 1048124.0}, "01111111111100001101": {"state": 524045.0}, "11111111111011110100": {"state": 1048308.0}, "11111111111000000111": {"state": 1048071.0}, "00000000000011111101": {"state": 253.0}, "01111111111111111010": {"state": 524282.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "01111111111101111001": 1, + "00000000011000001111": 1, + "11111111111101100010": 1, + "00000000001111000101": 1, + "01111111111101100100": 1, + "10000000011111111101": 3, + "11111111110110010010": 1, + "11111111110110010001": 1, + "10000000000111000000": 1, + "01111111111100000100": 1, + "01111111110001101111": 1, + "01111111100000001101": 1, + "01111111111111111111": 2, + "11111111110000001011": 1, + "11111111111100111100": 1, + "10000000000111110010": 1, + "10000000011111111001": 1, + "11111111111001011110": 1, + "00000000000000000010": 2, + "01111111110111001010": 1, + "01111111110011110101": 1, + "00000000011111111111": 1, + "00000000000000000001": 1, + "10000000000111111001": 1, + "01111111101001100001": 1, + "01111111111111110100": 2, + "10000000011000000010": 1, + "01111111101001100101": 1, + "01111111110000000010": 1, + "11111111110110010000": 9, + "00000000000011110100": 5, + "11111111111100001011": 6, + "11111111111100001110": 3, + "11111111111111110011": 6, + "11111111111000000011": 1, + "11111111111010011110": 5, + "11111111110011111010": 1, + "00000000000000001011": 26, + "10000000000000001010": 18, + "01111111110110010101": 2, + "11111111111010011101": 2, + "01111111110001100101": 1, + "00000000011111111011": 5, + "11111111111100000000": 8, + "11111111111011111111": 1, + "01111111111111000100": 1, + "01111111111111110101": 4, + "00000000000011110000": 1, + "10000000000000001101": 585, + "10000000000000000101": 234, + "01111111111010010011": 1, + "10000000000000000001": 370, + "11111111110110011100": 3, + "11111111110110010110": 1, + "01111111111101110101": 1, + "11111111111100000110": 4, + "01111111111100001100": 6, + "00000000000011111011": 1, + "10000000000111111101": 2, + "10000000000000001001": 46, + "00000000000000000011": 329, + "10000000001100001101": 1, + "11111111110001100111": 1, + "10000000000011111101": 7, + "01111111111111001101": 1, + "01111111111010100100": 2, + "00000000000000000100": 1290, + "01111111111111111110": 36, + "00000000000111110011": 74, + "01111111111100001010": 1, + "00000000000000001111": 1908, + "11111111111111111010": 2, + "00000000011000000000": 2, + "00000000000000001100": 132, + "01111111111111110001": 3, + "10000000000000000010": 1588, + "11111111110110011010": 2, + "11111111111010101101": 2, + "11111111111000111100": 1, + "10000000011111111010": 4, + "01111111110001100010": 1, + "11111111111111110000": 4, + "11111111111111110100": 5, + "01111111101110011100": 1, + "01111111110001100110": 1, + "11111111111100000111": 4, + "10000000001000001001": 1, + "11111111111010011010": 3, + "11111111111000001000": 1, + "11111111110011110000": 1, + "11111111110110010100": 1, + "00000000000111110000": 1, + "10000000011111110001": 11, + "11111111111111111000": 9, + "11111111111100001111": 6, + "10000000000111110001": 134, + "01111111110110010010": 14, + "01111111111001100000": 5, + "00000000001011110011": 1, + "10000000000000000000": 1, + "10000000000000000110": 166, + "11111111101110010000": 1, + "11111111111111110010": 5, + "01111111111010100000": 1, + "01111111111100001001": 6, + "00000000000000000000": 492, + "01111111111100001101": 18, + "10000000000111110110": 1, + "01111111110110011100": 3, + "11111111101110010010": 1, + "11111111111010011001": 1, + "11111111111100000010": 2, + "01111111111010101100": 2, + "00000000011111110011": 5, + "00000000000111111011": 5, + "11111111111100000101": 1, + "01111111111010101111": 1, + "11111111111011111100": 2, + "01111111111000110101": 1, + "00000000011111111100": 3, + "11111111110110011011": 8, + "01111111110110010001": 1, + "10000000001111000010": 1, + "01111111110110011110": 1, + "00000000000000001001": 1, + "01111111110110011001": 1, + "11111111111000000110": 1, + "01111111111001100100": 2, + "10000000000111111110": 303, + "01111111110001100011": 1, + "10000000011000001101": 1, + "01111111111001101111": 2, + "11111111111100000011": 4, + "11111111111100001101": 1, + "11111111111010010001": 2, + "10000000000000001111": 3, + "01111111111111110010": 1, + "11111111111111001111": 1, + "01111111111100000110": 10, + "11111111110011111011": 1, + "11111111111100000100": 2, + "11111111111101010001": 1, + "11111111101001101011": 1, + "11111111111111110111": 1, + "00000000000111111100": 4, + "01111111111100000101": 23, + "11111111111110000100": 1, + "10000000011111111110": 1, + "11111111111000000000": 1, + "10000000000000000100": 1, + "11111111111001100100": 1, + "11111111111011111000": 2, + "01111111111100000010": 4, + "00000000000101011010": 1, + "11111111101100000010": 1, + "01111111110011111001": 1, + "01111111111000111110": 3, + "11111111110110011111": 2, + "00000000000111110111": 1, + "10000000000111111010": 17, + "10000000001111000011": 1, + "01111111110110010111": 1, + "11111111110011111100": 2, + "00000000000000001000": 67, + "11111111111100000001": 1, + "11111111111011110001": 1, + "11111111111100001000": 2, + "10000000000011110010": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "01111111111101111001": { "state": 524153.0 }, + "00000000011000001111": { "state": 1551.0 }, + "11111111111101100010": { "state": 1048418.0 }, + "00000000001111000101": { "state": 965.0 }, + "01111111111101100100": { "state": 524132.0 }, + "10000000011111111101": { "state": 526333.0 }, + "11111111110110010010": { "state": 1047954.0 }, + "11111111110110010001": { "state": 1047953.0 }, + "10000000000111000000": { "state": 524736.0 }, + "01111111111100000100": { "state": 524036.0 }, + "01111111110001101111": { "state": 523375.0 }, + "01111111100000001101": { "state": 522253.0 }, + "01111111111111111111": { "state": 524287.0 }, + "11111111110000001011": { "state": 1047563.0 }, + "11111111111100111100": { "state": 1048380.0 }, + "10000000000111110010": { "state": 524786.0 }, + "10000000011111111001": { "state": 526329.0 }, + "11111111111001011110": { "state": 1048158.0 }, + "00000000000000000010": { "state": 2.0 }, + "01111111110111001010": { "state": 523722.0 }, + "01111111110011110101": { "state": 523509.0 }, + "00000000011111111111": { "state": 2047.0 }, + "00000000000000000001": { "state": 1.0 }, + "10000000000111111001": { "state": 524793.0 }, + "01111111101001100001": { "state": 522849.0 }, + "01111111111111110100": { "state": 524276.0 }, + "10000000011000000010": { "state": 525826.0 }, + "01111111101001100101": { "state": 522853.0 }, + "01111111110000000010": { "state": 523266.0 }, + "11111111110110010000": { "state": 1047952.0 }, + "00000000000011110100": { "state": 244.0 }, + "11111111111100001011": { "state": 1048331.0 }, + "11111111111100001110": { "state": 1048334.0 }, + "11111111111111110011": { "state": 1048563.0 }, + "11111111111000000011": { "state": 1048067.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "11111111110011111010": { "state": 1047802.0 }, + "00000000000000001011": { "state": 11.0 }, + "10000000000000001010": { "state": 524298.0 }, + "01111111110110010101": { "state": 523669.0 }, + "11111111111010011101": { "state": 1048221.0 }, + "01111111110001100101": { "state": 523365.0 }, + "00000000011111111011": { "state": 2043.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "11111111111011111111": { "state": 1048319.0 }, + "01111111111111000100": { "state": 524228.0 }, + "01111111111111110101": { "state": 524277.0 }, + "00000000000011110000": { "state": 240.0 }, + "10000000000000001101": { "state": 524301.0 }, + "10000000000000000101": { "state": 524293.0 }, + "01111111111010010011": { "state": 523923.0 }, + "10000000000000000001": { "state": 524289.0 }, + "11111111110110011100": { "state": 1047964.0 }, + "11111111110110010110": { "state": 1047958.0 }, + "01111111111101110101": { "state": 524149.0 }, + "11111111111100000110": { "state": 1048326.0 }, + "01111111111100001100": { "state": 524044.0 }, + "00000000000011111011": { "state": 251.0 }, + "10000000000111111101": { "state": 524797.0 }, + "10000000000000001001": { "state": 524297.0 }, + "00000000000000000011": { "state": 3.0 }, + "10000000001100001101": { "state": 525069.0 }, + "11111111110001100111": { "state": 1047655.0 }, + "10000000000011111101": { "state": 524541.0 }, + "01111111111111001101": { "state": 524237.0 }, + "01111111111010100100": { "state": 523940.0 }, + "00000000000000000100": { "state": 4.0 }, + "01111111111111111110": { "state": 524286.0 }, + "00000000000111110011": { "state": 499.0 }, + "01111111111100001010": { "state": 524042.0 }, + "00000000000000001111": { "state": 15.0 }, + "11111111111111111010": { "state": 1048570.0 }, + "00000000011000000000": { "state": 1536.0 }, + "00000000000000001100": { "state": 12.0 }, + "01111111111111110001": { "state": 524273.0 }, + "10000000000000000010": { "state": 524290.0 }, + "11111111110110011010": { "state": 1047962.0 }, + "11111111111010101101": { "state": 1048237.0 }, + "11111111111000111100": { "state": 1048124.0 }, + "10000000011111111010": { "state": 526330.0 }, + "01111111110001100010": { "state": 523362.0 }, + "11111111111111110000": { "state": 1048560.0 }, + "11111111111111110100": { "state": 1048564.0 }, + "01111111101110011100": { "state": 523164.0 }, + "01111111110001100110": { "state": 523366.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "10000000001000001001": { "state": 524809.0 }, + "11111111111010011010": { "state": 1048218.0 }, + "11111111111000001000": { "state": 1048072.0 }, + "11111111110011110000": { "state": 1047792.0 }, + "11111111110110010100": { "state": 1047956.0 }, + "00000000000111110000": { "state": 496.0 }, + "10000000011111110001": { "state": 526321.0 }, + "11111111111111111000": { "state": 1048568.0 }, + "11111111111100001111": { "state": 1048335.0 }, + "10000000000111110001": { "state": 524785.0 }, + "01111111110110010010": { "state": 523666.0 }, + "01111111111001100000": { "state": 523872.0 }, + "00000000001011110011": { "state": 755.0 }, + "10000000000000000000": { "state": 524288.0 }, + "10000000000000000110": { "state": 524294.0 }, + "11111111101110010000": { "state": 1047440.0 }, + "11111111111111110010": { "state": 1048562.0 }, + "01111111111010100000": { "state": 523936.0 }, + "01111111111100001001": { "state": 524041.0 }, + "00000000000000000000": { "state": 0.0 }, + "01111111111100001101": { "state": 524045.0 }, + "10000000000111110110": { "state": 524790.0 }, + "01111111110110011100": { "state": 523676.0 }, + "11111111101110010010": { "state": 1047442.0 }, + "11111111111010011001": { "state": 1048217.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "01111111111010101100": { "state": 523948.0 }, + "00000000011111110011": { "state": 2035.0 }, + "00000000000111111011": { "state": 507.0 }, + "11111111111100000101": { "state": 1048325.0 }, + "01111111111010101111": { "state": 523951.0 }, + "11111111111011111100": { "state": 1048316.0 }, + "01111111111000110101": { "state": 523829.0 }, + "00000000011111111100": { "state": 2044.0 }, + "11111111110110011011": { "state": 1047963.0 }, + "01111111110110010001": { "state": 523665.0 }, + "10000000001111000010": { "state": 525250.0 }, + "01111111110110011110": { "state": 523678.0 }, + "00000000000000001001": { "state": 9.0 }, + "01111111110110011001": { "state": 523673.0 }, + "11111111111000000110": { "state": 1048070.0 }, + "01111111111001100100": { "state": 523876.0 }, + "10000000000111111110": { "state": 524798.0 }, + "01111111110001100011": { "state": 523363.0 }, + "10000000011000001101": { "state": 525837.0 }, + "01111111111001101111": { "state": 523887.0 }, + "11111111111100000011": { "state": 1048323.0 }, + "11111111111100001101": { "state": 1048333.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "10000000000000001111": { "state": 524303.0 }, + "01111111111111110010": { "state": 524274.0 }, + "11111111111111001111": { "state": 1048527.0 }, + "01111111111100000110": { "state": 524038.0 }, + "11111111110011111011": { "state": 1047803.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "11111111111101010001": { "state": 1048401.0 }, + "11111111101001101011": { "state": 1047147.0 }, + "11111111111111110111": { "state": 1048567.0 }, + "00000000000111111100": { "state": 508.0 }, + "01111111111100000101": { "state": 524037.0 }, + "11111111111110000100": { "state": 1048452.0 }, + "10000000011111111110": { "state": 526334.0 }, + "11111111111000000000": { "state": 1048064.0 }, + "10000000000000000100": { "state": 524292.0 }, + "11111111111001100100": { "state": 1048164.0 }, + "11111111111011111000": { "state": 1048312.0 }, + "01111111111100000010": { "state": 524034.0 }, + "00000000000101011010": { "state": 346.0 }, + "11111111101100000010": { "state": 1047298.0 }, + "01111111110011111001": { "state": 523513.0 }, + "01111111111000111110": { "state": 523838.0 }, + "11111111110110011111": { "state": 1047967.0 }, + "00000000000111110111": { "state": 503.0 }, + "10000000000111111010": { "state": 524794.0 }, + "10000000001111000011": { "state": 525251.0 }, + "01111111110110010111": { "state": 523671.0 }, + "11111111110011111100": { "state": 1047804.0 }, + "00000000000000001000": { "state": 8.0 }, + "11111111111100000001": { "state": 1048321.0 }, + "11111111111011110001": { "state": 1048305.0 }, + "11111111111100001000": { "state": 1048328.0 }, + "10000000000011110010": { "state": 524530.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n+8.json b/algorithms/glued_trees/results/20-qubits/2n+8.json index be8258d2..7b427b1d 100644 --- a/algorithms/glued_trees/results/20-qubits/2n+8.json +++ b/algorithms/glued_trees/results/20-qubits/2n+8.json @@ -1 +1,384 @@ -{"vendor_format_result": {}, "counts": {"11111111111100011000": 1, "01111111110110011101": 1, "01111111101001100101": 1, "11111111111001100000": 2, "11111111110011111100": 1, "00000000000000001000": 1, "10000000001001011100": 1, "01111111111100000111": 2, "01111111111100000000": 1, "10000000000000000011": 1, "11111111111110100010": 1, "01111111111000001101": 2, "01111111111000000110": 1, "00000000000100000010": 1, "01111111111101110101": 1, "01111111111000111110": 1, "11111111110110011010": 1, "01111111111100001110": 2, "10000000000011110001": 1, "11111111110001101011": 2, "01111111111001100110": 1, "01111111111100000110": 4, "01111111111111111101": 1, "01111111111111110010": 1, "01111111111001101001": 1, "10000000000010100100": 1, "11111111111001011110": 1, "01111111110011111001": 2, "10000000011111111001": 1, "11111111111011110000": 1, "01111111111011111001": 2, "11111111111111111101": 4, "00000000000000001011": 6, "11111111111111111111": 3, "00000000000011110100": 2, "00000000011000001111": 1, "00000000000111110100": 2, "01111111111011110010": 1, "11111111110110011011": 9, "01111111110110010001": 2, "01111111111100001001": 2, "01111111111100001100": 1, "11111111101001100011": 1, "11111111111100000110": 1, "01111111111001010011": 1, "00000000000000001001": 2, "11111111111111000110": 1, "11111111110000001001": 1, "10000000000000001110": 13, "01111111110110011110": 7, "11111111110100001010": 1, "00000000000001100101": 1, "01111111111101100000": 2, "11111111111000000010": 3, "01111111111001010100": 1, "00000000011111111100": 7, "01111111111111110101": 3, "10000000000000001101": 24, "00000000011111110011": 8, "10000000000000001011": 1, "10000000000111110001": 216, "01111111110110010101": 3, "11111111111100001011": 14, "11111111111100001001": 2, "11111111111000001100": 1, "10000000000111111110": 323, "01111111111010011100": 4, "11111111111010101101": 1, "10000000000000000001": 33, "01111111111010010011": 5, "01111111110001100110": 1, "11111111111100000111": 20, "11111111101001101100": 2, "10000000000000001001": 705, "00000000000000000011": 8, "01111111111011111110": 1, "01111111111010100000": 3, "10000000000000000110": 678, "11111111110111101101": 1, "11111111111000111011": 3, "01111111111010101111": 1, "11111111110110010011": 4, "01111111111111110000": 1, "01111111111111110111": 9, "11111111111000111010": 1, "11111111111111111000": 10, "01111111111100001010": 7, "00000000000000001111": 1664, "10000000000011111011": 1, "00000000000000001100": 3, "01111111111111110001": 13, "10000000000000000010": 551, "10000000000100001101": 2, "00000000011000000000": 5, "11111111111000000000": 1, "10000000011111110110": 1, "11111111111100001000": 2, "11111111110110010111": 1, "11111111111101101101": 1, "00000000000000000111": 154, "00000000000100000100": 2, "01111111111001100000": 3, "01111111111000000010": 4, "11111111110000000100": 1, "01111111110001100010": 6, "11111111111000111100": 1, "11111111111100000100": 7, "10000000000000000101": 395, "10000000011111111110": 13, "01111111111100000101": 6, "11111111111011111000": 3, "01111111111100000010": 1, "10000000000100001001": 1, "11111111111111110011": 19, "11111111111111111011": 9, "11111111110110010010": 4, "10000000000000001010": 561, "00000000000000000000": 2384, "10000000000011110110": 1, "11111111111100000000": 6, "11111111111111001111": 1, "00000000011111110100": 2, "01111111111001101111": 1, "00000000000111110011": 30, "11111111110011111000": 2, "11111111110110010000": 7, "11111111110001100011": 3, "00000000000111111100": 4, "11111111111111110111": 1, "00000000000011110011": 3, "11111111111100000010": 4, "01111111111000001010": 2, "00000000000111111111": 1, "11111111110100000000": 1, "11111111111100001100": 4, "01111111111000001110": 1, "00000000001000110011": 1, "11111111111001101011": 1, "11111111111010011110": 4, "11111111100000000110": 1, "11111111110110010001": 2, "00000000000000000010": 1, "10000000000011111101": 2, "01111111111111111010": 1, "11111111111011111111": 1, "11111111111010100101": 1, "01111111110110011010": 1, "11111111111001101101": 1, "11111111111111000011": 1, "01111111111100001111": 3, "00000000000100000000": 1, "11111111111010101010": 1, "11111111110001101101": 1, "00000000000000111010": 1, "11111111111111001011": 4, "11111111111111111001": 1, "11111111111111001110": 1, "01111111110000001010": 1, "00000000000111110111": 2, "01111111111111111001": 4, "00000000011111111000": 2, "01111111110000000110": 1, "10000000000111111001": 1, "11111111110000000111": 2, "01111111111111111110": 1, "11111111111000110000": 1, "11111111110011111001": 1, "01111111110110010010": 1, "01111111111101011100": 1, "11111111111111110001": 4, "11111111110001100111": 2, "11111111111111111100": 33, "01111111111000001001": 2}, "counts_lsb_right": true, "parsed_states": {"11111111111100011000": {"state": 1048344.0}, "01111111110110011101": {"state": 523677.0}, "01111111101001100101": {"state": 522853.0}, "11111111111001100000": {"state": 1048160.0}, "11111111110011111100": {"state": 1047804.0}, "00000000000000001000": {"state": 8.0}, "10000000001001011100": {"state": 524892.0}, "01111111111100000111": {"state": 524039.0}, "01111111111100000000": {"state": 524032.0}, "10000000000000000011": {"state": 524291.0}, "11111111111110100010": {"state": 1048482.0}, "01111111111000001101": {"state": 523789.0}, "01111111111000000110": {"state": 523782.0}, "00000000000100000010": {"state": 258.0}, "01111111111101110101": {"state": 524149.0}, "01111111111000111110": {"state": 523838.0}, "11111111110110011010": {"state": 1047962.0}, "01111111111100001110": {"state": 524046.0}, "10000000000011110001": {"state": 524529.0}, "11111111110001101011": {"state": 1047659.0}, "01111111111001100110": {"state": 523878.0}, "01111111111100000110": {"state": 524038.0}, "01111111111111111101": {"state": 524285.0}, "01111111111111110010": {"state": 524274.0}, "01111111111001101001": {"state": 523881.0}, "10000000000010100100": {"state": 524452.0}, "11111111111001011110": {"state": 1048158.0}, "01111111110011111001": {"state": 523513.0}, "10000000011111111001": {"state": 526329.0}, "11111111111011110000": {"state": 1048304.0}, "01111111111011111001": {"state": 524025.0}, "11111111111111111101": {"state": 1048573.0}, "00000000000000001011": {"state": 11.0}, "11111111111111111111": {"state": 1048575.0}, "00000000000011110100": {"state": 244.0}, "00000000011000001111": {"state": 1551.0}, "00000000000111110100": {"state": 500.0}, "01111111111011110010": {"state": 524018.0}, "11111111110110011011": {"state": 1047963.0}, "01111111110110010001": {"state": 523665.0}, "01111111111100001001": {"state": 524041.0}, "01111111111100001100": {"state": 524044.0}, "11111111101001100011": {"state": 1047139.0}, "11111111111100000110": {"state": 1048326.0}, "01111111111001010011": {"state": 523859.0}, "00000000000000001001": {"state": 9.0}, "11111111111111000110": {"state": 1048518.0}, "11111111110000001001": {"state": 1047561.0}, "10000000000000001110": {"state": 524302.0}, "01111111110110011110": {"state": 523678.0}, "11111111110100001010": {"state": 1047818.0}, "00000000000001100101": {"state": 101.0}, "01111111111101100000": {"state": 524128.0}, "11111111111000000010": {"state": 1048066.0}, "01111111111001010100": {"state": 523860.0}, "00000000011111111100": {"state": 2044.0}, "01111111111111110101": {"state": 524277.0}, "10000000000000001101": {"state": 524301.0}, "00000000011111110011": {"state": 2035.0}, "10000000000000001011": {"state": 524299.0}, "10000000000111110001": {"state": 524785.0}, "01111111110110010101": {"state": 523669.0}, "11111111111100001011": {"state": 1048331.0}, "11111111111100001001": {"state": 1048329.0}, "11111111111000001100": {"state": 1048076.0}, "10000000000111111110": {"state": 524798.0}, "01111111111010011100": {"state": 523932.0}, "11111111111010101101": {"state": 1048237.0}, "10000000000000000001": {"state": 524289.0}, "01111111111010010011": {"state": 523923.0}, "01111111110001100110": {"state": 523366.0}, "11111111111100000111": {"state": 1048327.0}, "11111111101001101100": {"state": 1047148.0}, "10000000000000001001": {"state": 524297.0}, "00000000000000000011": {"state": 3.0}, "01111111111011111110": {"state": 524030.0}, "01111111111010100000": {"state": 523936.0}, "10000000000000000110": {"state": 524294.0}, "11111111110111101101": {"state": 1048045.0}, "11111111111000111011": {"state": 1048123.0}, "01111111111010101111": {"state": 523951.0}, "11111111110110010011": {"state": 1047955.0}, "01111111111111110000": {"state": 524272.0}, "01111111111111110111": {"state": 524279.0}, "11111111111000111010": {"state": 1048122.0}, "11111111111111111000": {"state": 1048568.0}, "01111111111100001010": {"state": 524042.0}, "00000000000000001111": {"state": 15.0}, "10000000000011111011": {"state": 524539.0}, "00000000000000001100": {"state": 12.0}, "01111111111111110001": {"state": 524273.0}, "10000000000000000010": {"state": 524290.0}, "10000000000100001101": {"state": 524557.0}, "00000000011000000000": {"state": 1536.0}, "11111111111000000000": {"state": 1048064.0}, "10000000011111110110": {"state": 526326.0}, "11111111111100001000": {"state": 1048328.0}, "11111111110110010111": {"state": 1047959.0}, "11111111111101101101": {"state": 1048429.0}, "00000000000000000111": {"state": 7.0}, "00000000000100000100": {"state": 260.0}, "01111111111001100000": {"state": 523872.0}, "01111111111000000010": {"state": 523778.0}, "11111111110000000100": {"state": 1047556.0}, "01111111110001100010": {"state": 523362.0}, "11111111111000111100": {"state": 1048124.0}, "11111111111100000100": {"state": 1048324.0}, "10000000000000000101": {"state": 524293.0}, "10000000011111111110": {"state": 526334.0}, "01111111111100000101": {"state": 524037.0}, "11111111111011111000": {"state": 1048312.0}, "01111111111100000010": {"state": 524034.0}, "10000000000100001001": {"state": 524553.0}, "11111111111111110011": {"state": 1048563.0}, "11111111111111111011": {"state": 1048571.0}, "11111111110110010010": {"state": 1047954.0}, "10000000000000001010": {"state": 524298.0}, "00000000000000000000": {"state": 0.0}, "10000000000011110110": {"state": 524534.0}, "11111111111100000000": {"state": 1048320.0}, "11111111111111001111": {"state": 1048527.0}, "00000000011111110100": {"state": 2036.0}, "01111111111001101111": {"state": 523887.0}, "00000000000111110011": {"state": 499.0}, "11111111110011111000": {"state": 1047800.0}, "11111111110110010000": {"state": 1047952.0}, "11111111110001100011": {"state": 1047651.0}, "00000000000111111100": {"state": 508.0}, "11111111111111110111": {"state": 1048567.0}, "00000000000011110011": {"state": 243.0}, "11111111111100000010": {"state": 1048322.0}, "01111111111000001010": {"state": 523786.0}, "00000000000111111111": {"state": 511.0}, "11111111110100000000": {"state": 1047808.0}, "11111111111100001100": {"state": 1048332.0}, "01111111111000001110": {"state": 523790.0}, "00000000001000110011": {"state": 563.0}, "11111111111001101011": {"state": 1048171.0}, "11111111111010011110": {"state": 1048222.0}, "11111111100000000110": {"state": 1046534.0}, "11111111110110010001": {"state": 1047953.0}, "00000000000000000010": {"state": 2.0}, "10000000000011111101": {"state": 524541.0}, "01111111111111111010": {"state": 524282.0}, "11111111111011111111": {"state": 1048319.0}, "11111111111010100101": {"state": 1048229.0}, "01111111110110011010": {"state": 523674.0}, "11111111111001101101": {"state": 1048173.0}, "11111111111111000011": {"state": 1048515.0}, "01111111111100001111": {"state": 524047.0}, "00000000000100000000": {"state": 256.0}, "11111111111010101010": {"state": 1048234.0}, "11111111110001101101": {"state": 1047661.0}, "00000000000000111010": {"state": 58.0}, "11111111111111001011": {"state": 1048523.0}, "11111111111111111001": {"state": 1048569.0}, "11111111111111001110": {"state": 1048526.0}, "01111111110000001010": {"state": 523274.0}, "00000000000111110111": {"state": 503.0}, "01111111111111111001": {"state": 524281.0}, "00000000011111111000": {"state": 2040.0}, "01111111110000000110": {"state": 523270.0}, "10000000000111111001": {"state": 524793.0}, "11111111110000000111": {"state": 1047559.0}, "01111111111111111110": {"state": 524286.0}, "11111111111000110000": {"state": 1048112.0}, "11111111110011111001": {"state": 1047801.0}, "01111111110110010010": {"state": 523666.0}, "01111111111101011100": {"state": 524124.0}, "11111111111111110001": {"state": 1048561.0}, "11111111110001100111": {"state": 1047655.0}, "11111111111111111100": {"state": 1048572.0}, "01111111111000001001": {"state": 523785.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "00000000001111001010": 1, + "11111111110001101010": 1, + "11111111110001101101": 1, + "00000000011111111000": 2, + "11111111100011110111": 1, + "01111111111000000011": 1, + "11111111111000110100": 1, + "11111111111111001011": 1, + "01111111111111111100": 1, + "01111111111111000000": 1, + "01111111111001100110": 1, + "00000000001111001001": 1, + "11111111101001100101": 1, + "11111111101001101100": 1, + "00000000001000111010": 1, + "11111111111010010001": 1, + "10000000000011111010": 1, + "11111111111010101101": 1, + "01111111111001011100": 1, + "01111111111000000111": 1, + "01111111101110011011": 1, + "11111111111001100100": 1, + "00000000000000001001": 1, + "11111111110001101111": 1, + "00000000000111110101": 1, + "11111111110001100101": 1, + "11111111110110100000": 1, + "00000000000111111111": 1, + "01111111111111000010": 1, + "11111111100000110011": 1, + "00000000011000000000": 2, + "10000000000000001011": 2, + "01111111111111110111": 5, + "11111111111000001111": 1, + "01111111110001100111": 1, + "11111111111111111101": 12, + "01111111111111110010": 1, + "01111111111111111101": 1, + "01111111111101111010": 1, + "10000000000111110001": 223, + "01111111111100000000": 1, + "10000000000000000100": 1, + "11111111110110010010": 1, + "01111111111101110100": 1, + "00000000011000001111": 2, + "01111111111110010001": 1, + "00000000001111000110": 1, + "10000000000000001110": 22, + "01111111110110011110": 6, + "11111111111111110001": 8, + "11111111110001100111": 1, + "10000000000011111101": 3, + "10000000001111000000": 1, + "10000000000011110100": 3, + "10000000000000000101": 421, + "00000000000111110011": 31, + "01111111110000000010": 2, + "00000000000111110100": 1, + "11111111110001100011": 1, + "11111111110110010000": 10, + "01111111110110011111": 3, + "01111111111100000111": 5, + "00000000000000000000": 2396, + "10000000000111111100": 1, + "10000000000011110110": 2, + "01111111110110010101": 9, + "00000000000111111100": 8, + "00000000011111110011": 15, + "01111111111100010101": 1, + "10000000000000001001": 754, + "00000000000000000011": 16, + "10000000000111111101": 1, + "01111111111100000101": 7, + "10000000011111111110": 13, + "11111111111110000100": 1, + "10000000000000000000": 1, + "01111111111010100000": 5, + "10000000000000000110": 669, + "00000000011111111100": 10, + "11111111111100000000": 9, + "01111111101111111001": 1, + "10000000000000001010": 540, + "01111111111100001010": 5, + "00000000000000001111": 1569, + "01111111110110010110": 1, + "10000000000111111110": 308, + "01111111111010011100": 2, + "00000000000000001100": 2, + "01111111111111110001": 16, + "10000000000000000010": 551, + "10000000000100001101": 3, + "00000000000111110111": 1, + "11111111111101111011": 1, + "11111111111111111011": 7, + "11111111111111110011": 24, + "01111111111111110000": 3, + "01111111110001100110": 1, + "11111111111100000111": 19, + "01111111111100001110": 7, + "01111111111100000010": 3, + "11111111111011111000": 1, + "01111111111011110101": 2, + "11111111110110011011": 5, + "01111111110110010001": 3, + "11111111110000001010": 1, + "11111111110110010011": 1, + "11111111111011110011": 2, + "11111111111111111100": 47, + "01111111111111111001": 6, + "01111111111000000010": 5, + "00000000000000000111": 138, + "01111111111100001001": 5, + "11111111111100001011": 9, + "11111111111100001001": 1, + "11111111111010011110": 6, + "11111111111001100000": 2, + "00000000011000001011": 1, + "11111111111100001100": 4, + "01111111111011111100": 1, + "01111111111000001110": 1, + "11111111111111000010": 1, + "01111111111010011111": 1, + "10000000001111001011": 1, + "11111111111011110001": 2, + "11111111110011111100": 2, + "00000000000000001000": 3, + "11111111111011111100": 1, + "10000000000000000001": 26, + "01111111111010010011": 7, + "11111111111100000100": 5, + "10000000000000001101": 29, + "10000000001111111011": 1, + "11111111110011111001": 1, + "01111111110110010010": 1, + "01111111110011111001": 2, + "01111111110110011010": 1, + "11111111100000000100": 3, + "11111111111001101101": 2, + "11111111111000111010": 1, + "11111111111111111000": 5, + "11111111111100001111": 1, + "10000000000100000011": 1, + "11111111110001100100": 1, + "11111111111100000010": 3, + "01111111111100001111": 1, + "00000000000100000000": 1, + "01111111101001101111": 1, + "01111111101001100101": 1, + "01111111111100000110": 5, + "01111111110011111111": 1, + "01111111110011110101": 2, + "11111111111000000010": 3, + "01111111110110011100": 1, + "00000000000000001011": 2, + "11111111111111111111": 2, + "11111111111100000110": 2, + "11111111101001100011": 1, + "11111111111100001000": 2, + "10000000000011110010": 1, + "00000000011111110100": 2, + "00000000001000001101": 1, + "01111111111111111110": 1, + "11111111110000000111": 2, + "11111111111000110000": 2, + "10000000000001010111": 1, + "11111111111111111001": 2, + "00000000000111111110": 1, + "11111111111010010101": 1, + "01111111111111110101": 3, + "10000000000100000110": 1, + "01111111111001100000": 5, + "00000000000100000100": 2, + "01111111111000111110": 1, + "11111111110111001001": 1, + "11111111110000001011": 1, + "01111111111011111001": 3, + "01111111111010010100": 1, + "01111111110011111000": 1, + "01111111111101101011": 1, + "11111111111001011110": 2, + "01111111111001101111": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "00000000001111001010": { "state": 970.0 }, + "11111111110001101010": { "state": 1047658.0 }, + "11111111110001101101": { "state": 1047661.0 }, + "00000000011111111000": { "state": 2040.0 }, + "11111111100011110111": { "state": 1046775.0 }, + "01111111111000000011": { "state": 523779.0 }, + "11111111111000110100": { "state": 1048116.0 }, + "11111111111111001011": { "state": 1048523.0 }, + "01111111111111111100": { "state": 524284.0 }, + "01111111111111000000": { "state": 524224.0 }, + "01111111111001100110": { "state": 523878.0 }, + "00000000001111001001": { "state": 969.0 }, + "11111111101001100101": { "state": 1047141.0 }, + "11111111101001101100": { "state": 1047148.0 }, + "00000000001000111010": { "state": 570.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "10000000000011111010": { "state": 524538.0 }, + "11111111111010101101": { "state": 1048237.0 }, + "01111111111001011100": { "state": 523868.0 }, + "01111111111000000111": { "state": 523783.0 }, + "01111111101110011011": { "state": 523163.0 }, + "11111111111001100100": { "state": 1048164.0 }, + "00000000000000001001": { "state": 9.0 }, + "11111111110001101111": { "state": 1047663.0 }, + "00000000000111110101": { "state": 501.0 }, + "11111111110001100101": { "state": 1047653.0 }, + "11111111110110100000": { "state": 1047968.0 }, + "00000000000111111111": { "state": 511.0 }, + "01111111111111000010": { "state": 524226.0 }, + "11111111100000110011": { "state": 1046579.0 }, + "00000000011000000000": { "state": 1536.0 }, + "10000000000000001011": { "state": 524299.0 }, + "01111111111111110111": { "state": 524279.0 }, + "11111111111000001111": { "state": 1048079.0 }, + "01111111110001100111": { "state": 523367.0 }, + "11111111111111111101": { "state": 1048573.0 }, + "01111111111111110010": { "state": 524274.0 }, + "01111111111111111101": { "state": 524285.0 }, + "01111111111101111010": { "state": 524154.0 }, + "10000000000111110001": { "state": 524785.0 }, + "01111111111100000000": { "state": 524032.0 }, + "10000000000000000100": { "state": 524292.0 }, + "11111111110110010010": { "state": 1047954.0 }, + "01111111111101110100": { "state": 524148.0 }, + "00000000011000001111": { "state": 1551.0 }, + "01111111111110010001": { "state": 524177.0 }, + "00000000001111000110": { "state": 966.0 }, + "10000000000000001110": { "state": 524302.0 }, + "01111111110110011110": { "state": 523678.0 }, + "11111111111111110001": { "state": 1048561.0 }, + "11111111110001100111": { "state": 1047655.0 }, + "10000000000011111101": { "state": 524541.0 }, + "10000000001111000000": { "state": 525248.0 }, + "10000000000011110100": { "state": 524532.0 }, + "10000000000000000101": { "state": 524293.0 }, + "00000000000111110011": { "state": 499.0 }, + "01111111110000000010": { "state": 523266.0 }, + "00000000000111110100": { "state": 500.0 }, + "11111111110001100011": { "state": 1047651.0 }, + "11111111110110010000": { "state": 1047952.0 }, + "01111111110110011111": { "state": 523679.0 }, + "01111111111100000111": { "state": 524039.0 }, + "00000000000000000000": { "state": 0.0 }, + "10000000000111111100": { "state": 524796.0 }, + "10000000000011110110": { "state": 524534.0 }, + "01111111110110010101": { "state": 523669.0 }, + "00000000000111111100": { "state": 508.0 }, + "00000000011111110011": { "state": 2035.0 }, + "01111111111100010101": { "state": 524053.0 }, + "10000000000000001001": { "state": 524297.0 }, + "00000000000000000011": { "state": 3.0 }, + "10000000000111111101": { "state": 524797.0 }, + "01111111111100000101": { "state": 524037.0 }, + "10000000011111111110": { "state": 526334.0 }, + "11111111111110000100": { "state": 1048452.0 }, + "10000000000000000000": { "state": 524288.0 }, + "01111111111010100000": { "state": 523936.0 }, + "10000000000000000110": { "state": 524294.0 }, + "00000000011111111100": { "state": 2044.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "01111111101111111001": { "state": 523257.0 }, + "10000000000000001010": { "state": 524298.0 }, + "01111111111100001010": { "state": 524042.0 }, + "00000000000000001111": { "state": 15.0 }, + "01111111110110010110": { "state": 523670.0 }, + "10000000000111111110": { "state": 524798.0 }, + "01111111111010011100": { "state": 523932.0 }, + "00000000000000001100": { "state": 12.0 }, + "01111111111111110001": { "state": 524273.0 }, + "10000000000000000010": { "state": 524290.0 }, + "10000000000100001101": { "state": 524557.0 }, + "00000000000111110111": { "state": 503.0 }, + "11111111111101111011": { "state": 1048443.0 }, + "11111111111111111011": { "state": 1048571.0 }, + "11111111111111110011": { "state": 1048563.0 }, + "01111111111111110000": { "state": 524272.0 }, + "01111111110001100110": { "state": 523366.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "01111111111100001110": { "state": 524046.0 }, + "01111111111100000010": { "state": 524034.0 }, + "11111111111011111000": { "state": 1048312.0 }, + "01111111111011110101": { "state": 524021.0 }, + "11111111110110011011": { "state": 1047963.0 }, + "01111111110110010001": { "state": 523665.0 }, + "11111111110000001010": { "state": 1047562.0 }, + "11111111110110010011": { "state": 1047955.0 }, + "11111111111011110011": { "state": 1048307.0 }, + "11111111111111111100": { "state": 1048572.0 }, + "01111111111111111001": { "state": 524281.0 }, + "01111111111000000010": { "state": 523778.0 }, + "00000000000000000111": { "state": 7.0 }, + "01111111111100001001": { "state": 524041.0 }, + "11111111111100001011": { "state": 1048331.0 }, + "11111111111100001001": { "state": 1048329.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "11111111111001100000": { "state": 1048160.0 }, + "00000000011000001011": { "state": 1547.0 }, + "11111111111100001100": { "state": 1048332.0 }, + "01111111111011111100": { "state": 524028.0 }, + "01111111111000001110": { "state": 523790.0 }, + "11111111111111000010": { "state": 1048514.0 }, + "01111111111010011111": { "state": 523935.0 }, + "10000000001111001011": { "state": 525259.0 }, + "11111111111011110001": { "state": 1048305.0 }, + "11111111110011111100": { "state": 1047804.0 }, + "00000000000000001000": { "state": 8.0 }, + "11111111111011111100": { "state": 1048316.0 }, + "10000000000000000001": { "state": 524289.0 }, + "01111111111010010011": { "state": 523923.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "10000000000000001101": { "state": 524301.0 }, + "10000000001111111011": { "state": 525307.0 }, + "11111111110011111001": { "state": 1047801.0 }, + "01111111110110010010": { "state": 523666.0 }, + "01111111110011111001": { "state": 523513.0 }, + "01111111110110011010": { "state": 523674.0 }, + "11111111100000000100": { "state": 1046532.0 }, + "11111111111001101101": { "state": 1048173.0 }, + "11111111111000111010": { "state": 1048122.0 }, + "11111111111111111000": { "state": 1048568.0 }, + "11111111111100001111": { "state": 1048335.0 }, + "10000000000100000011": { "state": 524547.0 }, + "11111111110001100100": { "state": 1047652.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "01111111111100001111": { "state": 524047.0 }, + "00000000000100000000": { "state": 256.0 }, + "01111111101001101111": { "state": 522863.0 }, + "01111111101001100101": { "state": 522853.0 }, + "01111111111100000110": { "state": 524038.0 }, + "01111111110011111111": { "state": 523519.0 }, + "01111111110011110101": { "state": 523509.0 }, + "11111111111000000010": { "state": 1048066.0 }, + "01111111110110011100": { "state": 523676.0 }, + "00000000000000001011": { "state": 11.0 }, + "11111111111111111111": { "state": 1048575.0 }, + "11111111111100000110": { "state": 1048326.0 }, + "11111111101001100011": { "state": 1047139.0 }, + "11111111111100001000": { "state": 1048328.0 }, + "10000000000011110010": { "state": 524530.0 }, + "00000000011111110100": { "state": 2036.0 }, + "00000000001000001101": { "state": 525.0 }, + "01111111111111111110": { "state": 524286.0 }, + "11111111110000000111": { "state": 1047559.0 }, + "11111111111000110000": { "state": 1048112.0 }, + "10000000000001010111": { "state": 524375.0 }, + "11111111111111111001": { "state": 1048569.0 }, + "00000000000111111110": { "state": 510.0 }, + "11111111111010010101": { "state": 1048213.0 }, + "01111111111111110101": { "state": 524277.0 }, + "10000000000100000110": { "state": 524550.0 }, + "01111111111001100000": { "state": 523872.0 }, + "00000000000100000100": { "state": 260.0 }, + "01111111111000111110": { "state": 523838.0 }, + "11111111110111001001": { "state": 1048009.0 }, + "11111111110000001011": { "state": 1047563.0 }, + "01111111111011111001": { "state": 524025.0 }, + "01111111111010010100": { "state": 523924.0 }, + "01111111110011111000": { "state": 523512.0 }, + "01111111111101101011": { "state": 524139.0 }, + "11111111111001011110": { "state": 1048158.0 }, + "01111111111001101111": { "state": 523887.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n-10.json b/algorithms/glued_trees/results/20-qubits/2n-10.json index 85da8b0c..15922d8d 100644 --- a/algorithms/glued_trees/results/20-qubits/2n-10.json +++ b/algorithms/glued_trees/results/20-qubits/2n-10.json @@ -1 +1,176 @@ -{"vendor_format_result": {}, "counts": {"11111111111000110100": 1, "11111111111000000000": 1, "00000000011000000000": 2, "11111111110001100111": 1, "10000000011111111101": 1, "01111111111111001101": 1, "10000000000011110010": 1, "10000000000111110010": 1, "01111111110011111001": 1, "11111111111010010010": 1, "10000000000000000010": 893, "00000000000000001100": 102, "01111111110110010101": 1, "11111111111111111100": 14, "00000000000111111100": 5, "10000000011111111110": 13, "10000000000000001101": 19, "10000000000000001010": 29, "10000000000111110101": 1, "00000000000000000000": 4663, "11111111111100000000": 1, "00000000000000000100": 11, "10000000000111110001": 28, "11111111111010011110": 4, "10000000000110100111": 1, "01111111111001100000": 1, "11111111110110011000": 1, "01111111111111111000": 2, "11111111111100000111": 22, "01111111110001101101": 1, "00000000000000001011": 142, "01111111111111110011": 1, "11111111111111111000": 4, "00000000000000000111": 97, "01111111110110011001": 4, "11111111111111111011": 11, "01111111111111110001": 6, "01111111111100000110": 2, "01111111111000111010": 2, "11111111110110010101": 1, "01111111110110011110": 13, "10000000000000001110": 35, "01111111111111111100": 1, "01111111111100000101": 5, "10000000000000000101": 127, "00000000000011111011": 15, "11111111110011111011": 1, "11111111111100000100": 3, "01111111111001101111": 1, "00000000000000001111": 927, "11111111111111111010": 2, "11111111111000110011": 4, "01111111111111111010": 3, "00000000000000000011": 733, "10000000000000001001": 8, "01111111111111111101": 1, "00000000011111111100": 2, "01111111110110010111": 2, "01111111111011111001": 1, "01111111111100001001": 3, "10000000000011111001": 1, "01111111111111110101": 1, "01111111111000111101": 1, "10000000011111110001": 3, "11111111111100000110": 1, "10000000000111111110": 182, "01111111110001100010": 1, "11111111110110011010": 1, "11111111111001100000": 1, "01111111111111111110": 5, "00000000000111110011": 1, "01111111110110011010": 5, "00000000000000001000": 7, "11111111111001101011": 1, "10000000000111111101": 1}, "counts_lsb_right": true, "parsed_states": {"11111111111000110100": {"state": 1048116.0}, "11111111111000000000": {"state": 1048064.0}, "00000000011000000000": {"state": 1536.0}, "11111111110001100111": {"state": 1047655.0}, "10000000011111111101": {"state": 526333.0}, "01111111111111001101": {"state": 524237.0}, "10000000000011110010": {"state": 524530.0}, "10000000000111110010": {"state": 524786.0}, "01111111110011111001": {"state": 523513.0}, "11111111111010010010": {"state": 1048210.0}, "10000000000000000010": {"state": 524290.0}, "00000000000000001100": {"state": 12.0}, "01111111110110010101": {"state": 523669.0}, "11111111111111111100": {"state": 1048572.0}, "00000000000111111100": {"state": 508.0}, "10000000011111111110": {"state": 526334.0}, "10000000000000001101": {"state": 524301.0}, "10000000000000001010": {"state": 524298.0}, "10000000000111110101": {"state": 524789.0}, "00000000000000000000": {"state": 0.0}, "11111111111100000000": {"state": 1048320.0}, "00000000000000000100": {"state": 4.0}, "10000000000111110001": {"state": 524785.0}, "11111111111010011110": {"state": 1048222.0}, "10000000000110100111": {"state": 524711.0}, "01111111111001100000": {"state": 523872.0}, "11111111110110011000": {"state": 1047960.0}, "01111111111111111000": {"state": 524280.0}, "11111111111100000111": {"state": 1048327.0}, "01111111110001101101": {"state": 523373.0}, "00000000000000001011": {"state": 11.0}, "01111111111111110011": {"state": 524275.0}, "11111111111111111000": {"state": 1048568.0}, "00000000000000000111": {"state": 7.0}, "01111111110110011001": {"state": 523673.0}, "11111111111111111011": {"state": 1048571.0}, "01111111111111110001": {"state": 524273.0}, "01111111111100000110": {"state": 524038.0}, "01111111111000111010": {"state": 523834.0}, "11111111110110010101": {"state": 1047957.0}, "01111111110110011110": {"state": 523678.0}, "10000000000000001110": {"state": 524302.0}, "01111111111111111100": {"state": 524284.0}, "01111111111100000101": {"state": 524037.0}, "10000000000000000101": {"state": 524293.0}, "00000000000011111011": {"state": 251.0}, "11111111110011111011": {"state": 1047803.0}, "11111111111100000100": {"state": 1048324.0}, "01111111111001101111": {"state": 523887.0}, "00000000000000001111": {"state": 15.0}, "11111111111111111010": {"state": 1048570.0}, "11111111111000110011": {"state": 1048115.0}, "01111111111111111010": {"state": 524282.0}, "00000000000000000011": {"state": 3.0}, "10000000000000001001": {"state": 524297.0}, "01111111111111111101": {"state": 524285.0}, "00000000011111111100": {"state": 2044.0}, "01111111110110010111": {"state": 523671.0}, "01111111111011111001": {"state": 524025.0}, "01111111111100001001": {"state": 524041.0}, "10000000000011111001": {"state": 524537.0}, "01111111111111110101": {"state": 524277.0}, "01111111111000111101": {"state": 523837.0}, "10000000011111110001": {"state": 526321.0}, "11111111111100000110": {"state": 1048326.0}, "10000000000111111110": {"state": 524798.0}, "01111111110001100010": {"state": 523362.0}, "11111111110110011010": {"state": 1047962.0}, "11111111111001100000": {"state": 1048160.0}, "01111111111111111110": {"state": 524286.0}, "00000000000111110011": {"state": 499.0}, "01111111110110011010": {"state": 523674.0}, "00000000000000001000": {"state": 8.0}, "11111111111001101011": {"state": 1048171.0}, "10000000000111111101": {"state": 524797.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "11111111111111111000": 1, + "11111111111000110011": 1, + "00000000011111110100": 1, + "10000000011111110001": 1, + "11111111111000110100": 1, + "11111111111100000110": 1, + "01111111111000001101": 1, + "10000000011111111001": 1, + "10000000000011111110": 1, + "00000000000000000100": 10, + "01111111110110010101": 2, + "11111111111010010001": 1, + "11111111110110011000": 1, + "01111111111001100000": 3, + "00000000000000000111": 105, + "00000000011000000000": 1, + "11111111111000000000": 3, + "01111111111111110101": 1, + "10000000000000001101": 25, + "11111111111111111001": 1, + "11111111111111111011": 5, + "01111111111111110001": 2, + "10000000000000001010": 18, + "00000000000000000000": 4664, + "01111111111111111010": 4, + "11111111111111111010": 1, + "00000000000000001111": 922, + "10000000011111111110": 8, + "11111111111010011110": 4, + "10000000000111110001": 39, + "11111111111101111011": 1, + "10000000000000000010": 878, + "00000000000000001100": 108, + "11111111111001101011": 1, + "00000000000000001000": 8, + "11111111111100000111": 35, + "00000000000011001100": 1, + "11111111111111110011": 3, + "00000000000000001011": 130, + "10000000000000001001": 11, + "00000000000000000011": 735, + "00000000000011111011": 5, + "01111111110110011000": 1, + "11111111111111111100": 17, + "11111111110110011010": 1, + "01111111111010011100": 1, + "10000000000111111110": 188, + "01111111111100000001": 1, + "01111111111111111100": 2, + "10000000000000000101": 133, + "01111111111100000101": 6, + "01111111111100000110": 4, + "01111111111000111010": 1, + "11111111110110010101": 1, + "01111111111100001010": 1, + "10000000000000001110": 44, + "01111111110110011110": 9, + "00000000011111111100": 2, + "11111111110001100111": 2, + "01111111111111001101": 1, + "10000000000011111101": 1, + "01111111111111111110": 4, + "00000000000111110011": 3, + "01111111111100001110": 1, + "01111111110110010001": 2, + "01111111111100001001": 4, + "10000000000011111001": 2, + "00000000000011111000": 2, + "01111111110110011010": 2, + "00000000000011110100": 1, + "10000000000111110010": 1, + "11111111110110010011": 1, + "10000000000000000110": 1, + "01111111111100001101": 4, + "10000000000000000011": 1, + "01111111111111110010": 1, + "10000000000011110001": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "11111111111111111000": { "state": 1048568.0 }, + "11111111111000110011": { "state": 1048115.0 }, + "00000000011111110100": { "state": 2036.0 }, + "10000000011111110001": { "state": 526321.0 }, + "11111111111000110100": { "state": 1048116.0 }, + "11111111111100000110": { "state": 1048326.0 }, + "01111111111000001101": { "state": 523789.0 }, + "10000000011111111001": { "state": 526329.0 }, + "10000000000011111110": { "state": 524542.0 }, + "00000000000000000100": { "state": 4.0 }, + "01111111110110010101": { "state": 523669.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "11111111110110011000": { "state": 1047960.0 }, + "01111111111001100000": { "state": 523872.0 }, + "00000000000000000111": { "state": 7.0 }, + "00000000011000000000": { "state": 1536.0 }, + "11111111111000000000": { "state": 1048064.0 }, + "01111111111111110101": { "state": 524277.0 }, + "10000000000000001101": { "state": 524301.0 }, + "11111111111111111001": { "state": 1048569.0 }, + "11111111111111111011": { "state": 1048571.0 }, + "01111111111111110001": { "state": 524273.0 }, + "10000000000000001010": { "state": 524298.0 }, + "00000000000000000000": { "state": 0.0 }, + "01111111111111111010": { "state": 524282.0 }, + "11111111111111111010": { "state": 1048570.0 }, + "00000000000000001111": { "state": 15.0 }, + "10000000011111111110": { "state": 526334.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "10000000000111110001": { "state": 524785.0 }, + "11111111111101111011": { "state": 1048443.0 }, + "10000000000000000010": { "state": 524290.0 }, + "00000000000000001100": { "state": 12.0 }, + "11111111111001101011": { "state": 1048171.0 }, + "00000000000000001000": { "state": 8.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "00000000000011001100": { "state": 204.0 }, + "11111111111111110011": { "state": 1048563.0 }, + "00000000000000001011": { "state": 11.0 }, + "10000000000000001001": { "state": 524297.0 }, + "00000000000000000011": { "state": 3.0 }, + "00000000000011111011": { "state": 251.0 }, + "01111111110110011000": { "state": 523672.0 }, + "11111111111111111100": { "state": 1048572.0 }, + "11111111110110011010": { "state": 1047962.0 }, + "01111111111010011100": { "state": 523932.0 }, + "10000000000111111110": { "state": 524798.0 }, + "01111111111100000001": { "state": 524033.0 }, + "01111111111111111100": { "state": 524284.0 }, + "10000000000000000101": { "state": 524293.0 }, + "01111111111100000101": { "state": 524037.0 }, + "01111111111100000110": { "state": 524038.0 }, + "01111111111000111010": { "state": 523834.0 }, + "11111111110110010101": { "state": 1047957.0 }, + "01111111111100001010": { "state": 524042.0 }, + "10000000000000001110": { "state": 524302.0 }, + "01111111110110011110": { "state": 523678.0 }, + "00000000011111111100": { "state": 2044.0 }, + "11111111110001100111": { "state": 1047655.0 }, + "01111111111111001101": { "state": 524237.0 }, + "10000000000011111101": { "state": 524541.0 }, + "01111111111111111110": { "state": 524286.0 }, + "00000000000111110011": { "state": 499.0 }, + "01111111111100001110": { "state": 524046.0 }, + "01111111110110010001": { "state": 523665.0 }, + "01111111111100001001": { "state": 524041.0 }, + "10000000000011111001": { "state": 524537.0 }, + "00000000000011111000": { "state": 248.0 }, + "01111111110110011010": { "state": 523674.0 }, + "00000000000011110100": { "state": 244.0 }, + "10000000000111110010": { "state": 524786.0 }, + "11111111110110010011": { "state": 1047955.0 }, + "10000000000000000110": { "state": 524294.0 }, + "01111111111100001101": { "state": 524045.0 }, + "10000000000000000011": { "state": 524291.0 }, + "01111111111111110010": { "state": 524274.0 }, + "10000000000011110001": { "state": 524529.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n-12.json b/algorithms/glued_trees/results/20-qubits/2n-12.json index 580511d6..a6a92b3c 100644 --- a/algorithms/glued_trees/results/20-qubits/2n-12.json +++ b/algorithms/glued_trees/results/20-qubits/2n-12.json @@ -1 +1,154 @@ -{"vendor_format_result": {}, "counts": {"10000000011111110001": 1, "00000000011111111011": 1, "11111111111111111011": 1, "01111111111010100000": 1, "11111111111111111100": 1, "01111111111100001101": 1, "00000000000000000100": 37, "01111111111100000110": 3, "01111111111111111110": 11, "00000000000111110011": 3, "01111111111111110101": 3, "10000000000000001101": 213, "11111111111000110001": 1, "00000000000011111111": 1, "11111111111100000100": 7, "00000000000011111011": 1, "11111111110110011011": 1, "11111111111100000011": 3, "01111111110011111001": 2, "00000000000000001100": 12, "00000000000000001000": 13, "10000000000000000010": 550, "11111111111010011110": 8, "00000000000000001011": 122, "00000000000000000111": 312, "11111111111100001000": 1, "01111111111001100000": 2, "11111111111111111010": 8, "00000000000000001111": 619, "00000000000011110111": 1, "11111111111100000111": 23, "10000000000000000101": 558, "01111111111100000101": 1, "00000000000000000000": 5089, "10000000000000001010": 81, "10000000011111111110": 12, "00000000000111111100": 1, "10000000000111110001": 29, "01111111111000111110": 1, "01111111110110011001": 2, "00000000000000000011": 188, "10000000000000001001": 16, "01111111111100001001": 2, "00000000000111111111": 2, "01111111111101111001": 1, "11111111111000110011": 3, "00000000011111111100": 1, "11111111101001100100": 1, "10000000000000000001": 36, "11111111110110011100": 2, "11111111111111111000": 4, "01111111111111110011": 1, "01111111110110011110": 12, "10000000000000001110": 1, "01111111111111110001": 2, "10000000000011110010": 1, "00000000000011111000": 5, "01111111110110011010": 2, "10000000011111111101": 1, "01111111110110010001": 1, "01111111111111111101": 1, "10000000000111111110": 170, "01111111111010011100": 1, "11111111111010101101": 1}, "counts_lsb_right": true, "parsed_states": {"10000000011111110001": {"state": 526321.0}, "00000000011111111011": {"state": 2043.0}, "11111111111111111011": {"state": 1048571.0}, "01111111111010100000": {"state": 523936.0}, "11111111111111111100": {"state": 1048572.0}, "01111111111100001101": {"state": 524045.0}, "00000000000000000100": {"state": 4.0}, "01111111111100000110": {"state": 524038.0}, "01111111111111111110": {"state": 524286.0}, "00000000000111110011": {"state": 499.0}, "01111111111111110101": {"state": 524277.0}, "10000000000000001101": {"state": 524301.0}, "11111111111000110001": {"state": 1048113.0}, "00000000000011111111": {"state": 255.0}, "11111111111100000100": {"state": 1048324.0}, "00000000000011111011": {"state": 251.0}, "11111111110110011011": {"state": 1047963.0}, "11111111111100000011": {"state": 1048323.0}, "01111111110011111001": {"state": 523513.0}, "00000000000000001100": {"state": 12.0}, "00000000000000001000": {"state": 8.0}, "10000000000000000010": {"state": 524290.0}, "11111111111010011110": {"state": 1048222.0}, "00000000000000001011": {"state": 11.0}, "00000000000000000111": {"state": 7.0}, "11111111111100001000": {"state": 1048328.0}, "01111111111001100000": {"state": 523872.0}, "11111111111111111010": {"state": 1048570.0}, "00000000000000001111": {"state": 15.0}, "00000000000011110111": {"state": 247.0}, "11111111111100000111": {"state": 1048327.0}, "10000000000000000101": {"state": 524293.0}, "01111111111100000101": {"state": 524037.0}, "00000000000000000000": {"state": 0.0}, "10000000000000001010": {"state": 524298.0}, "10000000011111111110": {"state": 526334.0}, "00000000000111111100": {"state": 508.0}, "10000000000111110001": {"state": 524785.0}, "01111111111000111110": {"state": 523838.0}, "01111111110110011001": {"state": 523673.0}, "00000000000000000011": {"state": 3.0}, "10000000000000001001": {"state": 524297.0}, "01111111111100001001": {"state": 524041.0}, "00000000000111111111": {"state": 511.0}, "01111111111101111001": {"state": 524153.0}, "11111111111000110011": {"state": 1048115.0}, "00000000011111111100": {"state": 2044.0}, "11111111101001100100": {"state": 1047140.0}, "10000000000000000001": {"state": 524289.0}, "11111111110110011100": {"state": 1047964.0}, "11111111111111111000": {"state": 1048568.0}, "01111111111111110011": {"state": 524275.0}, "01111111110110011110": {"state": 523678.0}, "10000000000000001110": {"state": 524302.0}, "01111111111111110001": {"state": 524273.0}, "10000000000011110010": {"state": 524530.0}, "00000000000011111000": {"state": 248.0}, "01111111110110011010": {"state": 523674.0}, "10000000011111111101": {"state": 526333.0}, "01111111110110010001": {"state": 523665.0}, "01111111111111111101": {"state": 524285.0}, "10000000000111111110": {"state": 524798.0}, "01111111111010011100": {"state": 523932.0}, "11111111111010101101": {"state": 1048237.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "00000000011111111011": 1, + "11111111111100001000": 1, + "11111111110001101000": 1, + "11111111110001100100": 1, + "00000000000011111011": 1, + "00000000001100001000": 1, + "01111111110011111001": 2, + "11111111111100000100": 6, + "10000000000000000101": 618, + "11111111110110011011": 1, + "10000000011111111110": 4, + "11111111111010011110": 6, + "01111111111111110111": 1, + "00000000000111110011": 1, + "01111111111111111110": 17, + "00000000000000000100": 19, + "01111111111100000110": 2, + "11111111111111111000": 2, + "01111111111111111111": 1, + "00000000000000001100": 23, + "10000000000000000010": 512, + "00000000000000001000": 8, + "00000000011000000000": 1, + "10000000000000001010": 62, + "11111111100011110111": 1, + "00000000000000000000": 5068, + "00000000000000001011": 105, + "11111111111111111111": 1, + "00000000000000000111": 325, + "01111111111001100000": 2, + "10000000000111111110": 171, + "11111111111100000111": 23, + "01111111111010010011": 1, + "10000000000111110001": 19, + "01111111110110010001": 1, + "10000000000000000001": 21, + "10000000000000001101": 180, + "01111111111111110101": 1, + "11111111111000111000": 1, + "00000000000000000011": 218, + "10000000000000001001": 17, + "11111111111100000011": 3, + "11111111111010010001": 3, + "11111111111000110011": 4, + "10000000000000000110": 2, + "11111111110110010011": 1, + "01111111110110011111": 1, + "11111111111111111011": 1, + "00000000000000001111": 689, + "11111111111001100101": 1, + "00000000000011111000": 4, + "01111111110110011010": 1, + "11111111111111111100": 2, + "01111111111100001001": 4, + "01111111111111111001": 1, + "11111111111000001011": 1, + "11111111111111110111": 4, + "10000000011111110001": 1, + "01111111110110011100": 3, + "01111111111100000010": 1, + "01111111111011111101": 1, + "01111111110110011110": 13, + "10000000000000001110": 1, + "01111111111101100000": 1, + "11111111111000000100": 1, + "10000000000011110010": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "00000000011111111011": { "state": 2043.0 }, + "11111111111100001000": { "state": 1048328.0 }, + "11111111110001101000": { "state": 1047656.0 }, + "11111111110001100100": { "state": 1047652.0 }, + "00000000000011111011": { "state": 251.0 }, + "00000000001100001000": { "state": 776.0 }, + "01111111110011111001": { "state": 523513.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "10000000000000000101": { "state": 524293.0 }, + "11111111110110011011": { "state": 1047963.0 }, + "10000000011111111110": { "state": 526334.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "01111111111111110111": { "state": 524279.0 }, + "00000000000111110011": { "state": 499.0 }, + "01111111111111111110": { "state": 524286.0 }, + "00000000000000000100": { "state": 4.0 }, + "01111111111100000110": { "state": 524038.0 }, + "11111111111111111000": { "state": 1048568.0 }, + "01111111111111111111": { "state": 524287.0 }, + "00000000000000001100": { "state": 12.0 }, + "10000000000000000010": { "state": 524290.0 }, + "00000000000000001000": { "state": 8.0 }, + "00000000011000000000": { "state": 1536.0 }, + "10000000000000001010": { "state": 524298.0 }, + "11111111100011110111": { "state": 1046775.0 }, + "00000000000000000000": { "state": 0.0 }, + "00000000000000001011": { "state": 11.0 }, + "11111111111111111111": { "state": 1048575.0 }, + "00000000000000000111": { "state": 7.0 }, + "01111111111001100000": { "state": 523872.0 }, + "10000000000111111110": { "state": 524798.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "01111111111010010011": { "state": 523923.0 }, + "10000000000111110001": { "state": 524785.0 }, + "01111111110110010001": { "state": 523665.0 }, + "10000000000000000001": { "state": 524289.0 }, + "10000000000000001101": { "state": 524301.0 }, + "01111111111111110101": { "state": 524277.0 }, + "11111111111000111000": { "state": 1048120.0 }, + "00000000000000000011": { "state": 3.0 }, + "10000000000000001001": { "state": 524297.0 }, + "11111111111100000011": { "state": 1048323.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "11111111111000110011": { "state": 1048115.0 }, + "10000000000000000110": { "state": 524294.0 }, + "11111111110110010011": { "state": 1047955.0 }, + "01111111110110011111": { "state": 523679.0 }, + "11111111111111111011": { "state": 1048571.0 }, + "00000000000000001111": { "state": 15.0 }, + "11111111111001100101": { "state": 1048165.0 }, + "00000000000011111000": { "state": 248.0 }, + "01111111110110011010": { "state": 523674.0 }, + "11111111111111111100": { "state": 1048572.0 }, + "01111111111100001001": { "state": 524041.0 }, + "01111111111111111001": { "state": 524281.0 }, + "11111111111000001011": { "state": 1048075.0 }, + "11111111111111110111": { "state": 1048567.0 }, + "10000000011111110001": { "state": 526321.0 }, + "01111111110110011100": { "state": 523676.0 }, + "01111111111100000010": { "state": 524034.0 }, + "01111111111011111101": { "state": 524029.0 }, + "01111111110110011110": { "state": 523678.0 }, + "10000000000000001110": { "state": 524302.0 }, + "01111111111101100000": { "state": 524128.0 }, + "11111111111000000100": { "state": 1048068.0 }, + "10000000000011110010": { "state": 524530.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n-2.json b/algorithms/glued_trees/results/20-qubits/2n-2.json index 62a004e7..4d3df592 100644 --- a/algorithms/glued_trees/results/20-qubits/2n-2.json +++ b/algorithms/glued_trees/results/20-qubits/2n-2.json @@ -1 +1,262 @@ -{"vendor_format_result": {}, "counts": {"11111111111011111011": 1, "01111111111010011111": 1, "10000000000000000111": 1, "01111111111111110101": 1, "01111111111010100000": 1, "01111111111111111010": 1, "10000000001100000101": 1, "00000000001111000010": 1, "01111111111100001001": 1, "11111111111100001110": 1, "11111111110110011001": 1, "11111111111010010101": 1, "01111111111001101010": 1, "01111111111001100010": 2, "11111111110110011111": 2, "11111111111001101000": 1, "10000000000011110001": 1, "01111111111000111000": 1, "00000000011111111000": 2, "01111111101001100010": 2, "11111111100011111011": 1, "01111111111000110001": 1, "11111111111100001000": 1, "11111111110100001101": 1, "00000000001100000100": 2, "01111111111001100101": 1, "00000000000111111011": 1, "00000000000000000101": 1, "11111111111100000010": 2, "11111111110110011101": 2, "11111111111001100100": 1, "00000000000011111100": 1, "10000000000100001110": 1, "11111111111111001111": 2, "10000000000111111010": 2, "11111111111100001011": 1, "11111111111011110011": 1, "01111111110110010001": 1, "11111111111110011100": 1, "10000000000011110010": 5, "10000000011111110001": 7, "00000000000010100010": 1, "00000000000011111011": 8, "01111111111100000110": 3, "00000000000000000100": 488, "11111111111001101011": 1, "00000000000000001000": 57, "10000000000000000010": 1149, "01111111111111111111": 2, "00000000000000001100": 296, "11111111111111111101": 2, "11111111111011111010": 1, "11111111111010011101": 1, "10000000000000001010": 10, "10000000000000000101": 106, "01111111111100000101": 23, "10000000000000000001": 214, "11111111111111111010": 1, "00000000000000001111": 1490, "10000000011111111110": 7, "00000000000111111100": 3, "11111111110011110100": 2, "01111111111010011100": 2, "10000000000111111110": 238, "11111111111100000110": 3, "10000000000000000110": 78, "10000000000111111101": 7, "11111111110001100111": 1, "01111111111011111001": 1, "01111111110110011010": 2, "00000000011111111111": 2, "10000000000000001001": 13, "00000000000000000011": 1173, "00000000000000000111": 95, "10000000000011111110": 2, "11111111111100000101": 2, "00000000000000001011": 93, "11111111111100001101": 3, "01111111110011110010": 1, "10000000000111110001": 91, "10000000000000001101": 22, "11111111111100000000": 3, "00000000011111111011": 5, "00000000000011110000": 2, "10000000011111111101": 6, "01111111111010011011": 1, "01111111111000110010": 3, "11111111111000110111": 1, "01111111100101100000": 1, "11111111110110010101": 1, "01111111110110011110": 7, "01111111111100001010": 3, "10000000000000001110": 28, "00000000011111111100": 3, "11111111111100000011": 1, "11111111111010010001": 2, "01111111110011111001": 2, "11111111111010011110": 11, "11111111111001100011": 2, "11111111111111111011": 1, "00000000000100000011": 1, "00000000000011110011": 2, "01111111111111110001": 2, "10000000000111110101": 1, "01111111111100000010": 5, "01111111110011111010": 2, "00000000000000000000": 2231, "01111111111011110110": 2, "10000000001111000001": 1, "11111111111100000001": 1, "01111111111100001101": 21, "11111111110011111011": 1, "11111111111100000100": 16, "10000000000011111010": 7, "10000000000011111101": 1, "11111111110011111101": 1, "11111111110110010100": 6, "01111111111111001101": 1, "01111111111100001000": 1, "11111111111100000111": 14, "10000000000011110101": 1, "01111111111111111110": 4, "00000000000111110011": 7, "01111111110110011101": 20, "11111111111111111000": 3, "00000000000111111000": 1, "00000000000011110100": 2}, "counts_lsb_right": true, "parsed_states": {"11111111111011111011": {"state": 1048315.0}, "01111111111010011111": {"state": 523935.0}, "10000000000000000111": {"state": 524295.0}, "01111111111111110101": {"state": 524277.0}, "01111111111010100000": {"state": 523936.0}, "01111111111111111010": {"state": 524282.0}, "10000000001100000101": {"state": 525061.0}, "00000000001111000010": {"state": 962.0}, "01111111111100001001": {"state": 524041.0}, "11111111111100001110": {"state": 1048334.0}, "11111111110110011001": {"state": 1047961.0}, "11111111111010010101": {"state": 1048213.0}, "01111111111001101010": {"state": 523882.0}, "01111111111001100010": {"state": 523874.0}, "11111111110110011111": {"state": 1047967.0}, "11111111111001101000": {"state": 1048168.0}, "10000000000011110001": {"state": 524529.0}, "01111111111000111000": {"state": 523832.0}, "00000000011111111000": {"state": 2040.0}, "01111111101001100010": {"state": 522850.0}, "11111111100011111011": {"state": 1046779.0}, "01111111111000110001": {"state": 523825.0}, "11111111111100001000": {"state": 1048328.0}, "11111111110100001101": {"state": 1047821.0}, "00000000001100000100": {"state": 772.0}, "01111111111001100101": {"state": 523877.0}, "00000000000111111011": {"state": 507.0}, "00000000000000000101": {"state": 5.0}, "11111111111100000010": {"state": 1048322.0}, "11111111110110011101": {"state": 1047965.0}, "11111111111001100100": {"state": 1048164.0}, "00000000000011111100": {"state": 252.0}, "10000000000100001110": {"state": 524558.0}, "11111111111111001111": {"state": 1048527.0}, "10000000000111111010": {"state": 524794.0}, "11111111111100001011": {"state": 1048331.0}, "11111111111011110011": {"state": 1048307.0}, "01111111110110010001": {"state": 523665.0}, "11111111111110011100": {"state": 1048476.0}, "10000000000011110010": {"state": 524530.0}, "10000000011111110001": {"state": 526321.0}, "00000000000010100010": {"state": 162.0}, "00000000000011111011": {"state": 251.0}, "01111111111100000110": {"state": 524038.0}, "00000000000000000100": {"state": 4.0}, "11111111111001101011": {"state": 1048171.0}, "00000000000000001000": {"state": 8.0}, "10000000000000000010": {"state": 524290.0}, "01111111111111111111": {"state": 524287.0}, "00000000000000001100": {"state": 12.0}, "11111111111111111101": {"state": 1048573.0}, "11111111111011111010": {"state": 1048314.0}, "11111111111010011101": {"state": 1048221.0}, "10000000000000001010": {"state": 524298.0}, "10000000000000000101": {"state": 524293.0}, "01111111111100000101": {"state": 524037.0}, "10000000000000000001": {"state": 524289.0}, "11111111111111111010": {"state": 1048570.0}, "00000000000000001111": {"state": 15.0}, "10000000011111111110": {"state": 526334.0}, "00000000000111111100": {"state": 508.0}, "11111111110011110100": {"state": 1047796.0}, "01111111111010011100": {"state": 523932.0}, "10000000000111111110": {"state": 524798.0}, "11111111111100000110": {"state": 1048326.0}, "10000000000000000110": {"state": 524294.0}, "10000000000111111101": {"state": 524797.0}, "11111111110001100111": {"state": 1047655.0}, "01111111111011111001": {"state": 524025.0}, "01111111110110011010": {"state": 523674.0}, "00000000011111111111": {"state": 2047.0}, "10000000000000001001": {"state": 524297.0}, "00000000000000000011": {"state": 3.0}, "00000000000000000111": {"state": 7.0}, "10000000000011111110": {"state": 524542.0}, "11111111111100000101": {"state": 1048325.0}, "00000000000000001011": {"state": 11.0}, "11111111111100001101": {"state": 1048333.0}, "01111111110011110010": {"state": 523506.0}, "10000000000111110001": {"state": 524785.0}, "10000000000000001101": {"state": 524301.0}, "11111111111100000000": {"state": 1048320.0}, "00000000011111111011": {"state": 2043.0}, "00000000000011110000": {"state": 240.0}, "10000000011111111101": {"state": 526333.0}, "01111111111010011011": {"state": 523931.0}, "01111111111000110010": {"state": 523826.0}, "11111111111000110111": {"state": 1048119.0}, "01111111100101100000": {"state": 522592.0}, "11111111110110010101": {"state": 1047957.0}, "01111111110110011110": {"state": 523678.0}, "01111111111100001010": {"state": 524042.0}, "10000000000000001110": {"state": 524302.0}, "00000000011111111100": {"state": 2044.0}, "11111111111100000011": {"state": 1048323.0}, "11111111111010010001": {"state": 1048209.0}, "01111111110011111001": {"state": 523513.0}, "11111111111010011110": {"state": 1048222.0}, "11111111111001100011": {"state": 1048163.0}, "11111111111111111011": {"state": 1048571.0}, "00000000000100000011": {"state": 259.0}, "00000000000011110011": {"state": 243.0}, "01111111111111110001": {"state": 524273.0}, "10000000000111110101": {"state": 524789.0}, "01111111111100000010": {"state": 524034.0}, "01111111110011111010": {"state": 523514.0}, "00000000000000000000": {"state": 0.0}, "01111111111011110110": {"state": 524022.0}, "10000000001111000001": {"state": 525249.0}, "11111111111100000001": {"state": 1048321.0}, "01111111111100001101": {"state": 524045.0}, "11111111110011111011": {"state": 1047803.0}, "11111111111100000100": {"state": 1048324.0}, "10000000000011111010": {"state": 524538.0}, "10000000000011111101": {"state": 524541.0}, "11111111110011111101": {"state": 1047805.0}, "11111111110110010100": {"state": 1047956.0}, "01111111111111001101": {"state": 524237.0}, "01111111111100001000": {"state": 524040.0}, "11111111111100000111": {"state": 1048327.0}, "10000000000011110101": {"state": 524533.0}, "01111111111111111110": {"state": 524286.0}, "00000000000111110011": {"state": 499.0}, "01111111110110011101": {"state": 523677.0}, "11111111111111111000": {"state": 1048568.0}, "00000000000111111000": {"state": 504.0}, "00000000000011110100": {"state": 244.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "01111111111001100101": 1, + "10000000000011110011": 1, + "01111111111101100011": 1, + "11111111101001101011": 1, + "11111111111110011110": 1, + "01111111111011111110": 1, + "10000000011111110001": 4, + "01111111111111110000": 1, + "11111111111100001110": 1, + "11111111111111000000": 1, + "00000000001100000100": 1, + "00000000000011110100": 2, + "01111111111111111000": 1, + "11111111110110010111": 1, + "10000000000111111010": 1, + "00000000001011111100": 1, + "11111111111111111110": 1, + "00000000001111001011": 1, + "11111111111111111001": 1, + "10000000011111110101": 1, + "01111111111001100001": 1, + "11111111111111110100": 1, + "11111111111000001111": 1, + "01111111111100000100": 1, + "11111111111100000010": 2, + "11111111111111001100": 1, + "10000000001111000100": 1, + "10000000000011111101": 2, + "11111111110110010100": 1, + "11111111111100001100": 1, + "01111111111111000101": 1, + "01111111111111000100": 2, + "01111111100011111101": 1, + "11111111111111001111": 1, + "01111111111100001101": 23, + "01111111111111111110": 5, + "00000000000111110011": 4, + "00000000000011111011": 17, + "10000000000011111011": 1, + "11111111111100001111": 1, + "01111111110110011101": 20, + "00000000000111111100": 1, + "10000000011111111110": 12, + "11111111111010011110": 9, + "01111111111111111111": 2, + "00000000000000001100": 276, + "10000000000000000010": 1158, + "00000000000000001000": 65, + "00000000011000000000": 3, + "01111111111100000110": 4, + "00000000000000000100": 479, + "10000000000111110001": 101, + "11111111111111111010": 1, + "11111111110011111100": 1, + "00000000000000001111": 1482, + "00000000000000000111": 104, + "10000000000011111110": 2, + "10000000011111111001": 1, + "01111111110110011011": 1, + "11111111111100000101": 2, + "11111111111000110100": 1, + "11111111111011111011": 4, + "11111111111011111101": 1, + "00000000000000001011": 81, + "11111111111100001101": 3, + "10000000000000000001": 208, + "10000000000000000101": 136, + "01111111111100000101": 22, + "00000000000111111011": 8, + "10000000000011110010": 8, + "01111111111011110110": 1, + "01111111110011111010": 3, + "00000000000000000000": 2237, + "00000000011111111011": 5, + "11111111111100000000": 3, + "10000000000000001010": 17, + "01111111111001101010": 1, + "01111111111100000010": 4, + "11111111111001100011": 2, + "11111111110110010010": 2, + "00000000000011110011": 3, + "01111111111111110001": 3, + "11111111111011110011": 1, + "01111111110110010001": 1, + "00000000000000000011": 1137, + "10000000000000001001": 11, + "10000000000000000110": 75, + "00000000000000000010": 1, + "10000000000111111101": 5, + "00000000000011110001": 1, + "00000000000011110000": 3, + "00000000000011111010": 1, + "10000000011111111101": 8, + "11111111110011110011": 2, + "11111111110001100010": 1, + "11111111101001100011": 1, + "01111111111000110001": 2, + "11111111111100000111": 18, + "01111111110001100010": 1, + "10000000000111111110": 257, + "01111111111100000001": 1, + "11111111111111111100": 2, + "11111111111100000110": 6, + "01111111111011111100": 1, + "11111111111100001000": 1, + "10000000011111111010": 1, + "11111111110110010101": 1, + "00000000000100001100": 1, + "01111111111100001010": 4, + "10000000000000001110": 29, + "11111111110011111011": 1, + "11111111111100000100": 23, + "10000000000011111010": 6, + "10000000000000001101": 9, + "11111111111100000011": 1, + "11111111111010010001": 3, + "11111111111100001011": 3, + "01111111111011111001": 2, + "01111111111100001001": 1, + "11111111110110100000": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "01111111111001100101": { "state": 523877.0 }, + "10000000000011110011": { "state": 524531.0 }, + "01111111111101100011": { "state": 524131.0 }, + "11111111101001101011": { "state": 1047147.0 }, + "11111111111110011110": { "state": 1048478.0 }, + "01111111111011111110": { "state": 524030.0 }, + "10000000011111110001": { "state": 526321.0 }, + "01111111111111110000": { "state": 524272.0 }, + "11111111111100001110": { "state": 1048334.0 }, + "11111111111111000000": { "state": 1048512.0 }, + "00000000001100000100": { "state": 772.0 }, + "00000000000011110100": { "state": 244.0 }, + "01111111111111111000": { "state": 524280.0 }, + "11111111110110010111": { "state": 1047959.0 }, + "10000000000111111010": { "state": 524794.0 }, + "00000000001011111100": { "state": 764.0 }, + "11111111111111111110": { "state": 1048574.0 }, + "00000000001111001011": { "state": 971.0 }, + "11111111111111111001": { "state": 1048569.0 }, + "10000000011111110101": { "state": 526325.0 }, + "01111111111001100001": { "state": 523873.0 }, + "11111111111111110100": { "state": 1048564.0 }, + "11111111111000001111": { "state": 1048079.0 }, + "01111111111100000100": { "state": 524036.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "11111111111111001100": { "state": 1048524.0 }, + "10000000001111000100": { "state": 525252.0 }, + "10000000000011111101": { "state": 524541.0 }, + "11111111110110010100": { "state": 1047956.0 }, + "11111111111100001100": { "state": 1048332.0 }, + "01111111111111000101": { "state": 524229.0 }, + "01111111111111000100": { "state": 524228.0 }, + "01111111100011111101": { "state": 522493.0 }, + "11111111111111001111": { "state": 1048527.0 }, + "01111111111100001101": { "state": 524045.0 }, + "01111111111111111110": { "state": 524286.0 }, + "00000000000111110011": { "state": 499.0 }, + "00000000000011111011": { "state": 251.0 }, + "10000000000011111011": { "state": 524539.0 }, + "11111111111100001111": { "state": 1048335.0 }, + "01111111110110011101": { "state": 523677.0 }, + "00000000000111111100": { "state": 508.0 }, + "10000000011111111110": { "state": 526334.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "01111111111111111111": { "state": 524287.0 }, + "00000000000000001100": { "state": 12.0 }, + "10000000000000000010": { "state": 524290.0 }, + "00000000000000001000": { "state": 8.0 }, + "00000000011000000000": { "state": 1536.0 }, + "01111111111100000110": { "state": 524038.0 }, + "00000000000000000100": { "state": 4.0 }, + "10000000000111110001": { "state": 524785.0 }, + "11111111111111111010": { "state": 1048570.0 }, + "11111111110011111100": { "state": 1047804.0 }, + "00000000000000001111": { "state": 15.0 }, + "00000000000000000111": { "state": 7.0 }, + "10000000000011111110": { "state": 524542.0 }, + "10000000011111111001": { "state": 526329.0 }, + "01111111110110011011": { "state": 523675.0 }, + "11111111111100000101": { "state": 1048325.0 }, + "11111111111000110100": { "state": 1048116.0 }, + "11111111111011111011": { "state": 1048315.0 }, + "11111111111011111101": { "state": 1048317.0 }, + "00000000000000001011": { "state": 11.0 }, + "11111111111100001101": { "state": 1048333.0 }, + "10000000000000000001": { "state": 524289.0 }, + "10000000000000000101": { "state": 524293.0 }, + "01111111111100000101": { "state": 524037.0 }, + "00000000000111111011": { "state": 507.0 }, + "10000000000011110010": { "state": 524530.0 }, + "01111111111011110110": { "state": 524022.0 }, + "01111111110011111010": { "state": 523514.0 }, + "00000000000000000000": { "state": 0.0 }, + "00000000011111111011": { "state": 2043.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "10000000000000001010": { "state": 524298.0 }, + "01111111111001101010": { "state": 523882.0 }, + "01111111111100000010": { "state": 524034.0 }, + "11111111111001100011": { "state": 1048163.0 }, + "11111111110110010010": { "state": 1047954.0 }, + "00000000000011110011": { "state": 243.0 }, + "01111111111111110001": { "state": 524273.0 }, + "11111111111011110011": { "state": 1048307.0 }, + "01111111110110010001": { "state": 523665.0 }, + "00000000000000000011": { "state": 3.0 }, + "10000000000000001001": { "state": 524297.0 }, + "10000000000000000110": { "state": 524294.0 }, + "00000000000000000010": { "state": 2.0 }, + "10000000000111111101": { "state": 524797.0 }, + "00000000000011110001": { "state": 241.0 }, + "00000000000011110000": { "state": 240.0 }, + "00000000000011111010": { "state": 250.0 }, + "10000000011111111101": { "state": 526333.0 }, + "11111111110011110011": { "state": 1047795.0 }, + "11111111110001100010": { "state": 1047650.0 }, + "11111111101001100011": { "state": 1047139.0 }, + "01111111111000110001": { "state": 523825.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "01111111110001100010": { "state": 523362.0 }, + "10000000000111111110": { "state": 524798.0 }, + "01111111111100000001": { "state": 524033.0 }, + "11111111111111111100": { "state": 1048572.0 }, + "11111111111100000110": { "state": 1048326.0 }, + "01111111111011111100": { "state": 524028.0 }, + "11111111111100001000": { "state": 1048328.0 }, + "10000000011111111010": { "state": 526330.0 }, + "11111111110110010101": { "state": 1047957.0 }, + "00000000000100001100": { "state": 268.0 }, + "01111111111100001010": { "state": 524042.0 }, + "10000000000000001110": { "state": 524302.0 }, + "11111111110011111011": { "state": 1047803.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "10000000000011111010": { "state": 524538.0 }, + "10000000000000001101": { "state": 524301.0 }, + "11111111111100000011": { "state": 1048323.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "11111111111100001011": { "state": 1048331.0 }, + "01111111111011111001": { "state": 524025.0 }, + "01111111111100001001": { "state": 524041.0 }, + "11111111110110100000": { "state": 1047968.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n-4.json b/algorithms/glued_trees/results/20-qubits/2n-4.json index e0c288f8..bd468ae9 100644 --- a/algorithms/glued_trees/results/20-qubits/2n-4.json +++ b/algorithms/glued_trees/results/20-qubits/2n-4.json @@ -1 +1,252 @@ -{"vendor_format_result": {}, "counts": {"00000000011111111100": 1, "01111111111111110100": 1, "01111111111010011011": 1, "11111111111000110011": 1, "00000000000100000100": 1, "10000000000111111010": 1, "11111111111010010010": 1, "11111111111000110111": 1, "11111111110110011101": 1, "10000000000011110101": 1, "11111111111100000111": 3, "01111111111100000000": 1, "10000000000000000100": 1, "00000000000011111111": 3, "01111111111100000110": 1, "11111111111000111100": 1, "01111111111001100010": 4, "01111111111100000011": 1, "10000000011111110001": 5, "10000000000000001011": 1, "00000000000111111011": 10, "10000000001100000101": 2, "11111111111011111011": 1, "11111111111000110100": 1, "00000000011111111011": 1, "11111111111100000000": 6, "01111111111111111010": 2, "01111111111111110000": 1, "11111111111100001110": 1, "00000000011000001111": 3, "01111111111101101111": 1, "11111111111000111010": 1, "11111111111001101011": 1, "00000000000000001000": 19, "10000000000000000010": 1187, "00000000001111000101": 1, "01111111111111111111": 3, "00000000000000001100": 340, "11111111111011110100": 1, "00000000011000000000": 1, "01111111111111111110": 10, "11111111111111111100": 3, "01111111111011111010": 3, "00000000000000000100": 72, "00000000000011111000": 2, "01111111110110011010": 8, "11111111110011111011": 1, "10000000000011111010": 3, "11111111111100000100": 23, "00000000000011111011": 16, "11111111111010010001": 7, "11111111111100000011": 10, "01111111111011110101": 1, "11111111110110010011": 2, "11111111111000111011": 1, "10000000000000000110": 23, "10000000000111111101": 5, "00000000011111110100": 1, "01111111111001101010": 1, "01111111110011111010": 5, "00000000000000000000": 2868, "11111111111010011101": 1, "01111111110001100101": 2, "10000000000000001010": 14, "11111111111010011110": 13, "11111111111001101010": 1, "00000000000011111100": 3, "11111111111100000010": 1, "00000000000111111111": 1, "11111111111111111000": 2, "01111111110110011101": 5, "11111111111100001111": 2, "10000000000000000101": 225, "01111111111100000101": 9, "11111111111100001100": 3, "00000000000000001111": 1237, "11111111111000001101": 1, "10000000000111111110": 224, "01111111111001100101": 2, "00000000000000001011": 121, "11111111111100001101": 2, "00000000000000000111": 62, "10000000000000001101": 18, "10000000000111110001": 65, "11111111110110010100": 5, "11111111110011110011": 1, "00000000000011110000": 1, "10000000011111111101": 5, "11111111101001101010": 1, "01111111111000111011": 1, "10000000000011110010": 7, "00000000000111111100": 2, "10000000011111111110": 8, "11111111110011110100": 1, "01111111111111111101": 2, "11111111111111111101": 1, "11111111110110010101": 1, "01111111111100001010": 1, "10000000000000001110": 25, "10000000000000000001": 248, "11111111110110011100": 1, "10000000000111110101": 3, "01111111111100000010": 5, "01111111111011111101": 3, "00000000000000000011": 1145, "10000000000000001001": 7, "01111111111111110010": 1, "01111111111111111000": 1, "11111111111111000100": 2, "01111111111100001101": 6, "11111111111100000101": 2, "10000000000011111110": 1, "01111111110110011011": 1, "01111111111111001100": 1, "11111111111001100110": 1, "00000000000011110011": 1, "01111111111111110001": 2, "00000000000100000011": 1, "11111111111111110100": 3, "11111111110001100100": 2}, "counts_lsb_right": true, "parsed_states": {"00000000011111111100": {"state": 2044.0}, "01111111111111110100": {"state": 524276.0}, "01111111111010011011": {"state": 523931.0}, "11111111111000110011": {"state": 1048115.0}, "00000000000100000100": {"state": 260.0}, "10000000000111111010": {"state": 524794.0}, "11111111111010010010": {"state": 1048210.0}, "11111111111000110111": {"state": 1048119.0}, "11111111110110011101": {"state": 1047965.0}, "10000000000011110101": {"state": 524533.0}, "11111111111100000111": {"state": 1048327.0}, "01111111111100000000": {"state": 524032.0}, "10000000000000000100": {"state": 524292.0}, "00000000000011111111": {"state": 255.0}, "01111111111100000110": {"state": 524038.0}, "11111111111000111100": {"state": 1048124.0}, "01111111111001100010": {"state": 523874.0}, "01111111111100000011": {"state": 524035.0}, "10000000011111110001": {"state": 526321.0}, "10000000000000001011": {"state": 524299.0}, "00000000000111111011": {"state": 507.0}, "10000000001100000101": {"state": 525061.0}, "11111111111011111011": {"state": 1048315.0}, "11111111111000110100": {"state": 1048116.0}, "00000000011111111011": {"state": 2043.0}, "11111111111100000000": {"state": 1048320.0}, "01111111111111111010": {"state": 524282.0}, "01111111111111110000": {"state": 524272.0}, "11111111111100001110": {"state": 1048334.0}, "00000000011000001111": {"state": 1551.0}, "01111111111101101111": {"state": 524143.0}, "11111111111000111010": {"state": 1048122.0}, "11111111111001101011": {"state": 1048171.0}, "00000000000000001000": {"state": 8.0}, "10000000000000000010": {"state": 524290.0}, "00000000001111000101": {"state": 965.0}, "01111111111111111111": {"state": 524287.0}, "00000000000000001100": {"state": 12.0}, "11111111111011110100": {"state": 1048308.0}, "00000000011000000000": {"state": 1536.0}, "01111111111111111110": {"state": 524286.0}, "11111111111111111100": {"state": 1048572.0}, "01111111111011111010": {"state": 524026.0}, "00000000000000000100": {"state": 4.0}, "00000000000011111000": {"state": 248.0}, "01111111110110011010": {"state": 523674.0}, "11111111110011111011": {"state": 1047803.0}, "10000000000011111010": {"state": 524538.0}, "11111111111100000100": {"state": 1048324.0}, "00000000000011111011": {"state": 251.0}, "11111111111010010001": {"state": 1048209.0}, "11111111111100000011": {"state": 1048323.0}, "01111111111011110101": {"state": 524021.0}, "11111111110110010011": {"state": 1047955.0}, "11111111111000111011": {"state": 1048123.0}, "10000000000000000110": {"state": 524294.0}, "10000000000111111101": {"state": 524797.0}, "00000000011111110100": {"state": 2036.0}, "01111111111001101010": {"state": 523882.0}, "01111111110011111010": {"state": 523514.0}, "00000000000000000000": {"state": 0.0}, "11111111111010011101": {"state": 1048221.0}, "01111111110001100101": {"state": 523365.0}, "10000000000000001010": {"state": 524298.0}, "11111111111010011110": {"state": 1048222.0}, "11111111111001101010": {"state": 1048170.0}, "00000000000011111100": {"state": 252.0}, "11111111111100000010": {"state": 1048322.0}, "00000000000111111111": {"state": 511.0}, "11111111111111111000": {"state": 1048568.0}, "01111111110110011101": {"state": 523677.0}, "11111111111100001111": {"state": 1048335.0}, "10000000000000000101": {"state": 524293.0}, "01111111111100000101": {"state": 524037.0}, "11111111111100001100": {"state": 1048332.0}, "00000000000000001111": {"state": 15.0}, "11111111111000001101": {"state": 1048077.0}, "10000000000111111110": {"state": 524798.0}, "01111111111001100101": {"state": 523877.0}, "00000000000000001011": {"state": 11.0}, "11111111111100001101": {"state": 1048333.0}, "00000000000000000111": {"state": 7.0}, "10000000000000001101": {"state": 524301.0}, "10000000000111110001": {"state": 524785.0}, "11111111110110010100": {"state": 1047956.0}, "11111111110011110011": {"state": 1047795.0}, "00000000000011110000": {"state": 240.0}, "10000000011111111101": {"state": 526333.0}, "11111111101001101010": {"state": 1047146.0}, "01111111111000111011": {"state": 523835.0}, "10000000000011110010": {"state": 524530.0}, "00000000000111111100": {"state": 508.0}, "10000000011111111110": {"state": 526334.0}, "11111111110011110100": {"state": 1047796.0}, "01111111111111111101": {"state": 524285.0}, "11111111111111111101": {"state": 1048573.0}, "11111111110110010101": {"state": 1047957.0}, "01111111111100001010": {"state": 524042.0}, "10000000000000001110": {"state": 524302.0}, "10000000000000000001": {"state": 524289.0}, "11111111110110011100": {"state": 1047964.0}, "10000000000111110101": {"state": 524789.0}, "01111111111100000010": {"state": 524034.0}, "01111111111011111101": {"state": 524029.0}, "00000000000000000011": {"state": 3.0}, "10000000000000001001": {"state": 524297.0}, "01111111111111110010": {"state": 524274.0}, "01111111111111111000": {"state": 524280.0}, "11111111111111000100": {"state": 1048516.0}, "01111111111100001101": {"state": 524045.0}, "11111111111100000101": {"state": 1048325.0}, "10000000000011111110": {"state": 524542.0}, "01111111110110011011": {"state": 523675.0}, "01111111111111001100": {"state": 524236.0}, "11111111111001100110": {"state": 1048166.0}, "00000000000011110011": {"state": 243.0}, "01111111111111110001": {"state": 524273.0}, "00000000000100000011": {"state": 259.0}, "11111111111111110100": {"state": 1048564.0}, "11111111110001100100": {"state": 1047652.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "00000000000011111001": 1, + "01111111101001100010": 1, + "11111111111010011010": 1, + "11111111111000000011": 1, + "11111111111100000010": 1, + "01111111111011111000": 1, + "11111111111100000110": 1, + "10000000001111000011": 1, + "00000000000100000100": 1, + "11111111111111110100": 2, + "01111111111111111110": 8, + "00000000000011111100": 4, + "11111111111111110111": 1, + "10000000000011110001": 1, + "01111111111111110010": 2, + "10000000001100000110": 1, + "11111111110001100100": 3, + "11111111111100000111": 3, + "11111111110110010100": 2, + "10000000000000000100": 1, + "00000000000011111111": 2, + "11111111111011111011": 1, + "10000000001111001011": 1, + "01111111101110011010": 1, + "00000000000111111100": 1, + "10000000011111111110": 9, + "10000000001100001010": 1, + "11111111111000110000": 1, + "10000000000111111101": 5, + "10000000011111110001": 4, + "00000000000011111011": 10, + "01111111111000111101": 1, + "10000000011111111101": 4, + "11111111110011110011": 2, + "11111111111100000101": 9, + "00000000000000000111": 84, + "11111111111000000000": 1, + "01111111111100000001": 1, + "10000000000111111110": 218, + "11111111110001101100": 1, + "00000000000111111011": 3, + "10000000000011110010": 6, + "01111111101001101101": 1, + "00000000000000000100": 84, + "01111111111111111010": 2, + "10000000011111110101": 3, + "10000000000000001001": 4, + "00000000000000000011": 1150, + "01111111110001101101": 1, + "00000000000000001011": 116, + "10000000000000001101": 28, + "10000000000111110101": 2, + "01111111111100000010": 4, + "01111111111011111101": 1, + "11111111110110011100": 2, + "10000000000000000001": 247, + "10000000000000000101": 249, + "01111111111100000101": 4, + "01111111111000111010": 1, + "01111111111111110001": 3, + "10000000000100000101": 1, + "00000000000011110011": 3, + "01111111111111001100": 1, + "01111111110011111010": 1, + "00000000000000000000": 2810, + "11111111111010011101": 1, + "10000000000000001010": 19, + "01111111111100001110": 1, + "11111111111011110011": 1, + "11111111111111111010": 3, + "11111111111000110101": 2, + "00000000000000001111": 1266, + "01111111111100000100": 2, + "11111111111000110011": 2, + "10000000000000000110": 34, + "11111111110110010011": 4, + "10000000000000000010": 1189, + "01111111111111111111": 3, + "00000000000000001100": 292, + "11111111111011111100": 1, + "11111111111001101011": 2, + "00000000000000001000": 21, + "00000000000100001100": 1, + "01111111111100001010": 1, + "10000000000000001110": 38, + "10000000000111110001": 72, + "01111111111111110000": 1, + "11111111111111111100": 5, + "11111111111111111000": 1, + "01111111110110011101": 6, + "11111111111100001111": 2, + "11111111111100001000": 1, + "10000000011111111010": 2, + "11111111111111000100": 1, + "01111111111100001101": 12, + "11111111111100000000": 5, + "00000000011111111011": 3, + "11111111111100001100": 5, + "01111111111001101101": 1, + "11111111111111111101": 1, + "01111111111111111101": 3, + "11111111111100000011": 6, + "11111111111010010001": 4, + "11111111111001100011": 1, + "11111111110011111011": 1, + "11111111111100000100": 25, + "10000000000011111010": 6, + "01111111111100001001": 1, + "11111111111000110110": 1, + "11111111111010011110": 5, + "00000000011111111100": 3, + "01111111111010011011": 2, + "01111111110110011010": 8, + "00000000000011111000": 3, + "00000000011111111111": 1 + }, + "counts_lsb_right": true, + "parsed_states": { + "00000000000011111001": { "state": 249.0 }, + "01111111101001100010": { "state": 522850.0 }, + "11111111111010011010": { "state": 1048218.0 }, + "11111111111000000011": { "state": 1048067.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "01111111111011111000": { "state": 524024.0 }, + "11111111111100000110": { "state": 1048326.0 }, + "10000000001111000011": { "state": 525251.0 }, + "00000000000100000100": { "state": 260.0 }, + "11111111111111110100": { "state": 1048564.0 }, + "01111111111111111110": { "state": 524286.0 }, + "00000000000011111100": { "state": 252.0 }, + "11111111111111110111": { "state": 1048567.0 }, + "10000000000011110001": { "state": 524529.0 }, + "01111111111111110010": { "state": 524274.0 }, + "10000000001100000110": { "state": 525062.0 }, + "11111111110001100100": { "state": 1047652.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "11111111110110010100": { "state": 1047956.0 }, + "10000000000000000100": { "state": 524292.0 }, + "00000000000011111111": { "state": 255.0 }, + "11111111111011111011": { "state": 1048315.0 }, + "10000000001111001011": { "state": 525259.0 }, + "01111111101110011010": { "state": 523162.0 }, + "00000000000111111100": { "state": 508.0 }, + "10000000011111111110": { "state": 526334.0 }, + "10000000001100001010": { "state": 525066.0 }, + "11111111111000110000": { "state": 1048112.0 }, + "10000000000111111101": { "state": 524797.0 }, + "10000000011111110001": { "state": 526321.0 }, + "00000000000011111011": { "state": 251.0 }, + "01111111111000111101": { "state": 523837.0 }, + "10000000011111111101": { "state": 526333.0 }, + "11111111110011110011": { "state": 1047795.0 }, + "11111111111100000101": { "state": 1048325.0 }, + "00000000000000000111": { "state": 7.0 }, + "11111111111000000000": { "state": 1048064.0 }, + "01111111111100000001": { "state": 524033.0 }, + "10000000000111111110": { "state": 524798.0 }, + "11111111110001101100": { "state": 1047660.0 }, + "00000000000111111011": { "state": 507.0 }, + "10000000000011110010": { "state": 524530.0 }, + "01111111101001101101": { "state": 522861.0 }, + "00000000000000000100": { "state": 4.0 }, + "01111111111111111010": { "state": 524282.0 }, + "10000000011111110101": { "state": 526325.0 }, + "10000000000000001001": { "state": 524297.0 }, + "00000000000000000011": { "state": 3.0 }, + "01111111110001101101": { "state": 523373.0 }, + "00000000000000001011": { "state": 11.0 }, + "10000000000000001101": { "state": 524301.0 }, + "10000000000111110101": { "state": 524789.0 }, + "01111111111100000010": { "state": 524034.0 }, + "01111111111011111101": { "state": 524029.0 }, + "11111111110110011100": { "state": 1047964.0 }, + "10000000000000000001": { "state": 524289.0 }, + "10000000000000000101": { "state": 524293.0 }, + "01111111111100000101": { "state": 524037.0 }, + "01111111111000111010": { "state": 523834.0 }, + "01111111111111110001": { "state": 524273.0 }, + "10000000000100000101": { "state": 524549.0 }, + "00000000000011110011": { "state": 243.0 }, + "01111111111111001100": { "state": 524236.0 }, + "01111111110011111010": { "state": 523514.0 }, + "00000000000000000000": { "state": 0.0 }, + "11111111111010011101": { "state": 1048221.0 }, + "10000000000000001010": { "state": 524298.0 }, + "01111111111100001110": { "state": 524046.0 }, + "11111111111011110011": { "state": 1048307.0 }, + "11111111111111111010": { "state": 1048570.0 }, + "11111111111000110101": { "state": 1048117.0 }, + "00000000000000001111": { "state": 15.0 }, + "01111111111100000100": { "state": 524036.0 }, + "11111111111000110011": { "state": 1048115.0 }, + "10000000000000000110": { "state": 524294.0 }, + "11111111110110010011": { "state": 1047955.0 }, + "10000000000000000010": { "state": 524290.0 }, + "01111111111111111111": { "state": 524287.0 }, + "00000000000000001100": { "state": 12.0 }, + "11111111111011111100": { "state": 1048316.0 }, + "11111111111001101011": { "state": 1048171.0 }, + "00000000000000001000": { "state": 8.0 }, + "00000000000100001100": { "state": 268.0 }, + "01111111111100001010": { "state": 524042.0 }, + "10000000000000001110": { "state": 524302.0 }, + "10000000000111110001": { "state": 524785.0 }, + "01111111111111110000": { "state": 524272.0 }, + "11111111111111111100": { "state": 1048572.0 }, + "11111111111111111000": { "state": 1048568.0 }, + "01111111110110011101": { "state": 523677.0 }, + "11111111111100001111": { "state": 1048335.0 }, + "11111111111100001000": { "state": 1048328.0 }, + "10000000011111111010": { "state": 526330.0 }, + "11111111111111000100": { "state": 1048516.0 }, + "01111111111100001101": { "state": 524045.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "00000000011111111011": { "state": 2043.0 }, + "11111111111100001100": { "state": 1048332.0 }, + "01111111111001101101": { "state": 523885.0 }, + "11111111111111111101": { "state": 1048573.0 }, + "01111111111111111101": { "state": 524285.0 }, + "11111111111100000011": { "state": 1048323.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "11111111111001100011": { "state": 1048163.0 }, + "11111111110011111011": { "state": 1047803.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "10000000000011111010": { "state": 524538.0 }, + "01111111111100001001": { "state": 524041.0 }, + "11111111111000110110": { "state": 1048118.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "00000000011111111100": { "state": 2044.0 }, + "01111111111010011011": { "state": 523931.0 }, + "01111111110110011010": { "state": 523674.0 }, + "00000000000011111000": { "state": 248.0 }, + "00000000011111111111": { "state": 2047.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n-6.json b/algorithms/glued_trees/results/20-qubits/2n-6.json index b14faf12..e56260c4 100644 --- a/algorithms/glued_trees/results/20-qubits/2n-6.json +++ b/algorithms/glued_trees/results/20-qubits/2n-6.json @@ -1 +1,222 @@ -{"vendor_format_result": {}, "counts": {"10000000001100000001": 1, "01111111111100000010": 1, "00000000011000000000": 1, "01111111111000111010": 1, "11111111111100001000": 1, "01111111110110011001": 1, "00000000011111110000": 1, "11111111111111110100": 2, "10000000000011111101": 1, "11111111110110010100": 1, "01111111111100000011": 1, "00000000001100001100": 1, "11111111110001100100": 1, "00000000000111110100": 1, "01111111110110011100": 1, "00000000011111111100": 2, "10000000000011110010": 3, "11111111111111110000": 1, "11111111111010010001": 4, "01111111111111111001": 1, "01111111101001101010": 2, "00000000001111000010": 1, "10000000001100000101": 1, "01111111110001100100": 1, "11111111110110011000": 1, "01111111110110010010": 1, "01111111111100011010": 1, "11111111111100000101": 2, "00000000000000000111": 137, "00000000000011111011": 13, "10000000000111110001": 63, "00000000000000001100": 90, "00000000000000001000": 24, "10000000000000000010": 524, "00000000011111111011": 1, "11111111111100000000": 8, "00000000000000000000": 4370, "10000000000000000001": 134, "11111111111100001100": 1, "11111111111111111111": 2, "00000000000000001011": 277, "11111111111100001101": 1, "01111111110110011101": 13, "11111111111111111000": 3, "11111111111111111010": 4, "00000000000000001111": 838, "00000000000100000000": 1, "11111111111100000111": 14, "10000000000111111110": 230, "10000000000000001101": 14, "00000000000011111111": 3, "11111111111000110011": 1, "01111111111100000100": 1, "01111111111100001101": 9, "01111111110110010110": 1, "10000000011111110101": 1, "01111111111111111110": 14, "00000000000000000100": 4, "01111111111101100000": 1, "10000000000000001110": 13, "01111111110110011110": 5, "10000000011111111110": 15, "11111111111010011110": 14, "11111111111111111011": 3, "00000000000011110010": 1, "00000000000000000011": 251, "10000000000000001001": 2, "10000000000000000110": 14, "11111111110110010011": 1, "01111111111111110001": 1, "01111111111111111011": 2, "11111111110001100010": 1, "01111111111000000011": 1, "11111111111111111100": 5, "11111111111100000110": 2, "00000000011111111000": 1, "10000000011111110001": 1, "11111111111111110011": 4, "11111111111111111001": 1, "10000000000000000101": 700, "01111111111100000101": 7, "00000000000011101100": 1, "10000000001100000010": 1, "11111111110001100111": 2, "01111111111111111101": 5, "11111111111111111101": 1, "11111111110011111011": 1, "11111111111100000100": 30, "10000000000011111010": 1, "01111111110001100101": 2, "10000000000000001010": 263, "01111111101110011100": 1, "00000000000011111000": 1, "00000000011111111111": 2, "01111111110110011010": 2}, "counts_lsb_right": true, "parsed_states": {"10000000001100000001": {"state": 525057.0}, "01111111111100000010": {"state": 524034.0}, "00000000011000000000": {"state": 1536.0}, "01111111111000111010": {"state": 523834.0}, "11111111111100001000": {"state": 1048328.0}, "01111111110110011001": {"state": 523673.0}, "00000000011111110000": {"state": 2032.0}, "11111111111111110100": {"state": 1048564.0}, "10000000000011111101": {"state": 524541.0}, "11111111110110010100": {"state": 1047956.0}, "01111111111100000011": {"state": 524035.0}, "00000000001100001100": {"state": 780.0}, "11111111110001100100": {"state": 1047652.0}, "00000000000111110100": {"state": 500.0}, "01111111110110011100": {"state": 523676.0}, "00000000011111111100": {"state": 2044.0}, "10000000000011110010": {"state": 524530.0}, "11111111111111110000": {"state": 1048560.0}, "11111111111010010001": {"state": 1048209.0}, "01111111111111111001": {"state": 524281.0}, "01111111101001101010": {"state": 522858.0}, "00000000001111000010": {"state": 962.0}, "10000000001100000101": {"state": 525061.0}, "01111111110001100100": {"state": 523364.0}, "11111111110110011000": {"state": 1047960.0}, "01111111110110010010": {"state": 523666.0}, "01111111111100011010": {"state": 524058.0}, "11111111111100000101": {"state": 1048325.0}, "00000000000000000111": {"state": 7.0}, "00000000000011111011": {"state": 251.0}, "10000000000111110001": {"state": 524785.0}, "00000000000000001100": {"state": 12.0}, "00000000000000001000": {"state": 8.0}, "10000000000000000010": {"state": 524290.0}, "00000000011111111011": {"state": 2043.0}, "11111111111100000000": {"state": 1048320.0}, "00000000000000000000": {"state": 0.0}, "10000000000000000001": {"state": 524289.0}, "11111111111100001100": {"state": 1048332.0}, "11111111111111111111": {"state": 1048575.0}, "00000000000000001011": {"state": 11.0}, "11111111111100001101": {"state": 1048333.0}, "01111111110110011101": {"state": 523677.0}, "11111111111111111000": {"state": 1048568.0}, "11111111111111111010": {"state": 1048570.0}, "00000000000000001111": {"state": 15.0}, "00000000000100000000": {"state": 256.0}, "11111111111100000111": {"state": 1048327.0}, "10000000000111111110": {"state": 524798.0}, "10000000000000001101": {"state": 524301.0}, "00000000000011111111": {"state": 255.0}, "11111111111000110011": {"state": 1048115.0}, "01111111111100000100": {"state": 524036.0}, "01111111111100001101": {"state": 524045.0}, "01111111110110010110": {"state": 523670.0}, "10000000011111110101": {"state": 526325.0}, "01111111111111111110": {"state": 524286.0}, "00000000000000000100": {"state": 4.0}, "01111111111101100000": {"state": 524128.0}, "10000000000000001110": {"state": 524302.0}, "01111111110110011110": {"state": 523678.0}, "10000000011111111110": {"state": 526334.0}, "11111111111010011110": {"state": 1048222.0}, "11111111111111111011": {"state": 1048571.0}, "00000000000011110010": {"state": 242.0}, "00000000000000000011": {"state": 3.0}, "10000000000000001001": {"state": 524297.0}, "10000000000000000110": {"state": 524294.0}, "11111111110110010011": {"state": 1047955.0}, "01111111111111110001": {"state": 524273.0}, "01111111111111111011": {"state": 524283.0}, "11111111110001100010": {"state": 1047650.0}, "01111111111000000011": {"state": 523779.0}, "11111111111111111100": {"state": 1048572.0}, "11111111111100000110": {"state": 1048326.0}, "00000000011111111000": {"state": 2040.0}, "10000000011111110001": {"state": 526321.0}, "11111111111111110011": {"state": 1048563.0}, "11111111111111111001": {"state": 1048569.0}, "10000000000000000101": {"state": 524293.0}, "01111111111100000101": {"state": 524037.0}, "00000000000011101100": {"state": 236.0}, "10000000001100000010": {"state": 525058.0}, "11111111110001100111": {"state": 1047655.0}, "01111111111111111101": {"state": 524285.0}, "11111111111111111101": {"state": 1048573.0}, "11111111110011111011": {"state": 1047803.0}, "11111111111100000100": {"state": 1048324.0}, "10000000000011111010": {"state": 524538.0}, "01111111110001100101": {"state": 523365.0}, "10000000000000001010": {"state": 524298.0}, "01111111101110011100": {"state": 523164.0}, "00000000000011111000": {"state": 248.0}, "00000000011111111111": {"state": 2047.0}, "01111111110110011010": {"state": 523674.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "11111111111011110011": 1, + "11111111111000110110": 1, + "11111111111100001101": 1, + "01111111111101111010": 1, + "11111111110110011111": 1, + "01111111111111110010": 1, + "00000000011111111100": 1, + "11111111111000111111": 1, + "10000000000111110010": 1, + "11111111111011111011": 1, + "01111111111111110101": 1, + "10000000011111110101": 1, + "11111111110001100111": 1, + "10000000011111110001": 2, + "11111111111111110100": 3, + "11111111111000110000": 2, + "01111111111111111101": 7, + "11111111111111111001": 2, + "11111111111111110011": 1, + "01111111110110011001": 6, + "00000000000011111111": 2, + "10000000001100000101": 1, + "10000000011111111010": 1, + "00000000000111110100": 1, + "00000000011111111000": 1, + "00000000000111110011": 1, + "01111111111111111110": 17, + "00000000000000000100": 8, + "11111111111111111100": 4, + "11111111111100000001": 1, + "00000000000000001100": 120, + "00000000000000001000": 39, + "11111111101001101111": 1, + "10000000000000000010": 516, + "01111111111100000010": 1, + "00000000000011110011": 3, + "01111111111111110001": 6, + "11111111111001100011": 1, + "11111111111111111011": 4, + "11111111110110010100": 1, + "01111111111111001101": 2, + "01111111110001101010": 1, + "01111111111100000001": 1, + "10000000000111111110": 203, + "11111111111100000100": 31, + "10000000000000000101": 762, + "00000000000011111011": 10, + "01111111111111110011": 1, + "11111111111111111000": 2, + "01111111110110011101": 5, + "10000000000000001010": 253, + "11111111111100000000": 2, + "10000000000111110001": 61, + "11111111111000110011": 1, + "01111111111100000100": 1, + "10000000000000001101": 11, + "10000000000000000001": 145, + "11111111110110011000": 1, + "11111111111100001100": 4, + "01111111111000111010": 2, + "10000000000011110101": 1, + "11111111111100000111": 7, + "11111111111111111010": 5, + "00000000000000001111": 863, + "00000000000000000000": 4269, + "01111111110011111010": 1, + "01111111110110010101": 2, + "11111111111010010001": 2, + "01111111111111111001": 2, + "10000000000000000110": 14, + "10000000011111110010": 3, + "00000000000000000011": 208, + "00000000000000000111": 163, + "10000000011111111001": 1, + "11111111111100000101": 5, + "11111111111111111111": 1, + "00000000000000001011": 299, + "00000000000111111100": 3, + "10000000011111111110": 10, + "11111111111010011110": 7, + "01111111111001100010": 3, + "11111111110110010101": 1, + "01111111110110011110": 4, + "10000000000000001110": 8, + "11111111110011111010": 3, + "01111111111001101010": 1, + "11111111110110000100": 1, + "01111111110011110011": 1, + "00000000000111111011": 2, + "10000000000011110010": 6, + "11111111111100000010": 1, + "00000000000111111111": 1, + "01111111111100001101": 12, + "10000000011111111101": 2, + "11111111110001100100": 3, + "01111111111111111011": 2, + "01111111110110011010": 4, + "00000000000011111000": 3, + "01111111111000110010": 2, + "11111111111100000110": 2 + }, + "counts_lsb_right": true, + "parsed_states": { + "11111111111011110011": { "state": 1048307.0 }, + "11111111111000110110": { "state": 1048118.0 }, + "11111111111100001101": { "state": 1048333.0 }, + "01111111111101111010": { "state": 524154.0 }, + "11111111110110011111": { "state": 1047967.0 }, + "01111111111111110010": { "state": 524274.0 }, + "00000000011111111100": { "state": 2044.0 }, + "11111111111000111111": { "state": 1048127.0 }, + "10000000000111110010": { "state": 524786.0 }, + "11111111111011111011": { "state": 1048315.0 }, + "01111111111111110101": { "state": 524277.0 }, + "10000000011111110101": { "state": 526325.0 }, + "11111111110001100111": { "state": 1047655.0 }, + "10000000011111110001": { "state": 526321.0 }, + "11111111111111110100": { "state": 1048564.0 }, + "11111111111000110000": { "state": 1048112.0 }, + "01111111111111111101": { "state": 524285.0 }, + "11111111111111111001": { "state": 1048569.0 }, + "11111111111111110011": { "state": 1048563.0 }, + "01111111110110011001": { "state": 523673.0 }, + "00000000000011111111": { "state": 255.0 }, + "10000000001100000101": { "state": 525061.0 }, + "10000000011111111010": { "state": 526330.0 }, + "00000000000111110100": { "state": 500.0 }, + "00000000011111111000": { "state": 2040.0 }, + "00000000000111110011": { "state": 499.0 }, + "01111111111111111110": { "state": 524286.0 }, + "00000000000000000100": { "state": 4.0 }, + "11111111111111111100": { "state": 1048572.0 }, + "11111111111100000001": { "state": 1048321.0 }, + "00000000000000001100": { "state": 12.0 }, + "00000000000000001000": { "state": 8.0 }, + "11111111101001101111": { "state": 1047151.0 }, + "10000000000000000010": { "state": 524290.0 }, + "01111111111100000010": { "state": 524034.0 }, + "00000000000011110011": { "state": 243.0 }, + "01111111111111110001": { "state": 524273.0 }, + "11111111111001100011": { "state": 1048163.0 }, + "11111111111111111011": { "state": 1048571.0 }, + "11111111110110010100": { "state": 1047956.0 }, + "01111111111111001101": { "state": 524237.0 }, + "01111111110001101010": { "state": 523370.0 }, + "01111111111100000001": { "state": 524033.0 }, + "10000000000111111110": { "state": 524798.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "10000000000000000101": { "state": 524293.0 }, + "00000000000011111011": { "state": 251.0 }, + "01111111111111110011": { "state": 524275.0 }, + "11111111111111111000": { "state": 1048568.0 }, + "01111111110110011101": { "state": 523677.0 }, + "10000000000000001010": { "state": 524298.0 }, + "11111111111100000000": { "state": 1048320.0 }, + "10000000000111110001": { "state": 524785.0 }, + "11111111111000110011": { "state": 1048115.0 }, + "01111111111100000100": { "state": 524036.0 }, + "10000000000000001101": { "state": 524301.0 }, + "10000000000000000001": { "state": 524289.0 }, + "11111111110110011000": { "state": 1047960.0 }, + "11111111111100001100": { "state": 1048332.0 }, + "01111111111000111010": { "state": 523834.0 }, + "10000000000011110101": { "state": 524533.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "11111111111111111010": { "state": 1048570.0 }, + "00000000000000001111": { "state": 15.0 }, + "00000000000000000000": { "state": 0.0 }, + "01111111110011111010": { "state": 523514.0 }, + "01111111110110010101": { "state": 523669.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "01111111111111111001": { "state": 524281.0 }, + "10000000000000000110": { "state": 524294.0 }, + "10000000011111110010": { "state": 526322.0 }, + "00000000000000000011": { "state": 3.0 }, + "00000000000000000111": { "state": 7.0 }, + "10000000011111111001": { "state": 526329.0 }, + "11111111111100000101": { "state": 1048325.0 }, + "11111111111111111111": { "state": 1048575.0 }, + "00000000000000001011": { "state": 11.0 }, + "00000000000111111100": { "state": 508.0 }, + "10000000011111111110": { "state": 526334.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "01111111111001100010": { "state": 523874.0 }, + "11111111110110010101": { "state": 1047957.0 }, + "01111111110110011110": { "state": 523678.0 }, + "10000000000000001110": { "state": 524302.0 }, + "11111111110011111010": { "state": 1047802.0 }, + "01111111111001101010": { "state": 523882.0 }, + "11111111110110000100": { "state": 1047940.0 }, + "01111111110011110011": { "state": 523507.0 }, + "00000000000111111011": { "state": 507.0 }, + "10000000000011110010": { "state": 524530.0 }, + "11111111111100000010": { "state": 1048322.0 }, + "00000000000111111111": { "state": 511.0 }, + "01111111111100001101": { "state": 524045.0 }, + "10000000011111111101": { "state": 526333.0 }, + "11111111110001100100": { "state": 1047652.0 }, + "01111111111111111011": { "state": 524283.0 }, + "01111111110110011010": { "state": 523674.0 }, + "00000000000011111000": { "state": 248.0 }, + "01111111111000110010": { "state": 523826.0 }, + "11111111111100000110": { "state": 1048326.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/glued_trees/results/20-qubits/2n-8.json b/algorithms/glued_trees/results/20-qubits/2n-8.json index 68072334..0e656dc0 100644 --- a/algorithms/glued_trees/results/20-qubits/2n-8.json +++ b/algorithms/glued_trees/results/20-qubits/2n-8.json @@ -1 +1,192 @@ -{"vendor_format_result": {}, "counts": {"00000000000011110000": 1, "00000000000011111111": 1, "00000000000111111011": 1, "00000000001100001100": 1, "11111111111011110011": 1, "11111111111111110111": 1, "11111111111100000101": 1, "01111111110110011011": 1, "01111111101001100110": 1, "00000000000111110100": 2, "11111111111111111100": 1, "01111111110011111001": 2, "00000000000011111001": 1, "00000000000100000100": 1, "00000000011111110100": 2, "11111111111111001000": 1, "11111111111111110011": 2, "01111111111100000100": 2, "11111111111000110011": 2, "11111111110110011111": 1, "00000000011111111100": 2, "11111111111100001000": 2, "00000000000000000111": 173, "00000000000000001100": 45, "11111111111000000000": 1, "00000000011000000000": 1, "10000000000000000010": 758, "11111111110010000111": 1, "00000000000011111011": 10, "10000000000000000101": 545, "11111111111111111000": 3, "01111111111111110011": 2, "01111111110110011101": 3, "11111111111100000100": 9, "01111111111100001101": 2, "11111111111111111011": 2, "00000000000000000011": 162, "11111111111000001111": 1, "00000000000000001011": 187, "11111111111111111111": 2, "00000000000111111100": 1, "10000000011111111110": 6, "11111111111010011110": 10, "01111111111111110111": 2, "01111111110110011001": 3, "00000000000000001111": 886, "00000000000000000000": 4545, "10000000000000001010": 256, "11111111111100000000": 1, "11111111111100000111": 22, "00000000000000000100": 45, "11111111100111111100": 1, "01111111111001100011": 1, "11111111111100001011": 1, "01111111110011110110": 1, "10000000000000001101": 61, "00000000000000001000": 39, "11111111111011111100": 1, "11111111110110011100": 2, "10000000000000000001": 27, "01111111111111110001": 6, "01111111111111001100": 1, "01111111111000111010": 2, "01111111111001100010": 1, "10000000000111110001": 36, "01111111111111111001": 1, "11111111110110100000": 1, "01111111111100001001": 1, "10000000000111111110": 185, "01111111111010011100": 1, "01111111111000110010": 1, "01111111111111111010": 2, "10000000011111110001": 1, "11111111110110010011": 1, "10000000011111110010": 1, "10000000000000000110": 3, "11111111110110010100": 1, "10000000001111000000": 1, "10000000000011111101": 3, "11111111110001100111": 4, "10000000000011110010": 2, "11111111111100000011": 1, "11111111111010010001": 4, "01111111111111111110": 28, "00000000000111110011": 1, "01111111111000000100": 1, "11111111110001100100": 1, "01111111111010100000": 1, "01111111111101100000": 1, "01111111110110011110": 5, "10000000000000001110": 38, "11111111110110010101": 2, "00000000000011111000": 2, "01111111110110011010": 4}, "counts_lsb_right": true, "parsed_states": {"00000000000011110000": {"state": 240.0}, "00000000000011111111": {"state": 255.0}, "00000000000111111011": {"state": 507.0}, "00000000001100001100": {"state": 780.0}, "11111111111011110011": {"state": 1048307.0}, "11111111111111110111": {"state": 1048567.0}, "11111111111100000101": {"state": 1048325.0}, "01111111110110011011": {"state": 523675.0}, "01111111101001100110": {"state": 522854.0}, "00000000000111110100": {"state": 500.0}, "11111111111111111100": {"state": 1048572.0}, "01111111110011111001": {"state": 523513.0}, "00000000000011111001": {"state": 249.0}, "00000000000100000100": {"state": 260.0}, "00000000011111110100": {"state": 2036.0}, "11111111111111001000": {"state": 1048520.0}, "11111111111111110011": {"state": 1048563.0}, "01111111111100000100": {"state": 524036.0}, "11111111111000110011": {"state": 1048115.0}, "11111111110110011111": {"state": 1047967.0}, "00000000011111111100": {"state": 2044.0}, "11111111111100001000": {"state": 1048328.0}, "00000000000000000111": {"state": 7.0}, "00000000000000001100": {"state": 12.0}, "11111111111000000000": {"state": 1048064.0}, "00000000011000000000": {"state": 1536.0}, "10000000000000000010": {"state": 524290.0}, "11111111110010000111": {"state": 1047687.0}, "00000000000011111011": {"state": 251.0}, "10000000000000000101": {"state": 524293.0}, "11111111111111111000": {"state": 1048568.0}, "01111111111111110011": {"state": 524275.0}, "01111111110110011101": {"state": 523677.0}, "11111111111100000100": {"state": 1048324.0}, "01111111111100001101": {"state": 524045.0}, "11111111111111111011": {"state": 1048571.0}, "00000000000000000011": {"state": 3.0}, "11111111111000001111": {"state": 1048079.0}, "00000000000000001011": {"state": 11.0}, "11111111111111111111": {"state": 1048575.0}, "00000000000111111100": {"state": 508.0}, "10000000011111111110": {"state": 526334.0}, "11111111111010011110": {"state": 1048222.0}, "01111111111111110111": {"state": 524279.0}, "01111111110110011001": {"state": 523673.0}, "00000000000000001111": {"state": 15.0}, "00000000000000000000": {"state": 0.0}, "10000000000000001010": {"state": 524298.0}, "11111111111100000000": {"state": 1048320.0}, "11111111111100000111": {"state": 1048327.0}, "00000000000000000100": {"state": 4.0}, "11111111100111111100": {"state": 1047036.0}, "01111111111001100011": {"state": 523875.0}, "11111111111100001011": {"state": 1048331.0}, "01111111110011110110": {"state": 523510.0}, "10000000000000001101": {"state": 524301.0}, "00000000000000001000": {"state": 8.0}, "11111111111011111100": {"state": 1048316.0}, "11111111110110011100": {"state": 1047964.0}, "10000000000000000001": {"state": 524289.0}, "01111111111111110001": {"state": 524273.0}, "01111111111111001100": {"state": 524236.0}, "01111111111000111010": {"state": 523834.0}, "01111111111001100010": {"state": 523874.0}, "10000000000111110001": {"state": 524785.0}, "01111111111111111001": {"state": 524281.0}, "11111111110110100000": {"state": 1047968.0}, "01111111111100001001": {"state": 524041.0}, "10000000000111111110": {"state": 524798.0}, "01111111111010011100": {"state": 523932.0}, "01111111111000110010": {"state": 523826.0}, "01111111111111111010": {"state": 524282.0}, "10000000011111110001": {"state": 526321.0}, "11111111110110010011": {"state": 1047955.0}, "10000000011111110010": {"state": 526322.0}, "10000000000000000110": {"state": 524294.0}, "11111111110110010100": {"state": 1047956.0}, "10000000001111000000": {"state": 525248.0}, "10000000000011111101": {"state": 524541.0}, "11111111110001100111": {"state": 1047655.0}, "10000000000011110010": {"state": 524530.0}, "11111111111100000011": {"state": 1048323.0}, "11111111111010010001": {"state": 1048209.0}, "01111111111111111110": {"state": 524286.0}, "00000000000111110011": {"state": 499.0}, "01111111111000000100": {"state": 523780.0}, "11111111110001100100": {"state": 1047652.0}, "01111111111010100000": {"state": 523936.0}, "01111111111101100000": {"state": 524128.0}, "01111111110110011110": {"state": 523678.0}, "10000000000000001110": {"state": 524302.0}, "11111111110110010101": {"state": 1047957.0}, "00000000000011111000": {"state": 248.0}, "01111111110110011010": {"state": 523674.0}}, "histogram": null, "output_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "state_vector": null, "parsed_state_vector_states": null, "physical_qubits_map": {"state": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]}, "num_shots": 8192} \ No newline at end of file +{ + "vendor_format_result": {}, + "counts": { + "11111111111000111010": 1, + "10000000001100000101": 1, + "11111111111010010001": 1, + "01111111110110011010": 1, + "00000000000011111111": 1, + "00000000000111110000": 1, + "00000000011111111011": 1, + "01111111111100001001": 1, + "10000000000111111101": 1, + "11111111110110011101": 1, + "00000000011111110100": 1, + "01111111111111110100": 1, + "11111111111100000110": 1, + "11111111111000110011": 2, + "10000000011111110001": 2, + "11111111111111111000": 1, + "01111111110110011101": 1, + "01111111111000111010": 1, + "11111111111111111100": 3, + "00000000000000001100": 38, + "00000000000000001000": 16, + "10000000000000000010": 728, + "11111111111011110100": 1, + "00000000011000000000": 1, + "11111111110001100111": 2, + "00000000000011111011": 8, + "11111111111100000100": 8, + "01111111111111111100": 1, + "10000000000000000101": 517, + "11111111111111110111": 3, + "01111111111101111001": 1, + "00000000011111111100": 3, + "11111111111010011110": 9, + "11111111111010011101": 1, + "10000000000000001010": 249, + "10000000000111110101": 1, + "11111111111100000111": 18, + "01111111111010010011": 1, + "01111111111010011100": 1, + "01111111111100000001": 1, + "10000000000111111110": 206, + "10000000001111000111": 1, + "01111111110110011001": 5, + "11111111111111111010": 3, + "00000000000000001111": 857, + "01111111110110011110": 4, + "10000000000000001110": 37, + "00000000000000000111": 166, + "11111111111100001000": 1, + "00000000000000000011": 142, + "00000000000000001011": 202, + "11111111111111111111": 5, + "10000000000000001101": 59, + "00000000000000000100": 37, + "10000000011111110101": 1, + "01111111111111111010": 5, + "10000000000000000001": 30, + "11111111110110011100": 3, + "10000000000011110010": 2, + "01111111111111111101": 4, + "01111111110110010001": 2, + "11111111111001100011": 1, + "10000000000011111101": 2, + "11111111110110010100": 1, + "10000000000011111110": 1, + "01111111111111111110": 19, + "00000000000111110011": 2, + "10000000000111110001": 43, + "11111111111100001010": 1, + "01111111111111111001": 1, + "01111111111010011011": 1, + "01111111111010100000": 1, + "11111111110001100100": 2, + "00000000000000000000": 4685, + "01111111110011111010": 2, + "11111111110110010011": 2, + "10000000000000000110": 2, + "01111111111111110001": 6, + "00000000000011110011": 1, + "01111111111111110101": 2, + "01111111111000111101": 1, + "10000000011111111110": 4, + "00000000000111111100": 3, + "11111111111111000100": 2, + "01111111111100001101": 4 + }, + "counts_lsb_right": true, + "parsed_states": { + "11111111111000111010": { "state": 1048122.0 }, + "10000000001100000101": { "state": 525061.0 }, + "11111111111010010001": { "state": 1048209.0 }, + "01111111110110011010": { "state": 523674.0 }, + "00000000000011111111": { "state": 255.0 }, + "00000000000111110000": { "state": 496.0 }, + "00000000011111111011": { "state": 2043.0 }, + "01111111111100001001": { "state": 524041.0 }, + "10000000000111111101": { "state": 524797.0 }, + "11111111110110011101": { "state": 1047965.0 }, + "00000000011111110100": { "state": 2036.0 }, + "01111111111111110100": { "state": 524276.0 }, + "11111111111100000110": { "state": 1048326.0 }, + "11111111111000110011": { "state": 1048115.0 }, + "10000000011111110001": { "state": 526321.0 }, + "11111111111111111000": { "state": 1048568.0 }, + "01111111110110011101": { "state": 523677.0 }, + "01111111111000111010": { "state": 523834.0 }, + "11111111111111111100": { "state": 1048572.0 }, + "00000000000000001100": { "state": 12.0 }, + "00000000000000001000": { "state": 8.0 }, + "10000000000000000010": { "state": 524290.0 }, + "11111111111011110100": { "state": 1048308.0 }, + "00000000011000000000": { "state": 1536.0 }, + "11111111110001100111": { "state": 1047655.0 }, + "00000000000011111011": { "state": 251.0 }, + "11111111111100000100": { "state": 1048324.0 }, + "01111111111111111100": { "state": 524284.0 }, + "10000000000000000101": { "state": 524293.0 }, + "11111111111111110111": { "state": 1048567.0 }, + "01111111111101111001": { "state": 524153.0 }, + "00000000011111111100": { "state": 2044.0 }, + "11111111111010011110": { "state": 1048222.0 }, + "11111111111010011101": { "state": 1048221.0 }, + "10000000000000001010": { "state": 524298.0 }, + "10000000000111110101": { "state": 524789.0 }, + "11111111111100000111": { "state": 1048327.0 }, + "01111111111010010011": { "state": 523923.0 }, + "01111111111010011100": { "state": 523932.0 }, + "01111111111100000001": { "state": 524033.0 }, + "10000000000111111110": { "state": 524798.0 }, + "10000000001111000111": { "state": 525255.0 }, + "01111111110110011001": { "state": 523673.0 }, + "11111111111111111010": { "state": 1048570.0 }, + "00000000000000001111": { "state": 15.0 }, + "01111111110110011110": { "state": 523678.0 }, + "10000000000000001110": { "state": 524302.0 }, + "00000000000000000111": { "state": 7.0 }, + "11111111111100001000": { "state": 1048328.0 }, + "00000000000000000011": { "state": 3.0 }, + "00000000000000001011": { "state": 11.0 }, + "11111111111111111111": { "state": 1048575.0 }, + "10000000000000001101": { "state": 524301.0 }, + "00000000000000000100": { "state": 4.0 }, + "10000000011111110101": { "state": 526325.0 }, + "01111111111111111010": { "state": 524282.0 }, + "10000000000000000001": { "state": 524289.0 }, + "11111111110110011100": { "state": 1047964.0 }, + "10000000000011110010": { "state": 524530.0 }, + "01111111111111111101": { "state": 524285.0 }, + "01111111110110010001": { "state": 523665.0 }, + "11111111111001100011": { "state": 1048163.0 }, + "10000000000011111101": { "state": 524541.0 }, + "11111111110110010100": { "state": 1047956.0 }, + "10000000000011111110": { "state": 524542.0 }, + "01111111111111111110": { "state": 524286.0 }, + "00000000000111110011": { "state": 499.0 }, + "10000000000111110001": { "state": 524785.0 }, + "11111111111100001010": { "state": 1048330.0 }, + "01111111111111111001": { "state": 524281.0 }, + "01111111111010011011": { "state": 523931.0 }, + "01111111111010100000": { "state": 523936.0 }, + "11111111110001100100": { "state": 1047652.0 }, + "00000000000000000000": { "state": 0.0 }, + "01111111110011111010": { "state": 523514.0 }, + "11111111110110010011": { "state": 1047955.0 }, + "10000000000000000110": { "state": 524294.0 }, + "01111111111111110001": { "state": 524273.0 }, + "00000000000011110011": { "state": 243.0 }, + "01111111111111110101": { "state": 524277.0 }, + "01111111111000111101": { "state": 523837.0 }, + "10000000011111111110": { "state": 526334.0 }, + "00000000000111111100": { "state": 508.0 }, + "11111111111111000100": { "state": 1048516.0 }, + "01111111111100001101": { "state": 524045.0 } + }, + "histogram": null, + "output_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "state_vector": null, + "parsed_state_vector_states": null, + "physical_qubits_map": { + "state": [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 + ] + }, + "num_shots": 8192 +} diff --git a/algorithms/grover/3_sat_grover/3_sat_grover.json b/algorithms/grover/3_sat_grover/3_sat_grover.metadata.json similarity index 100% rename from algorithms/grover/3_sat_grover/3_sat_grover.json rename to algorithms/grover/3_sat_grover/3_sat_grover.metadata.json diff --git a/algorithms/grover/3_sat_grover_large/3_sat_grover_large.json b/algorithms/grover/3_sat_grover_large/3_sat_grover_large.metadata.json similarity index 100% rename from algorithms/grover/3_sat_grover_large/3_sat_grover_large.json rename to algorithms/grover/3_sat_grover_large/3_sat_grover_large.metadata.json diff --git a/algorithms/grover/grover_max_cut/grover_max_cut.json b/algorithms/grover/grover_max_cut/grover_max_cut.metadata.json similarity index 100% rename from algorithms/grover/grover_max_cut/grover_max_cut.json rename to algorithms/grover/grover_max_cut/grover_max_cut.metadata.json diff --git a/algorithms/hhl/hhl/hhl.json b/algorithms/hhl/hhl/hhl.metadata.json similarity index 100% rename from algorithms/hhl/hhl/hhl.json rename to algorithms/hhl/hhl/hhl.metadata.json diff --git a/algorithms/hhl/hhl/hhl.qmod b/algorithms/hhl/hhl/hhl.qmod index 92a5d7c7..1388d772 100644 --- a/algorithms/hhl/hhl/hhl.qmod +++ b/algorithms/hhl/hhl/hhl.qmod @@ -26,7 +26,7 @@ qfunc main(output res: qbit[floor(log(4, 2))], output indicator: qbit) { 0.7302967433, 0.5477225575 ], 0.0>(res); - my_matrix_inversion_flexible(arg1) { + my_matrix_inversion_flexible(target) { suzuki_trotter1_with_power_logic<[ PauliTerm { pauli=[Pauli::I, Pauli::I], @@ -68,6 +68,6 @@ qfunc main(output res: qbit[floor(log(4, 2))], output indicator: qbit) { pauli=[Pauli::Y, Pauli::Y], coefficient=-0.06 } - ], pw, 4, 1.8, -6.2831853072>(arg1); + ], pw, 4, 1.8, -6.2831853072>(target); }, 4>(res, indicator); } diff --git a/algorithms/qml/qsvm/qsvm.json b/algorithms/qml/qsvm/qsvm.metadata.json similarity index 100% rename from algorithms/qml/qsvm/qsvm.json rename to algorithms/qml/qsvm/qsvm.metadata.json diff --git a/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.json b/algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.metadata.json similarity index 100% rename from algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.json rename to algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.metadata.json diff --git a/algorithms/qpe/qpe_for_matrix/qpe_for_matrix.json b/algorithms/qpe/qpe_for_matrix/qpe_for_matrix.metadata.json similarity index 100% rename from algorithms/qpe/qpe_for_matrix/qpe_for_matrix.json rename to algorithms/qpe/qpe_for_matrix/qpe_for_matrix.metadata.json diff --git a/algorithms/qpe/qpe_for_matrix/qpe_for_matrix.qmod b/algorithms/qpe/qpe_for_matrix/qpe_for_matrix.qmod index 80af55a3..695024fb 100644 --- a/algorithms/qpe/qpe_for_matrix/qpe_for_matrix.qmod +++ b/algorithms/qpe/qpe_for_matrix/qpe_for_matrix.qmod @@ -24,13 +24,13 @@ qfunc my_qpe_flexible(arg1: qbit[]), preci qfunc main(output phase_result: qnum<8, False, 8>) { state: qbit[]; prepare_amplitudes<[ - 0.513396396241511, - 0.451402223282909, - 0.714366707564118, - 0.149466987209476 + 0.30132518685935, + 0.675974655003596, + 0.286332054507695, + 0.608502548982623 ], 0.0>(state); phase_array: qbit[]; - my_qpe_flexible(arg1) { + my_qpe_flexible(target) { if (True) { unitary_with_power_logic) { ((-0.026023894036146) + 0.012295427374176j), ((-0.895413431349899) - 0.401691392328609j) ] - ]>(arg1); + ]>(target); } else { suzuki_trotter1_with_power_logic<[ PauliTerm { @@ -100,7 +100,7 @@ qfunc main(output phase_result: qnum<8, False, 8>) { pauli=[Pauli::Y, Pauli::Y], coefficient=0.09539162 } - ], pw, 2, 1.8, -6.283185307179586>(arg1); + ], pw, 2, 1.8, -6.283185307179586>(target); } }, 8>(state, phase_array); phase_array -> phase_result; diff --git a/algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.json b/algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.metadata.json similarity index 100% rename from algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.json rename to algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.metadata.json diff --git a/algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.qmod b/algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.qmod index f295a61d..58453d18 100644 --- a/algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.qmod +++ b/algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.qmod @@ -25,24 +25,24 @@ qfunc my_qsvt(arg1: qbi qfunc qsvt_fpaa(qbv_reg: qbit[], output qbv_aux: qbit) { allocate<1>(qbv_aux); - my_qsvt(arg1, arg2) { - hadamard_transform(arg1); - apply_to_all(arg1); - control (arg1) { - X(arg2); + my_qsvt(state, aux) { + hadamard_transform(state); + apply_to_all(state); + control (state) { + X(aux); } - RZ(arg2); - control (arg1) { - X(arg2); + RZ(aux); + control (state) { + X(aux); } - apply_to_all(arg1); - hadamard_transform(arg1); - }, lambda(arg1, arg2) { - arith_oracle(arg1, arg2); - RZ(arg2); - arith_oracle(arg1, arg2); - }, lambda(arg0) { - IDENTITY(arg0); + apply_to_all(state); + hadamard_transform(state); + }, lambda(state, aux) { + arith_oracle(state, aux); + RZ(aux); + arith_oracle(state, aux); + }, lambda(state) { + IDENTITY(state); }>(qbv_reg, qbv_aux); } @@ -50,33 +50,33 @@ qfunc main(output state: qbit[], output aux: qbit) { allocate<6>(state); hadamard_transform(state); qsvt_fpaa<[ - 3.7966, - 4.059, - 4.3526, - 1.9162, - 2.8594, - (-1.0825), - 3.6073, - 3.1312, - 6.962, - 2.5015, - 2.4699, - 1.6874, - 4.1289, - 4.1289, - 1.6874, - 2.4699, - 2.5015, - 6.962, - 3.1312, - 3.6073, - (-1.0825), - 2.8594, - 8.1994, - (-1.9306), - 4.059, - (-2.4866) - ], lambda(arg0, arg1) { - arith_equation(arg0[0:2], arg0[2:3], arg0[3:6], arg1); + 4.6247, + 3.3506, + 3.2361, + 2.6425, + 2.7655, + 4.6477, + 3.1328, + 1.3116, + 3.1851, + 4.7221, + 2.8952, + 3.466, + 1.3118, + 1.3118, + 3.466, + 2.8952, + 4.7221, + 3.1851, + 1.3116, + 3.1328, + 4.6477, + 2.7655, + 2.6425, + 3.2361, + 3.3506, + (-1.6585) + ], lambda(state_reg, aux_reg) { + arith_equation(state_reg[0:2], state_reg[2:3], state_reg[3:6], aux_reg); }>(state, aux); } diff --git a/algorithms/qsvt/qsvt_matrix_inversion/qsvt_matrix_inversion.json b/algorithms/qsvt/qsvt_matrix_inversion/qsvt_matrix_inversion.metadata.json similarity index 100% rename from algorithms/qsvt/qsvt_matrix_inversion/qsvt_matrix_inversion.json rename to algorithms/qsvt/qsvt_matrix_inversion/qsvt_matrix_inversion.metadata.json diff --git a/algorithms/simon/simon_example.json b/algorithms/simon/simon_example.metadata.json similarity index 100% rename from algorithms/simon/simon_example.json rename to algorithms/simon/simon_example.metadata.json diff --git a/algorithms/simon/simon_example.qmod b/algorithms/simon/simon_example.qmod index 89c39c4a..6ea8f381 100644 --- a/algorithms/simon/simon_example.qmod +++ b/algorithms/simon/simon_example.qmod @@ -11,7 +11,7 @@ qfunc simon_qfunc(x: qnum) { qfunc main(output x: qnum) { allocate<5>(x); - simon_qfunc(arg0, arg1); + simon_qfunc(x, res); }>(x); } diff --git a/algorithms/simon/simon_shallow_example.json b/algorithms/simon/simon_shallow_example.metadata.json similarity index 100% rename from algorithms/simon/simon_shallow_example.json rename to algorithms/simon/simon_shallow_example.metadata.json diff --git a/algorithms/simon/simon_shallow_example.qmod b/algorithms/simon/simon_shallow_example.qmod index 18f3e0c3..4efeecee 100644 --- a/algorithms/simon/simon_shallow_example.qmod +++ b/algorithms/simon/simon_shallow_example.qmod @@ -18,7 +18,7 @@ qfunc simon_qfunc(x: qnum) { qfunc main(output x: qnum) { allocate<6>(x); - simon_qfunc(arg0, arg1); + simon_qfunc(x, res); }>(x); } diff --git a/algorithms/swap_test/swap_test.json b/algorithms/swap_test/swap_test.metadata.json similarity index 100% rename from algorithms/swap_test/swap_test.json rename to algorithms/swap_test/swap_test.metadata.json diff --git a/algorithms/vqls/lcu_vqls/vqls_with_lcu.ipynb b/algorithms/vqls/lcu_vqls/vqls_with_lcu.ipynb index 49005fe7..65e88a49 100644 --- a/algorithms/vqls/lcu_vqls/vqls_with_lcu.ipynb +++ b/algorithms/vqls/lcu_vqls/vqls_with_lcu.ipynb @@ -209,6 +209,7 @@ "\n", " def get_cond_prop(self, res):\n", " aux_prob_0 = 0\n", + " all_prob_0 = 0\n", " for s in res:\n", " if s.state[self.aux_var_name] == 0:\n", " aux_prob_0 += s.shots\n", @@ -698,7 +699,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Constructing the model, synthesizing and executing on \"aer_simulator\": " + "Constructing the model, synthesizing and executing on Classiq's simulator:" ] }, { @@ -718,9 +719,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "from classiq.synthesis import set_execution_preferences\n", "\n", - "backend_preferences = ClassiqBackendPreferences(\n", - " backend_name=\"aer_simulator_statevector\"\n", - ")\n", + "backend_preferences = ClassiqBackendPreferences(backend_name=\"simulator_statevector\")\n", "model = create_model(main)\n", "\n", "model = set_execution_preferences(\n", @@ -838,9 +837,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "from classiq.synthesis import set_execution_preferences\n", "\n", - "backend_preferences = ClassiqBackendPreferences(\n", - " backend_name=\"aer_simulator_statevector\"\n", - ")\n", + "backend_preferences = ClassiqBackendPreferences(backend_name=\"simulator_statevector\")\n", "qmod = create_model(main)\n", "\n", "qmod = set_execution_preferences(\n", @@ -1105,9 +1102,9 @@ ], "metadata": { "kernelspec": { - "display_name": "dev_py3.11", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "dev_py3.11" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1119,7 +1116,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.11.7" }, "vscode": { "interpreter": { diff --git a/algorithms/vqls/lcu_vqls/vqls_with_lcu.json b/algorithms/vqls/lcu_vqls/vqls_with_lcu.metadata.json similarity index 100% rename from algorithms/vqls/lcu_vqls/vqls_with_lcu.json rename to algorithms/vqls/lcu_vqls/vqls_with_lcu.metadata.json diff --git a/applications/chemistry/molecular_energy_curve/molecular_energy_curve.json b/applications/chemistry/molecular_energy_curve/molecular_energy_curve.metadata.json similarity index 100% rename from applications/chemistry/molecular_energy_curve/molecular_energy_curve.json rename to applications/chemistry/molecular_energy_curve/molecular_energy_curve.metadata.json diff --git a/applications/chemistry/molecule_eigensolver/molecule_eigensolver.json b/applications/chemistry/molecule_eigensolver/molecule_eigensolver.metadata.json similarity index 100% rename from applications/chemistry/molecule_eigensolver/molecule_eigensolver.json rename to applications/chemistry/molecule_eigensolver/molecule_eigensolver.metadata.json diff --git a/applications/chemistry/protein_folding/protein_folding.ipynb b/applications/chemistry/protein_folding/protein_folding.ipynb index 62bcae3a..e5e0db72 100644 --- a/applications/chemistry/protein_folding/protein_folding.ipynb +++ b/applications/chemistry/protein_folding/protein_folding.ipynb @@ -273,7 +273,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/chemistry/protein_folding/protein_folding.json b/applications/chemistry/protein_folding/protein_folding.metadata.json similarity index 100% rename from applications/chemistry/protein_folding/protein_folding.json rename to applications/chemistry/protein_folding/protein_folding.metadata.json diff --git a/applications/chemistry/qpe_for_molecules/qpe_for_molecules.json b/applications/chemistry/qpe_for_molecules/qpe_for_molecules.metadata.json similarity index 100% rename from applications/chemistry/qpe_for_molecules/qpe_for_molecules.json rename to applications/chemistry/qpe_for_molecules/qpe_for_molecules.metadata.json diff --git a/applications/chemistry/second_quantized_hamiltonian/second_quantized_hamiltonian.json b/applications/chemistry/second_quantized_hamiltonian/second_quantized_hamiltonian.metadata.json similarity index 100% rename from applications/chemistry/second_quantized_hamiltonian/second_quantized_hamiltonian.json rename to applications/chemistry/second_quantized_hamiltonian/second_quantized_hamiltonian.metadata.json diff --git a/applications/cybersecurity/link_monitoring/link_monitoring.ipynb b/applications/cybersecurity/link_monitoring/link_monitoring.ipynb index bdadf58a..797d3c7d 100644 --- a/applications/cybersecurity/link_monitoring/link_monitoring.ipynb +++ b/applications/cybersecurity/link_monitoring/link_monitoring.ipynb @@ -547,7 +547,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/cybersecurity/link_monitoring/link_monitoring.json b/applications/cybersecurity/link_monitoring/link_monitoring.metadata.json similarity index 100% rename from applications/cybersecurity/link_monitoring/link_monitoring.json rename to applications/cybersecurity/link_monitoring/link_monitoring.metadata.json diff --git a/applications/cybersecurity/patching_management/patch_min_vertex_cover.json b/applications/cybersecurity/patching_management/patch_min_vertex_cover.metadata.json similarity index 100% rename from applications/cybersecurity/patching_management/patch_min_vertex_cover.json rename to applications/cybersecurity/patching_management/patch_min_vertex_cover.metadata.json diff --git a/applications/cybersecurity/patching_management/patching_managment.ipynb b/applications/cybersecurity/patching_management/patching_managment.ipynb index e67573f6..bc9c415a 100644 --- a/applications/cybersecurity/patching_management/patching_managment.ipynb +++ b/applications/cybersecurity/patching_management/patching_managment.ipynb @@ -639,7 +639,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.json b/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.metadata.json similarity index 100% rename from applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.json rename to applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.metadata.json diff --git a/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod b/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod index fffbc22b..ac68ec73 100644 --- a/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod +++ b/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod @@ -37,8 +37,8 @@ qfunc my_diffuser(x: qnum, y: qnum) sp_operand(x, y); } } apply { - my_oracle(); } } @@ -54,12 +54,12 @@ qfunc main(output x: qnum, output y: qnum) { my_sp(x, y); power (4) { my_grover_operator(); }, lambda() { - my_diffuser(x, y); }>(); } diff --git a/applications/finance/credit_card_fraud/credit_card_fraud.json b/applications/finance/credit_card_fraud/credit_card_fraud.metadata.json similarity index 100% rename from applications/finance/credit_card_fraud/credit_card_fraud.json rename to applications/finance/credit_card_fraud/credit_card_fraud.metadata.json diff --git a/applications/finance/option_pricing/option_pricing.json b/applications/finance/option_pricing/option_pricing.metadata.json similarity index 82% rename from applications/finance/option_pricing/option_pricing.json rename to applications/finance/option_pricing/option_pricing.metadata.json index f1a703d0..91e5bafb 100644 --- a/applications/finance/option_pricing/option_pricing.json +++ b/applications/finance/option_pricing/option_pricing.metadata.json @@ -2,6 +2,7 @@ "friendly_name": "Option Pricing", "description": "Estimating European Call Options Price Using Amplitude Estimation", "vertical_tags": ["finance"], + "problem_domain_tags": ["risk analysis"], "qmod_type": ["application"], "level": ["demos"] } diff --git a/applications/finance/option_pricing/option_pricing.qmod b/applications/finance/option_pricing/option_pricing.qmod index 9166436b..3aac9f86 100644 --- a/applications/finance/option_pricing/option_pricing.qmod +++ b/applications/finance/option_pricing/option_pricing.qmod @@ -1,8 +1,8 @@ qfunc qmci(phase: qnum, packed_vars: qbit[]) { - amplitude_estimation(phase, packed_vars); } @@ -27,17 +27,15 @@ qfunc main(output phase_port: qbit[2]) { } cscope ``` -def execute_amplitude_estimation(phase_port_size): - result = sample() - estimation = qae_with_qpe_result_post_processing( - estimation_register_size=phase_port_size, - estimation_method=1, - result=result - ) - save({"result": result, "estimation": estimation}) - return estimation - -estimation = execute_amplitude_estimation(2) -result = log_normal_finance_post_process(struct_literal(LogNormalModel, num_qubits=5, mu=0.7, sigma=0.13), struct_literal(FinanceFunction, f=FinanceFunctionType.EUROPEAN_CALL_OPTION, threshold=1.9, larger=True, polynomial_degree=0, use_chebyshev_polynomial_approximation=False, tail_probability=0.0), estimation) -save({'result': result}) +phase_port_size = 2 +counts = sample() +save({"counts": counts}) +probability_estimation = qae_with_qpe_result_post_processing( + estimation_register_size=phase_port_size, + estimation_method=1, + result=counts +) +save({"probability_estimation": probability_estimation}) +payoff_estimation = log_normal_finance_post_process(struct_literal(LogNormalModel, num_qubits=5, mu=0.7, sigma=0.13), struct_literal(FinanceFunction, f=FinanceFunctionType.EUROPEAN_CALL_OPTION, threshold=1.9, larger=True, polynomial_degree=0, use_chebyshev_polynomial_approximation=False, tail_probability=0.0), probability_estimation) +save({"payoff_estimation": payoff_estimation}) ``` diff --git a/applications/finance/portfolio_optimization/portfolio_optimization.ipynb b/applications/finance/portfolio_optimization/portfolio_optimization.ipynb index 7611569e..cfa4ee45 100644 --- a/applications/finance/portfolio_optimization/portfolio_optimization.ipynb +++ b/applications/finance/portfolio_optimization/portfolio_optimization.ipynb @@ -283,7 +283,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/finance/portfolio_optimization/portfolio_optimization.json b/applications/finance/portfolio_optimization/portfolio_optimization.metadata.json similarity index 100% rename from applications/finance/portfolio_optimization/portfolio_optimization.json rename to applications/finance/portfolio_optimization/portfolio_optimization.metadata.json diff --git a/applications/logistics/facility_location/facility_location.ipynb b/applications/logistics/facility_location/facility_location.ipynb index 43410afd..474a5755 100644 --- a/applications/logistics/facility_location/facility_location.ipynb +++ b/applications/logistics/facility_location/facility_location.ipynb @@ -406,7 +406,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/logistics/facility_location/facility_location.json b/applications/logistics/facility_location/facility_location.metadata.json similarity index 100% rename from applications/logistics/facility_location/facility_location.json rename to applications/logistics/facility_location/facility_location.metadata.json diff --git a/applications/logistics/task_scheduling_problem/task_scheduling_problem.ipynb b/applications/logistics/task_scheduling_problem/task_scheduling_problem.ipynb index 05e89360..a011aac3 100644 --- a/applications/logistics/task_scheduling_problem/task_scheduling_problem.ipynb +++ b/applications/logistics/task_scheduling_problem/task_scheduling_problem.ipynb @@ -676,7 +676,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" @@ -1527,7 +1527,7 @@ ")\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/logistics/task_scheduling_problem/task_scheduling_problem.json b/applications/logistics/task_scheduling_problem/task_scheduling_problem.metadata.json similarity index 100% rename from applications/logistics/task_scheduling_problem/task_scheduling_problem.json rename to applications/logistics/task_scheduling_problem/task_scheduling_problem.metadata.json diff --git a/applications/logistics/task_scheduling_problem/task_scheduling_problem_large.json b/applications/logistics/task_scheduling_problem/task_scheduling_problem_large.metadata.json similarity index 100% rename from applications/logistics/task_scheduling_problem/task_scheduling_problem_large.json rename to applications/logistics/task_scheduling_problem/task_scheduling_problem_large.metadata.json diff --git a/applications/logistics/traveling_salesman_problem/traveling_saleman_problem.json b/applications/logistics/traveling_salesman_problem/traveling_saleman_problem.metadata.json similarity index 100% rename from applications/logistics/traveling_salesman_problem/traveling_saleman_problem.json rename to applications/logistics/traveling_salesman_problem/traveling_saleman_problem.metadata.json diff --git a/applications/logistics/traveling_salesman_problem/traveling_salesman_problem.ipynb b/applications/logistics/traveling_salesman_problem/traveling_salesman_problem.ipynb index d54beddd..dc8d7aae 100644 --- a/applications/logistics/traveling_salesman_problem/traveling_salesman_problem.ipynb +++ b/applications/logistics/traveling_salesman_problem/traveling_salesman_problem.ipynb @@ -430,7 +430,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/electric_grid_optimization/electric_grid_optimization.ipynb b/applications/optimization/electric_grid_optimization/electric_grid_optimization.ipynb index 67967d01..0bdba387 100644 --- a/applications/optimization/electric_grid_optimization/electric_grid_optimization.ipynb +++ b/applications/optimization/electric_grid_optimization/electric_grid_optimization.ipynb @@ -311,7 +311,7 @@ ")\n", "\n", "# defining cosntraint such as computer and parameters for a quicker and more optimized circuit.\n", - "preferences = Preferences(transpilation_option=\"none\", timeout_seconds=3000)\n", + "preferences = Preferences(timeout_seconds=3000)\n", "\n", "qmod = set_preferences(qmod, preferences)" ] diff --git a/applications/optimization/electric_grid_optimization/electric_grid_optimization.json b/applications/optimization/electric_grid_optimization/electric_grid_optimization.metadata.json similarity index 100% rename from applications/optimization/electric_grid_optimization/electric_grid_optimization.json rename to applications/optimization/electric_grid_optimization/electric_grid_optimization.metadata.json diff --git a/applications/optimization/integer_linear_programming/integer_linear_programming.ipynb b/applications/optimization/integer_linear_programming/integer_linear_programming.ipynb index 80ab1209..93f7b4ae 100644 --- a/applications/optimization/integer_linear_programming/integer_linear_programming.ipynb +++ b/applications/optimization/integer_linear_programming/integer_linear_programming.ipynb @@ -325,7 +325,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/integer_linear_programming/integer_linear_programming.json b/applications/optimization/integer_linear_programming/integer_linear_programming.metadata.json similarity index 100% rename from applications/optimization/integer_linear_programming/integer_linear_programming.json rename to applications/optimization/integer_linear_programming/integer_linear_programming.metadata.json diff --git a/applications/optimization/knapsack_binary/knapsack_binary.ipynb b/applications/optimization/knapsack_binary/knapsack_binary.ipynb index 512df04d..a6ca876d 100644 --- a/applications/optimization/knapsack_binary/knapsack_binary.ipynb +++ b/applications/optimization/knapsack_binary/knapsack_binary.ipynb @@ -251,7 +251,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/knapsack_binary/knapsack_binary.json b/applications/optimization/knapsack_binary/knapsack_binary.metadata.json similarity index 100% rename from applications/optimization/knapsack_binary/knapsack_binary.json rename to applications/optimization/knapsack_binary/knapsack_binary.metadata.json diff --git a/applications/optimization/knapsack_integer/knapsack_integer.ipynb b/applications/optimization/knapsack_integer/knapsack_integer.ipynb index f4dbf2eb..4f2c0075 100644 --- a/applications/optimization/knapsack_integer/knapsack_integer.ipynb +++ b/applications/optimization/knapsack_integer/knapsack_integer.ipynb @@ -267,7 +267,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/knapsack_integer/knapsack_integer.json b/applications/optimization/knapsack_integer/knapsack_integer.metadata.json similarity index 100% rename from applications/optimization/knapsack_integer/knapsack_integer.json rename to applications/optimization/knapsack_integer/knapsack_integer.metadata.json diff --git a/applications/optimization/max_clique/max_clique.ipynb b/applications/optimization/max_clique/max_clique.ipynb index 29447ba5..b90d89ba 100644 --- a/applications/optimization/max_clique/max_clique.ipynb +++ b/applications/optimization/max_clique/max_clique.ipynb @@ -251,7 +251,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/max_clique/max_clique.json b/applications/optimization/max_clique/max_clique.metadata.json similarity index 100% rename from applications/optimization/max_clique/max_clique.json rename to applications/optimization/max_clique/max_clique.metadata.json diff --git a/applications/optimization/max_cut/max_cut.ipynb b/applications/optimization/max_cut/max_cut.ipynb index b47bccf6..e5c6bbc8 100644 --- a/applications/optimization/max_cut/max_cut.ipynb +++ b/applications/optimization/max_cut/max_cut.ipynb @@ -274,7 +274,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/max_cut/max_cut.json b/applications/optimization/max_cut/max_cut.metadata.json similarity index 100% rename from applications/optimization/max_cut/max_cut.json rename to applications/optimization/max_cut/max_cut.metadata.json diff --git a/applications/optimization/max_independent_set/max_independent_set.ipynb b/applications/optimization/max_independent_set/max_independent_set.ipynb index fdd9e557..cc5e0e16 100644 --- a/applications/optimization/max_independent_set/max_independent_set.ipynb +++ b/applications/optimization/max_independent_set/max_independent_set.ipynb @@ -339,7 +339,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/max_independent_set/max_independent_set.json b/applications/optimization/max_independent_set/max_independent_set.metadata.json similarity index 100% rename from applications/optimization/max_independent_set/max_independent_set.json rename to applications/optimization/max_independent_set/max_independent_set.metadata.json diff --git a/applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.ipynb b/applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.ipynb index 8b9307c1..a5d78c0e 100644 --- a/applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.ipynb +++ b/applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.ipynb @@ -340,7 +340,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.json b/applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.metadata.json similarity index 100% rename from applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.json rename to applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.metadata.json diff --git a/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.ipynb b/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.ipynb index 7aee3256..50fb1612 100644 --- a/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.ipynb +++ b/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.ipynb @@ -338,7 +338,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.json b/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.metadata.json similarity index 100% rename from applications/optimization/max_k_vertex_cover/max_k_vertex_cover.json rename to applications/optimization/max_k_vertex_cover/max_k_vertex_cover.metadata.json diff --git a/applications/optimization/min_graph_coloring/min_graph_coloring.ipynb b/applications/optimization/min_graph_coloring/min_graph_coloring.ipynb index 659add94..6b5be50b 100644 --- a/applications/optimization/min_graph_coloring/min_graph_coloring.ipynb +++ b/applications/optimization/min_graph_coloring/min_graph_coloring.ipynb @@ -372,7 +372,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/min_graph_coloring/min_graph_coloring.json b/applications/optimization/min_graph_coloring/min_graph_coloring.metadata.json similarity index 100% rename from applications/optimization/min_graph_coloring/min_graph_coloring.json rename to applications/optimization/min_graph_coloring/min_graph_coloring.metadata.json diff --git a/applications/optimization/minimum_dominating_set/minimum_dominating_set.ipynb b/applications/optimization/minimum_dominating_set/minimum_dominating_set.ipynb index cb9907f0..2cc5bb24 100644 --- a/applications/optimization/minimum_dominating_set/minimum_dominating_set.ipynb +++ b/applications/optimization/minimum_dominating_set/minimum_dominating_set.ipynb @@ -344,7 +344,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/minimum_dominating_set/minimum_dominating_set.json b/applications/optimization/minimum_dominating_set/minimum_dominating_set.metadata.json similarity index 100% rename from applications/optimization/minimum_dominating_set/minimum_dominating_set.json rename to applications/optimization/minimum_dominating_set/minimum_dominating_set.metadata.json diff --git a/applications/optimization/set_cover/set_cover.ipynb b/applications/optimization/set_cover/set_cover.ipynb index bd6b882e..9afbff69 100644 --- a/applications/optimization/set_cover/set_cover.ipynb +++ b/applications/optimization/set_cover/set_cover.ipynb @@ -332,7 +332,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/set_cover/set_cover.json b/applications/optimization/set_cover/set_cover.metadata.json similarity index 100% rename from applications/optimization/set_cover/set_cover.json rename to applications/optimization/set_cover/set_cover.metadata.json diff --git a/applications/optimization/set_partition/set_partition.ipynb b/applications/optimization/set_partition/set_partition.ipynb index 16500061..6361c5bb 100644 --- a/applications/optimization/set_partition/set_partition.ipynb +++ b/applications/optimization/set_partition/set_partition.ipynb @@ -298,7 +298,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/optimization/set_partition/set_partition.json b/applications/optimization/set_partition/set_partition.metadata.json similarity index 100% rename from applications/optimization/set_partition/set_partition.json rename to applications/optimization/set_partition/set_partition.metadata.json diff --git a/applications/physical_systems/ising_model/ising_model.ipynb b/applications/physical_systems/ising_model/ising_model.ipynb index ffe96756..927ecaf3 100644 --- a/applications/physical_systems/ising_model/ising_model.ipynb +++ b/applications/physical_systems/ising_model/ising_model.ipynb @@ -198,7 +198,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "\n", "backend_preferences = ExecutionPreferences(\n", - " backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", ")\n", "\n", "qmod = set_execution_preferences(qmod, backend_preferences)" diff --git a/applications/physical_systems/ising_model/ising_model.json b/applications/physical_systems/ising_model/ising_model.metadata.json similarity index 100% rename from applications/physical_systems/ising_model/ising_model.json rename to applications/physical_systems/ising_model/ising_model.metadata.json diff --git a/built_in_apps/chemistry/chemistry.json b/built_in_apps/chemistry/chemistry.metadata.json similarity index 100% rename from built_in_apps/chemistry/chemistry.json rename to built_in_apps/chemistry/chemistry.metadata.json diff --git a/built_in_apps/grover/grover.json b/built_in_apps/grover/grover.metadata.json similarity index 100% rename from built_in_apps/grover/grover.json rename to built_in_apps/grover/grover.metadata.json diff --git a/built_in_apps/option_pricing/option_pricing.json b/built_in_apps/option_pricing/option_pricing.metadata.json similarity index 82% rename from built_in_apps/option_pricing/option_pricing.json rename to built_in_apps/option_pricing/option_pricing.metadata.json index f1a703d0..91e5bafb 100644 --- a/built_in_apps/option_pricing/option_pricing.json +++ b/built_in_apps/option_pricing/option_pricing.metadata.json @@ -2,6 +2,7 @@ "friendly_name": "Option Pricing", "description": "Estimating European Call Options Price Using Amplitude Estimation", "vertical_tags": ["finance"], + "problem_domain_tags": ["risk analysis"], "qmod_type": ["application"], "level": ["demos"] } diff --git a/built_in_apps/option_pricing/option_pricing.qmod b/built_in_apps/option_pricing/option_pricing.qmod index 9d97c0f2..a5c529aa 100644 --- a/built_in_apps/option_pricing/option_pricing.qmod +++ b/built_in_apps/option_pricing/option_pricing.qmod @@ -1,8 +1,8 @@ qfunc qmci(phase: qnum, packed_vars: qbit[]) { - amplitude_estimation(phase, packed_vars); } @@ -27,17 +27,15 @@ qfunc main(output phase_port: qbit[1]) { } cscope ``` -def execute_amplitude_estimation(phase_port_size): - result = sample() - estimation = qae_with_qpe_result_post_processing( - estimation_register_size=phase_port_size, - estimation_method=1, - result=result - ) - save({"result": result, "estimation": estimation}) - return estimation - -estimation = execute_amplitude_estimation(1) -result = log_normal_finance_post_process(struct_literal(LogNormalModel, num_qubits=5, mu=0.7, sigma=0.13), struct_literal(FinanceFunction, f=FinanceFunctionType.EUROPEAN_CALL_OPTION, threshold=2.0, larger=True, polynomial_degree=0, use_chebyshev_polynomial_approximation=False, tail_probability=0.0), estimation) -save({'result': result}) +phase_port_size = 1 +counts = sample() +save({"counts": counts}) +probability_estimation = qae_with_qpe_result_post_processing( + estimation_register_size=phase_port_size, + estimation_method=1, + result=counts +) +save({"probability_estimation": probability_estimation}) +payoff_estimation = log_normal_finance_post_process(struct_literal(LogNormalModel, num_qubits=5, mu=0.7, sigma=0.13), struct_literal(FinanceFunction, f=FinanceFunctionType.EUROPEAN_CALL_OPTION, threshold=2.0, larger=True, polynomial_degree=0, use_chebyshev_polynomial_approximation=False, tail_probability=0.0), probability_estimation) +save({"payoff_estimation": payoff_estimation}) ``` diff --git a/community/QClass_2024/Submissions/HW1/HW1_QClass2024.ipynb b/community/QClass_2024/Assignments/HW1_QClass2024.ipynb similarity index 70% rename from community/QClass_2024/Submissions/HW1/HW1_QClass2024.ipynb rename to community/QClass_2024/Assignments/HW1_QClass2024.ipynb index 33c673d5..fde33bd8 100644 --- a/community/QClass_2024/Submissions/HW1/HW1_QClass2024.ipynb +++ b/community/QClass_2024/Assignments/HW1_QClass2024.ipynb @@ -10,7 +10,7 @@ "\n", "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", + "The [QMOD language reference](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", "\n", "This workshop consists of step-by-step exercises. It is structured as follows:\n", "\n", @@ -24,7 +24,7 @@ "\n", "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", + "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/classiq_101/registration_installations/).\n", "\n", "### Python Qmod Exercises - General Instructions\n", "\n", @@ -32,7 +32,7 @@ "1. Make sure you define a `main` function that calls functions you create.\n", "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" + "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/reference-manual/platform/executor/). You can also execute it with the IDE after visualizing the circuit.\n" ] }, { @@ -46,15 +46,10 @@ }, { "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-19T02:17:30.695401Z", - "start_time": "2024-05-19T02:17:30.691705Z" - } - }, + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "import math\n", - "\n", "from classiq import *\n", "\n", "\n", @@ -64,15 +59,13 @@ " X(target=q)\n", " H(target=q)\n", "\n", - "##Syntax may not be correct on this exercise or other exercises\n", + "\n", "# Define a main function\n", "@qfunc\n", "def main(res: Output[QBit]) -> None:\n", " allocate(1, res)\n", " foo(q=res)" - ], - "outputs": [], - "execution_count": 3 + ] }, { "cell_type": "markdown", @@ -85,33 +78,14 @@ }, { "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-19T02:14:17.739674Z", - "start_time": "2024-05-19T02:14:17.727247Z" - } - }, + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ], - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'main' is not defined", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mNameError\u001B[0m Traceback (most recent call last)", - "\u001B[0;32m/var/folders/xd/g2xmyd4n50qf68f46q132kk00000gn/T/ipykernel_42181/919198635.py\u001B[0m in \u001B[0;36m\u001B[0;34m\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[0;32mfrom\u001B[0m \u001B[0mclassiq\u001B[0m \u001B[0;32mimport\u001B[0m \u001B[0;34m*\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 2\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 3\u001B[0;31m \u001B[0mqmod\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mcreate_model\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mmain\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 4\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n", - "\u001B[0;31mNameError\u001B[0m: name 'main' is not defined" - ] - } - ], - "execution_count": 2 + "# Your code here:" + ] }, { "cell_type": "markdown", @@ -119,7 +93,7 @@ "source": [ "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", + "See also [Quantum Variables](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_variables_and_functions/).\n", "\n", "We will discuss other quantum types during the workshop.\n" ] @@ -142,7 +116,7 @@ "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" + "See also [Functions](https://docs.classiq.io/latest/reference-manual/platform/qmod/library-reference/core-library-functions/)\n" ] }, { @@ -153,16 +127,7 @@ "source": [ "from classiq import *\n", "\n", - "def test(a: QBit, b: QBit) -> None:\n", - " H(target=a)\n", - " CX(\n", - " control=a,\n", - " target=b\n", - " ) \n", - "\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(2, res)\n", - " test(a=res[0], b=res[1])\n", + "# Your code here:\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -185,16 +150,7 @@ "source": [ "from classiq import *\n", "\n", - "def test(res: QArray[QBit]) -> None:\n", - " H(target=res[0])\n", - " CX(\n", - " control=res[0],\n", - " target=res[1]\n", - " ) \n", - "\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(2, res)\n", - " test(a=res[0], b=res[1])\n", + "# Your code here:\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -209,7 +165,7 @@ "\n", "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", + "See also [Classical repeat](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", "\n", "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" ] @@ -222,12 +178,7 @@ "source": [ "from classiq import *\n", "\n", - "def my_hadamard_transform(res: QArray[QBit]) -> None:\n", - " repeat(H(target=res[0]), 0)\n", - "\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(10, res)\n", - " my_hadamard_transform(res)\n", + "# Your code here:\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -242,7 +193,7 @@ "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." + "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/operators/#example-2)." ] }, { @@ -256,7 +207,7 @@ "Sometimes, however, power can be simplified, thus saving computational resources.\n", "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", + "See also [Power operator](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/power/).\n", "\n", "Use the following code to generate a 2-qubit (real) unitary matrix:" ] @@ -314,9 +265,7 @@ "source": [ "from classiq import *\n", "\n", - "def main(res: Output[QBit], res2: Output[QBit]) -> None:\n", - " unitary_matrix(res)\n", - " power(unitary_matrix, 3)(res2)\n", + "# Your code here:\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -330,7 +279,7 @@ "## Exercise 4 - User-defined Operators\n", "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", + "See also [Operators](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/operators/).\n", "\n", "Follow these guidelines:\n", "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", @@ -348,13 +297,7 @@ "source": [ "from classiq import *\n", "\n", - "def my_apply_to_all(res: QArray[QBit]) -> None:\n", - " for i in res:\n", - " H(target=i)\n", - "\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(10, res)\n", - " my_apply_to_all(res)\n", + "# Your code here:\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -370,7 +313,7 @@ "### Exercise 5a - Control Operator\n", "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" + "See also [Quantum operators](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_operations/).\n" ] }, { @@ -381,12 +324,8 @@ "source": [ "from classiq import *\n", "\n", - "def function(a: QBit, b: QBit) -> None:\n", - " control(a, RY(b, angle=math.pi/2, ))\n", - " \n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(2,res)\n", - " function(a=res[0], b=res[1])\n", + "# Your code here:\n", + "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", "show(qprog)" @@ -399,11 +338,11 @@ "### Exercise 5b - Control (\"Quantum If\")\n", "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", + "See also [Numeric types](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/quantum-types/).\n", "\n", "In QMOD this generalization is available as a native statement - control.\n", "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", + "See also [control](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/operators/).\n", "\n", "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", @@ -413,46 +352,23 @@ }, { "cell_type": "code", - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-19T20:22:27.509721Z", - "start_time": "2024-05-19T20:22:27.503014Z" - } - }, + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", "\n", - "def main(x: Output[QNum], y: QBit) -> None:\n", - " prepare_int(x, 9)\n", - " control(x, RX(y))\n", + "# Your code here:\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", "show(qprog)" - ], - "outputs": [ - { - "ename": "IndentationError", - "evalue": "expected an indented block (3255054010.py, line 5)", - "output_type": "error", - "traceback": [ - "\u001B[0;36m File \u001B[0;32m\"/var/folders/xd/g2xmyd4n50qf68f46q132kk00000gn/T/ipykernel_50658/3255054010.py\"\u001B[0;36m, line \u001B[0;32m5\u001B[0m\n\u001B[0;31m qmod = create_model(main)\u001B[0m\n\u001B[0m ^\u001B[0m\n\u001B[0;31mIndentationError\u001B[0m\u001B[0;31m:\u001B[0m expected an indented block\n" - ] - } - ], - "execution_count": 1 - }, - { - "metadata": {}, - "cell_type": "code", - "outputs": [], - "execution_count": null, - "source": "" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.11.7 ('classiq')", "language": "python", "name": "python3" }, @@ -466,7 +382,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.8" + "version": "3.11.7" + }, + "vscode": { + "interpreter": { + "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" + } } }, "nbformat": 4, diff --git a/community/QClass_2024/Assignments/HW2_QClass2024.ipynb b/community/QClass_2024/Assignments/HW2_QClass2024.ipynb index 8bea9958..57665786 100644 --- a/community/QClass_2024/Assignments/HW2_QClass2024.ipynb +++ b/community/QClass_2024/Assignments/HW2_QClass2024.ipynb @@ -11,10 +11,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ + "from dataclasses import dataclass\n", + "\n", "from classiq import *" ] }, @@ -26,18 +28,18 @@ "\n", "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", + "See also [Classical Types](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/classical_variables_and_operations/)\n", "\n", "The builtin struct type `PauliTerm` is defined as follows:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ - "@struct\n", + "@dataclass\n", "class PauliTerm:\n", " pauli: CArray[Pauli]\n", " coefficient: CReal" @@ -58,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -82,50 +84,28 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 28, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "The current version of 'classiq' has been deprecated, and will not be supported as of 2024-06-06. Please run \"pip install -U classiq\" to upgrade the classiq SDK to the latest version.\n" - ] - }, - { - "ename": "ClassiqAPIError", - "evalue": "An unknown error occurred.\n\nError identifier: ED0CFFBF2-00D3-4B9E-9F24-F74A461E998F.\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mClassiqAPIError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[6], line 17\u001b[0m\n\u001b[1;32m 7\u001b[0m suzuki_trotter(\n\u001b[1;32m 8\u001b[0m \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m,\n\u001b[1;32m 9\u001b[0m evolution_coefficient\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 12\u001b[0m qbv\u001b[38;5;241m=\u001b[39mq,\n\u001b[1;32m 13\u001b[0m )\n\u001b[1;32m 16\u001b[0m qmod \u001b[38;5;241m=\u001b[39m create_model(main)\n\u001b[0;32m---> 17\u001b[0m qprog \u001b[38;5;241m=\u001b[39m \u001b[43msynthesize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqmod\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 18\u001b[0m show(qprog)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages/classiq/_internals/async_utils.py:45\u001b[0m, in \u001b[0;36msyncify_function..async_wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(async_func)\n\u001b[1;32m 44\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21masync_wrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T:\n\u001b[0;32m---> 45\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43masync_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages/classiq/_internals/async_utils.py:39\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(coro)\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun\u001b[39m(coro: Awaitable[T]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T:\n\u001b[1;32m 35\u001b[0m \u001b[38;5;66;03m# Use this function instead of asyncio.run, since it ALWAYS\u001b[39;00m\n\u001b[1;32m 36\u001b[0m \u001b[38;5;66;03m# creates a new event loop and clears the thread event loop.\u001b[39;00m\n\u001b[1;32m 37\u001b[0m \u001b[38;5;66;03m# Never use asyncio.run in library code.\u001b[39;00m\n\u001b[1;32m 38\u001b[0m loop \u001b[38;5;241m=\u001b[39m get_event_loop()\n\u001b[0;32m---> 39\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mloop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_until_complete\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcoro\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages/nest_asyncio.py:98\u001b[0m, in \u001b[0;36m_patch_loop..run_until_complete\u001b[0;34m(self, future)\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m f\u001b[38;5;241m.\u001b[39mdone():\n\u001b[1;32m 96\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[1;32m 97\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mEvent loop stopped before Future completed.\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 98\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresult\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.11/asyncio/futures.py:203\u001b[0m, in \u001b[0;36mFuture.result\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 201\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__log_traceback \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 203\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception\u001b[38;5;241m.\u001b[39mwith_traceback(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception_tb)\n\u001b[1;32m 204\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_result\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.11/asyncio/tasks.py:277\u001b[0m, in \u001b[0;36mTask.__step\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 274\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m exc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 275\u001b[0m \u001b[38;5;66;03m# We use the `send` method directly, because coroutines\u001b[39;00m\n\u001b[1;32m 276\u001b[0m \u001b[38;5;66;03m# don't have `__iter__` and `__next__` methods.\u001b[39;00m\n\u001b[0;32m--> 277\u001b[0m result \u001b[38;5;241m=\u001b[39m coro\u001b[38;5;241m.\u001b[39msend(\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 278\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 279\u001b[0m result \u001b[38;5;241m=\u001b[39m coro\u001b[38;5;241m.\u001b[39mthrow(exc)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages/classiq/synthesis.py:21\u001b[0m, in \u001b[0;36msynthesize_async\u001b[0;34m(serialized_model)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msynthesize_async\u001b[39m(\n\u001b[1;32m 18\u001b[0m serialized_model: SerializedModelInput,\n\u001b[1;32m 19\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m SerializedQuantumProgram:\n\u001b[1;32m 20\u001b[0m model: ModelInput \u001b[38;5;241m=\u001b[39m pydantic\u001b[38;5;241m.\u001b[39mparse_raw_as(ModelInput, serialized_model) \u001b[38;5;66;03m# type: ignore[arg-type]\u001b[39;00m\n\u001b[0;32m---> 21\u001b[0m quantum_program \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m ApiWrapper\u001b[38;5;241m.\u001b[39mcall_generation_task(model)\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m SerializedQuantumProgram(quantum_program\u001b[38;5;241m.\u001b[39mjson(indent\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m))\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages/classiq/_internals/api_wrapper.py:108\u001b[0m, in \u001b[0;36mApiWrapper.call_generation_task\u001b[0;34m(cls, model)\u001b[0m\n\u001b[1;32m 106\u001b[0m poller \u001b[38;5;241m=\u001b[39m JobPoller(base_url\u001b[38;5;241m=\u001b[39mroutes\u001b[38;5;241m.\u001b[39mTASKS_GENERATE_FULL_PATH)\n\u001b[1;32m 107\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m poller\u001b[38;5;241m.\u001b[39mrun_pydantic(model, timeout_sec\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m--> 108\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_parse_job_response\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresult\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgenerator_result\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mQuantumProgram\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.11/site-packages/classiq/_internals/api_wrapper.py:58\u001b[0m, in \u001b[0;36m_parse_job_response\u001b[0;34m(job_result, output_type)\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output_type\u001b[38;5;241m.\u001b[39mparse_obj(job_result\u001b[38;5;241m.\u001b[39mdescription)\n\u001b[1;32m 57\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(job_result, JobDescriptionFailure):\n\u001b[0;32m---> 58\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqAPIError(job_result\u001b[38;5;241m.\u001b[39mdescription\u001b[38;5;241m.\u001b[39mdetails)\n\u001b[1;32m 60\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqAPIError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUnexpected response from server\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[0;31mClassiqAPIError\u001b[0m: An unknown error occurred.\n\nError identifier: ED0CFFBF2-00D3-4B9E-9F24-F74A461E998F.\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support" + "Opening: https://platform.classiq.io/circuit/338a2b73-d26c-49cc-84ba-1e42239bc2ea?version=0.41.2\n" ] } ], "source": [ - "from classiq import *\n", - "\n", - "\n", "@qfunc\n", "def main(q: Output[QArray[QBit]]) -> None:\n", " allocate(4, q)\n", - " suzuki_trotter(\n", - " ...,\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", + " # suzuki_trotter(\n", + " # ...,\n", + " # evolution_coefficient=3,\n", + " # repetitions=4,\n", + " # order=2,\n", + " # qbv=q,\n", + " # )\n", "\n", "\n", "qmod = create_model(main)\n", @@ -142,8 +122,8 @@ "#### Exercise 7a\n", "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", + "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_variables_and_functions/).\n", + "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/numeric-assignment/)\n", "\n", "Create the following quantum programs:\n", "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", @@ -157,17 +137,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" + "# Your code here:" ] }, { @@ -196,17 +170,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" + "# Your code here:" ] }, { @@ -218,7 +186,7 @@ "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", + "See also [Within Apply](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/within-apply/).\n", "\n", "#### Exercise 8a\n", "\n", @@ -241,17 +209,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" + "# Your code here:" ] }, { @@ -264,7 +226,7 @@ "To understand the motivation, we will create another arithmetic circuit.\n", "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", + "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/classiq_101/classiq_concepts/optimize/).\n", "\n", "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", "\n", @@ -278,17 +240,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" + "# Your code here:" ] }, { @@ -305,17 +261,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" + "# Your code here:" ] }, { @@ -328,8 +278,6 @@ "\n", "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", "\n", "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", @@ -346,53 +294,6 @@ "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" ] }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/820a33c8-8d74-40f1-910d-bc58a9036ae0?version=0.40.0\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -405,23 +306,18 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/d865c2f7-c7ab-4092-8192-602cf2de60dc?version=0.40.0\n" + "Opening: https://platform.classiq.io/circuit/462d8604-ac48-4518-8d41-9580a986d56a?version=0.41.2\n" ] } ], "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", "from math import pi\n", "\n", "\n", @@ -435,10 +331,13 @@ " msb = QNum(\"msb\", 2, False, 0)\n", " bind(x, [lsb, msb])\n", "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", + " control(\n", + " msb == 1, lambda: RY(pi / 3, lsb)\n", + " ) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", "\n", " bind([lsb, msb], res)\n", "\n", + "\n", "model = create_model(main)\n", "qprog = synthesize(model)\n", "show(qprog)" @@ -473,39 +372,15 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", + "def pre_prepared_state(q: Output[QArray[QBit]]) -> None:\n", " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", + " [1 / 8, 1 / 8, 1 / 8, 1 / 8 + 0.10825, 1 / 8 - 0.10825, 1 / 8, 1 / 8, 1 / 8],\n", + " 0.01,\n", " q,\n", " )\n", "\n", @@ -516,7 +391,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.11.7 ('classiq_devolpment')", "language": "python", "name": "python3" }, @@ -530,7 +405,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.8" + "version": "3.11.7" + }, + "vscode": { + "interpreter": { + "hash": "e992e515f6583afc67b46eeabcda0f30363069fab8b382c7517b274ba7a59477" + } } }, "nbformat": 4, diff --git a/community/QClass_2024/Assignments/HW3_VQE.ipynb b/community/QClass_2024/Assignments/HW3_VQE.ipynb deleted file mode 100644 index a0960f84..00000000 --- a/community/QClass_2024/Assignments/HW3_VQE.ipynb +++ /dev/null @@ -1,287 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [...]) #TODO: Complete Hamiltonian" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " ..., # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "11\n", - "Optimal parameters: {'angles_0': -3.0292653800801213, 'angles_1': 0.13084292242999915, 'angles_2': -5.614248543217801}\n", - "Eigenstate: {'10': (0.07328774624724109+0j), '11': (0.07328774624724109+0j), '01': (0.9946144039274718+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class?" - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - "\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " ..., # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'vqe_result' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOptimal energy: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[43mvqe_result\u001b[49m\u001b[38;5;241m.\u001b[39menergy\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOptimal parameters: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvqe_result\u001b[38;5;241m.\u001b[39moptimal_parameters\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEigenstate: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvqe_result\u001b[38;5;241m.\u001b[39meigenstate\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[0;31mNameError\u001b[0m: name 'vqe_result' is not defined" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Assignments/Preparation_for_Week2_Git & GitHub.ipynb b/community/QClass_2024/Assignments/Preparation_for_Week2_Git_GitHub.ipynb similarity index 99% rename from community/QClass_2024/Assignments/Preparation_for_Week2_Git & GitHub.ipynb rename to community/QClass_2024/Assignments/Preparation_for_Week2_Git_GitHub.ipynb index 3b1d78cb..e3c15657 100644 --- a/community/QClass_2024/Assignments/Preparation_for_Week2_Git & GitHub.ipynb +++ b/community/QClass_2024/Assignments/Preparation_for_Week2_Git_GitHub.ipynb @@ -83,7 +83,7 @@ "\n", "\n", "**Starting Steps:**\n", - "To begin, visit the [Classiq Library](https://github.com/Classiq/classiq-library) page and click the **Fork** button in the upper right corner (as indicated in the image).\n" + "To begin, visit the [Classiq Library](https://github.com/Classiq/classiq-library/blob/main/) page and click the **Fork** button in the upper right corner (as indicated in the image).\n" ] }, { @@ -155,7 +155,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.11.7 ('classiq')", "language": "python", "name": "python3" }, @@ -169,7 +169,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.8" + "version": "3.11.7" + }, + "vscode": { + "interpreter": { + "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" + } } }, "nbformat": 4, diff --git a/community/QClass_2024/HW1/Stefanie_Muroya_Lei_HW1_QClass2024.ipynb b/community/QClass_2024/HW1/Stefanie_Muroya_Lei_HW1_QClass2024.ipynb deleted file mode 100644 index eb1805c5..00000000 --- a/community/QClass_2024/HW1/Stefanie_Muroya_Lei_HW1_QClass2024.ipynb +++ /dev/null @@ -1,1601 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Quantum Software Development Journey: \n", - "# From Theory to Application with Classiq - Part 1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Welcome to the Classiq Workshop Series for QClass 2024!**\n", - "\n", - "In this series, we will develop the skills needed to participate in quantum software development!\n", - "\n", - "- Week 1: Classiq's Basics & High-Level Functional Design\n", - "- Week 2: Using Git as a Tool for In-Team Collaboration and Open Source Contributions\n", - "- Weeks 3-4: Advanced Algorithms, Introduction to Quantum Machine Learning (QML), and Their Applications\n", - "\n", - "**Here, you have early access to our [New Classiq's documentation](https://nightly.docs.classiq.io/latest/)!**\n", - "\n", - "\n", - "\n", - "\n", - "Additional resources you should use are\n", - "- The IDE of the classiq platform at [platform.classiq.io](platform.classiq.io)\n", - "- The [community Slack of Classiq](https://short.classiq.io/join-slack) - Classiq's team will answer any question you have over there, including implementation questions\n", - "- [Classiq's documentation](https://docs.classiq.io/latest/user-guide/platform/) with the dedicated [Python SDK explanations](https://docs.classiq.io/latest/user-guide/platform/qmod/python/functions/)\n", - "\n", - "Good luck!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setting The Scene" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Install the Classiq SDK package:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting classiq\n", - " Downloading classiq-0.41.0-py3-none-any.whl.metadata (3.1 kB)\n", - "Collecting ConfigArgParse<2.0.0,>=1.5.3 (from classiq)\n", - " Downloading ConfigArgParse-1.7-py3-none-any.whl.metadata (23 kB)\n", - "Collecting Pyomo<6.6,>=6.5 (from classiq)\n", - " Downloading Pyomo-6.5.0.tar.gz (2.4 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.4/2.4 MB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0mm\n", - "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25ldone\n", - "\u001b[?25hCollecting black<25.0,>=24.0 (from classiq)\n", - " Downloading black-24.4.2-cp310-cp310-macosx_11_0_arm64.whl.metadata (77 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.1/77.1 kB\u001b[0m \u001b[31m12.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: httpx<1,>=0.23.0 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from classiq) (0.27.0)\n", - "Collecting keyring<24.0.0,>=23.5.0 (from classiq)\n", - " Downloading keyring-23.13.1-py3-none-any.whl.metadata (20 kB)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from classiq) (3.8.4)\n", - "Collecting networkx<3.0.0,>=2.5.1 (from classiq)\n", - " Downloading networkx-2.8.8-py3-none-any.whl.metadata (5.1 kB)\n", - "Collecting numexpr<3.0.0,>=2.7.3 (from classiq)\n", - " Downloading numexpr-2.10.0-cp310-cp310-macosx_11_0_arm64.whl.metadata (7.9 kB)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from classiq) (1.26.4)\n", - "Collecting packaging<23.0,>=22.0 (from classiq)\n", - " Downloading packaging-22.0-py3-none-any.whl.metadata (3.1 kB)\n", - "Collecting pandas<3.0.0,>=1.4.0 (from classiq)\n", - " Downloading pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl.metadata (19 kB)\n", - "Collecting plotly<6.0.0,>=5.7.0 (from classiq)\n", - " Downloading plotly-5.22.0-py3-none-any.whl.metadata (7.1 kB)\n", - "Collecting pydantic<2.0.0,>=1.9.1 (from classiq)\n", - " Downloading pydantic-1.10.15-cp310-cp310-macosx_11_0_arm64.whl.metadata (150 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m150.6/150.6 kB\u001b[0m \u001b[31m18.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: scipy<2.0.0,>=1.10.1 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from classiq) (1.13.0)\n", - "Collecting sympy<1.11.0,>=1.9.0 (from classiq)\n", - " Downloading sympy-1.10.1-py3-none-any.whl.metadata (12 kB)\n", - "Requirement already satisfied: tabulate<1,>=0.8.9 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from classiq) (0.9.0)\n", - "Collecting click>=8.0.0 (from black<25.0,>=24.0->classiq)\n", - " Downloading click-8.1.7-py3-none-any.whl.metadata (3.0 kB)\n", - "Collecting mypy-extensions>=0.4.3 (from black<25.0,>=24.0->classiq)\n", - " Downloading mypy_extensions-1.0.0-py3-none-any.whl.metadata (1.1 kB)\n", - "Collecting pathspec>=0.9.0 (from black<25.0,>=24.0->classiq)\n", - " Downloading pathspec-0.12.1-py3-none-any.whl.metadata (21 kB)\n", - "Requirement already satisfied: platformdirs>=2 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from black<25.0,>=24.0->classiq) (4.2.1)\n", - "Requirement already satisfied: tomli>=1.1.0 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from black<25.0,>=24.0->classiq) (2.0.1)\n", - "Requirement already satisfied: typing-extensions>=4.0.1 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from black<25.0,>=24.0->classiq) (4.11.0)\n", - "Requirement already satisfied: anyio in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from httpx<1,>=0.23.0->classiq) (4.3.0)\n", - "Requirement already satisfied: certifi in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from httpx<1,>=0.23.0->classiq) (2024.2.2)\n", - "Requirement already satisfied: httpcore==1.* in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from httpx<1,>=0.23.0->classiq) (1.0.5)\n", - "Requirement already satisfied: idna in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from httpx<1,>=0.23.0->classiq) (3.7)\n", - "Requirement already satisfied: sniffio in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from httpx<1,>=0.23.0->classiq) (1.3.1)\n", - "Requirement already satisfied: h11<0.15,>=0.13 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from httpcore==1.*->httpx<1,>=0.23.0->classiq) (0.14.0)\n", - "Collecting jaraco.classes (from keyring<24.0.0,>=23.5.0->classiq)\n", - " Downloading jaraco.classes-3.4.0-py3-none-any.whl.metadata (2.6 kB)\n", - "Collecting importlib-metadata>=4.11.4 (from keyring<24.0.0,>=23.5.0->classiq)\n", - " Downloading importlib_metadata-7.1.0-py3-none-any.whl.metadata (4.7 kB)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.2.1)\n", - "Requirement already satisfied: cycler>=0.10 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.51.0)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.5)\n", - "Requirement already satisfied: pillow>=8 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (10.3.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.1.2)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.9.0.post0)\n", - "Collecting pytz>=2020.1 (from pandas<3.0.0,>=1.4.0->classiq)\n", - " Using cached pytz-2024.1-py2.py3-none-any.whl.metadata (22 kB)\n", - "Collecting tzdata>=2022.7 (from pandas<3.0.0,>=1.4.0->classiq)\n", - " Using cached tzdata-2024.1-py2.py3-none-any.whl.metadata (1.4 kB)\n", - "Collecting tenacity>=6.2.0 (from plotly<6.0.0,>=5.7.0->classiq)\n", - " Downloading tenacity-8.3.0-py3-none-any.whl.metadata (1.2 kB)\n", - "Requirement already satisfied: ply in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from Pyomo<6.6,>=6.5->classiq) (3.11)\n", - "Requirement already satisfied: mpmath>=0.19 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.3.0)\n", - "Collecting zipp>=0.5 (from importlib-metadata>=4.11.4->keyring<24.0.0,>=23.5.0->classiq)\n", - " Downloading zipp-3.18.2-py3-none-any.whl.metadata (3.5 kB)\n", - "Requirement already satisfied: six>=1.5 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n", - "Requirement already satisfied: exceptiongroup>=1.0.2 in /Users/stefaniemuroyalei/Documents/qworld_education/.env/lib/python3.10/site-packages (from anyio->httpx<1,>=0.23.0->classiq) (1.2.1)\n", - "Collecting more-itertools (from jaraco.classes->keyring<24.0.0,>=23.5.0->classiq)\n", - " Downloading more_itertools-10.2.0-py3-none-any.whl.metadata (34 kB)\n", - "Downloading classiq-0.41.0-py3-none-any.whl (398 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m398.1/398.1 kB\u001b[0m \u001b[31m28.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading black-24.4.2-cp310-cp310-macosx_11_0_arm64.whl (1.5 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.5/1.5 MB\u001b[0m \u001b[31m39.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading ConfigArgParse-1.7-py3-none-any.whl (25 kB)\n", - "Downloading keyring-23.13.1-py3-none-any.whl (37 kB)\n", - "Downloading networkx-2.8.8-py3-none-any.whl (2.0 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m44.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m\n", - "\u001b[?25hDownloading numexpr-2.10.0-cp310-cp310-macosx_11_0_arm64.whl (92 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m92.7/92.7 kB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading packaging-22.0-py3-none-any.whl (42 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl (11.3 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m11.3/11.3 MB\u001b[0m \u001b[31m31.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m0:01\u001b[0m\n", - "\u001b[?25hDownloading plotly-5.22.0-py3-none-any.whl (16.4 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.4/16.4 MB\u001b[0m \u001b[31m26.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", - "\u001b[?25hDownloading pydantic-1.10.15-cp310-cp310-macosx_11_0_arm64.whl (2.6 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.6/2.6 MB\u001b[0m \u001b[31m14.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n", - "\u001b[?25hDownloading sympy-1.10.1-py3-none-any.whl (6.4 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m14.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", - "\u001b[?25hDownloading click-8.1.7-py3-none-any.whl (97 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.9/97.9 kB\u001b[0m \u001b[31m13.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading importlib_metadata-7.1.0-py3-none-any.whl (24 kB)\n", - "Downloading mypy_extensions-1.0.0-py3-none-any.whl (4.7 kB)\n", - "Downloading pathspec-0.12.1-py3-none-any.whl (31 kB)\n", - "Using cached pytz-2024.1-py2.py3-none-any.whl (505 kB)\n", - "Downloading tenacity-8.3.0-py3-none-any.whl (25 kB)\n", - "Using cached tzdata-2024.1-py2.py3-none-any.whl (345 kB)\n", - "Downloading jaraco.classes-3.4.0-py3-none-any.whl (6.8 kB)\n", - "Downloading zipp-3.18.2-py3-none-any.whl (8.3 kB)\n", - "Downloading more_itertools-10.2.0-py3-none-any.whl (57 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.0/57.0 kB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hBuilding wheels for collected packages: Pyomo\n", - " Building wheel for Pyomo (setup.py) ... \u001b[?25ldone\n", - "\u001b[?25h Created wheel for Pyomo: filename=Pyomo-6.5.0-py2.py3-none-any.whl size=3066212 sha256=684b17b7788af8822ee5ac62a7d41e3943781b7216f30a5ecf38dc8e08720e0d\n", - " Stored in directory: /Users/stefaniemuroyalei/Library/Caches/pip/wheels/27/1c/3d/2c758b6a4065881cd0f05b7d8e95d3f537ac7f9873b499ac6c\n", - "Successfully built Pyomo\n", - "Installing collected packages: pytz, zipp, tzdata, tenacity, sympy, Pyomo, pydantic, pathspec, packaging, numexpr, networkx, mypy-extensions, more-itertools, ConfigArgParse, click, plotly, pandas, jaraco.classes, importlib-metadata, black, keyring, classiq\n", - " Attempting uninstall: sympy\n", - " Found existing installation: sympy 1.12\n", - " Uninstalling sympy-1.12:\n", - " Successfully uninstalled sympy-1.12\n", - " Attempting uninstall: packaging\n", - " Found existing installation: packaging 24.0\n", - " Uninstalling packaging-24.0:\n", - " Successfully uninstalled packaging-24.0\n", - " Attempting uninstall: networkx\n", - " Found existing installation: networkx 3.3\n", - " Uninstalling networkx-3.3:\n", - " Successfully uninstalled networkx-3.3\n", - "Successfully installed ConfigArgParse-1.7 Pyomo-6.5.0 black-24.4.2 classiq-0.41.0 click-8.1.7 importlib-metadata-7.1.0 jaraco.classes-3.4.0 keyring-23.13.1 more-itertools-10.2.0 mypy-extensions-1.0.0 networkx-2.8.8 numexpr-2.10.0 packaging-22.0 pandas-2.2.2 pathspec-0.12.1 plotly-5.22.0 pydantic-1.10.15 pytz-2024.1 sympy-1.10.1 tenacity-8.3.0 tzdata-2024.1 zipp-3.18.2\n" - ] - } - ], - "source": [ - "# !pip install -U classiq" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You need to authenticate your device in order to use Classiq's backend synthesis engine and IDE. \n", - "**Make sure to register to the platform** at [platform.classiq.io](https://platform.classiq.io/) before you run the next cell:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Your user code: FSWF-CZBV\n", - "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=FSWF-CZBV\n" - ] - } - ], - "source": [ - "import classiq\n", - "classiq.authenticate()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## A Warm Up" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### First Example" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Write a function that prepares the minus state $\\ket{-}=\\frac{1}{\\sqrt2}(\\ket{0}-\\ket{1})$, assuming it recives the qubit $\\ket{x}=\\ket{0}$ (hint): \n", - "\n", - "
\n", - "\n", - "HINT\n", - "\n", - "\n", - "Use `H(x)`,`X(x)`\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def prepare_minus_state(x:QBit):\n", - " X(x)\n", - " hadamard_transform(x)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we will test our code:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x: Output[QBit]):\n", - " allocate(1,x) # Initialize the qubit x\n", - " prepare_minus_state(x)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0271d743-8117-45b4-a600-46dd5c3c7def?version=0.41.0\n" - ] - } - ], - "source": [ - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Uniform Superposition" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's continue warming up with creating a function that receives a quantum register and creates a uniform superposition for all qubits within this array. You should use the function `apply_to_all(gate_operand=, target=)`:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def create_initial_state(reg: QArray[QBit]):\n", - " #TODO use the function apply_to_all in order create a uniform superposition\n", - " apply_to_all(gate_operand=hadamard_transform, target=reg)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Test your function by creating a new main function, synthesizing and viewing the circuit:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(reg: Output[QArray[QBit]]): #TODO fill in the correct declaration here, what variables this model should output?\n", - " #TODO allocate reg with a few qubits\n", - " allocate(num_qubits=5, out=reg)\n", - " create_initial_state(reg)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0271d743-8117-45b4-a600-46dd5c3c7def?version=0.41.0\n" - ] - } - ], - "source": [ - "# TODO uncomment the following line:\n", - "qprog = synthesize(create_model(main))\n", - "\n", - "#TODO show the quantum program\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Another implementation could utilize the `repeat(count=, iteration=)` function. The `repeat` function can be thought of as a \"classical for loop\". It could be handy in many situations, especially when combined with `if_` function, the \"classical if\" statement in Classiq. Together, they form 'Classical Control Flow'. \n", - "\n", - "Read more: [Classical Control Flow (repeat, if_)](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/?h=repea#__tabbed_1_2)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/6918f036-a65d-4a57-9f39-ee055588546b?version=0.41.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def create_initial_state(q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]): \n", - " allocate(4,reg)\n", - " create_initial_state(reg)\n", - "\n", - "qprog = synthesize(create_model(main))\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Guidelines for High-Level Functional Design with Classiq" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Some basic explanations about the high-level functional design with Classiq:**\n", - "\n", - "* There should always be a main (`def main(...)`) function - the model that captures your algorithm is described there\n", - "\n", - "* The model is always generated out of the main function \n", - "\n", - "* The model is sent to the synthesis engine (compiler) that return a quantum program which contains the quantum circuit" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Some basic guidelines about the modeling language (QMOD):**\n", - "\n", - "1. Every function you use with the QMOD language should have the decorator `@qfunc` before it\n", - "2. Every quantum variable should be declared, either as an argument of a function e.g. `def prepare_minus(x: QBit)` or as a local variable within the function itself with `x = QBit('x')`\n", - "\n", - "\n", - "3. Some quantum variables need to be initialized with the `allocate` function. This is required in 2 cases:\n", - "* A variable is an argument of a function with the declaration `Output` like `def main(x: Output[QNum])`\n", - "* A variable that was declared within a function like `a = QNum('a')`\n", - "\n", - "4. For the `main` function, you will always use `Output` for all variables. The `output` indicates that these quantum variables are not initialized outside the scope of the function.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - " Types of Initializations \n", - "There are a few ways to initialize a quantum variable:\n", - "\n", - "1. With `allocate` or `allocate_num` \n", - "2. With `prepare_int`, `prepare_state` or `prepare_amplitudes`\n", - "3. As the result of a numeric operation `|=`\n", - "4. With the `bind` operation (`->` in native)\n", - "5. With any function that declares its quantum variable argument as `output`\n", - "\n", - "
\n", - "\n", - "
\n", - " Types of Quantum Variables \n", - "In Qmod there are 3 types of quantum variables:\n", - "\n", - "1. `QBit` (`qbit`)\n", - "2. `QArray[QBit]` (`qbit[]`)\n", - "3. `QNum` (`qnum`)\n", - "\n", - "(See also [Quantum Variables](https://nightly.docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_variables_and_functions/))\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tutorial - State Preparation " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prepare State" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now, we will see how we can easily make arbitrary state using Classiq's `prepare_state`.\n", - "\n", - "For example, let’s say we want to prepare the state $ \\ket{\\Phi^+}=\\frac{1}{\\sqrt{2}}(\\ket{00}+\\ket{11}) $" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8f29a5a9-1ca2-4887-acc0-dee6661510d3?version=0.41.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " prepare_state(probabilities=[0.5,0,0,0.5], bound=0.01, out=x)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Or using `prepare_bell_state` in order to prepare states with relative phase:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x:Output[QArray]):\n", - " prepare_bell_state(state_num=1, q=x) # phi-" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/81f1c173-9a7d-4df3-a9eb-b5dc69091c9e?version=0.41.0\n" - ] - } - ], - "source": [ - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - "\n", - "NOTE\n", - "\n", - "\n", - "\n", - "| State Number | Bell State | \n", - "|--------------|------------|\n", - "| 0 | $ \\ket{\\phi^+}= \\frac{1}{\\sqrt{2}}[\\ket{00}+\\ket{11}] $ | \n", - "| 1 | $ \\ket{\\phi^-}= \\frac{1}{\\sqrt{2}}[\\ket{00}-\\ket{11}]$ |\n", - "| 2 | $ \\ket{\\psi^+}= \\frac{1}{\\sqrt{2}}[\\ket{01}+\\ket{10}]$ |\n", - "| 3 | $ \\ket{\\psi^-}= \\frac{1}{\\sqrt{2}}[\\ket{01}-\\ket{10}]$ |\n", - "| 4=0 | $ \\ket{\\phi^+}= ...$ |\n", - "| ... | ... | ... | \n", - "\n", - "\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now it's your turn to prepare the state $ \\ket{\\Psi^+}=\\frac{1}{\\sqrt{2}}(\\ket{01}+\\ket{10}) $" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8d827a63-de2c-4858-8057-edaa6ab7f84f?version=0.41.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " #TODO use the function prepare_state/ prepare_bell_state in order create a the desired state\n", - " prepare_bell_state(state_num=2, q=x) # phi-\n", - "\n", - "#TODO create model, synthesize it, and show it\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that we can use `prepare_state` to create much more complex states, for instance, we can create list of probabilities:" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "probabilities = [\n", - " 0,\n", - " 0.002,\n", - " 0.004,\n", - " 0.006,\n", - " 0.0081,\n", - " 0.0101,\n", - " 0.0121,\n", - " 0.0141,\n", - " 0.0161,\n", - " 0.0181,\n", - " 0.0202,\n", - " 0.0222,\n", - " 0.0242,\n", - " 0.0262,\n", - " 0.0282,\n", - " 0.0302,\n", - " 0.0323,\n", - " 0.0343,\n", - " 0.0363,\n", - " 0.0383,\n", - " 0.0403,\n", - " 0.0423,\n", - " 0.0444,\n", - " 0.0464,\n", - " 0.0484,\n", - " 0.0504,\n", - " 0.0524,\n", - " 0.0544,\n", - " 0.0565,\n", - " 0.0585,\n", - " 0.0605,\n", - " 0.0625,\n", - "]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And then generate the state:" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/812fe320-5244-4f7d-8829-d83fc7c7d777?version=0.41.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " prepare_state(probabilities=probabilities, bound=0.01, out=x)\n", - " \n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prepare Int" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also have a `prepare_int` function, which allows us to register integers effortlessly. For example, $binary(9) = 1001$, or any other integer can be prepared in a single line of code:" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a909dbba-7adc-4db9-88db-df392b39db1e?version=0.41.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum]) -> None:\n", - " prepare_int(9, x)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise: Parallel Addition " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this exercise, we will conclude state preparation and also get a teaser of the next part of the tutorial - Arithmetic Operations. \n", - "\n", - "Let's say that for some reason we used `prepare_int` to create the integer 7, and we want to perform addition operations with the integers 0, 4, and 7. We will do that using `prepare_state`." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\") #TODO complete the declarations of x,y\n", - " y = QNum(\"y\")\n", - " \n", - " # TODO prepare the above-mentioned integer using prepare_int\n", - " prepare_int(7, x)\n", - " prepare_state(probabilities=[1/3, 0,0,0, 1/3, 0 ,0, 1/3], bound=0.01, out=y) # TODO complete the 'probabilities' list\n", - " \n", - " res|=x+y\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/bc807842-7b3e-437a-84ef-f0aa2e69fa5f?version=0.41.0\n" - ] - } - ], - "source": [ - "# TODO uncomment the folllowing lines:\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tutorial - Arithmetic Operations with Classiq" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "One of the key advantages of Classiq is it's simplistic and powerful compiler for quantum arithmetic. Let's see an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "num_qubits = 4\n", - "fraction_digits = 0 \n", - "is_signed = True\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum]):\n", - " allocate_num(num_qubits=num_qubits, is_signed=is_signed, fraction_digits=fraction_digits, out=x)\n", - " hadamard_transform(x)\n", - " y|= x**2 + 1\n", - "\n", - "qmod = create_model(main)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `allocate_num` function initializes a quantum variable that represent numbers. By default, it is initialized to the $\\ket{0}$ state. Then the `hadmard_transform` creates a superposition of all possible states in the domain $[-2^3,2^3-1]$. Finally, the arithmetic operation creates the entangled superposition of states:\n", - "$\\begin{equation}\n", - "\\sum_{x =-2^3}^{2^3-1}\\ket{x}\\ket{x^2+1}.\n", - "\\end{equation}$\n", - "\n", - "The `qmod` variable is a string that captures the algorithm we have just created in a JSON format. Now, what we want is to synthesize (compile) in order to receive a concrete quantum program that contains the quantum circuit implementation." - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/af93bf3d-a459-4bfe-b057-3502afd1c9ca?version=0.41.0\n" - ] - } - ], - "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Advanced Arithmetics" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's create a general linear function with Classiq: $y= ax+b$ where $a,b$ are classical integer parameters and $x,y$ is a quantum states representing integers:" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def linear_func(a:CInt,b: CInt, x:QNum, y: Output[QNum]):\n", - " y |= a*x+b" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x:Output[QNum], y: Output[QNum]):\n", - "\n", - " a = 2\n", - " b = 1\n", - " allocate_num(num_qubits=4,is_signed=False,fraction_digits=0,out=x)\n", - " hadamard_transform(x)\n", - " linear_func(a,b,x,y)\n", - "\n", - "qmod = create_model(main)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [], - "source": [ - "qprog = synthesize(qmod)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's execute the circuit from directly from the SDK:" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [], - "source": [ - "job = execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And we can view the results in the IDE:" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [], - "source": [ - "job.open_in_ide()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Or to directly analyze it within the SDK:" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'x': 2.0, 'y': 5.0}\n", - "{'x': 6.0, 'y': 13.0}\n", - "{'x': 3.0, 'y': 7.0}\n", - "{'x': 0.0, 'y': 1.0}\n", - "{'x': 8.0, 'y': 17.0}\n", - "{'x': 5.0, 'y': 11.0}\n", - "{'x': 7.0, 'y': 15.0}\n", - "{'x': 12.0, 'y': 25.0}\n", - "{'x': 1.0, 'y': 3.0}\n", - "{'x': 11.0, 'y': 23.0}\n", - "{'x': 13.0, 'y': 27.0}\n", - "{'x': 14.0, 'y': 29.0}\n", - "{'x': 4.0, 'y': 9.0}\n", - "{'x': 15.0, 'y': 31.0}\n", - "{'x': 10.0, 'y': 21.0}\n", - "{'x': 9.0, 'y': 19.0}\n" - ] - } - ], - "source": [ - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "for sampled_state in parsed_counts: print(sampled_state.state)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Now it's your turn!** \n", - "\n", - "Implement the same linear function, but now $x$ is in the domain $[0,1)$ and is represented by 4 qubits. The parameters $a,b$ should be now `float` with the values of: $a=0.5, b=1.5$." - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def linear_func2(a:CReal,b: CReal, x:QNum, y: Output[QNum]):\n", - " y |= a*x+b\n", - " \n", - "@qfunc\n", - "def main(x:Output[QNum], y: Output[QNum]):\n", - "\n", - " a = 0.5\n", - " b = 1.5\n", - " allocate_num(num_qubits=4,is_signed=False,fraction_digits=4,out=x)\n", - " hadamard_transform(x)\n", - " linear_func2(a,b,x,y)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "job = execute(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'x': 0.0625, 'y': 1.53125}\n", - "{'x': 0.4375, 'y': 1.71875}\n", - "{'x': 0.1875, 'y': 1.59375}\n", - "{'x': 0.25, 'y': 1.625}\n", - "{'x': 0.375, 'y': 1.6875}\n", - "{'x': 0.0, 'y': 1.5}\n", - "{'x': 0.8125, 'y': 1.90625}\n", - "{'x': 0.6875, 'y': 1.84375}\n", - "{'x': 0.5, 'y': 1.75}\n", - "{'x': 0.75, 'y': 1.875}\n", - "{'x': 0.875, 'y': 1.9375}\n", - "{'x': 0.9375, 'y': 1.96875}\n", - "{'x': 0.125, 'y': 1.5625}\n", - "{'x': 0.625, 'y': 1.8125}\n", - "{'x': 0.3125, 'y': 1.65625}\n", - "{'x': 0.5625, 'y': 1.78125}\n" - ] - } - ], - "source": [ - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "for sampled_state in parsed_counts: print(sampled_state.state)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Tutorial - Two controlled Linear operations" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's say we want now to have two linear operations applied on the same quantum variable (register). But the arithmetic operation initialize a new quantum variable, so how can we do that? The answer is that we need to apply the operation to another variable and then XOR it to the variable we want. \n", - "\n", - "This can be useful if the linear operation we want to apply is controlled upon a control variable. Let's first define the functional building block:" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def inplace_linear_attempt(a:CInt,b: CInt, x:QNum, y: QNum):\n", - " tmp = QNum('tmp')\n", - " linear_func(a,b,x,tmp)\n", - " inplace_xor(tmp,y)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And checking our basic function implementation:" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f09b4bff-fba8-4d90-83a8-f4acf6543af6?version=0.41.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(x: Output[QNum],y: Output[QNum]):\n", - " a = 1\n", - " b = 2\n", - "\n", - " allocate_num(4,False,0,y)\n", - " allocate_num(4,False,0,x)\n", - " hadamard_transform(x)\n", - " inplace_linear_attempt(a,b,x,y)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "OK, cool. So now we want to add a control qubit that controlled on the state $\\ket{0}$ implements the linear function $\\ket{x}\\rightarrow\\ket{x}\\ket{x+2}$ and controlled on the state $\\ket{1}$ implements the linear function $\\ket{x}\\rightarrow\\ket{x}\\ket{2x+1}$:" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "@qfunc\n", - "def control_logic(a: CArray[CInt], b: CArray[CInt], controller:QNum, x: QNum, y: QNum):\n", - " \n", - " repeat( count=a.len, \n", - " iteration=lambda i: control(controller==i, lambda: inplace_linear_attempt(a[i],b[i],x,y)))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(controller: Output[QNum], x: Output[QNum],y: Output[QNum]):\n", - "\n", - " # Linear polynom parameters\n", - " a = [1,2]\n", - " b = [2,1]\n", - "\n", - " # Initializing x to a superposition in the domain [0,2^4-1]\n", - " allocate_num(4,False,0,x)\n", - " hadamard_transform(x)\n", - " \n", - " #Initialize y\n", - " allocate_num(4,False,0,y)\n", - "\n", - " # Setting the controller in a superposition\n", - " allocate_num(1,False,0,controller)\n", - " H(controller)\n", - "\n", - " # Implementing the control logic\n", - " control_logic(a,b,controller,x,y)\n", - "\n", - " \n", - "qmod = create_model(main)" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5ddd48f7-190b-426c-b8fd-9bde42324a91?version=0.41.0\n" - ] - } - ], - "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "By executing we can actually see we get what we want:" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'controller': 1.0, 'x': 5.0, 'y': 11.0}\n", - "{'controller': 0.0, 'x': 2.0, 'y': 4.0}\n", - "{'controller': 0.0, 'x': 13.0, 'y': 15.0}\n", - "{'controller': 0.0, 'x': 11.0, 'y': 13.0}\n", - "{'controller': 0.0, 'x': 6.0, 'y': 8.0}\n", - "{'controller': 1.0, 'x': 7.0, 'y': 15.0}\n", - "{'controller': 0.0, 'x': 12.0, 'y': 14.0}\n", - "{'controller': 1.0, 'x': 10.0, 'y': 5.0}\n", - "{'controller': 0.0, 'x': 1.0, 'y': 3.0}\n", - "{'controller': 1.0, 'x': 12.0, 'y': 9.0}\n", - "{'controller': 0.0, 'x': 15.0, 'y': 1.0}\n", - "{'controller': 1.0, 'x': 2.0, 'y': 5.0}\n", - "{'controller': 0.0, 'x': 0.0, 'y': 2.0}\n", - "{'controller': 1.0, 'x': 8.0, 'y': 1.0}\n", - "{'controller': 1.0, 'x': 11.0, 'y': 7.0}\n", - "{'controller': 1.0, 'x': 4.0, 'y': 9.0}\n", - "{'controller': 0.0, 'x': 3.0, 'y': 5.0}\n", - "{'controller': 1.0, 'x': 0.0, 'y': 1.0}\n", - "{'controller': 1.0, 'x': 15.0, 'y': 15.0}\n", - "{'controller': 0.0, 'x': 8.0, 'y': 10.0}\n", - "{'controller': 1.0, 'x': 3.0, 'y': 7.0}\n", - "{'controller': 0.0, 'x': 9.0, 'y': 11.0}\n", - "{'controller': 1.0, 'x': 13.0, 'y': 11.0}\n", - "{'controller': 0.0, 'x': 10.0, 'y': 12.0}\n", - "{'controller': 1.0, 'x': 6.0, 'y': 13.0}\n", - "{'controller': 0.0, 'x': 5.0, 'y': 7.0}\n", - "{'controller': 1.0, 'x': 1.0, 'y': 3.0}\n", - "{'controller': 1.0, 'x': 9.0, 'y': 3.0}\n", - "{'controller': 0.0, 'x': 14.0, 'y': 0.0}\n", - "{'controller': 1.0, 'x': 14.0, 'y': 13.0}\n", - "{'controller': 0.0, 'x': 4.0, 'y': 6.0}\n", - "{'controller': 0.0, 'x': 7.0, 'y': 9.0}\n" - ] - } - ], - "source": [ - "def print_parsed_counts(job):\n", - " results = job.result()\n", - " parsed_counts = results[0].value.parsed_counts\n", - " for parsed_state in parsed_counts: print(parsed_state.state)\n", - "\n", - "job = execute(qprog)\n", - "print_parsed_counts(job)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Of course there is the issue of rounding and overflow - when one tries to represent $2*15+1=31$ with $4$ binary digits that's not possible (because the domain $[0,31]$ of integers is represented by at least 5 bits). See our [documentation](https://docs.classiq.io/latest/user-guide/platform/qmod/python/quantum-expressions/#inplace-arithmetic-operators) for further explanations.\n", - "\n", - "Let's try to use Classiq and optimize the circuit for minimal circuit width:" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 20, depth: 688\n" - ] - } - ], - "source": [ - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - " \n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And when optimizing for depth:" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 32, depth: 398\n" - ] - } - ], - "source": [ - "qmod = set_constraints(qmod,Constraints(optimization_parameter='depth'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Firstly, we can see here a clear demonstration of the power of high-level functional design!** The same algorithm with the same functionality was optimized once for depth and once for width and the result is 2 different circuits with different characteristics that implement the same functionality.\n", - "\n", - "Secondly, is this the best we can do? Obviously the Classiq synthesis engine is optimizing for us the algorithm quite good. But, can we change something with our functionality, with our algorithm to get more efficient circuits? \n", - "\n", - "If we go back to out `inplace_linear_attempt` function, we can see that we initialize a `tmp` variable that requires more qubits and is not used. For such scenarios we have the `within_apply`. This logic implements sort of $UVU^{\\dagger}$ and when temporary variables are outputs of $U$ and used only by $V$ they are uncomputed by $U^{\\dagger}$. Let's see for our example:" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def inplace_linear_func(a:CInt,b: CInt, x:QNum, y: QNum):\n", - " tmp = QNum('tmp')\n", - " within_apply(compute= lambda: linear_func(a,b,x,tmp),\n", - " action= lambda: inplace_xor(tmp,y))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With the new `control_logic`:" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def control_logic_2(a: CArray[CInt], b: CArray[CInt], controller:QNum, x: QNum, y: QNum):\n", - " \n", - " repeat( count=a.len, \n", - " iteration=lambda i: control(controller==i, lambda: inplace_linear_func(a[i],b[i],x,y)))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And when we put all together now:" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(controller: Output[QNum], x: Output[QNum],y: Output[QNum]):\n", - "\n", - " # Linear polynom parameters\n", - " a = [1,2]\n", - " b = [2,1]\n", - "\n", - " # Initializing x to a superposition in the domain [0,2^4-1]\n", - " allocate_num(4,False,0,x)\n", - " hadamard_transform(x)\n", - " \n", - " #Initialize y\n", - " allocate_num(4,False,0,y)\n", - "\n", - " # Setting the controller in a superposition\n", - " allocate_num(1,False,0,controller)\n", - " H(controller)\n", - "\n", - " # Implementing the control logic\n", - " control_logic_2(a,b,controller,x,y)\n", - "\n", - " \n", - "qmod = create_model(main)" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [], - "source": [ - "qprog = synthesize(qmod)" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/1b37f533-7e54-4085-8efa-3fb61cca0a0d?version=0.41.0\n" - ] - } - ], - "source": [ - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And now when we optimize for width:" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 16, depth: 244\n" - ] - } - ], - "source": [ - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And for depth:" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 45, depth: 203\n" - ] - } - ], - "source": [ - "qmod = set_constraints(qmod,Constraints(optimization_parameter='depth'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "So using the `within_apply` logic enabled us to reduce the optimal circuit implementation in terms of width from $20$ to $16$ and the optimal circuit depth from $398$ to $203$! " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Cheat Sheet" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initalizations" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "ename": "SyntaxError", - "evalue": "invalid syntax (519441306.py, line 2)", - "output_type": "error", - "traceback": [ - "\u001b[0;36m Cell \u001b[0;32mIn[77], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m num_qubits: CInt,\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" - ] - } - ], - "source": [ - "allocate(\n", - " num_qubits: CInt,\n", - " out: Output[QArray[QBit, Literal[\"num_qubits\"]]])\n", - " '''\n", - " x = QArray('x')\n", - " allocate(4,x)\n", - " '''\n", - "\n", - "allocate_num(\n", - " num_qubits: CInt,\n", - " is_signed: QParam[bool],\n", - " fraction_digits: CInt,\n", - " out: Output[QNum])\n", - "'''\n", - "x = QNum('x')\n", - "allocate_num(4,False,4,x)\n", - "'''" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Operations" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "repeat(\n", - " count: CInt,\n", - " iteration: QCallable[CInt],\n", - ")\n", - "'''\n", - "x = QArray\n", - "allocate(4,x)\n", - "repeat(x.len,lambda index: H(x))\n", - "'''\n", - "\n", - "control(\n", - " operand: QCallable,\n", - " ctrl: QArray[QBit],\n", - ") \n", - "'''\n", - "x = QArray('x')\n", - "y = QArray('y')\n", - "x = allocate(4,x)\n", - "y = allocate(4,y)\n", - "repeat(x.len,lambda i: control(lambda: X(y[i]),x[i]))\n", - "'''" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.13" - }, - "vscode": { - "interpreter": { - "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/HW2/Stefanie_Muroya_Lei_HW2_QClass2024.ipynb b/community/QClass_2024/HW2/Stefanie_Muroya_Lei_HW2_QClass2024.ipynb deleted file mode 100644 index f0575bf6..00000000 --- a/community/QClass_2024/HW2/Stefanie_Muroya_Lei_HW2_QClass2024.ipynb +++ /dev/null @@ -1,650 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/e33741d2-bec4-4a30-bfdd-3a097fba66f8?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3),\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/78e20727-cd38-44eb-b936-633e818af4ca?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], res0: Output[QNum], res1: Output[QNum], res2: Output[QNum]) -> None:\n", - " \n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - "\n", - " res0 |= x + y\n", - " res1 |= x * y\n", - " res2 |= x * y -z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/7a0111aa-483b-4c69-9625-d15287ffceda?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y:Output[QNum], res: Output[QNum]):\n", - " prepare_state([0.5, 0, 0.5, 0], bound=0, out=x)\n", - " prepare_state([0, 0.25, 0.25, 0.25, 0, 0, 0.25, 0], bound=0, out=y)\n", - " res |= x + y\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/98539fec-c38f-4582-a004-21be7c41aa62?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "def addition(x: Output[QNum], y: Output[QNum], temp: Output[QNum]):\n", - " temp |= x + y\n", - "\n", - " \n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], res: Output[QNum]) -> None:\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " temp = QNum(\"temp\")\n", - " within_apply(lambda: addition(x,y,temp), lambda: addition(temp, z, res))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/bcf7b3b3-7383-454e-a65f-60c5f533f983?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "def addition(x: Output[QNum], y: Output[QNum], temp: Output[QNum]):\n", - " temp |= x + y\n", - "\n", - " \n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], w: Output[QNum], res: Output[QNum]) -> None:\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - " temp = QNum(\"temp\")\n", - " temp2 = QNum(\"temp2\")\n", - " within_apply(lambda: addition(x,y,temp), lambda: addition(temp, z, temp2))\n", - " res |= temp2 + w\n", - "\n", - "constraints = Constraints(\n", - " max_width=16,\n", - " max_depth=1200,\n", - ")\n", - "\n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod, constraints)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ff505abe-5784-4b24-8a6a-8d66dfb9f5bb?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], w: Output[QNum], res: Output[QNum]) -> None:\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - " res |= x + y + z + w\n", - "\n", - "constraints = Constraints(\n", - " max_width=15,\n", - " max_depth=1200,\n", - ")\n", - "\n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod, constraints)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/820a33c8-8d74-40f1-910d-bc58a9036ae0?version=0.40.0\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/dba94f6c-1abe-4d42-b0a2-8c5541c63c70?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/cdb5ffbc-00ae-4577-ac53-c16ceba55e5d?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "from math import pi\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " bound=0.0,\n", - " out=q,\n", - " )\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.13" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/HW3/Stefanie_Muroya_Lei_HW3_QClass2024.ipynb b/community/QClass_2024/HW3/Stefanie_Muroya_Lei_HW3_QClass2024.ipynb deleted file mode 100644 index 37214512..00000000 --- a/community/QClass_2024/HW3/Stefanie_Muroya_Lei_HW3_QClass2024.ipynb +++ /dev/null @@ -1,321 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [\n", - " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X], 0.1809)\n", - "]) #TODO: Complete Hamiltonian\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/660cc65e-5a89-4101-908e-3b3af9e6fc5a?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "6843dd8d-f19b-4eb4-bbef-a1b4765cd678", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.07072861328125\n", - "Optimal parameters: {'angles_0': 2.959328274164938, 'angles_1': 1.1257088647469409, 'angles_2': -3.5693364096056146}\n", - "Eigenstate: {'10': (0.11048543456039805+0j), '01': (0.10364452469860624+0j), '11': (0.9884587908709194+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "11\n", - "Optimal parameters: {'angles_0': -3.0292653800801213, 'angles_1': 0.13084292242999915, 'angles_2': -5.614248543217801}\n", - "Eigenstate: {'10': (0.07328774624724109+0j), '11': (0.07328774624724109+0j), '01': (0.9946144039274718+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class?" - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " CX(control=q[0], target=q[1])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.8515594726562499\n", - "Optimal parameters: {'angles_0': 3.0043706282977434, 'angles_1': -1.328156889572427, 'angles_2': 6.343052137377648}\n", - "Eigenstate: {'11': (0.07654655446197431+0j), '10': (0.07967217989988726+0j), '00': (0.02209708691207961+0j), '01': (0.9936320684740404+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Presentations/QClass_week1.pptx.pdf b/community/QClass_2024/Presentations/QClass_week1.pptx.pdf deleted file mode 100644 index dd8bc4bd..00000000 Binary files a/community/QClass_2024/Presentations/QClass_week1.pptx.pdf and /dev/null differ diff --git a/community/QClass_2024/Presentations/QClass_week2.pptx.pdf b/community/QClass_2024/Presentations/QClass_week2.pptx.pdf deleted file mode 100644 index c7a55ba4..00000000 Binary files a/community/QClass_2024/Presentations/QClass_week2.pptx.pdf and /dev/null differ diff --git a/community/QClass_2024/Presentations/QClass_week3.pptx.pdf b/community/QClass_2024/Presentations/QClass_week3.pptx.pdf deleted file mode 100644 index 95a85b5b..00000000 Binary files a/community/QClass_2024/Presentations/QClass_week3.pptx.pdf and /dev/null differ diff --git a/community/QClass_2024/Presentations/_QClass_week4.pptx.pdf b/community/QClass_2024/Presentations/_QClass_week4.pptx.pdf deleted file mode 100644 index 7889e7e9..00000000 Binary files a/community/QClass_2024/Presentations/_QClass_week4.pptx.pdf and /dev/null differ diff --git a/community/QClass_2024/README.md b/community/QClass_2024/README.md index 4139b473..1149e538 100644 --- a/community/QClass_2024/README.md +++ b/community/QClass_2024/README.md @@ -1,34 +1,35 @@ # Welcome to QClass 2024! -**This repository serves as our central hub for all course activities, including mastering Git & GitHub skills, submitting assignments, and accessing course materials.** +**This is our workspace for mastering Git & GitHub skills.** ## What is This Repository For? -- **Assignment Submissions:** As an initial practice in opening a pull request, we'll use this repository to submit assignments. -- **Practice and Learning:** Gain hands-on experience with Git & GitHub, crucial for collaborative software development. + +We'll use this repository to submit assignments as an initial practice in opening a pull request. ## Getting Started -If you haven't already, please ensure you fork and clone the [classiq-library](https://github.com/Classiq/classiq-library): + +If you didn't forked and clone the [classiq-library](https://github.com/Classiq/classiq-library) already, follow this: + 1. **Fork** the repo to add it to your GitHub account. 2. **Clone** your forked repository to your local machine. ## Submission: Rules & Instructions -To ensure efficient tracking and management of submissions, please adhere to the following: + +To keep track of submissions, we kindly ask you to: + 1. Complete the assignment. -2. Rename the files to include your full name, e.g., `Nadav_Ben-Ami_HW1_QClass2024.ipynb`. +2. Rename the files to include your full name, for example: `Nadav_Ben-Ami_HW1_QClass2024.ipynb`. 3. Navigate to your local clone of the `classiq-library`. -4. Access the `community/QClass_2024` folder. +4. Go to `community/QClass_2024`. 5. Place your solutions in the correct folder. -6. Use command line commands to `add`, `commit`, and `push` your changes to the remote (your fork of the `classiq-library`). -7. Create a new Pull Request (PR) from your fork to the original repository (`Classiq/classiq-library`). Ensure your PR is descriptive. -8. Confirm your submission by completing the Typeform linked in `index.md` in the submission folder. - -### Important Dates -- **Submission Deadline:** All assignments must be submitted by 10.6.2024, 7 A.M GMT+3. Note that the deadline for HW4 may be extended depending on the project specifics. +6. Use the command line to `add`, `commit`, and `push` those changes to the remote (your fork of the `classiq-library`). +7. Navigate to your GitHub repository `classiq-library` and create a new Pull Request (PR) to merge the changes from your fork to the original repository (`Classiq/classiq-library`). Make sure that your PR is well described. +8. After you are done, please let us know by submitting the Typeform (links in index.md in the submission folder). -## Certification -Upon fulfilling the course requirements, complete the following [Survey](https://fvrn0h72gwo.typeform.com/to/V2nZ8Nnn) to receive your certificate. +**Please ensure you follow these steps carefully to properly submit your assignment!** ## Support -For assistance or inquiries, please reach out on our Slack channel. -## Enjoy your learning journey at QClass 2024! \ No newline at end of file +If you need help or have questions, feel free to reach out in our Slack channel! + +## Enjoy your learning journey at QClass 2024! diff --git a/community/QClass_2024/Sessions/week 4/QNN_full_example.ipynb b/community/QClass_2024/Sessions/week 4/QNN_full_example.ipynb deleted file mode 100644 index c4b6dac9..00000000 --- a/community/QClass_2024/Sessions/week 4/QNN_full_example.ipynb +++ /dev/null @@ -1,679 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "882c596f-7a9c-4456-9ce1-b7a4cb72d10b", - "metadata": { - "id": "882c596f-7a9c-4456-9ce1-b7a4cb72d10b" - }, - "source": [ - "# Quantum Software Development Journey:\n", - "# From Theory to Application with Classiq - Part 4" - ] - }, - { - "cell_type": "markdown", - "id": "2dbea8e0-9710-4ee8-90f6-a04358d2e157", - "metadata": { - "id": "2dbea8e0-9710-4ee8-90f6-a04358d2e157" - }, - "source": [ - "**Welcome to the Classiq Workshop Series for QClass 2024!**\n", - "\n", - "In this series, we will develop the skills needed to participate in quantum software development!\n", - "\n", - "- Week 1: Classiq's Basics & High-Level Functional Design\n", - "- Week 2: Using Git as a Tool for In-Team Collaboration and Open Source Contributions\n", - "- Week 3: Introduction to Quantum Machine Learning (QML) & VQE\n", - "- **Week 4: QNN and and Advanced Applications**\n", - "\n", - "**[New Classiq's documentation](https://docs.classiq.io/latest/)!**\n", - "\n", - "\n", - "\n", - "\n", - "Additional resources you should use are\n", - "- The IDE of the classiq platform at [platform.classiq.io](platform.classiq.io)\n", - "- The [community Slack of Classiq](https://short.classiq.io/join-slack) - Classiq's team will answer any question you have over there, including implementation questions\n", - "- Course's [GitHub repository](https://github.com/Classiq/classiq-library/tree/main/community/QClass_2024)\n", - "\n", - " \n", - "**Good luck!**" - ] - }, - { - "cell_type": "markdown", - "source": [ - "## Setting The Scene" - ], - "metadata": { - "id": "p5c9gA_h9tZF" - }, - "id": "p5c9gA_h9tZF" - }, - { - "cell_type": "markdown", - "source": [ - "When running from Google Colab, we need to install Classiq's SDK and authenticate the remote device:" - ], - "metadata": { - "id": "F5A8mXw389nQ" - }, - "id": "F5A8mXw389nQ" - }, - { - "cell_type": "code", - "source": [ - "# !pip install -U classiq" - ], - "metadata": { - "id": "4oEdGj8m88xp" - }, - "id": "4oEdGj8m88xp", - "execution_count": 15, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# import classiq\n", - "# classiq.authenticate()" - ], - "metadata": { - "id": "wUz9_4419L1H" - }, - "id": "wUz9_4419L1H", - "execution_count": 16, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "If you are working locally, make sure to install PyTorch according to your operating system using the official installation [website](https://pytorch.org/)." - ], - "metadata": { - "id": "Ugp1GzuuBXQt" - }, - "id": "Ugp1GzuuBXQt" - }, - { - "cell_type": "markdown", - "id": "44ebd39d-edc7-47d6-8132-f98c662a3443", - "metadata": { - "id": "44ebd39d-edc7-47d6-8132-f98c662a3443" - }, - "source": [ - "## Intro" - ] - }, - { - "cell_type": "markdown", - "id": "a215faeb-363d-49e4-b2d9-34c945138ba0", - "metadata": { - "id": "a215faeb-363d-49e4-b2d9-34c945138ba0" - }, - "source": [ - "In this example, we will show a simple example of parametric quantum program (PQC).\n", - "\n", - "We will take 1 input from the user, and consider 1 weight, while utilizing 1 qubit in the PQC. During this example, the goal of the learning process is to assess the right angle for a Rx gate for performing a \"NOT\" operation (spoiler, the correct answer is $\\pi$\n", - ").\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "5f7de2e4-a645-44af-99a3-f3eb85473ec5", - "metadata": { - "id": "5f7de2e4-a645-44af-99a3-f3eb85473ec5" - }, - "source": [ - "## General flow" - ] - }, - { - "cell_type": "markdown", - "id": "d41dd8d0-6eca-4edc-8af5-5c5b7767008b", - "metadata": { - "id": "d41dd8d0-6eca-4edc-8af5-5c5b7767008b" - }, - "source": [ - "In [section 1](#step-1-create-our-torchnnmodule) we will see the code required for defining a quantum layer.\n", - "This will include:\n", - "\n", - "- section 1.1: defining the quantum model and synthesizing it to a quantum program\n", - "- section 1.2: defining the execute and post-process callables\n", - "- section 1.3: defining a `torch.nn.Module` network\n", - "\n", - "In section 2 we will choose our dataset, loss function, and optimizer.\n", - "Section 3 will demostrate how to handle the learning process, and section 4 will test our network's performance.\n", - "\n", - "If you're not familiar with PyTorch, it is highly recommended that you'll check out the following pages from their documentation:\n", - "\n", - "- [Creating Models](https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html#creating-models)\n", - "- [Build the Neural Network](https://pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html)\n", - "- [Optimizing the Model Parameters](https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html#optimizing-the-model-parameters)\n", - "- [Tensors](https://pytorch.org/tutorials/beginner/basics/tensorqs_tutorial.html)\n", - "- [Datasets & DataLoaders](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html)\n" - ] - }, - { - "cell_type": "markdown", - "id": "ed136231-3910-45ca-9ec6-c33f5ef428cd", - "metadata": { - "id": "ed136231-3910-45ca-9ec6-c33f5ef428cd" - }, - "source": [ - "# Step 1 - Create our `torch.nn.Module`" - ] - }, - { - "cell_type": "markdown", - "id": "dae15b1c-0d3f-4807-ae48-edfba8425962", - "metadata": { - "id": "dae15b1c-0d3f-4807-ae48-edfba8425962" - }, - "source": [ - "## Step 1.1 - Create our parametric quantum program" - ] - }, - { - "cell_type": "markdown", - "id": "5105b43a-340e-4f79-8d54-f6e898ba415c", - "metadata": { - "id": "5105b43a-340e-4f79-8d54-f6e898ba415c" - }, - "source": [ - "Our quantum model will be defined and synthesized as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "16b7cd0b-5438-4ec8-ae83-3b17b450bbe5", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "16b7cd0b-5438-4ec8-ae83-3b17b450bbe5", - "outputId": "817659cc-4556-49b3-cdf9-cc6cb33c35ee" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/9087e174-1b7d-4e73-a0ba-dc5e37ad097b?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import synthesize, qfunc, QArray, QBit, RX, Output, allocate, CReal, show\n", - "from classiq.qmod.quantum_function import create_model\n", - "\n", - "\n", - "@qfunc\n", - "def encoding(theta: CReal, q: QArray[QBit]) -> None:\n", - " RX(theta=theta, target=q[0])\n", - "\n", - "\n", - "@qfunc\n", - "def mixing(theta: CReal, q: QArray[QBit]) -> None:\n", - " RX(theta=theta, target=q[0])\n", - "\n", - "\n", - "@qfunc\n", - "def main(input_0: CReal, weight_0: CReal, res: Output[QArray[QBit]]) -> None:\n", - " allocate(1, res)\n", - " encoding(theta=input_0, q=res) # Loading input\n", - " mixing(theta=weight_0, q=res) # Adjustable parameter\n", - "\n", - "\n", - "model = create_model(main)\n", - "\n", - "quantum_program = synthesize(model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "id": "7abccf3f-59a9-4ca4-9abd-a3f73f80efc0", - "metadata": { - "id": "7abccf3f-59a9-4ca4-9abd-a3f73f80efc0" - }, - "source": [ - "The input (`input_0`), logically indicating the state `|0>` or `|1>`, is transformed into an angle, either `0` or `pi`.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "bef15105-d942-45a6-a615-7b5458241703", - "metadata": { - "id": "bef15105-d942-45a6-a615-7b5458241703" - }, - "source": [ - "## Step 1.2 - Create the Execution and Post-processing" - ] - }, - { - "cell_type": "markdown", - "id": "69875135-2a3d-4d8a-91df-ee501f01eac2", - "metadata": { - "id": "69875135-2a3d-4d8a-91df-ee501f01eac2" - }, - "source": [ - "The following example defines a function that takes in a parametric quantum program plus parameters, executes the program, and returns the result. Notes:\n", - "\n", - "1. The code can be executed on a physical computer or on a simulator. In any case, implement the execution using `execute_qnn`.\n", - "2. Post-process the result of the execution to obtain a single number (`float`) and a single dimension `Tensor`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "e86e8923-1b0a-48a3-a973-9a31773f08e6", - "metadata": { - "id": "e86e8923-1b0a-48a3-a973-9a31773f08e6" - }, - "outputs": [], - "source": [ - "import torch\n", - "\n", - "from classiq.applications.qnn.types import (\n", - " MultipleArguments,\n", - " SavedResult,\n", - " ResultsCollection,\n", - ")\n", - "\n", - "from classiq.execution import execute_qnn\n", - "from classiq.synthesis import SerializedQuantumProgram\n", - "\n", - "\n", - "def execute(\n", - " quantum_program: SerializedQuantumProgram, arguments: MultipleArguments\n", - ") -> ResultsCollection:\n", - " return execute_qnn(quantum_program, arguments)\n", - "\n", - "\n", - "# Post-process the result, returning a dict:\n", - "# Note: this function assumes that we only care about\n", - "# differentiating a single state (|0>)\n", - "# from all the rest of the states.\n", - "# In case of a different differentiation, this function should change.\n", - "def post_process(result: SavedResult) -> torch.Tensor:\n", - " \"\"\"\n", - " Take in a `SavedResult` with `ExecutionDetails` value type, and return the\n", - " probability of measuring |0> which equals the amount of `|0>` measurements\n", - " divided by the total amount of measurements.\n", - " \"\"\"\n", - " counts: dict = result.value.counts\n", - " # The probability of measuring |0>\n", - " p_zero: float = counts.get(\"0\", 0.0) / sum(counts.values())\n", - " return torch.tensor(p_zero)\n" - ] - }, - { - "cell_type": "markdown", - "id": "aa6a64b5-bdff-4e66-b16c-6ede1d69877d", - "metadata": { - "id": "aa6a64b5-bdff-4e66-b16c-6ede1d69877d" - }, - "source": [ - "## Step 1.3 - Create a network" - ] - }, - { - "cell_type": "markdown", - "id": "1937b4d5-abfa-40bd-b26e-32c93936be18", - "metadata": { - "id": "1937b4d5-abfa-40bd-b26e-32c93936be18" - }, - "source": [ - "Now we're going to define a network, just like any other PyTorch network, only that this time, we will have only 1 layer, and it will be a quantum layer." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "9731c78f-ed71-47e8-9529-dcbb7e6d0bdf", - "metadata": { - "id": "9731c78f-ed71-47e8-9529-dcbb7e6d0bdf" - }, - "outputs": [], - "source": [ - "import torch\n", - "\n", - "from classiq.applications.qnn import QLayer\n", - "\n", - "\n", - "class Net(torch.nn.Module):\n", - " def __init__(self, *args, **kwargs) -> None:\n", - " super().__init__()\n", - " self.qlayer = QLayer(\n", - " quantum_program, # the quantum program, the result of `synthesize()`\n", - " execute, # a callable that takes\n", - " # - a quantum program\n", - " # - parameters to that program (a tuple of dictionaries)\n", - " # and returns a `ResultsCollection`\n", - " post_process, # a callable that takes\n", - " # - a single `SavedResult`\n", - " # and returns a `torch.Tensor`\n", - " *args,\n", - " **kwargs\n", - " )\n", - "\n", - " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", - " x = self.qlayer(x)\n", - " return x\n", - "\n", - "\n", - "model = Net()" - ] - }, - { - "cell_type": "markdown", - "id": "a94ff1bc-58f5-4743-aa09-0cc77dcfecd6", - "metadata": { - "id": "a94ff1bc-58f5-4743-aa09-0cc77dcfecd6" - }, - "source": [ - "# Step 2 - Choose a dataset, loss function, and optimizer" - ] - }, - { - "cell_type": "markdown", - "id": "8ac9fb68-bbf5-48c1-ba7a-2af0d9219b74", - "metadata": { - "id": "8ac9fb68-bbf5-48c1-ba7a-2af0d9219b74" - }, - "source": [ - "We will use the DATALOADER_NOT dataset, defined [here](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/qml/qnn/datasets/) as well as [L1Loss](https://pytorch.org/docs/stable/generated/torch.nn.L1Loss.html) and [SGD](https://pytorch.org/docs/stable/generated/torch.optim.SGD.html)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "a5d47c00-3040-43d2-b3d6-1d5a1614a2ee", - "metadata": { - "id": "a5d47c00-3040-43d2-b3d6-1d5a1614a2ee" - }, - "outputs": [], - "source": [ - "from classiq.applications.qnn.datasets import DATALOADER_NOT\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "\n", - "_LEARNING_RATE = 1\n", - "\n", - "# choosing our data\n", - "data_loader = DATALOADER_NOT\n", - "# choosing our loss function\n", - "loss_func = nn.L1Loss() # Mean Absolute Error (MAE)\n", - "# choosing our optimizer\n", - "optimizer = optim.SGD(model.parameters(), lr=_LEARNING_RATE)\n" - ] - }, - { - "cell_type": "markdown", - "id": "b0087ab6-addd-41ac-b609-f60b0b4591cd", - "metadata": { - "id": "b0087ab6-addd-41ac-b609-f60b0b4591cd" - }, - "source": [ - "# Step 3 - Train" - ] - }, - { - "cell_type": "markdown", - "id": "ae072cf7-431f-4583-b5c7-a21be4ef56f2", - "metadata": { - "id": "ae072cf7-431f-4583-b5c7-a21be4ef56f2" - }, - "source": [ - "For the training process, we will use a loop similar to [the one recommended by PyTorch](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#update-the-weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "bab03c43-9d90-4d3b-9ece-4b2f8655be33", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "bab03c43-9d90-4d3b-9ece-4b2f8655be33", - "outputId": "2801de37-411f-4fa8-d9c7-bb9d3fa0db87" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "0 Parameter containing:\n", - "tensor([0.1470], requires_grad=True)\n", - "1 Parameter containing:\n", - "tensor([0.3423], requires_grad=True)\n", - "2 Parameter containing:\n", - "tensor([0.5132], requires_grad=True)\n", - "3 Parameter containing:\n", - "tensor([0.6474], requires_grad=True)\n", - "4 Parameter containing:\n", - "tensor([0.9892], requires_grad=True)\n", - "5 Parameter containing:\n", - "tensor([0.9282], requires_grad=True)\n", - "6 Parameter containing:\n", - "tensor([1.0137], requires_grad=True)\n", - "7 Parameter containing:\n", - "tensor([1.0747], requires_grad=True)\n", - "8 Parameter containing:\n", - "tensor([1.5386], requires_grad=True)\n", - "9 Parameter containing:\n", - "tensor([2.1977], requires_grad=True)\n", - "10 Parameter containing:\n", - "tensor([2.8691], requires_grad=True)\n", - "11 Parameter containing:\n", - "tensor([3.0522], requires_grad=True)\n", - "12 Parameter containing:\n", - "tensor([3.0034], requires_grad=True)\n", - "13 Parameter containing:\n", - "tensor([3.1743], requires_grad=True)\n", - "14 Parameter containing:\n", - "tensor([3.1499], requires_grad=True)\n", - "15 Parameter containing:\n", - "tensor([3.1499], requires_grad=True)\n", - "16 Parameter containing:\n", - "tensor([3.1499], requires_grad=True)\n", - "17 Parameter containing:\n", - "tensor([3.1499], requires_grad=True)\n", - "18 Parameter containing:\n", - "tensor([3.1499], requires_grad=True)\n", - "19 Parameter containing:\n", - "tensor([3.1499], requires_grad=True)\n" - ] - } - ], - "source": [ - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from torch.utils.data import DataLoader\n", - "\n", - "\n", - "def train(\n", - " model: nn.Module,\n", - " data_loader: DataLoader,\n", - " loss_func: nn.modules.loss._Loss,\n", - " optimizer: optim.Optimizer,\n", - " epoch: int = 20,\n", - ") -> None:\n", - " for index in range(epoch):\n", - " print(index, model.qlayer.weight)\n", - " for data, label in data_loader:\n", - " optimizer.zero_grad()\n", - "\n", - " output = model(data)\n", - "\n", - " loss = loss_func(output, label)\n", - " loss.backward()\n", - "\n", - " optimizer.step()\n", - "\n", - "\n", - "train(model, data_loader, loss_func, optimizer)" - ] - }, - { - "cell_type": "markdown", - "id": "61fa4f83-8bd2-4290-9ca4-f6c5c1ca0e32", - "metadata": { - "id": "61fa4f83-8bd2-4290-9ca4-f6c5c1ca0e32" - }, - "source": [ - "# Step 4 - Test" - ] - }, - { - "cell_type": "markdown", - "id": "7533b162-6214-4606-9e66-ec3332a2f446", - "metadata": { - "id": "7533b162-6214-4606-9e66-ec3332a2f446" - }, - "source": [ - "Lastly, we will test our network accuracy, using [the following answer](https://stackoverflow.com/questions/52176178/pytorch-model-accuracy-test#answer-64838681)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "010caccd-d1ca-4aac-88a4-d115a63c7c7d", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "010caccd-d1ca-4aac-88a4-d115a63c7c7d", - "outputId": "36e7fdd7-5bdf-4050-f8c4-a929c719e8b8" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Test Accuracy of the model: 100.00%\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "1.0" - ] - }, - "metadata": {}, - "execution_count": 22 - } - ], - "source": [ - "def check_accuracy(model: nn.Module, data_loader: DataLoader, atol=1e-4) -> float:\n", - " num_correct = 0\n", - " total = 0\n", - " model.eval()\n", - "\n", - " with torch.no_grad(): # Temporarily disable gradient calculation\n", - " for data, labels in data_loader:\n", - " # Let the model predict\n", - " predictions = model(data)\n", - "\n", - " # Get a tensor of booleans, indicating if each label is close to the real label\n", - " is_prediction_correct = predictions.isclose(labels, atol=atol)\n", - "\n", - " # Count the amount of `True` predictions\n", - " num_correct += is_prediction_correct.sum().item()\n", - " # Count the total evaluations\n", - " # the first dimension of `labels` is `batch_size`\n", - " total += labels.size(0)\n", - "\n", - " accuracy = float(num_correct) / float(total)\n", - " print(f\"Test Accuracy of the model: {accuracy*100:.2f}%\")\n", - " return accuracy\n", - "\n", - "\n", - "check_accuracy(model, data_loader)" - ] - }, - { - "cell_type": "markdown", - "id": "0bc93c12-6643-4623-9ce5-7984ba5ff429", - "metadata": { - "id": "0bc93c12-6643-4623-9ce5-7984ba5ff429" - }, - "source": [ - "**The results show that the accuracy is $1$**, meaning a 100% success rate at performing the required transformation (i.e. the network learned to perform a X-gate). We may further test it by printing the value of `model.qlayer.weight`, which is a tensor of shape (1,1), which should, after training, be close to $\\pi$" - ] - }, - { - "cell_type": "markdown", - "id": "eb4ce7b7-3410-491e-aaff-430b61f67157", - "metadata": { - "id": "eb4ce7b7-3410-491e-aaff-430b61f67157" - }, - "source": [ - "# Summary" - ] - }, - { - "cell_type": "markdown", - "id": "fadd4057-34e8-4103-8aca-a13026fea660", - "metadata": { - "id": "fadd4057-34e8-4103-8aca-a13026fea660" - }, - "source": [ - "In this example, we wrote a fully working Quantum Neural Network from scratch, trained it, and saw its success at learning the requested transformation.\n", - "\n", - "In section 1 we defined our parametric quantum program, as well as our execution function. Together, these two are sent as arguments to [the QLayer object](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/qml/qnn/qlayer/). In section 2 we set some hyperparameters, and in section 3 we trained our model. Section 4 helped us verify that our network is working as intended." - ] - }, - { - "cell_type": "markdown", - "source": [ - "# Advanced Application: Quantum Auto-Encoder" - ], - "metadata": { - "id": "EhRpt6iTcmYC" - }, - "id": "EhRpt6iTcmYC" - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "2t_yTMCu-ngV" - }, - "id": "2t_yTMCu-ngV", - "execution_count": null, - "outputs": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.8" - }, - "colab": { - "provenance": [] - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/community/QClass_2024/Sessions/week 4/quantum_autoencoder.ipynb b/community/QClass_2024/Sessions/week 4/quantum_autoencoder.ipynb deleted file mode 100644 index e2a97a9e..00000000 --- a/community/QClass_2024/Sessions/week 4/quantum_autoencoder.ipynb +++ /dev/null @@ -1,1567 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "## Setting The Scene" - ], - "metadata": { - "id": "-0f46r38ypTZ" - }, - "id": "-0f46r38ypTZ" - }, - { - "cell_type": "markdown", - "source": [ - "When running from Google Colab, we need to install Classiq's SDK and authenticate the remote device:" - ], - "metadata": { - "id": "YnCW9MSjyvEu" - }, - "id": "YnCW9MSjyvEu" - }, - { - "cell_type": "code", - "source": [ - "# !pip install -U classiq" - ], - "metadata": { - "id": "EQ3Hd32IyjCn" - }, - "id": "EQ3Hd32IyjCn", - "execution_count": 69, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# import classiq\n", - "# classiq.authenticate()" - ], - "metadata": { - "id": "jBUGnP8ky0h3" - }, - "id": "jBUGnP8ky0h3", - "execution_count": 70, - "outputs": [] - }, - { - "cell_type": "markdown", - "id": "88da6df0", - "metadata": { - "id": "88da6df0" - }, - "source": [ - "# Short introduction" - ] - }, - { - "cell_type": "markdown", - "id": "201ce387", - "metadata": { - "id": "201ce387" - }, - "source": [ - "### Classical encoders:\n", - "Refer to encoding/compressing classical data into a smaller sized data via deterministic algorithm. For example, JPEG is essentially an algorithm which compresses images into a smaller sized images.\n", - "\n", - "### Classical auto-encoders:\n", - "One can use machine-learning technics and train a variational network for compressing data. In general, an auto-encoder network looks as follows:\n", - "\n", - "
\n", - "\n", - "![Autoencoder_structure.png](data:image/png;base64,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)\n", - "\n", - "\n", - "The network has three main parts: (1) The encoder part that compresses the data into a smaller, coded layer (2). The latter is the input to a decoder part (3). Typically, training is done against the comparison between the input and the output of this network.\n", - "\n", - "**Classical auto encoders can also be used for anomaly detection (see below).**" - ] - }, - { - "cell_type": "markdown", - "id": "5be9dbfd", - "metadata": { - "id": "5be9dbfd" - }, - "source": [ - "### Quantum auto-encoders:\n", - "In a similar fashion to the classical counterpart, quantum auto-encoder refers to \"compressing\" quantum data stored initially on $n$ qubits into a smaller quantum register of $m\n", - "\n", - "![Autoencoder_structure.png]()\n", - "\n", - "
Quantum auto encoder layout: uncoded data of size 5 transforms into two outputs, a coded register of size 3 and trash outputs of size 2 at state $|00\\rangle$
\n", - "
-->" - ] - }, - { - "cell_type": "markdown", - "id": "e40c41f0", - "metadata": { - "id": "e40c41f0" - }, - "source": [ - "# Training of quantum auto encoders\n", - "\n", - "To train a quantum auto encoder one should define a proper cost function. Below we propose two common approaches, one using a swap test and the other uses Hamiltonian measurements. We focus on the swap test case, and comment on the other approach at the end of this notebook.\n", - "\n", - "## The swap test\n", - "\n", - "The swap test is a quantum function which checks the overlap between two quantum states: the inputs of the function are two |quantum registers of the same size, $|\\psi_1\\rangle, \\,|\\psi_2\\rangle$, and it returns as an output a single \"test\" qubit whose state encodes the overlap between the two inputs: $|q\\rangle_{\\rm test} = \\alpha|0\\rangle + \\sqrt{1-\\alpha^2}|1\\rangle$, with\n", - "$$\n", - "\\alpha^2 = \\frac{1}{2}\\left(1+|\\langle \\psi_1 |\\psi_2 \\rangle |^2\\right).\n", - "$$\n", - "Thus, the probability to measure the test qubit at state $0$ is 1 if the states are identical (up to a global phase), and 0.5 if the states are orthogonal to each other.\n", - "\n", - "The quantum model starts with an H gate on the test qubit, followed by swapping between the two states controlled on the test qubit, and a final H gate on the test qubit:\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - "\n", - "\n", - "
\n", - "\n", - "![swap_test_closed.png](data:image/png;base64,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)\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "![swap_test_opened.png](data:image/png;base64,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)\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - "
Closed (left panel) and opened (right panel) visualization of the swap test algorithm
\n", - "\n", - "
" - ] - }, - { - "cell_type": "markdown", - "id": "443577d1", - "metadata": { - "id": "443577d1" - }, - "source": [ - "## Quantum neural network for quantum auto encoder\n", - "\n", - "The quantum auto encoder can be built as a quantum neural network, having the following three parts:\n", - "\n", - "1. A data loading block that loads classical data on $n$ qubits.\n", - "2. An encoder block which is some variational quantum ansatz; input port of size $n$ and output ports of size $m$ and $n-m$.\n", - "3. A swap test block between the $n-m$ trash output of the encoder and new $n-m$ zero registers.\n", - "\n", - "We train the network such that the test qubit of the swap test is at state |0⟩ with probability 1.\n", - "
\n", - "\n", - "![qae_qlayer.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABYkAAAHYCAYAAAAI1mdtAAAKqmlDQ1BJQ0MgUHJvZmlsZQAASImVlwdQk9kWgO///+kktIQISAm99xZASuihSwcbIQkQSoyBoCI2ZHEF1oKKCCgrsiig4KoUWQtiwbYoWEBFF2QRUdfFgqhY3g8MYXffvPfmncyZ++XktHvn3pkTACg0jkiUBssDkC7MFIf5ejBiYuMY+BEAAQQQAQHocrgZIlZoaCBAZXb9u7y/h3qjcttsKte///5fRYHHz+ACAIWinMDL4KajfBLVV1yROBMApBq166zMFE3xFZRpYrRBlPunOGmGx6Y4YZoxmGmfiDBPlJUBIJA5HHESAGRd1M7I4iahecheKFsKeQIhyuh34JqevpyHMloXGKI+IpSn8jMT/pIn6W85E6Q5OZwkKc/sZVoIXoIMURpn9f95HP9b0tMkszX0USUni/3C0JWOnllf6vIAKQsTgkNmWcCb9p/mZIlf5CxzMzzjZpnH8QqQxqYFB85yosCHLc2TyY6YZX6Gd/gsi5eHSWslij1Zs8wRz9WVpEZK7cl8tjR/dnJE9CxnCaKCZzkjNTxgzsdTahdLwqT984W+HnN1faR7T8/4y34FbGlsZnKEn3TvnLn++ULWXM6MGGlvPL6X95xPpNRflOkhrSVKC5X689N8pfaMrHBpbCZ6IediQ6VnmMLxD51l4AW8QSD6YYBQYA0cULUGaLeZ/FVTdxR4LhetFguSkjMZLPSV8RlsIdfclGFtaW0DwNSbnbkSb/um3yJEJ8zZhGh/dlNn3ztn4xkAcAqNpJrO2XTRe6VQBMA5Y65EnDVjm3pOAAtIQA7QgArQADrAEJihndkDZ+COduwPQkAEiAVLARckg3QgBitBDtgI8kEh2A52gzJQCQ6Cw+AoOA5awGlwHlwG18EtcBc8BANgGLwAY+A9mIQgCA9RICqkAmlCepAJZA0xIVfIGwqEwqBYKB5KgoSQBMqBNkGFUDFUBh2AaqGfoVPQeegq1A3dhwahUegN9AlGYDJMg9VhfdgCZsIsOACOgJfASfAKOBvOg7fCpXAVfARuhs/D1+G78AD8Ah5HACKD0BEtxAxhIp5ICBKHJCJiZB1SgJQgVUgD0oZ0IreRAeQl8hGDw1AxDIwZxhnjh4nEcDErMOswRZgyzGFMM+Yi5jZmEDOG+YqlYNWwJlgnLBsbg03CrsTmY0uwNdgm7CXsXeww9j0Oh6PjDHAOOD9cLC4FtwZXhNuHa8S147pxQ7hxPB6vgjfBu+BD8Bx8Jj4fvxd/BH8O34Mfxn8gyBA0CdYEH0IcQUjIJZQQ6ghnCT2EEcIkUZ6oR3QihhB5xNXEbcRqYhvxJnGYOElSIBmQXEgRpBTSRlIpqYF0idRPeisjI6Mt4yizUEYgs0GmVOaYzBWZQZmPZEWyMdmTvJgsIW8lHyK3k++T31IoFH2KOyWOkknZSqmlXKA8pnyQpcqay7JlebLrZctlm2V7ZF/JEeX05FhyS+Wy5UrkTsjdlHspT5TXl/eU58ivky+XPyXfKz+uQFWwUghRSFcoUqhTuKrwTBGvqK/orchTzFM8qHhBcYiKUHWonlQudRO1mnqJOkzD0QxobFoKrZB2lNZFG1NSVLJVilJapVSudEZpgI7Q9elsehp9G/04/R790zz1eax5/Hlb5jXM65k3oTxf2V2Zr1yg3Kh8V/mTCkPFWyVVZYdKi8ojVYyqsepC1ZWq+1Uvqb6cT5vvPJ87v2D+8fkP1GA1Y7UwtTVqB9VuqI2ra6j7qovU96pfUH+pQddw10jR2KVxVmNUk6rpqinQ3KV5TvM5Q4nBYqQxShkXGWNaalp+WhKtA1pdWpPaBtqR2rnajdqPdEg6TJ1EnV06HTpjupq6Qbo5uvW6D/SIeky9ZL09ep16E/oG+tH6m/Vb9J8ZKBuwDbIN6g36DSmGboYrDKsM7xjhjJhGqUb7jG4Zw8Z2xsnG5cY3TWATexOByT6TblOsqaOp0LTKtNeMbMYyyzKrNxs0p5sHmueat5i/stC1iLPYYdFp8dXSzjLNstryoZWilb9VrlWb1RtrY2uudbn1HRuKjY/NeptWm9e2JrZ82/22fXZUuyC7zXYddl/sHezF9g32ow66DvEOFQ69TBozlFnEvOKIdfRwXO942vGjk71TptNxpz+dzZxTneucny0wWMBfUL1gyEXbheNywGXAleEa7/qj64CblhvHrcrtibuOO8+9xn2EZcRKYR1hvfKw9BB7NHlMeDp5rvVs90K8fL0KvLq8Fb0jvcu8H/to+yT51PuM+dr5rvFt98P6Bfjt8Otlq7O57Fr2mL+D/1r/iwHkgPCAsoAngcaB4sC2IDjIP2hnUH+wXrAwuCUEhLBDdoY8CjUIXRH6y0LcwtCF5QufhlmF5YR1hlPDl4XXhb+P8IjYFvEw0jBSEtkRJRe1OKo2aiLaK7o4eiDGImZtzPVY1VhBbGscPi4qriZufJH3ot2LhhfbLc5ffG+JwZJVS64uVV2atvTMMrllnGUn4rHx0fF18Z85IZwqzngCO6EiYYzryd3DfcFz5+3ijfJd+MX8kUSXxOLEZ0kuSTuTRpPdkkuSXwo8BWWC1yl+KZUpE6khqYdSv6VFpzWmE9Lj008JFYWpwovLNZavWt4tMhHliwZWOK3YvWJMHCCuyYAylmS0ZtLQ4eiGxFDynWQwyzWrPOvDyqiVJ1YprBKuurHaePWW1SPZPtk/rcGs4a7pyNHK2ZgzuJa19sA6aF3Cuo71Ouvz1g9v8N1weCNpY+rGX3Mtc4tz322K3tSWp563IW/oO9/v6vNl88X5vZudN1d+j/le8H3XFpste7d8LeAVXCu0LCwp/FzELbr2g9UPpT9825q4tWub/bb923Hbhdvv7XDbcbhYoTi7eGhn0M7mXYxdBbve7V62+2qJbUnlHtIeyZ6B0sDS1r26e7fv/VyWXHa33KO8sUKtYkvFxD7evp797vsbKtUrCys//Sj4se+A74HmKv2qkoO4g1kHn1ZHVXf+xPyptka1prDmyyHhoYHDYYcv1jrU1tap1W2rh+sl9aNHFh+5ddTraGuDWcOBRnpj4TFwTHLs+c/xP987HnC84wTzRMNJvZMVTdSmgmaoeXXzWEtyy0BrbGv3Kf9THW3ObU2/mP9y6LTW6fIzSme2nSWdzTv77Vz2ufF2UfvL80nnhzqWdTy8EHPhzsWFF7suBVy6ctnn8oVOVue5Ky5XTl91unrqGvNay3X768037G40/Wr3a1OXfVfzTYebrbccb7V1L+g+2+PWc/621+3Ld9h3rt8Nvtt9L/JeX+/i3oE+Xt+z+2n3Xz/IejD5cEM/tr/gkfyjksdqj6t+M/qtccB+4Myg1+CNJ+FPHg5xh178nvH75+G8p5SnJSOaI7XPrJ+dHvUZvfV80fPhF6IXky/z/1D4o+KV4auTf7r/eWMsZmz4tfj1tzdFb1XeHnpn+65jPHT88fv095MTBR9UPhz+yPzY+Sn608jkys/4z6VfjL60fQ342v8t/ds3EUfMmR4FEFThxEQA3hwCgBKLzg63ACAtmpmppwWa+R8wTeA/8czcPS32ANS1AzA1VoW4A7APVT2U5TcAEIpyhDuAbWykOjv/Ts/qUyJ/BAAPd4/w8MBHOZg+8A+ZmeP/0vc/VyDN+rf1X9jVAtADvBolAABAAElEQVR4Aex9B5wlVZ317dc9PTCphwGGODMgQUCCkgTMYRd0DbArJgwgwbC7rrtrQPfb/dD9/Pb7rbCGFVHCktQlGVaRqIiiosKgoICAIGmAISPIDMxM93fO+d9br173657unp7U71T3q7p164aqc88/3H/Vq9c1f/6CgZTwn5cubbtSP/IiHQe6UKS/0YW8KD4wgDQzsXDdQJp5WiIDFZBgPmrV22JeF8pGbR6JFOtGOfdv/M2/usxQ1Cx/1j/WvxAE/tv+2P5SKWLh2v6H/S/7n9ljCIGw/+35h+dfnn/CPnr+rSjDQPgL9fhDZOV8+BGOP9CjasZfuroyIoCozD81C1Osp5+FW/yvAQJKOBErWpvxn67uxpD+y7UMILo1OP6k88Zpe/w5os3x5x4Xxx+a/Ce/O2n+2TV//nyKNK67ZkooKXCwKFTSBSrBUs2F5Rs83uYYW+tKDaypRIrYIUlwIbvNbFaO4+7f+FeujPln+bP+sf61/bH9pS1o42PY/7D/Zf/T/rfnH9CPQxbPvzz/9Py7XfyhX9EuCIzCDu3jD/QtVjX+gSgpOll78Y/x9N/o4jljGWH+3Qy0hv/RzxtxQxbmNa+fAdgC9+qI/5Rzap5Ga//Mp69Qjz9pjOVY6syQGhp/Yb3xxr/q1892Vuf1s/3WZej1u38gBFhWB/9asefe5MK/a/48BInBoHhGjxdXExfkD0AJyBlnmk9vSZgCBskdq6hWiIV2yUjoR+qccOJYi93wKA9yyXk5y/0HHkS2UlfG3/yz/Fn/5GCp9a/tD60ELajMJu2DDG7s0y3XLgvY/tr/sP9l/zMrBPvfnn94/iWrCePIxfNP6YQMSafNvxm41KWvtevPPtx60j8mYSPGf/qB59j8zzVz/RFvyrIeIx7in+U/nnZmqSjDs1oz8Zc1c/3Dx9/cv+UfvB+l/pHQDKh01GhAYCIT4lI9zRVOFoWpLAO8UZYXVS+ChmZ4B6Z89YCvpWBAmWFkbpTPPKQjn+XZt/unujL+IguJYv5Z/vLdXOsfujHWv1k30FrY/gCFWGx/iUN29O1/2P+CmrD/SUGgj00/ivJh/5sweP5BUtCXIDfIC2Di+RdRwMfzr06Yf3Yh6MmH3xp8habmWBz7NTn+ZJropl7XvPyN3D8x4fk1Ggj98tURnIvjTIebf5AzXXwqEEVZZuXxn5H7JzTjmf+X/nXOagP9jGD/yvgzwh26cE3J/+q5ft36AI3XFv7un+BPLvy7+2b3HUenKQxDvhdEh0ESg1wkY8Wvr+j6M7uRpv5QrjQDVQMLl3+kmMZHFbFCkp/oK+ejDfdv/M0/CoflT8rC+if0JjWlVCpX1r8yI0BCdgQb25/CCugO/YssOc0NM/ERcFghyY/tbwaCuNj/sP9l/zfrBPsf9j9oJ/ihjrT/Yf+LPkMYSq75kR/BNNTFpJn/k+8Icup3lnBdESRt0D2Qj9CVuuO6VYyeFRIMNPM46qo8cGKglAFo/ukVB/o6da7KPlinyBarKgDL7HWrf14TL3z8/F871y+kCSWx5ZrXIeJiFZm8Kh1VPgawHn/y+AMn8z/kGUB0qvzX9V93X9/s4ygyqSH1D7nJioG7WZYoaBK4KosHUS4q6hhzqvtMvI3BfbSZi2Av8pTPFXtSA7ll919QCcVs/M0/iow+lj/rn9CfQQnrX9sf21/7H3QZOOWJ2/P2v7KVsP8ZvqT975h1RCRHmHBF6+n5h+dfnn+GNynP0vPvohU8/45gjuffIR7AwfNvz7+lJSMcIw+ic+ZfMA3QCGElpCS7uvgyQyR1CylrC2z0FS26VjmwK1cr5+vXIksVtqI7akpwpfcj8usUATMO6zj32Lv7N/4kiTx5cMP8s/yBDtY/0o91PUspsf6VcQpsbH9kl21/8WvVYIRUBoVE/oUSXNn/gEm1/2X/0/53qAPPPyALmsd5/uX5p+ffnn9TL3r+TRQcf3D8pTmZgG5kfDLPM8mPTpx/d82fP09WgnBwkkXfgWmk8AcTiox4HD8O4pt5rQs9Tx7ihseKJ5pLcRe0q7LZh9z1akYXlbTGyv0bf3KBjDH/LH/WP9a/tj/8fk8YR9tfGYfmyv6H/S+KBhhh/1NuU1M28q79b88/yrTM8y/PPz3/hjQ4/pDtBGfbnGkHJI6/OP5CLpATjr84/sL4S/N1E6ErJCH8tl7lVJAv9L6z9mgeKyVYgEuzUrNMCJweVUcbA3z/Ti4aidhRrvsP0IFDHb/Axvibf2BCCzeyLFWChP2cVedPiBXrWv6sfzJB8iaoI+1cFPUgjmVKWf8DCMoQ/rEJ+FpABJTVgVqZAiuOWf5s/+3/FJVTWS3KjSQpDNUgGcuyZv0DIKhD8F+pGaHWgmNWTLUyqhIIW/9Y/1j/WP8QgRbVYf0rOGx/ghctNsb2N7gBUGx/7X+0yEaLEg2lmrOaPtrk8L/0JqK4s5iNBy5UXzygYw6vlGsKiK4fK275yUd4NC9EMJJ8Y4DSQEv1sKsXIefj1V08Oq4qWmsYSfdPUAIZQWb8zT9QgiBQnvix/BVlQmC4YD9nWf8EHIwWkCtcrH+BRaFMSdj+2P5CNuz/1AwLkva/SAoqC/u/Upn2P8OO1sTE/lcxphATLdjPWfa/AAixsP9l/zOEw/43bUhRGSVh/zvUBKUE/+Vj/4u6Uwo0TIr9j9CjNZqsSf8D7+6PwZAuQ3C32tMvfcbXEHiMcV8eZdiB40dOxwgykRdl4hhDz0iX9+DxgthuroXGIAYYeH7cf4V4vDsRKAkr4y/DGrwx/yx/1B/WP9a/tj+2v9mTKMaBqoGL/Y+Awf6XuGD/U7c/5H2HqGQBsf+tuYfnH55/ef5JzZANqef/QkJoeP7t+TfiU1kyHP+SZ+n5dyfOvxsDdBi5UBoYuy1SwZmo0oSlzL8oNPiTr4mDKp8dT7aRl34W4D8+bKIpamoQGbRGkXb/xl+0IR3MP8tfVhHSD0pb/1DD8hOa1PrX9odcgHDY/kJfhmQQkbLY/wAm/MeHKtT+V2VUgiL2P+1/e/4hWfD8y/OvIALWnn95/lWZSiSU9vyLHiY/4Ul5/uX5F7kA4eiQ+Vc8SVykANcdd1YpDwoHa4LBVCgMYgOlgfJUHYojl7rNAiFQVDD8aAkRY5JZ+mVdHcOdCUalSxtMlii1+wdWvHMT4yDgBKDxN/8sf9Y/1r+2PzLHYT+bBsL2tzga8jG4Y/+DKHAhJPa/wAdxw/6n/W9OOigUIRyef2Sl6fkXVITnX55/ev5NBMJeUkc6/uD4A82l55+dMv+MH02XBoiJFH/Nruk15busJEQcxqFQGDSfNCDSHrorjwKoG3/RBH+VnosMTa6vWnyQWJKG9lEk2okC7p84lI/xF4HIkMwf88/yR51h/WP9a/tD+0ph4BYK0vYXKPAv4LD/QV6Ef1Xsp/0vaA37n/a/Pf+AYvD8y/PPsA9cc/H8mziUj+ffIgXwKP6D59/0t/nv+ZfnX/SvSQZuoTMm6fyru29233FB+FAHvGb6T7r4nKVdpqtEHIjpWCgQHhqAJuF74Ljlvp5Y4XYglC3jy3FAT2pjJ/bdf+AlPIy/+Sc5o7DEUoldlSj5kjIZcKYsf9Y/1r+2P7a/9j9kGcKRs/9l/1MOg/1vwBAuE78pGgv2Pf/w/IO00OL5l+dfIoPnX0UkKtmoEnEke1mefwIXQuP5t+ffk3H+3d3X13dcJfuYVIRq5JoPGUMN4CC3XDe4ZdScd6CZxU/ZIK3HkpHZyPlxnOWjHO9G6UHk7K22FFND7t/4kwjmn+XP+sf61/bH9tf+h/0veor2P+1/gweef2AS5fmX5pR5AqkNVp5/ct7k+bfjD5xDY5FgOP7i+FPQwfE3xx/HE3/tmj9/fsQlpVP49plsecPeYC/n5f28UfC4H1/bK5PYLjpvvD3PAi0L20NBtst/HFcfChQju1a+6ov1ma8q7l94ZTzyxviDG+YfRAQ4kB+WP0iG9U+LPqUalRK1/g0cbH9sf6Em7H9kQaB6oEORF/tf9n8lG+RDdjQrTuT9vLH/af/T/rfnv55/eP7l+afn344/TOL4J8MqEUegX8jXRZR9Kb88oVK0lhOLKIoNysKdzGVUCy0Rp/qkg01FC7ldFYg8Jvkj01rYIBb3b/zNPwgC5SHLVkzasENhi38dtvxZ/1j/hrmx/YHWtP21/2H/y/6nHCh602WhB2H/W7B4/pFJgZshAMTzrwwH/Gounn96/ik9QT7gw7TnXxkMzz89/wYVMhugKz3/7pT5dwSJq+Aw3UkQQZoyCEE1GbuI6OYHgmlM8aUWqdD4agdqoRDrKpjV3GFOfmdN0EvPaiBJcxQvyY8C6gOoq5T7F27Ckzhpz/ibfyACSGH5s/6x/rX9odG1/aVxpFLUGitazWqHB+1/AJLsWQGZcO7tf9n/tP9NXREKQj625x+ef4EOnv9KKsQF2lLPP4mH59+ef1M5QCIc/wIMnn9RN3bC/AvvJJ51HFVguEswBxAA7chSMjemF8qkgDAnCiOdE2wAe9wvpaOgDiCP7SINRClg0QEyVJ0HclLlkKkizI+yKsY0/pUbGUjnhFpw/8bf/LP8VcqhKBVoCWgNKg7rH+tf259sVyEQEhUKRhEVygkymW/7n1EpGjVwIVr2fwACFvtfEqAAA2jY/7L/VbSF/I1MD/sftCsQE/tf9r/sf0EQqBggENIPFIycZJ79rwDD/mdmRbEoIAv+yRb7n5QYYiEBih3s2f9aPf4XbgcUoEW/aje+mcVjAF9FolwhKEemEfoNKR6Lewsqz4NRXIl+7LAeH1Fv6DtOHFB0rfqloPsXaBkO419IZP5Z/goXICFFXSDL+oe4cCEo1r+8t237Q9uKpZKTLjwAYvtr/8P+l/1P+9+ef/DroJ5/ef7p+Xero+T4g5xGxx/oPSNWxTXBcPzB8YfCBTCimld1TvxB8+oQCP42rCRDQPBGju6AEx+l6Vxk4cl3u4I8ODhQO4Yyce+DbfEY4vtAlnshcoFy1XZpE0Fj90+UgojG3/yrZAS0YKiHi2TV8idlYv0jRlj/2v40dQNStr/hadj/sP9l/9P+t+cfnn95/imXGXNsz7/pLFVzK6Qd/yAijr84/uT4EyWBgWDH35o6UkFiRceBSiMbkHglBKdYNChhVEifYmj5iwdUrARSiPLFHLkolS//NFHNwawSRFYZ1lNLqJsX9w8gjL/5JwGh01JkLgsV6EFRk7hRZix/1j/UoyIEOGL9S6Oij+2P7a/9D/tf9j+hEO1/h13INxE9/wgn0vMvOk7NxfNPYOH5p+efnn9KKXj+zckU4w15UqW04w+dGn9BkDgI0YWobz+sZQCBNd8fBcNBZ5vHWI7GNEpjW/ijby+hHIqwlL7amknVpSiGasYrK1gG9SryqbFo0f0bf/PP8heaBmvrH+tf2x/bX/sf9r/sf9r/9vzD8y9MFWO26Pmn599Sifo9OT4x4viD4y+OPzn+5vijHo+IOO5ExV8XLJg/0A/pUtN0xosVhg6Ox/UigwKoVJVggdqC6C8NF5/iUUm1xRrc5wZpvY+45Klw6kKY2v0TMeIBrAhPWSoMA0UdMv6tGFVYmX+WP8qJ9Y8EpNId1r9SEbY/oAXv6NKKFBnBnu2v/Q/Qwf6H/S/7nxKE4lFmfzwc8qwxK9XZLJRTnv94/kcVUtlWcqnYWppcpG1/AUTBRGDZ/7D/Zf/L/pf9T+rFdTT+16jOi1/Joh0rPg+3MHJ0jpSZvSTZvVxKEwsclmFE1BrPwmpPVdSQaqs+n0qWoVRzuRfWQXYUdf8EIiOTcTf+YhBBYYL4CKBAyfwLHCx/VCLWP9a/tj+hKIuelPaU3rT9BRacqMuMxFY6g6qDmfZ/BERGxv6HiGL/SxqEpGACW/tfIgZXgCOkxf4Xlaj9L/tf9r/sf8liZDsRaapJ+5/Awv5ni920/w2bSdNJVNbh+QfuY+WF77XEoldB8MRjNy4Auj8f1kWxFC9NRhHlGvjj0oVtvEpCblO+ehwoQOQ2CUy8yqLZfenA/QMk42/+Wf6yTsHG+qeoR+tfmh4qSNsfoADBsP21/2H/i0rB/qf9b+hEOk6ef8hMZh+S5lLJvO/5l+efnn9TUzj+IMPJleM/gsLxJxgJ2otsK7Tx/LuIR0fOv7v7+mYdR+mQwgQ59K2YQhCFuaFI876kKOtVZeU7IywgpwTlG2RXKV/IxoN8khj5FML4y31FTeShYRRx/4Ap46d3QfP7wAVPDoDxFw0FifknLEgQihg1mOUPzCjyQpXDNMGx/hEu1r+2P7a/RCD7GvY/gARVg/0v+5/2vz3/yD4TdYLnfwDB86/Kn6ah8PyTKAQknn8KC6Lh+Seg8Pzb8YdJGP/smj9/Pm67Y8rUgJhL0kPuFVfJKkB3HVFGDhTuKkhDluBLLsPN0KxmTqS4jga0Xzpx/8bf/LP8Wf9U2rSoRmZY/yK0bftj+wunoXqtYzgUlbwwMTSrmRMpru1/ECnhUZSM/S/7X/a/7H/Z/6rsSVGNzLD/Zf/L/qfjP45/2f/uxPmH7guGEQz7yMkDvaV8w1B7VJB6EE9SEpOx/Nw1LSgmHOFdaI1VGFiulaN17MURNtrPjqKzbISZW7Lcv/EPPogT5p/lD6qDeog6Q2qDT7lwsf6x/q3ZGSbDynAdHCmp+BJyGB3bH8ATUNj+wrmhf8MlILH/Yf8j+CBO2P+w/wH9YP8D2jH+YVqzwrT/Zf+r5mfZ/7L/Sc0QMaHQEVzHJ47Qptr/FkiEwv63/e91ev6BuQAEl7Kbl359PztEnBOmCAFjXyWjINf82jIXBphbplTZiehXTZYpJdFWmYkhV19lYgPs3P0LCa6Mf7COlIgUuWj+Wf6oJkJRcF20ivWP9a/tTy2kZ/sru2H/g56b/a+mpbD/af+7OdHw/KNggW1Jev7h+Zfn/5p5UiQ8/yQGnn87/uD4SyfHX7oWLODrJkoABmpR2jGrSGrJyNDXPAdkQGL6RQ1abiazmNIqz1V+J4UOYFfb2GHLnNKyPB8M1PvSmc79uH/iZfxFGlLG/CMhLH9QKdY/FAjrXwW/AIXtD/VjNq/ZZMSe7W9lPwoudDayl2H/I2TH/pf9T/vfUgtZM9CoUKHa/670p/1vWVh+zdj+p/1P+9+ef3j+AT1AU0kzKe2Y01QPCvZ5/lHZz0kw/2gMYKYQY60R1g898UdMlMcVZxJRQEkW4G6/vi9AUuSQMN9ppgVb1mFAmVxB6SBTHGcver0FizDt/jO8RCNgM/7mn6SFK8sfVYgWQmH9Y/1LOtj+hL2gYMgls/0lFFjADvsf9r/sf9r/9vxD+tDzr2wXsNGcEzcBqB6U9vzT80/SQ2wIs+n5t+ffmnJy5fm3598iQ1ChE+MP8cN1lAX86Q5J0Zf9NKQISMiSMrN1YfkGj2cABx8NRZvvKOAgm6E14mPb5UFjZWTl7P6Nv/knKQlhsfxZ/1j/2v7Y/oabQP+httj/sP9l/9P+t+cfNaVYJTmXYKDH868q+EdsPP/0/NvxB8dfKrXI4FXMuR1/cvzJ8af28ad8y4ivgKD25AJxkexEgHiAwSpmY5VT2q8A5TEsTXHDjoLHKI1tLF1yV/gEcbMg2o9GVcT9G//givln+QMTcoDU+sf61/aH8mD7a/8j/Cmu7X8FFuEz1NxKZtj/hA9v/9vzjyIjnn8xLuT5p+ffjj/QPspIOv7i+FM4TqCD42+Ov1ErkBCD40/ds2f3HadjUhwR6m2EFlEFOVo8RqcTm5bJSS0yzPivnjyW6okAsxiIR5G7iL/aj5blwCJP7Sm/HHf/RMX4F1LkiQ53zb+QlxAkAEJM8MlQWf4ABYMD1j+ghPWvvgFDAbH9sf21/5HthP2vcCXgV9j/lOtQe46jcijsf9r/pHtJB9PzP3AhlEbIi9aBDt2Lsmv/2/635x+ef3n+yTih55+Taf7Z3YcgMYO24RhyNgXLFxYPaeTKEHIVDx0zVQwjXx0RuWFIqSJ0MNtVBZTphTKb4WkaW3yir5yPNty/8Tf/KByWP+sf6kl+gg/Wv7QZNCC2P0SBH9tfggAs7H/Y/2rxOSkd0Jvxjw0T+EhwsEKSH/ufGQjiYv/b8w/P/7JOsP9t/5t2gh/qSMc/PP+gzxCGkmt+5Ecwbf8TEkJEICv6r6eZxUx8BBxWSPJj/ysDQVzWA/+ru69v9nE85ZR/+EbhSg1qDGgMLIdbpWJXo46hjoo6FlVyqQijQ4h4V4FtcxX1mWJZrvlOOeZHmSo3ZJK7cRhb92/8gz9BCZLD/LP8gQYyOXF7Ku5hIsv6h8BY/9r+ZNtKNoT+FC+4sv21/2H/C3Jg/1Oawf5/0Yqef9C99vzL88+YbHn+7fhDsZLyImO25fm35980mQz5ev4dJjP7kpMs/gDXEJcXXqKcpK4uvL1JxqF4Ctjyn08CYxnIE4vIjHz+QEJVhYVw5yUESA3rRel8H1TewzEe5x57R7s6oEgy8t1/E0xiTvADZ0Jr/EmW4E7Bxfyz/IkVFBcu1j/Wv7IpWtn+wKTa/tr/yNJg/8v+p/1vzz/gKHn+5fknnGYZBs+/NXVw/CH4ABtJ/aAPNo7/EAvg4PgXUKDCICmCF46/TO74S9f8+fMw1PlFEUxh/LEREZhLoYjXQcTBHCtWiVxMFUQbVpTBaT3MHw0o2dQ9mq5JCbFcVNIaK/dv/MkFMsb8s/xZ/1j/2v7w+z1hHG1/ZRyaKzke4V8Im+Jo5BLctf9h/6vQwv6n/W/PPyANnn9lC6GZZ8xCPf/0/Bui4fknRcPzb8cfHH9w/KErNV83EbZSGpJPS1dONfUFZ185ets8VkqwAJdmpWaZULh6CBttDDRynZaq5RHtaIIaul5fRd3/sPhXd/g0YmHeiF/EFKjmODLIMP7mn+UP0iCBiG3eCR2T861/rH9BCHGiUMX2Z1j70xSkJmh1+237Y/tr/wOyYf/L/pf9rzAXxbhqz/M/wRGGUvO2uv2MYzjo+fcgbFpIFJ5azqrjZ//D/of9DwiG/Q/7H+P0P7rmzZ8PnUrtSkNU22hiTCsemjcfYoZy6k/nKJOrmqGLPNTSHWv2gCBxKajHOXCMxIXxc/8Z3fpmJfivIHb9/akfHwaKuS34C1Hg2mh0p0Y39vBT3uSH8c8ENP9ABsuf9Y/1r+2P7a/9j7rjkd3Alfgf9v+KZ1ycWmzt/2byFEzAK/v/AIMaxvMfzz+yXHj+4fmH51/ggOcfnn94/rGuzz+65i/A6yaosLjAijMZezh1GLN+5HE//F9+UQtffC0TiMhU1fqK9QbQEA/zTUfNCUVuiZ3wgNpBKfcf8GUoRsKfWK1YsSKt6F+RFsxfkN7wxjeml7z0xWmXnXdJc+bMScuWLUuLFt2Trrn2unTpJZek7114YWr09KTuBgLFCBprJI2/+Wf5s/6x/o0ghu3PqO2P7b/9H/t/cNSaTnHITm1t/9f+v+c/nv95/uv5v+Mfjv84/tWMKTr+lIN861P8Zd68BbiZwROHl1vXaNjnN1z4Sma+D5GHy8K0XAA+BdyPFOvXFh2PSGe0q9olgwWjBaUwQXf/wIOQrAR/Ts4YIJ45a1b6+Mc+lt59+OGEcMjSRDelP/zhD+mEE45PF1zwjTRlyhQEisVO1InxoDNr/EeHfwE68MXa/Lf8W/9Z/9v+FdWorfRjMffcqdn7KBgaVEdsf2x/7X+Oyv8L2SnSZP/D/pfnX55/ev7t+IOcrGIewtuy/9V0Ne1/AotCCMJi/7vg4fjXyuN/+OG6+fGz31nPMPjbkiFy4SCftiLPuG2gBLLiDgnzeZwNqEDeYtNmYSm9+kCVc51SDcfcf3v8B4DX8hXL0wv3fWE68UtfTFtuuVVN1An0yPifdfbZ6SMf/nCa0tuberoR9jf+wVty1vwL+lj+rH+s/23/6gqxpG3/s52AsbD/Y/8P7pb9X4oE/SeAYf9f3lPTD6dPPnShl+75D1Dy/CPkRvIDUpAYWDz/bT//dfyhzFPtf9j/cvzN8cc15392983qO05PkuoxVlopKCEaLi186pQL71bm3HIIeTRosXDLAnIZmdIun3ztUh4Uf3UMR1Fc++wLafdP/DLWxCQQrPLofy/H6yX2feG+6Vvf/FaahSeJuQT+LM/63HIpW+Rm/Hl89z32SDvuuGP6zv98ByVQBk8Uc2yMPxCjxhkBfyENqISsVoGz+U/cuGT+VTKOLFLL8m/9J05Y/9v+Fd+AigH/5IXtj7Cw/bH9tf8xvP9r/8vzL88/Pf/w/CvmVZxxkQ2ef3r+GVzw/Fva0fEHxaiKnpyo+Et33+y+4/jksBom48A3zt2U4AZLdaxKlHxmNB0YvYcLATc9ws0j0RAeNAgHULG4qFJCcmrc/Y+MP3+grq+vL5173nkIEM8M8LWOASn4MZiseXfeFvwZ4Wf+TjvtpFdO/PiqH6cevXZCw4chH7n/6CXK1jrPtTz+xYE1/8kFy7/1X+iTon+s/23/aDds/7MNhUHNITH7P8DC/of9r8rH9PzD8y+RAUTIS8WNKhEHspfB6Y3mqPa/7X97/uH5l+dfnn/RVHj+GQZzVeff3Qg+HlfZXkQSwzRzzTcRg2w4yC3XePYUG3pxmOIwi5+yQZo1mMmvU2nRluVjV8Ycu/EOoaZjXIqzM7bAvtx/4E8sli1fkT75qePSi1/04ox/hZjQKnscKy5lG3vEPw4Q1f1euF/6/g9+kBYvXqwfs1P5KKhyxp9gmH+WP+s/63/bP5oO23/aT/s/9v8oDPSn7P/a/4dKCLc6Nkh7/kO/2fM/z39BAy6SD+rL2PX8H1AADsc/Qk9kWhR6ABzHf4gMfU3Pvz3/Xlfm3woSi5dYhYhSdPEBTzlBLGLblW/XVl+bZRG8V6pMIvWUUGUdS4vc8pmZrBTUXs5DuqkdmFf6ygfcf2CLH6rbZptt0he+8AVhVPDnTvXkMLELiFWmdUU8M/48gN1p06anC793YWrg3cTNUL3xN/8LiUASy5/1H2hg/U+ZoH4VGHDwQ2PK7tn+2f5LVYITpIn9H8lK68r+X+V/hQohUeSH2f9tZYr9L/tflWDY/7T/af/T/rdiF/a/Pf/w/Iv+4tqYf9KDD7uMjb6uU/Z5QsyTJ8sBikHCWjnxvosoI+cOLTFomWWareRF8fDIVgFm8ysRaIc/XsCFjWJx/zkkk0HuB0gr+gfSG9/4xgAI6wwV0coT9JzXPFCVbSZKqIcDlNJf/uUheG1FX0orYr802qn4g43g3kDCWz0SMS9/kc6DYf6LaBkN4aVAGfhk+YccWf9Jp0N4Bi3rh/4fTv6hfsVw2z9IfvzLXNj+1+2v5d/6j/4rVMV6qv+o5TrV/+t0/9fXT/ab/5b/1vl3qHPP/8Lxs/9n/1dMsP8vW9E5/n9PWEcqR140n5LCFtqRCpLqkSnk4I8RNOQwGIItyyKshodnsOVTVvCQVZ6RI5bllvmsj43uhJTWdIz5jFGzM/c/HP4DeFz7pS99WeCUR4SQCV8kODJDl+bolWNRKsaDI/ueIw5PDz/yaHrqySfTRRddzFEaMv5vfctb0ky+AzkGUEPFfstTy6eccnLb8e/t7Unveve7o57aRRJtaNixfwVed3HHHXe0Hf+jjz4y869Zvt7/qaed2pZ/z8cP8+2zz95Vnzxl1cv9n3LKaYKiXCf52g8c+vGk9pvedGhasmQJXuuxDG2vEKaN7p60wQZT02OPPZp+9OOf4DqBD9+tXeP/297+1jR9+vTgf+6n9Mn+T1Wf5Hkr/1nn7W9/O2vgHDka2kQCGZdfelm66+67lc8jMcohf0cdc3SFfxWoiYsVvnGdQ+Vv7z33Tnvu+YKqtdIuMtTPyaeeMmT8eV4sd9RRR/MC4iRr48/+77rrznT55T/AMV0NyrFW9P+ud7479fZOiXHHOZbxR0rtxrmy3Vb5nzVjZnrzW95alc8AVv1f/L2L0333LcKZDdU/Rx+Nc+VVqovoR/3m/slZvasI51vXP/vuuy9+3HF31Y1LbZ4vGzv11JOH1X9HHhl96tKj46r/22//ffrhlT8EfDwXnVnV/+HvOTJ1d3cPGf/S/6kYk1wDZWL8yb/ZfXPSmw79K0AOzNGs9C+uufT/3Qu/kx7A62TySWhT+j/y6KPQVuCiERvEv1NPAQ/KUDfPOL3ogP3SLrs8T+PL42yi3j/PVVeok2jl31Hosy7/9f5vveWW9OMfX8UREy5kQun/6KOOUj/5AghFS//D6Z9NNpmTDj7kkOr6C0baopH/+fa300MPPYRm8ZUm6Nd+3CxbAbkfQET4tX/xmjSwguffwPvbe9LUqb3QA9Pw6cVY9aTTzzi9rf556Utekp773B2rPoMGgTP7bad/Cv+OBn94aQFguf7g3403/jb99Gc/x6Hm+Bf7e+RR0JUah2Y/9TEfTv9sscUW6XWvex2RFqZRu9n/Ny/4Rnr0scfidFCK5Ur/I+mfFdClp59+BhpqHX9i8cqXvzJtv/12VWvsuN7/ePXPb35zQ/rFL65Bc2pN/Cj9H1WTy3b8G07/bL3lVumg17w2sMVZDubfuf99bnrqqSdxZGz655lnlqazzz5LPOf5lvFn+69+9avTNttuA+xwHeySmGt4ov/x6p/rrluYrvvVdW31z5HHHMOONM7YDOHfcPpn3tYL0oEH/TkuAWfJcwyyK81r+drXv5qehj0VbuiAh0ejf55++un09a9/rZJ/VMMSPDkI/c3bep7GdyL1z7XXXJN+/evroxdcTF3/HANbwt7zBfBUWvofTv9su+2C9CqMZ7n+glEZz7PPOis988wzOAxlntvXVaLASP7PH5/4Yzrv/PPa6p+/eO1r05ZbblH1GUNCBGOMxqt/fv7zq9MNv7mxkv+6/zNe/cMfUH7Zy17GM9Plx1kSW3yQe8Z/nZ6WQ5doF/uShaz/RtI/jz/+WLrggm+ijaH65+A3HJzmzt20ao391Psfr/65+uqfpRtvvBnNqTXxo/Q/Xv2z83N3Si968Uta5L8pFPBFTj4Vx8jUsemfhx9+KH37299S3cH65xDYy4032Vj4j0X/9MB/OeKII6OeBjJGs/Dvxz++Mt16222V/Bees//x6p9ddt41HfCi/dEEMEd3g/XPKfTVdKB5LqPRP3wF33e/ix/2psjjili78ORQ+Fuz+2ar3bHoH/q/7373u3SOOiWxLp8XevjhFVek22/HXIj5KDAR+mePPXZL+8CfHU7/nHbqqQRtzPrnvnvuSxddelFb/aO54swZVZ9l/Ikfr3s4/bPhhhukdxz2DpTCIsBRXviH/bv88svSH+7kXGji/J+99ipzIXSIvmI0mv2fdgrmmGUXKZxR1f9I+ufuu+9Kl132fdQcqn/eedg7E6+1tMaO2S5W6n84/TNjxvT01re+HYUECrY4l3xy5P+ll16S7rlnEdpRazpe+h+v/tl3730wF3p+iBBPMAy4zpWZ49U/d9xxe7riih+gCV53K//effi79XtJ7KQ+/kSJ/Q/n/2w0ezbm728G5qingYzRLPz7Hr4xff8D96NN5rMUy0X/49U/+71w/7TrbrviEqLPidI/t0FP/uhHVzaHunnG6cgjj0AMAv4Czr0+/nEpxKf9/GvjjefoocB2/i/OPs+FHq5wqeufGmIoOVT+2tmfGISh/G+Hfzv/x/1jVIqo18Z/beKPIDE1DrinNQYXwiR50pkylwqSZZDGP+QCPJDoUtxydR6X+DEnyqKpYDM3OMYi+DomJ7ixsCF8dABJZbr/Vvyh7hG42PV5uwCdgltKD8LZ45gQUgqf3nGkneZ+DB/qAF/W7O2dmvAjhdjFeCJj8822gPJ8AE/OcqCijIxLy/hHezyu89IW/VJRIT3S+Ff04XnxoxXPBzXx0TLc+PNgboA9qS7r8Q9tDc8/HGNprIb0z4qZf1Tu/QgKrcCjw9tus016wQuen3bbfbe03XO2S7Nm9iFY/KwMy62/uzX95Kc/Sd///g9ST09P4m/9MVDc2n/prLrCqv/IYZ0472b/xCBfI6pHOp+7rrN5/czllesoyrJwwb/1YktvKMMDg+SvOpqxZ4sCKffPpoeOP3Nz/xn/If3HSaAcRydGq+pf561DecXOoqeqf128aqBMln+kygAOHn+BhcGNP7bHwlxF/9pD9pDxVxnizom5SuVCakBpMWwQ/lX/vE52h+Kt44+21FmcBYpU458vFYdxbuymnf7jtfBYNI90jLbaRDYP1Mc/yrICT4QbVkQ6/pWlA4PGv/Q/BH9Ur/evdthuBWCtf2SzcFv+oeKQ8WcbqlNW7IyN63SjD3aomszN41/1zyvhDi9Oo4Nts/9V0T/SAQPL0/Jly9Juu+2eXvf616UD9t8/7bzT89KMmdPTM88uTffC+b7pppvS9b/+dbrzzrvw46GzpI/5VoHqrHWJsce1zharCr44pPNuO/68HrbGOrzS+vgLqxr+KMCxKvxr7SzOSW2wLfars2QaPXC/0n/AkvsslNscbf+s2Hb80VQeWja8bugfgVFg0AVXJ8m9GCSlBGXFv+oYsc+N1PjHevFH8FiYK+awbHQxZPxZBnZzndI/OiecL08fp64rrfNPVzOUf8It19Wg62IDhUAA63HoH7WAcwnaVwmcF5At5BqOfyizPumfgJbXSPAD+5XxL8aHNOK1Ei3kqHrsca0yWA3hH/tpZ3+IJxthHbZZH/8YCOTnllGAzZT+WzuLU1EbbItV4uSQRg/cX936h11qwQkM4l/BuSgpnR5PslyT6g22P7yazH/hgvK8luz/lrpxnUQxtIUaVf+ozo7UGVfsjG3mLA2SDvIIltw/k3kAh9c/bIPtsTBX0b/2kJ2rl0NRZgT9wzHlOA8e/6p/9sXu0FUZf9Vg1+osukIRXWLVPyoNHn+eY3Viuc3cfGv/KsczUCdV/+qPeS2dNfvXgUHjX/g3BP9a/2oBzQbtq4T6n3z6h/jxGvHBQihXxj+WGDz+GhqsNBQ43jIkJZNdsGI7/YO6/GNFFZecsSHkxUAgnw1EgXr/UYH5LKv/lqzI4WHyGk2U/lmW+6yH6pFWEunobbj+Wbgu/zrHWv9olQ2v5/qnYErZQ1rgSjsEWLhewjdm/cM6w8y/oJrQE8epFf+qf54H/jlWY9M/KM8x4wmX8UeSZ69PbjM339q/yg3VP6Il66Pu4PFnlg6sDv2j/obhH7HDCbXrX5eqFY7GyUcWeatUyG8l/2xEnFYCbbIc0qzOyx5h/FlDBYe5fsf/AiHhLoyJrRDDOtt/FlmX8J8/f36cZSECzxhLUI4Blf5QiiIXGaKDLNK8jpxZDrHBAgVTbCtagpzmloPQuWu11lrL/QMPYL5ixbJ076L7animdOKJJ+KJrdNHwL+pLggtkf0hnt6d2den0eCYnPTlr6R//dQnFfzUnTWVao7aZMW/C0Hx5XhSsG/2RukTx34sveOd7xT7AqXB1x+MvuPOO9Px/358+uY3v5Gm4MkA3dFDrUqONTqhaIl1K5PNf8u/9d+6pP/5Ch/qgOdsu0069thj0+tf//ohUhv6L+Sfkn3dwuvSCSccr6fCe/BEcQN3jCz/MlHUhMIv1tZ/1v/BCJACi+2f7Z/t37pk/2jPYoZATVWWVq01Wf1/zz9jZD3+Jfhn/gcClv+612L9N6AHCRcvvt/xP94U7uD4J54kxqQO+qGLX71FQJiqk3d1GNQudwwY9eLjznIumCZgDYqRapcG4m4NDrENNZAPd/EODjphbqxZJmqrCNt0/0CkFX+itXz5ckKEhXhl1ID/i/H1ZuFZcNVOIM/hYUnVwA73ozbbYUGMzorSLo51CP680GXLV6T9D9g/nfjFE9Pmm28uLOL6A7FAECgFiDjelbbdZtv0pS99Mb0QX+H6yMc+mqZOmZoaPXksiGw0oA3hNf/JMd5KxEJuWf7BDes/smJt638FiKFT3/CGN0Cmv6TXfaxM/knjvfZ6Ab4K//X0meOPTyd85oQ0ZSoCxdXXxaVALf+AwfrP+t/2z/bP9t/+D+2m/T/7v/b/MVe0/0/XcK37/2t7/rG+9P+Kl70yHXbY29MH/+6D6U9PL8HYOf7HsdNckbGhDop/dlVPEuO69WSULDt2+BqCPAmOuV/cW6GgU9QJGHBK1bcHIpswKtTJO+cEFBlMRYLpKvgcLfGoFuy6/0BKoAF/Yvzss8+ka665Ns2btxVgKpjlsajwzRhqUxun6niVyEMxkD7xiX9KZ555ZrwTNb7rManxJxf53tED9jsgnX/BeTUs69jV0jXIIjcyvvHNb6a//sD7U8+U3tTDGxskellQxPy3/PNWj/Xfuqf/qRmXP7sc7+g6OH3xxC8VqW2/HUb+Wfikk76Ujvvkp9LUHrxvu6emACz/1n/2f+z/Wf/b/sFOeP4DEDRlycaUac//8sNXZS4HTLhg1/Pf1vmv4w+aReToSW1ejxzHXxx/Wt3xt0/+67+mmTNmpL//h3+QX0/OhdYy/zpJ/rr7+mYfFzYKwR0FhflKCCx8+g+MwJdqw9vhI9c0ZDyGha8oUJr2XyqL4bGSYh7LhHPAknowE7vcRiulsWhRwTX3T3Ca+BNRfDV67z33TM/daScdKyuhT+gEceDMNbENRJmMfOaVlMYB+5/97OfS4gcfwNemu3OtyT3+yxF0n7PRnHTueefpx+Z00S2rQOgrJ5+cfrVwYdpr770qzCIRqO6y885C+Kc//SkC7JAUETrUJ1toKlKgbv4DEfLR8m/9F+pober/frxiYpddn5fOOeecFsmPnZB/rk+FDuB73rfYckswF4sOVVpVP5D5wAOL029uuAHH+Y7yYLnl3/rP+r/pf9j+hU6x/bP9t/1f+/af7vja9D/cv/E3/+hQ05eW05zT3Jvc8Yf1Uf/f/Lub0xtf/4b0q+uuS0/gR3Md/wvmisEdFP9slFdK8K1hXQhIUnzp2nLFff6RHSVPd8dZChnKYwWKOKSAAWXtVsfjKSuW69IP1kX7URO51V1l5rj/wfjzThG/qnPZ9y8PrAl1E3TuEfpYsWzZZdagcopXIpNl7rtvEZ5O/iViyBgvHGDRyYx/P0jbv6wfT09/XL9wncEZtOlK1167MJ2CABG3XPjC+0hURZX4xw9/OO2666764buCv/lv+bf+W3f1/8ByvrpnWfqXf/5niHSW65YNNCP2r8MNIt4o4juIh5N/atp//dSn0uyNNkIVNmL7Z/1n/Wf9t+7qP/vf9Hw9/yAKYf9gtzz/6oj5jzwUz78t/9Z/MV2Xz279tzL9v/i++9P999+fDnjRAUKMK8f/aD9jrki9GoSa3PO/BgddjoNeL5HTuPYAIAeHw7/SQd5NKKWKSxyBZK7hdURN3XUoaWHavI2KXTWCZlDH/Y+Ifxd+IOn8C85PD0BYtWToYifWTbIq1bac7mBqldJZZ50Vr5ngg7AdgH8/uL39jtunt7317Rm2Jv+YoT0BgUmEIMw4lpsjuZY2uerRRx+D9zrjlSCoZ/6TRJZ/6791V//3wza96pWvTi/Bu9yL/crCXpN/HKIe0AJBH0H+p02blo488kj8sOgKfNmDs23z3/xfd/nPJ+PzY3Tge9P+dYL95+X6+j3+5n/IveXf+i9cHPgsdN254/m/gMjMcPyDnCj+L0GhW4yt4z8ChivAEWyZzPP/Rx9/LO343Od6/DuY//GoLxmPJ1a56F47DUfshhhg7pMP5zl0IKZJIco18MeFz9LEvXqJDTNiYXtRQPs0THTaWb5a3L+g2HmX56V/+7d/w+sg/iPtsMMOwL0r9TR60gnHn1BB1UxwHJowMxU5zRIlVfC/++678KNtX8IPr2HUuuJVEyozSfFnEJfB3IMPPrgJFPknpApBCSLTwA/bOoYqgYxaScH15jcfmqZN31DtmP+Wf5LC+m/d1P8D+EZMP4K5Bx9yiGSXAt5e/mmXIOlUAAyqccNVG/ln9qGHHqr3nFv+Lf/kg+V/3ZT/Sn6zEbf/ST1n/9vzD8+/qLe1TNL5j66t+C/WfwEH8LD+s/63/rf+D+WPtfV/NhUx/1U4DDk0GWAJJ8NQGHzKlMqTKx7hht40d+KQ8kpcV6G0qk4cGsDdSNGO9bnwAStu2Uw0GEnksr9+TcR50P0Tj5kzZqb/QHD4oosuSlf84Ip02imnpKlTN0gNvPv2q1/7arrg/PMJZHMh/nkRxMSxZHAbmU38kfHRjx2b+hE0YWCjU/BnkPileoIw37wANLwLWOApkJHv/KswFP9VuBRp2e73wv1xAz7aFIvNf8s/GVIIZP0XUEjQsIK+D5lb8/q/Hz9a+YpXvKyS+XbyHwd5nhhDnuhK5H/e1vPSTs/dCU8SZx1g+bf8W/6t/6z/KQX2/23/1xn7L4O+Fv0P9792/T/jb/zX5vxjfeXf4sUPpoceeqiaGoWDTxcPfHL8T8OqqSLcncka/+yRR4/BHuALcLEU/1Z7CidjAsynDlgGB7vg+LAQ080lAmv8MTvVi6ZQjvvYYT388b2FCA3nfdRWW9FYp/XPoOUheLLtrnvuSffj3S9X//xnaffddtdLwq+66irheNBBB+nr0d+/4vI0BX8f+Nu/STNnzkoHHnRgQF8bg0jWMlii7Grblf7u7z6UfnTlD9OUKb16QhkxDZTBQY7tZB3/HPjd9XnPEyAZCqJDmxEY5W3ZDd4SmgJgdURKoeD6tqNenN7+if601YIZqWdKt7JZkgtrUiqyBFT70UA+XpqlMBH/Ull1owzb0omyDBvN8pcb1OGyij5jL9LuvxPxf/rJ5en3Nz6RfnLp4nTh1+4UbzpZ/9IGbb7Z5mmTTTZtCgdSg+W/LlMSxZXIP8t/4NhXpk12/H2au8V0vMKHbGt2Yfm3/ulE/UMJsP2x/bf+s/6z/osbyEUfFidf+3QWlMDK/n+BRg5UgUY7dNRGOf9ZgYd2Ft+7JP3qpw+nS867F37w4x3v/5Jjnez/+/rHP/5nnHE6RC9bcvIoxx8ojs2Fx3FM8T4kqklQ1v7m33otf13z58/X81J8ArgoZpq1cG+aNAg9TSoEISrTB7Z0gTmRG42QQPziYclrtkuyxiKdn8nETSf1zx89+9wXPp/+4UN/n3beeWe9XuJNb/qrtM8++6ae7p504pe+KPyP/fjH06JFi/QOYeK/AiP17LPP6EeTjnnvezOQ2PBgQbZKVol09913p2OPPTZd8UMEiHt6UgPvOe4U/Pm6Cb7X+a477wQfK5TSV045OZ3ylZOFYT0/GE7mNgM+LESIr1l4rcqX1Q9+8tX09IwL07ztZqUpvfnVHbmxUI/B9tJ+2bJ+HX/uR79l275/fRU+S9VI8sfG3P/o9c9kxv8Pv/tj+tz/+m267YbHW/hf5x95OZn174r+/rTtNtukH+PmG+WMC6/5fce8Ny28bmELLjwezBkq/5S/a6+9htWr5duXn5Cmz78ubbb1jNSNV/iUxix/lr/R+j8kU/CubK3/29lf279gSdFRYgsU+WD/m2Sy/rH+sf6hpFQmuZjmyKOM0AnIS8iU9W/gMHnszzkn/j6d+flbW+wrh7yT/N8y7yxbX7/H3/xv6n/KxWSe/xa5L9uxyj+eJEZVMYZV8aAiJsI0ns0G9ewvUITTxYAbyvBYmBFW5V6BGEkaX2z6seavXfO9xXT4uXSp4ZxWaJppdoZtZHdE/6961avS9y+7PN1www34XJ/4I2gEYObMmenxJ55QmqguX7YMQd0pwpr482nu3t7e9L+POy5ddMkl6b3HHJMOes1rKnxRpcKRicUPLEaA+cz0xRNPTMuXL0fdHuRyrHC0g/Anjrpmcg0IcNn7BXumhXvuhRTzkMu7YEgu/NV14v8LcCxTMmqBu83aUat/YAWoD5bn99lEQ1qjLFnfyv8G28AYqt0a/sobN/958gxOxXVE4zw/92/8u9K2O81Mnz59n3TsO36R7vgddAt1LSlT49/k17/QpdB/lMYi/0Rhr733Qk7ITZF/ys91Cxem4eSf2HEpLfWnFfgWRqv9i+OWP8uf9X/d/7P9s/23/0OtSANSLEjmRJjlccx/0Jb9v4wnsSC4tM+2v7a/Xemtf71dmjq9O53yf292/MHxFyiGUBCdNf/J1+zx9/iPg/89nByTQjFZRhpf11CUDLnRXgR54zFzlsz7SNLPYQ6nQpXPo5woowAyG2EhblGerpGm1NhnFn+YTYd1pDP65xU//PAjgQWu/75F9yI9kB588MG02dzNCJZQnTW7L13/mxtk3Ar+DEj2TpmSFuKJtvf8/Odp7ty5af/990vbb79j2njjOXjSeFm6775F6frrr8crLK5O3Y1uPOGGD378LnDuPPxX4H2kD9z/QNp8i80zsggQ7bV3+srJewsTgI1lAE8JLkzve+/7cGxPHPtKZJcaHBItMTbE8ulnH04b9DLsXh1EbkEZLRalrCzwHcWiNopV/I9bKeOXP948iHZ1eu6f4AoK409idKUZs/Cqmn95Xvrw264WMp2nfwfSA7hhFpYqJJRAHI2bbMfgEws5wyeFoQMWHpP2RgA5jkV+TXBVjiLNZemyR9KcKdDonKhrsfxb/sgZih62dHKs/4WD7V9IhnSH7b9EowG9qflDVrBjn3/Y/7H/F3IlpWv/l5ZHUNj+hP095Iht080LH8fr1+4XMp3n/8oZES3IDF8/oKjsb+fFnzz+Hv+x8L+hwjIpcl0x2eWcJoe9qFE4yQmboyQLcLe/P8qzql5TwncqacFWEyMc5wGUVgA5N8JaNF7RD9IUVtWL9jqh/4svvSi9Gk8Td+MJtA03nJ723mcfINCVrr766vSKV748bbjBtDRt+vS0/377pxt/eyMh1EJYAzgGJXrwbuEp6dFHH03f+e6F6bOfPT790z/9U/rkJ49Lp55yaroWT8P19vSmHgSIGcAoMYxOxJ/YXocnhLkEywAoEpFWto7QXJB/XGXIqxosVecpOf3E0jvTBtPxpDfxpaeuBVsm2dCo+N/aLsdp7PLH83b/xp8ItOffLnttlF584ObifKfpX0rUkiVPpxtvvFHXL4zayD/RoxxV8seMXIOpkLDQGmHTcKNoxd2pdwO8wie/bWY4/Ou1W/GvH0Fvlv8m/gR8VP6H9Z/1v+0fdZT1T3v7V9ey1r/1+VcdGdsf2196PGOd/6/79vfg92wr7UjvrVX+y1wv/LpOiD/4+uv6z+Nfn9eY/+PRf7Sbdf8TumTU8Z91n3+YksbFxZOMsSclglmw1GboTs3V9Ih+wQKPthIHLtww2FstnGizXKx0nEfzLoJnBRgW6rz+b7n51nTNNb9M3/jGBelb3/pmeuThhwlguu222/TezMu/f1m68DvfSWefdVZahKeCuRDewfg38FQx3y/M9wx3d09BQLgnPvgRtR5ELRr4ISUFiFG/U/Hn9TMYf/lllxWqBZiBqtZckf91NsbXUarDArDG8PTQI4tSf+/dado0vuMZfB4j/6Pleo9FDnh6lJ8if7nXNuMfCp2nxhsxtbNTffQwgvy5fyLQWfjv90p8S4E06UD9Sx1wycUXZ9oXWQmZCyYMlb8onNeUv3oGZOt3t12TpvU9k6ZO5b352lHLX1Y9xBQ2KKOT1ZH4F1B2lvz5+jMRqgcMPP5hg8L/oEwIEekP239p1NokY7D/a/8nrI79P/u/9v9H9r+e94LZaYutp4XAdKD/Kx8s3LGO9P99/aC+x9/yT0EYo/6rvinf0JcQwk3VU1LwwBh3GsDrJ9guVzmVJ33K5REthX/aYV0GuYqDhxp8qJLBL3nBuUG1x4pYOq3/E/7js+mtb3t7eu1rXpv+gB9Vi6l0Sv/v3/4t/fmBB+FzYDrz7LNGhf9hhx2WDnvHO+LVHfKcjX+dfw0EzM857zy84uOhIFumbp1/xD+ys8OZuct2ytJM4UfsfvPdVkONzwAAQABJREFUNHfL6al3Kp/UrtGahZFR75/CM5j/7Lvef8V/9Ncqf3x1C2WHfcQZct08W3bo/jk2gQ4Txr8d/+bvML1GlGH4B5a18i+zbhj+kXtcxoo/R6st/1dD/3oVBILE55x7TpxsJkq9/yJPvJBy/bou7US1uvyz/A13XJI22WyafrRyrNfPvuv9W/4ZaMcCvAv+4X9Y/5Gu1v/UMSG4XBd5LTJp+bP9y2rd9t/+D2wItAUdcy32vz3/SGnr7TvT/6VlGDz+zGvrfyK31f/KVhei1M7+ZgHDsbHZH/e/fuC/YP6CtO0222hwPf5hT7gu/mcn8J+vBNaiAG4Wdb4lLDJBCzoc3KXRlZrIx5hFzZMX3aVQCagL/qOYAmxI6yu8qhYtK59PS6BuJ/f/zNKleG0HfviIGAofpvDV6D89rR9aEuajwH9W3yy9p5h1oeKNPyGo8Q/xIfHs348/nkiTmNoIcq20G9gBw2ZW8L8cLfkPLL473feni9LsjadWXzOPY1zX8M/pwfxX/3X+a4x5Tvzwy165p+zojkr+dJLu3/gPz7+pG04RszpR/3Z3N9K9996X/vMLXxhW/skdSn8lf9wvBkrHJGRa3XTLL9PTjWvTrI16oQNKDcuf5W94+eOtcGl22h/rf2Eh8bL9g79C289PTf/Y/kv/2v8hNWibwj7JADGrPv9Spu2P7Y/tD9Wo5n9KcO5HPy7hgZ78uzyD7S9laVX1L1W3JLSGP/vBf+m/2P9O9L/DjQ7/x9dPUlCXkxvkzbrLv1e84hXpoNe+Fie4EvuDSzL/J2f8rVGCadKRmMRQqw3wV9JEXgi1Bp+reOi4X8dJCJRk8I1akIvKxw/WMc1dhds4AaAzwx/Ey3UVmQ4tHsqcBFQzndn/Rz784XQT3pdJjMeDf2BHxI1/cK6VfyRZN147cdaZZ6Zvf/vbOCiyAq9YZLSQ3HvvvfHDVdfgR+u+nI+gnHjJVTCdqcuv/c+0YIdZadrMXrzKorTVBn9yvA3/FXjiMSwSg36M26ryXxI3aPzdv/Fvw79O1L+UL76f/f/830+nn//8F5K9siryTxnfa+890zXX/jL/aB1kVHLJVVP+lz7zdPr5705J83foS9OnY+IhUebK8teif61/rH/a6B/bP+oVKQ3bf0Jh/8f+n/1f+A/jm/+FH2P/Y6X+F+IMVLud6P86/kIF4/EfD/9j5uP4HxnUifFPjDyndaCBolR8DhWGiu+M013qECpOkGmCqg/vkOU8lld9AcgSTGCLIv25Tdm+mElHPooMcELN4u4/Pbj4wbT02aVCZTz4cyw4cgxRaDH+Q/jX6O7WD/29//3vT9//wQ9Iz2oJdkeO7u9Rk5YCgjRw5fr8Sz6dpm96Z5qzyYYIOlFxFv4H/qqW8Wczaoi+Xzv+6zB7H538qRk2pU7KWbt/4Zf5b/xBkNHyj/zsIP0b72+fko5+7zHp+htuoPRpKZLEnZXJ/4rly9L5l/5Lmrvtn1LfnKmpq5tPpzT1r/kHEEfLPwFO9Kz/RuN/Wf/T07H9s/2n4iha2/6P7Y/tb5n/2f+AahjO/5C/i8Mo4viD4y+OP1EQVu5/U6fI7ypbx/+ERKiT4n9QrzAHS9Y/kyX+id/kAwV0bZyCIFmeIi4BXh7nv4hBThW6NPNLeDKcVzaCqbbaLKCxnqbfuQ8e5zH27v5XHf/A1viLXsPyjz9e1Y1g8WGHvS2ddtqpmX/Y1LhKd1P7ykOa+1gWP3Rv+uqFH03dG1+ftt52Vpo6jcqhMDjUw1D8VTVRpMbOf9bN/WND+dNeCFYcY77+3D/HwviTM1ioa8XfvDsu/mXukXX8nyT6n4Hixx57JP3lXx6SvvWNb/LSRiX/LHjHnTemsy/+UNpowT1ps62m4RU/3cJ6ePu3KvizLs+O4Af+2qsGNufjoPu3/rP+s/63/Qt9OzH2z/rX9kcW1/a3I/2PPPY1/0saQf5XzPyaftlw/kd2wu1/j2P+a/wH69+1xT/6FZNl/kcM4/UvIcOOP2JwpaaGj//iy/IUxkwClo/HH5ETEfKEr+mzRHmvDn9hOGqwVkqbbLpxOuqoo6OfyNJ6y622Si998UvSrJkzoSCiXbXDVT9OCFuGNle1f5welniqQB3nVelLVJj0/ROB1qWzrn/049+DH7Hr7dkg/fP/+mcEiv4qXXbpJQKOeAWx60h2pUcefzhd/KPT0nd+/jdp7g6L0vznzEobzuhJDDaxZMRscv+1qqU9ZvHGEuWqjEnFf1Qenv88xopF/qKvuvyxbfcPEAIpbqrF+AMKgEBIhuWfcBNS4QSw/Bj1//qmfym1jdSTnn3m2fT+v/5AOuKIw9NPf/bTEH1BUSOR0OtKix64M333is+nK2/5eJq38x/TFgtmpg2mdetVM5Y/ipz1n1hTo46oRHkaSf6s/4GPkGqjf2z/bP8hPfZ/wm8kFPzU5l/ULbY/tj9ggexMrIhHnsrY/ggS+7/UG23mn+LNcPZ3dPGf9c3/141Ux5+kIEYdf6Ofmh88qtsf6hmPv1Coq15mhM3O+nd9j3/2VAaGugJeBx8Y00XhMpWlDKTpjeiOmIpFYZTYdONN01//zd+kU089DQcG8BX8nvRfp5+e9t1nn3Trrbem7bbfPh1z9DHppz+5Cu8w7kq77rpr+u1vf0sc85IN3Dj710miJT1LKw2Qz5/tYcEpSxXyxcjsP5Z8UDuToH+MTVx/vjpcZoaiM64flz2W8W90d6UpjSnpl7/8Zbr66qvT5pttll70ogPSG96yb5raOxM/Jrg8PbX0ofT4ktvTssbv09wtp6dddpiTpiE43NPbjXdaEWdiDh5lKlX9c5/Hc37FP4xEPIXPulUlFVZzzOK9k3yIZZikUmZmO/lz/8QGIGEx/lnoRRoBIlxa+QecKrLpMFaTQP/pcvP1M91MttV/NGUMFU+ZMiVdftnl6dKLL0nbbLNtevmrD0ivOvD5yJ+WVqxYCh3woHRAf+/dae5WM9Ium2ySNsA7iPluY34TxvJn+bP+CT1i/ZuVzoj6F2W0VEYLezX9a/tv/ydTgx6NqGT/D1DY/7X/D905KP4wZv8L2tb+Lw1QpWRa7Q8glrqhKRuF/lE7lSljpdhZmf/t/tdD/MGIwfLn8cc4dgD/e+Ias4Bjw4UP5+rxcuyH8x+OrIQfx1iML3BWca3YSgB21FFHpbmbbJpe9tKXpcV41+6RRx2RPvf5z6UD9tsvLVu+PL3yla9Id975h/TUU39iJxH8YktUMGprjP2j51iifzXFyIgWnHdWXPFjKSWbZdHZpOkf15Px78zr57iObfzJaL5+ogufhx95NF18yYXpoPc9lp5+dgWCwAgg9XWleTOmpA2nbZambtCNwBBq5JsMpGnhP9NEv+qfycw/9kH+8TjTTKg8OSn+xUa5haesj2W08uf+BSsRKwnjPwz/MsVAt8K/zta//AGTLtzU7MZ7he9ddG+64kcXphcdem96ajls0NSUpm7cnRZM603Tps9NU6ciMIy3S5RvEFj+w/5b/xS1Y/2TDaH17zD61/bf/o/9P+jLyv9gmt4uVvZ/CYTmB9za/4c9BS1WFn+QPBGwUfj/9n8FVMjapIp/1MafqqTj4j+r8/qBJ+dJlDBiiy0/Zf7DnmPJ/i/LGP+MScR/uLM+xx8xT8bgFu8eg1vtIVAWT0vF9ca4U2XjHlPo76palCASKb35zW9O/33O19LiBxfLGfj6176OX4Cfnl76spepwNlnfxWvpziGqOkz0f3zXLrwpmWeS3kPLMN0vC5lcsOvG0yi/k/60knpjDPOqC6v066fQ6oFY85lLNePGDECPwgY4+nAedvMTAt2nJ3m7TArbbXNrLTJ3Glp2swpaUovg8lsfCj/g1fqtlqV/uPF5azV5J/KV/wjDZmTWxlB/qKE+x+sfzJyFfZMGH+gArq245+AqvhXjNjK+Tda/V/Hf33RvzQFDP5O7e1J87brgw7AZ4fZacv5M9NGm0xNG06fkrqnNKQnzL9W+2/5k0S1rKx/htc/4kulf2z/bP/JiKxF7P8ICaExaP4VCNn/s/21/a3HH7LmGJ39paPHpbI/9n9Ha38ms/8/GvvTqdd/zrnnptPxZoBOvf6iXzr5+hsDVJhciAZjpwUVamKlaZYVc9BaAS/pWhxU+ax4eRRKeOutt0633PJ7VaBOXrJ0aVp07z1pwYIFKDGAHw16LD344ANp9912wz5yJrB/NYhVf77lwf55CfzqRCx5q18Si7T7n7jxzyCvl/iT5T14WpA/RtWLV0p090RQSE8bSgJ4dWQS/ur8r47psCAYE/8GWvGvqMoE/nleIYHu3/ivBv5Z/0pmJWt4DQ1fJUH570FQuLs7fuiSOiCW1YC/5b/CP77ClKG2/rP+t/2z/bf/Y/8PCNj+EgH7HxM+/7L/G6LFcMgqxn+iIcdfxjT/X8f5t2TJ0rR0yZKsgdvonwiGlKHXdjJdf0RguObSmdcfTxITAX7olJcoMbb8y7BEtJU4gRScMzNwpThyKY+ym266Kb6W25ueeOLxKE/Fg+Wxx57QMaaZdS7uThx22GGahKu/VeofDbK+Wo5ttZv7zwV4UKWaj37j+nj+7j8wIBRlPEc9/gC1AjwQrnbXZ/zBFP6RMQO6qcBrwzKY/8wrF6zrpcwgK6ryKBYVUIrZLfxjH6qAA0wW/NkvM7h2/8ImABykf5hp/MUT0QWrMfGPfGvHv06Uf9wutvxR53Cx/rH+tf2x/bX/Yf8LhrEyC/a/Wua/NJX2P+UvjMv/ZKV2/uea8j/s/7bHvxP9f1KRfODi65cErjz+R6wIWGUgmrslK3JYSKVa4h+Wv3Ve/no4ahSMgfwYj16QX90d4OhzpEEVJMUFDqr+GSaOh7CZxaP9/VFWT16h8AD2SYgePJG1ZOkSFkKprrRieX/61re/nd729sPSV886e6X9Nxrd6T1HHonaaC+6R0PsADvY6se90C7/4+R4vrlgPl6dPwqxWpTFRm2o5dwem2BDtUJMsz/3P2nx78ETxCndg6HHOA/mP/Yr/rThf0Uocg2tkC4sX/iP2vjqP3lK2mEPcsF+pCwlIyuRP/dv/MEncWsV+Edqjot/5Oxo+6faxDKh/F9T/VNmLf8xeBpFMi6U2ajHX4M/weNv/Td6+TP+hbK2v9n/tv9h/8v+p/3vTp9//MWfHZZ2mf/HarpGU+n5vyaljGzAbkZazgb9PuZpYX74gnn6EfuOvwgHx58yV0QXpOWvc0sKUe8y3oGkuARvJBfn7mSQv1NPOZlXkq9VF6nrnbD4D9qu8FvZ/J/YYmH5ieofL1vNXw/QiKJ1Pk2lNHuLHjm4/MSKCS5UK3GEJ8TlEfwA2IoVK9KsvtmqqiAY8jeaPSfde88iBcniQErP32P3dN3ChWpTj6evpP84jI6orDSRl1pTcwIE2SRfnHUEk+OOBXN4kB+WwYpNaIdZmbRiLvJ5OKypyqAoi6uuUu6fABHICpfJhP/4+C+GQCiDX5ibZR5FfsJXyjOlgkjIbgQZRanR8F8t5eZIx2AuM6hA4oD7N/7Ub2uTf/xBA/ZPehf9X/Gf+Tqw+vi/tvtf2/i7/7XLf+Nv/Nem/jX/zD/zz/53zGPzhMHzj4g9wP+kfuTE1fN/gsF/xz8U+tGq6I0mR2KGHdOWIA7Jgw/K85gw5G5kcRcfHGMTuZzqOf4UWE1K+RMTFP9Z2/PP1dF/D3kel8gEVWfQPE/jkUWniyX6UwPbULLx8hqW5MhTINTIwPJ0++23pz0QAL766p8pb3ZfX5q/zfx09z134WlKZKHsZltsnmbMmJluvukmtbCy/pfD6znl1JMRWGvtX5XjJNSX7ligDNtTthLl5CKP/ccPKtXKqSGseP0SftZRGE/XP1Cu3/23jL9gE9DEjmMr9bhe4r/Bht3p9f9wUJP/+OEQkSjzn0/Ndw3if1x/k/9kDE0Hf+NOsGT+iT4ozOfug3+qWeHEYlrq8uf+jT9JNMH8IzH1LQuwT/RkF8E+JMah/6kvdZ7UmDRRaBcNtuU/8oP/UWGd7F9g4Pwsf5Y/0TT8H+t/2z/b/3b+d13/2/+x/2f/1/7/MP5fuLMKqNHlHNH/Ww3+14Xf/1r62SUPeP4PJ5zef8G/uP+Ofzj+4/gXZYOO/+jjf5oyYjUp5r+69tbrz7+aFWqiC48i6oK5zsFSBv4ImhxkFIunFpmHdLxtIvL4FCWiA2eeeWZ657velbbccksEyxrp7//+H9Ovf/2rtPDahQoeMIBw5HuOTCd9+SSUj37Letz982xy/2yLl6hFCV5i5LBvfTCcusRJ0v+G06anaRtMy2NTrrZc9uS/frFxosc/Pw5Z8Z9SAPIM0AOkPGDdX/hf8Q+ZWFbOPxIR5dhIbWnhv/sHMtQ7xJof4z9x/Jtc+k/SaPmv9In1T1aqw9p/61/bH9tf+x815wtJ+1+1+Z/9T/ufk83/pozL9Nv/Xan9L/OuastZGG0mJ63yuJvxHzY20f531W+e/8FYuX/jb/6tefljBFEBK274xKzmVTwPfCSUTPAT2rXsxRO3LINCDOQw7srNueecm6768Y/SVVddheDwr9POOz03ffQjH8XTyDiIzz777JMW4jUTTz31p8Tf49LCLrCMq3/U01nn/uMC1Fxe5QAT93gOWvDEA5KTpf8j3v2u9Oa3vjkur1xivlJcNPDJ4zpJr3/Cxr/glCnPSZTQY3AYx7jXIG+YApYUCcKte06UpCHYI081467USvnn/gNCAkxshS/Ya/zFInJptfJvPPpfQwXiT0b9a/6Jd5Y/63/bPxql1ax/bf+BcNh+23/7P/b/qHHs/64x/8P+b6v+lcWj3cNnuPiPjk5S/9/Xn959+BHpAx/4gMe/g/nP0Ja8kXDOGE4EH7Qj1cCDoTh4q4hBXRRgMBdfKtKxBoMDyozyy5YvT8cee2zabffd0stf/or05re8Jd3+hztQIpTNXvvsnS677BLsoV0Cz6VSzuPoX03wpPL5qs1qpzRf9a8vxKH4ZOq/jr+UeROMjrj+IOUEjH9hSeG/tvGOu7hVKqq28l/UC/4JbLRRI2PGX64e0mJdtrdt+O/+hV6lf4y/uKSHenSrfjXzD7qT7K3wD/ZSm2AZRv+zAmuhUCS5rnZ4UMH+ov/XK/1r/mks1xj/wCCyp+Kf8Tf+0CXmH2iwJvS/5c/6x/rX9kd2t9jhSaR/4d+uV/4n1b7OmNsO9L952b5+IMBlLY6/TmAt9r+2r7/D+1eIl4KoCX5xRAlKmanJcSRLUAL/ehgVx+IPSleHuGJOWbrS0089nR599BFl6EljFoSSPvOMsxVkywewibqr1H9uo94/LyXa5qXgSO5/AC/xj3cM47CucRL0n6+jY69/wsafPMmsqfGfzwFH+CJTajD/S/9BYhJLOn1k/qFMnX+q6/6N/5ri3yTSf0X+cEmxjEb+ULIuf6oIo2H5F5qBDUHh7WDrP+t/GahQTrZ/kAj+Zf8XKQLDJx9jGY3+QZm6/lFd239CSTStf4QCgbD+BSOsf7NyIS2sf6ltxQrFH5Aalf6Vvl498/+ZM2ekKVN7cR5cRqP/WSzOm3Wn9rJue/+ToW21iWZ1vcONP0rFMrb+iV2wy/0TaqJdtz/G3/zrZPlDkDjUQ4gG0nk3lC93ivMbB/SgbmgiffVZSXnH8WyxyjMzt8ME33TFevyK/pKnn8RBKvgcn64KNonI6mPqX22Mrv+G3jExyfofA/6T8vonbPybvK3zjz+4WMxoRVcU5Vf/YyHZwT/tk1va1SE6t3X+NxowxDLyarRZMDqs5Mb9FxDxJIPxnzj+TUb9N2HyD6JRlLFY/ogCwbD8Wf/Y/tn+Z8WYN9QO9n+IAheCYv/P/i+5YP9/nZ7/rCb/979OPyP95cGHDBl/6oWW+V+b/k8//fR0yMEHS4dIlbCVCkTwSTo3FG/b+EvRP6g3mH+j6V/VNGtFH9GN+zf+oAXJYP51uvwhUlsUEp8XkmTE1+GRjDso4gnSCG6VskQN/9zccsvv0gv33ad5DKm468u28IG2i3cKFcqReLW2WUrdjq//6KN2bmqbfXRO/2WcAkfjPzH8YysipqiUTX1wtcb/4fkHCqJ+vLs4WqKw6Sl2NFu1rTyWHcx/919hJLzkahl/qTXoN/yH8UJG/gXRVvknp9rwjxWxVNiyFNscwr9amYw/S6nsqPivE1WF9VP/W/4qjuTxFyIa1lXgH7mj9thQLO35Z/yNf+aI+GL9b/mDRJASo7I/1C1t7J/1j/Wv9EnWLWSJkva/W+f/k9T+ri7/FyQKHtFvpo8tRSVyjcb/1Y9Sqw7q072qc1TpWoxjVPpvbP3b/x8s/50+/6ldvxht/smjkFiNZv4zeeSvhxeuu1PQSg0oH10alRAdrKxQBY5ySBwsuBvGYBfvHLPos8uX5QPc4MkjFGkwxcbUFHOQYBrJrvIkJXa5rFL/jdxuNMVeO65/vduZ2AqKzrt+8Woixl/soV2nmQfH+bR7wIo0lywRdf4Py79oR+emIB6MEC3/KPnv/o3/xPNPFLb+Hc7+ZEVi+bf+s/61/p14/Wv7b/9ndPMf6x/rH+ufiZ5/tfd/N9tsbnr+8/fg9C79+vrr04MPPqSCm2w6N+2O31Z66qk/pRtu+HV6esnS8BDz/G9zHN/peTunZ555Nk3dYKriGCX+0NPoRt090lZbb5Vuu/XWdAs+qpznf5vO3SztvDPqPvtMmorXVLCeYibseSzxl2Hnn46/OP4EMjEupPhDjpONMv5AYYhoB+pBLvCvD5trif+Zf4ExccFS5H8yxT8RJBaLcOeKXyuFUsZW91Qw+KQJA8ciGSK55Q4XCaPALlEB6XjbK6aVJBJTmVB5Mq5jyGSMTPpPJeoZqOX+x48/sBO2wt34j5d/ups7Av/J3YJz3NgYgf8sKwnCeKAwXd7h+M9ylLsByB+fPB5O/ty/8V8V/olmFA7r38CgEshif8JuWf6gi9rYf+sf659V0T+VuA3SP7Z/tv/2f+z/2f+1/7865z/t/N+DDnxN+sLnP5fuuefudM+i+9JfHXpoet8xx6Q/O+jA9PkvfCHdefsfZK2mzZie3vmud6a777yLzaSjjz46/dMnPp5uvul3aekzS9MeCAh/deCrmOd1pQ2mTk1nnHlmeu6OO6Qbb7o5HbD/fuk/PvvZdOIXT1T84+ijjkkf/8Qn0u9uuTktXfJM2mOPPdLXvoq6nFSOMP/j4Rb7S1fe8ReBohgT4IAnr/HiGJWHEXWsYOf5D5GJT+WQlfnP0PgfsZN/xm3BUNhixcX8m/T866Egxa9HI/bNBIhAAeOKgVsFdcEOCR1WyMKBKMQky3OlJ4uVrQIqSKPPhpTDF/vhDhwpp8ZZjXc18Diy+ycY48f/oosuAqR8JzPHyfiLlOLu6PnH0CyJmKktiq4S/9FWxX8MSZciLMPzn6Pn/o3/auUfdIPUtXSE9e9Q+yPNEehIZlfB/ln+rf+K/2P9b/tn+w/lav9nuPmP/T/7v/b/V7f/3+r/9vb0pk9/+l/TZz/3+fTlL38Zz8IxIJFSL35E7tP/59Pp+H//TDrttNMwJ+xKXzrppPSP//CP6YN/+8G0/Q47pE98/OPpiCPek6688kpO3tMFF3xD5ehfH3bYYWmLzTZP++zzwrRixfJ00IEHphNOYJD4i2mH7XdAgPjY9J73HJGu/OGViH+kdP7534CvBM3AQAgawHrV559jnP+uSvyBJ+34DzS4xo6jx0Rt/s+c9TT+tXTpUtwEWSJOKqasywuSiqdIevwnN/97GPTVOPORdCoqDDkHP7jAoKOy444BFFocL+sISjIwiapYszQXtFPfz+kIlOlolATr4qu9qOL+BXQgOzb877zrTiJOEAk+FuM/Pv4RuSaKJHHFfyXK8ShFzMl5/lX96dCq4x/D6P6NPzhXSIltYR5ZOlb+8UYSl6jHhPVvq/0p+Aom7Fj+LH+iQTbIhR9FCq3/bf9s/+3/2P+z/0sTAWsp02D/v+JDOJzCZizzf3lgE+x/DfZ/t9v+OWmTTTZN3/nO/yD8sEKGnsO33Xbbpblz5yY+fEX/hyN77jnnps8c/xn54gcc8KL00EMPpx9d+aN8lCPP74qy9EDab7/9091335UOfdNfKWfWrFlp+szpac5GG6cDDjggPfzwwxFczv436/CBJHJH9FErPJ2a/8knNh1/yfgESm3nPxqRVZc/jqTx70pfP+e/xXkR2fzrSP5h2PPC2yBYGHogIajkuWgDBZUP8wYJFokQ1nHnrUHthYV3w1UfaxXLbXBHybzPNvh+Vt09V02s3L+QMP4gCfmSuaLNWuBfELbG/8xT8VrspgFv8p/nKf4rENeG/1FADY6G/+4/AK/G3/gLgVXmH1oZDf/Wtvyt7f4tf5Y/ImD9AxBof4MOsnzt/D/bP9t/+z98XQAlwf6f/BQpT8ER/nwoiVH5H7a/oXAFofXvxNifYsNATsYfNp6zSXryySfTokWLWuIPczaak5586sl0//33V/b/KZSbM2cjcXfu3E3xjuIbWud/aJNBcM7f52w0Gztdaev589K8efNSX19f+uIX/zP98ck/prl4//H1v0bdWvyDr9jIz2+oPlZrff67tv1v9z9I/rMu5dytnf/FXMffHH9cHfFXvJNYrIOCi/chSXmRkFJ6VF68fZCdHhblbIHHsAqHKFpQK3gauAHpzn6SJhcUdhEbbVDjxpNbuNOD3X4qymC9+zf+4Ab5Bk6sFf6RnPhfWf/l3Nrwn28e1is/chnFkNlsCMcI/Kc8QG5Gc/3uX+PUTv8Y/5XxL/Q478Bb/w61P5J/rEbUP5Y/y59cmaH+j/XPyvQPbaG0zyD9Y/tn+2//x/7fKPx/21/b33Hb31b/96FHH04zZsxAEHdW+uMTT1bzr8UPLk4zpiN/5sz0xJNPKf7x/Oc/Pz1w3/2KfzzyyCNp4403wjiQjBqONHXDDTkjVHhk8UMPpnvvuRevqzhevqTmf3S4Ufzhhx9JB+y3seZ7Jf6xIerqKWsUWen80/GXYfnPb6M7/uT4m+OPWSnxGUbonLr+ae9/U8UNH/9lBBitoEBWYqH2JIfI414YbilD7qLjKl0Kc2KNzPJ4PnZjQX0lcZBTA/ajHAbiWF5tRb77DyNCXLgQN+NPNNY+/zSj5aDwdEbif7Bbg6dxlPxEvSb/uT+Y/1Tsw4+/+5cWMf4Twj/ybDD/rP8tf9Y/1O/S21DR1DjF/lr/Wv+CDrY/E2J/iONg+2P/x/bH9sf2Z03YX/Is9M/vb7kt3XPvvekjH/lYavREKGTbbbZJt99+e7rt979Pf/t3f6cgy4JtF6Q3vPEN6dLLL9P87xe/+EV6wZ57pj333lNm4SUveXHafbfd0pSeHvkNl1x8CV418Sa8u3h77fdO7cWP2D0XDkUj/VJ1X5D22mtPxT9e8pKXpt123S11T+nWxbfzP6Qb0JOCXyPNP0u8JZtrnrySaLQ5/2xev+MvHD6A4/jXiPEH8y8EqlPlj/elRBDGqLiEkoo7YpGDPKDD47rbJYWDI/F4pDRXVkWhkFCOTUVeNMp1fOII2+V7vHNn7p9GK6Ay/iQH2CJiKr32+UfrrPGhlhgF/+O0m4yPFK8qDzIK1PnPxkcaf/dv/CeOf1S8rfyjEzAS/zpd/1v+LH8TJ38SP+v/mv9n+zey/rX+sf6x/oHetP/t+ccqz7+a/u8KvIf47z/0ofRnf/5n6bc3/CYtXLgwfeqTn0Jooz996IMfTK9+9avTr371q/TDH/wwPYJ3EH/us58X/jffdBN+hO7EdMH5F6SF1y5MH/voR9JnPnN8ms3XTGCKd+H3vpe+9a1vpksuuST97GdXp4XXXZde9/rXa/53E+ueeGI67wLURX8f/ehH02dOOD5tNBt1scTZrVvz3073/339YX8d/wvlIxntpPjn/Pnz8C0nvM0EV65gFu4+Va+AyGqLN6+64KUQl1BiUZZp1kGNnMImL8yP54ZVO3Lp6dDQa4mabMH9G/+1zb9p07rTN64/EPQcK/9RXvQnn1sXyoXeW5ylJmSoSMtE8d/9G3/wrhitGgUH8+/eO55Mxxx0VS4xUfybPPp/wY4z04nfe+kY7Z/lz/I3Ovmz/g9fL7zFidI/lj/Ln+VvNPbf+sf6J75urFk3hCZr4lWa/68/+vfTf7sw/fTSxW3936232jL96emn02NPPNHi/82du1n605Il6amn/jgk/jENr4mYgVdSPPTgQ5oDNhqNtGIFfgAPC63b1Cm9abPN56YHHlicli1bBriRm+MfG264QZo5c1Z6EK+2YKSkp7uRlqPu2Oefk8f/Jma+fshTnstFpIwvMcMYO/42RP5Ce5n/YAwlB5/mwr2Jir/iFS4lQBmddPVLVNUb9dkAvpNAgvKrCeVkeErlh+yY1lPD1TnGCWtNpcgL4A5XaDDnNNPuPwfoA8Dx4P+BD7wvHX744QQZi5CPtfEPPFYr//gUUEX+jD/HgRRv5T8dtKpkkQW88zsC5OMdf/dv/CtWgXUi+4j8U4mKf9b/lj/oqqyZxm5/rH+sf8amf7JyCl/Q9s/2HwbJ+sf+H/WC7Q95EFyAizaK+bft72jt70jxh0X3LUqPP/74EP4tfugBBYjbxT+WIHj80IMPwuOG9kLcJALE9K4xJlg/u/zZdA/eTbxsOQLEzCk+N/aWPL00LWZdxD9Yf/mK5cgdD//ZMvgSlGEL+ET/g+ef9f6rtOMvq2h/Jzf+f37Qn6eD8GnHf/FVjDP/JrP8NZqBKyoXEB4bhA3imql4ZKl0SEkWYHa/vi8f+brT0ShaioRhI/jwAEpHDC2Osxd9vVn9IJ0VJ3vl4v7Hjr/uDisgSQSN/yrxT6+mGiv/Yehb8M9EHhX/NWKswMFL+p3IMcuf+zf+df1LIoFPo+Jf6POKf9LLY+U/eVvvn42sp/1b/sdh/61/rH/q8j8W/WP7F8hBXxI26x/rH/t/Y5x/2v7Y/ozC/si3hb3BXC3iDEg7/hCyVuafwqiD/X9ff4v93WLzLdJztn2OfBOG9Sg4lDTH/whGLJM9/gmXNJRruZPPPSlRRHYFQ8ZCcV9Ge6M4yMInjAMkbqhsq4VKmOVipXZ4NO+CYSUwod5Uzf0HsEJE+I0efw6K8V9d/MvtYqM71jFMFf/F63HgH7IyGv67f2Fl/CeUfzVtY/0LBIa3P5Y/yx8QsP6ZUP0jTsmZLJqobCGLLf6P5c/yZ/mz/rH/7fkHbESYiVWef9WsjdTr8P5ftlTD2H8epYXy/DvbaQHi+E/Eusgy3MDKHFk/418xro7/tbc/ojtWk1n+8y0jvr8C8WItDDgiwTsG4Ae/RiGaMB2pTPogT64k3V3lsC6DzCWKjBqMttP5bxZkoFiNqgn3P378iXuoozwaxn/8/ANvW/mPmyHibnv+E3cuY8Wf3G/Lf/dv/EWmon9XD//ovLTlH3Jb+a9SLB7lwXXKQ7g+ZH4sY+X/Otu/5W/Q+K8e/ln/DSN/5p/5twb0v+XP8tfW/lv/WP9MVv0DD5b/cmCxast/5Ha0/+vr9/gPkX/M+Dpl/mf+D+E/3kmcJ/m6zREalC881gJtyUCvHhJmWmo1H0MB/Ahotai6SoQiVoCZ2hb//CpM9BMtM4DMx4rZkvsPCBVAJ1hAZaz46y6PmuEIBebGH9Rbk/zL+IvwHAKQu4zFYP5LCuv8l4xx7Mc3/uw6pJLr2vjntPtv1T+djr/1L2SkLn+UGuxb/qx/xmN/QRzrX4IgFGx/ZHZt/wFDcMH+h/2P+vyv0/0vXz/0Qt3/WlPzH7zLRzMkxx9a8YflXmX/l64j0C063/EHYLom4w/G3/xbTfLXKMKsObKeJoaYx1uqATqUqsjHVTx03E81EBGpNICHX6kWtCiPTx0hEf85jRIMJucfxGNdRabVMZVTCJP7J4p8mnjs+Ad2ABLPaxv/IB/RCCzWEP9I+sH4k9x0gAbxX0/Y8xgW8b8f4yYxGt/4qyH3DxgG8d/4t+Wf9S9kT4KXN3Dmmjp07PrX8kcErP+sf6x/W/wv25+29sf+T7Y/0Jr2/4CB/V/7/2ti/gM/j/Jm/3c4/3cV5p90/wbPv+gTtpn/Gv/1C/+I8Tn+RxXVifFPjDzdWtBAs2QoUQYq+aN0eko4lCongNQB1Yd3SHIey6t+VhHYRH0U6c9tKvYZt5LhEUTTA1QobND9B36rgD/HgiPHKZoWjp/xn3D+0YRKBkh/jRphLvwP/HUo40+HRAOhinls6vzX4dHLn/s3/hPKPzZm/StJDvsX8jyc/bP8Wf4mVP6s/8ekfyx/lj/LHzhg/xOaM+ak9r89/4j4wyjmX/J3HX9gaMfxF8efRht/o7mR3S1bx//a2B/qFaKEZZLF3/Cb9KCAro0uOJLlKeIS4OVx/osY9OkLXZr5JTwZzgsbKV+vKqCxHvLUA/vgce6xd/e/6vgHtsa/EGwi+Me2wE1++M+70NwTb/MxHWJ+qIeh+LMc+A6rPHb+s6Z61Mb9G/81y7/MPZEfFOw4/W/5s/6x/g3jE/K/ZvWP5c/yZ/mz/IED/Lf/HbMBzz9oGLBkXmC7euZfWfeUfjrO//X1i2Mef92U7Lz5n/lf+N8Tj5JjDSXIIFd5KpivPtDzqTBKPNbQQQR2s7EORY3yjC3rabRosuQT4mgvAutdKFPyBvSeCir30pv7XxX8TzrppIgzF/A5JMZ/zPwjaIWRkSK1C/8JKIGNYCVSgbnyWItlmRsL8Y/2RuA/2tYvFqP20PEvbbr/0D/A0/hPLP8AKNglYIfyr/P0v+Q12ynLv/VP6HTrX+tf+r+2P7a/9Ons/8m3zeIQnCi2Apl5sf8LIAAC1QYfLGs7/7X/v3bnPxgd+7/2/ymlnv+0j/+dceZZwsbxPypzKPKa/aep64T4J0K8YeD1FGRgoLABLZzUB0BhIIsBXb5blXmx0PxhyRk8zn9l5S3T/GqDemAbyFcgTZ3xKBf3T7iMv6hAGcyUWgv8gzQ0+T24fxwbxH+VbcP/Igdkd8V/tDyE/6pb47/7N/4kjZY1wD/1U+Mf9TM4GZQe3H+H6P+MPlEgDrR9Yf8s/9Z/RTZIkpheFoVV93+s/yshsv0TU+jh2f7b/wELKmdflKjYIf/f/l9RpyEvRMf21/4HOEBfbJX9D7ZRlz/s045XWUh0vP/b6f6/rz/r4MHznw6Z/3n8h4w/XjcBxUg1KU0pnalXCEtb4giPM4LOw/Vi+Qhz81Khq6/XqyI0suqhBF8vUcWGS6Io/3rDqABfKbS1+zf+5MKa4h+7yp/R8r/wm1IUg4UGGBnGLp8eEJfVZvBf5Sv+R5VK/nLfKkNvBY1wPdL1u38CxMX4B1kAxQj8E1QV/4JfFf9IJnw6Wf9mCEAny5/1j/Wv7Q914vD+r+2vLApWtr+jsb/iS2V/hRqqITcTiRslbX/EKesfEsL6RzKBVZGPEn9QPiAarf5R0Ur+7P+Gl1sDFslO9v9JMF8/xSmYsTL9K3nSCiVVGDKa55+8I1Pk0/G/iP+sj/oHPzQZZNDJY3CrPTxHzYHN4664A49y2MkfDX45WJiSGdHF0DPS5T2sVMVRNBfohxiibRk/9w/0MpDGX0gIjXWMfzFCQ/mfR65IgLaF//HDjRzdJv9VvuI/RYA5uZURxj9KuP/B+icjZ/xrCIzEPxWr+Ac0R8k/2n3ydDD+yi6rSaz/LX/tx9/yV8jf3I4kf8Krkj/r/9HqH8uf5a+d/bH+aeqdkrL+ASvgi9j/LlrT8w8hwZgDl8r+2v8drf3tdP/f10/B6dz5XyePf2OACjPGX7dQFDPQPtRqaFYFhEO9MmiMP+3gIGO9sRNt5HU/8/iPD5tohprVIDIAue5UYOP+AzVCIzwziMRHcDEsIzi1Nv6rl3+BOccg8Cf6MQLMa8N/jQ6PYeFAYRkT//l+bi55/N1/wGH81xD/rH+DcJa/eISCOGhZQ/yz/qvg1iMsxt/8s/wBAesfQmD/0/635x95YrU65l/2f1v8D8d/ivsR9ic0cJnat5n/O/6VAWtuxhT/sPyt8/IXTxKXKCSdkqIlsOVfFosIYvFyIBR6CJhHKEelLj0aLayDhbslK3LyUfaBEjqGsuyvtMGk+xdOfDeH8V+L/BP6JClGQTc1YliG8J/ZhfCF08yKqrmSCijN7Bb+UxDa8d/9CwHjv5r5Z/3blD/cu6zsj+XP8gcErH9Ws/4hxrZ/gQGhKP6v9Y/1j/WP9S+lwPOPHC8gHQbFH5C1SvMv+7/t7S9w4Z/jP4GDVDG5Nph/xXdpFqjoWGVFDmsrq2X+b/6Zf4VDdf9vHZK/BllLRZA1LWSgnDG3+SlHluAuF5Ja/7y/yXrc4RYFUDf+Ype/GMlFiibXVy0+SKxIM9pHEfef8QNW48F/rxfsmfbac2/jv7r4B/KPmv86B44jPhPFf/dv/Eerf1cH/6ihR9u/LICU/sTxf031T5mlXUJ/8SlP+Y/h+lcH/pb/0fPP+Iu9tj+2v/Y/Jmj+Yf1r/Tta/8f2Z/LZnzXlf45z/u/4S46fSPYYYQr3fcLsn8d/9PofWBn/ycU/vHg4fz1eAV9cHJ+mKsHfnMdBLwOPZF54lymOxMQaTjnq9qNOP2UWH90xYWl8pVQ3TOSz8QDDz9gyiIa0Hk/Pfbl/QkKgykcQCelYEVAuTfz33e+FabfddzP+6wD/aJjIf/EdRiuGKvM/djSgq4v/7t/4r03+dbr+t/xZ/tam/Jl/5p/5Z//L/ic4YP/b8w8i4PiD4y95Tq64iuNPo46/HX744ekD73//iPEnx/8izjNZ4596VCqHsmhVdceAD9hHGBdH8N+Plb56oLglV5EfT5chWJmzGvhaDAPHjdKgtqipAmiH+yibH+BnK/+fvesArKLY2ich9N57UYqCSBFFRRERFey9P8Xeffb+fM+uv+Kzgx0LForoE1FRehEUkF6ld0IPLZQk//ed2b3Ze3OT3FQCOQvZuzs7M2fnzHfKnJ2d1c3/NfrGf50BVRTwhw/n+TgnqolahbHODsY5kxS4Qfw7QSD+eeRfD+GfaYp/d12L+9l4LSh/Rt9xBkwy/hMp+Yk/p+GzxJ+6Ecjh8b/Y6X+TP5M/gt/Df/7Kn+l/ZykBMYcy7yDg/5j8Oc4Y/sz+qyOZn/bf9I/pH294Upz0L3SpG3+Z/5st/ou7/2/t54hTlQR/i934z/o/1P/e+7Sej45QOPWoQ4aDRhyCYoQIP1BHxeKeGjANx5i5yU3PcBx6ouCSeQEbSegBY2Duj2k4dkFmPzOSjL7ytWTJUvL2W29JQgnOQI2B/2Ss8T9/8cfpOES2z39KAYO4+gTE4T81A/4dlh3afdhHwz8FIRv8G33jf4Hhz/SvyZ/pnyz9D9O/pn8LTP+a/Tf9a/rX9K8bL/j7sPGv2Z/8tz+oUWMQFn/Ifvzpj3tDvxb/0YgAAUS/gPsM43+m8qq36UG08f/BNf7S9lr8T/u1OMY/iWBVGPxJ84CgEgC8q1D4J067+me63iSTmEfVB2qCPnEJrCy0UaCcgnEZeAHPJZCX6/Hr5mQLaV4+nhdT+jVq1pQPP/pQzr/gfPCA/PCYkRX/yUzjf97x5+PUx59iEOgN9UOaxBO3gCdf6/Xxr0tHUJKI/wwbe1BzsJB3NRP8G33HQuO/03+FjT/Tv4Y/aiiTvwMjf6b/Tf5M/kz/mP41/Uvfr7D9v+Juf8z/Dbe/sEUxxR9YyuIPeY8/FFH86bI9WcWfrP8PafwztKXWSMNXAIL6J14si8dUE+4UEV0GdWm4AGYGvnjNLS2h1kzLauSMJbSwVwN+vJq1Noc31MsDbiHhKD70T+l8srz2xuty3333y5WXXykNGzUCk+Lk1VdekSH/+0G2bNnqWKgcI5My578q8hDLydPQCQuqs2H8J18YdHfBXT2KxJ+PUgd4zCJW7rk1tnWqtuNlJP59/jO3A34k/5nD6Bv/izj+IA+KUh//iudirP9N/oEAt8are1XF9B9clQz+j+l/MkWVhdk/1aBm/5UNbgf/0/wf8//M/zX/9wD7v/Bvsxz/mf9r/j89GBv/qDNHjU3Hzs1tyzz+pDGPkMvDUqETVwOSYrJ/Jn9FUv74/Ec71QECQMApU0KSot3LFO1pBxhIkfsHpauZuWOKvyEvqvJq0lf2NSOVNBaRZ5BNN5VGV7Y40T/qqKPl6aefkU8/7Str1q6WF196UWrWqA6WpMpNN94k3w4enDP+e3w0/jtYKVZzhT9w0P0P4z/nATslh/rJ5Mzw78E6NvrIHMS/ljX6xn9Payo2iGc3Dz3/8edw7KhpmAsJpv8Nf4WFP9N/pv9pTN0fXEN37EygZxuZVlD6z/Bn+DP8mfyZ/iEGioX+hS2x+IPFX4p7/Mnar85mePyFrqaNf9UdoEV0vqEecDqwxzB11uk48wLyupw80pmo/gVnTDSLvnrvjljIzS3W/Ez0q8WBfs4O53xFnx+3c3m8+HQoIwkik1fuUKbfrVtX+fW34TJzxkwZ0H+ALF26lCzR9qf6C93wVJkRA/816G7859z2vOHPYzlrCeCfH1z0w2g+PkmJS0+4jaAF//Xce1ji4ZjBvTD8xwP/GmTWSrWc1uEIRsW/0Tf+5xv+TP9C3Cijsdsfkz+Tv3yTP9P/Zv/M/jt/KuRjUSV7zpTnN5n/Ra+QzMCbHOoqeozxfnjV/E9ygRuZYv63jT+IhWzGX+b/ejyK3f91c/qc4rH4DzHmtgz6V5PD8Ue9FDb+N/yBSzkbfxn+CKwDJ38aV3MOGedLOkeNioAT2fhyhm56rFMznS/HXsN/13m46AU20/08NohleY1PKV1NLpX7QN3MxawYtBcb+uDHpo0b2GjdVq5cBV6SR8qIwIod7pzJVDXclFcR/O/T+13MSv7U4yPzGv/BKXJLGZY7/JGL4fzXFK0W/MX/rPGvvYU+Scc/hU2f4qGOUN1+n2bAv9EP8Uj5paY2Kv6j6x/jP/GfAX+qG2LBXyCPx3/laMz414x5kL8DTd/kz+SPGMbm4d/0PxARs/w7xmXQPzSayk+Pt2SvHkb6fyZ/Jn8eRhQvZv9N/5j+Mf1Lg5GH8Zf5vzTMMYw/A3k8/ctyseOPuht/KJC78bfRj7T/B4L/M2bMkIkTJwEvmcefoo+/rf8PFfxrkJhBYUaF4z0F6k9Hd7NneFGbS5F3OfA0hMqCgWSNaHJhYq2DPwx1siQSPGXug0jzsJzWxFrdVtzoD/v5Z+nWrZvEx8dLuXLlpGPH45QnQf6TncZ/D1TKC4dBpvCLhwWNP4djR9/1Bem7HomNPm8aJbUwFSxq9CqKBf9G3+e2ahLVGH6K8T8W/OcNfyhdrPWPyZ8vbSZ/pv+d7fURYfq34PWv6R8fbaZ/TP+Y/uFQ25cI078Fr3+Lu/9r7S/e4x+//6dNmy7Tpk3zxt8unBGb/oHVCot/oMYcxD98+h5Fow+GaLiVjCmE+FeQ/wgSs+ewR9QtVWezMgW3g8Cv/8EJXmMqg7kuN355wD/Gv3CdAWPmcs/7vQZpFFlLhgJkxE0o+KmV6a5Y0Z+/YKFMnjxFBn07SL777nvMKt4IzoF3Af4rn8A/usjG/8LBn5vNTbzCHYvAvw5VAFWHVvzygI9YMsM/8/r4Z796AhIN/6yKfWz0VfMY/wsZf4BfsdK/mdsfz24VMv9N/k3/mf43+2f23+y/83TN/zT/240Z/PGfjT84oNL/dFfzdfyl9Vn8Iyz+YPGfcPkj8jjmp6+ueOEB/zIb//OyP/5HRo77MazQ38zHH+n2z/hv/C8q8dd4ApmOic4jTnXw5TkT43CuV73gJdM0Xkzp4DHzEfwUAkgBZ8LqKfd6XScqa744LqyFI3edJfEHASuu9P/739fk6iuvlnPOOUuWLF2mnCG/HZdE2rVtJyl79yEdfDL+kwsOU3rg4wtpCqj8wZ8E+K9s9/DPwRttAdPC8M97yYw+Cui6pyyGfFnhX+0MI85GP4R/4z8x4/RvQeOPMDb9D+tFe+TEnAwpNP6b/Hu60vSf4c/kj6rH9I/pX7M/heT/mP0tJvYXsQ4drqmGhYKhv2fxD48b9H/T4w9B/9fiDy54S56Ejf9ppzMb/zOvziJTUw7eupGF4c9zbshMk7+DQv/EawBL+4095mEe5+hCalDv10vgdUW5g7ofEnaBTO6dufWKeoVYD+rjUxV9nMJTVx7T11wAjQW4rjGSvSvFgn7ynt2yf3+K8lRnCxez9hfl/ickw/Cv55rECzzD3v2G4Z845zW95I6ZLaf49ytxcqhnSjZb+TP6Puvwa/x3zMg5/hzuiq/+90Fk8gdOODVn+gd8MP1LyXCAMPvn+GD2H1qSvryO+pzNNf+HcuJ4Yf5fzv0Pcs/874D/pfww+1NY9tf5fQH+MyEW++/JfF71n9GPkH/jv+HP5C/78UcB6B831ZcGiOsKY9NnSRBIp+QUlxrx9y57T1KcxDqnkG/du2o4l9h/FuWUnFapvpLW7khoHW4qdTr54kz/4Ycfljnz5hr/ixD+/MCIQhbPL3ykKq5VEOlAuAcbxD/zKf6990oy4N9lUIHig5ns8G/0ne4w/oMP+Yk/ylgM+Cvu+t/kz+SPHDD9Aybkp/4BQ2PRPyZ/Jn8mf6Z/TP+a/s03++NUakz2p7j7v9b+CPurisj5LtjjYvj4n7kt/mXxv0Mx/onYFwGPpjG4xeABdxQI/tCb54m7pGl+tEyfsYXKuEtpmA2swTSW5+ZiaO6iq5B7bJiDgrKpOuuRKcWb/vr162Rv8l7lk/GfwFNIFE38ediOxD+gDhRngX/KEmfbqABE4p+XnJBl2/9GH5wmRMDIEM9U1Rj/Y8Gfxz3Tv7m0PyZ/Jn+mf0z/mv0x+2v+hzdmMf/L/P+DZPxj/q96L+b/59L/92aLRY4/Oay3+FcW8Q/6S/q2EQUwMv5RvON/1Jwxx38OAP5AksEpPAFgwBaH3hiYXYo0niFspcFcnuOU1hCbHvuZ2UikxSE/y7mdJrhDXNRXE0FHc6A+za914cjoOx4rn8hAx8JY+X/HnbfLDddfb/wvIPxRuelG0GaFf4du7TxmDU7HT8c/0yPxD6kgjUz63+gb/wknVZp5xh9xFok/0/8mf6Z/TP86FUNVQ43r+x9mf8z+EBP5Y39YT6T9Mf/H7I/ZH7M/hWF/iLNI/WP+b1b6R69BbVv8B0zIavxVQPGHA8n/66/vKXfceQcabv1fXPGvcWmCEP910+AWhghewNqlgTu8rtFuP5DlpkRK9Wo15JZbbtZ8WgV2/G1Qv5507nyyVKxY0Q04kKazJNXThKyRkCOmAbLc0qfm8kLTSoc70ndpPHLnPDp06Wszi3H70/u5IPpfMaYAcuBX2Hr4j4a/9N5wiHPY8/Hnrgbxr06La4InEuHyZ/Sd/iEfyCDjP5WZB5go+i9r/Cn3TP+SDY4VgFXW9s/kz+RP/RPTP6Z/oTNUbeRa/5r9JwfM/0m3P+b/mf3Navxr/kd++h/O6Qvqn+z8P8Y92D/R4h/aN27kbeNvKnbwiSOT4hV/cWMx3R+S7Sf2Df/FVf4RC/ZQTQHHlqqzh52IU51CPSIH/jSnioEqAaZxq1Grhtx51916zF1CyQT54vMvZPiIkfLIw4/IH39MkpNPOkmv80uirVu3dse+k51H+lTwYSE13BbvLBV7/mP73J0inUj3NreUBk/y1v6iQd9vIZqDQ54Vr/YHHmkUevuBoLhw+g5VGfEX7+GP/RPEX0gU2G85lD/GLYy+8Z+Y043gwkatF6n/fPzxehB/VIH+lnP8FXf9a/Jn+sf0j68/1PnASVb6x+xfuP41+x9Cj/k/5v8BDLGPP83/Nf8jVv/j0B3/h/sftK82/s84/rH+Tx/o2fjP58WhEP8rWPkQ4UUAAEAASURBVPmP5xIR/Cidm/MI85xK5jkGOgMMdYPgVhym2QeDDv6H7NThZ35XBLOKb5FatWpKly5d5LwLzpPXer0mb775piSUKElrJl27niYVKlTQYxbJb/q8S96M7jUohyOecAf6SpOn/nE+t/+A0WebdNOWF7/2e/grfP4Da8FRngOb9gQfIOj9ePhL8zDnXXRYRIA5b/Jn9I3/IfA7vCnAqOKi40/heKjpvxALClv/mfyZ/IXAF5P8mf4HB0L6x+yf2X/AQb0heEs5Hn+Y/jX9a/rXc/nM/mQx/grZHDIrZH/yN/5R+ONPUgT+QyJQ2P6v0T/U+c9pxLHG/wz/h578xacHrjR0oMuouq80UpE6ZeorIOhVYMAFWlP1fQ2cY2MdcfFOS1122WXy1ZdfyfrERD7Oki+/+lLKlS8vXbp20bz9+n0hN2N5Cj4wV3Z6ytqdafVI51cSWTH/kMtVrYfR6HOZGJ++ZmYZEtD1Y+B+hipzVBg8OZToK/81IOQxrZi1P1/7Hw9lco4/4D+M/wRkrPjz4Y38LGb0jf851n95wZ/T504zOtjmHP/EraekqawPZv1j8mfyV6jyZ/rfaQ6zf2b/zf8x/4+eSE7Hf3nxf0z/Fhv9CxNDK3Oojf/zdfyrPMqp/B1C/r+1Pxf61/r/kBn/RsE/hsTORPhP8nmmShSRVSpUt2MaDhltddlxwhnGzMCNgVga6jhp0KCBLPx7IR8+sIAkJ++R1atWSeOGDTVty9YtkrguUY5u00bL+RXmhT5vg/RDG+j69NkAXtE/vSecIMDtmsG9f+T/IkXLx97+A02fbSjO7S9Y/rN2bPiJhn9eJZpyyn+tU7Hn487/jcSf0VdeGf/zFX8BtCl7Tf8GOBKm/03+TP7AAdM/+ap/FFNm/8AGX+/4v2b/w/1v07+mf03/mv3J3/FXQNuqeJn/G+BImP+r7Mky/kMNndPxb4Ca8Z/8C/kBkfb/QPPf2d+s4n/W/4c2/r1HRoJnt4gX68aAFw4Q8CUw0vD6l8KEx+5I9y706kooSHBYq2ZNKV26tGxL2oY6kNuLIm/ZshVrF9fS4Ctl4Zv+38g11/xD4ksksFLd8kKfFegtu6rcvQfoc4THp210PtMzMrSnjdJSBzN9n//81Y19V4zazzbnW/+Db/gfwD9XdyJ2SMNxmHsf/8zKLaf0WVdU/Bl9438h4I8Ijoo/pIbj30N9Jvh36M85/ossfZO/iP43/Ud9b/rf7J+nCdULMPvvfCHzf5wFNP+PFt3bYhh/UJai+h9mf83+FpT/C8TxvwNqJvgr7v6vtT9C/orZ+CdD/9P/h2bH/2j+j6/yQ2LFhBj0PyuMqv8z0C/u/D/w7U9gHJcd7AKorqvjtQNxDIPNQC8HSHrM/idatAT2upwDfpHE+Guqt54Y8/hleJCQEI8Zxcko52pOSUmR778fLFdfdZV82a9ftvTjSsTLTTfciPI+fd4B79XbvFtSupruErRtyObayDTepyvprqEEbtzrBlTKI5dPKWg12Omvo+dfL0r0D2t6OG9Xbr75FvzwPvWGXbuLQfu95uKHiid37S9Zkg9JVijvcoR/slpL+XsIBTCv+Oe94CD0KgK+/qh3CJzxmQxlRnGInd4305HD6KfzI1v9Y/wn8IAaf58F/hRZ0NPUc0H8oWiu9b/Pf4Uu+w1OhY9/4jkK/ossfU93mPyZ/Pn62PQPsEAZp87Aj/N/KOxIov/ny7+m8CQL/WP2D+wCsqgXg/rX7L/5P7Q9xAUQYvbH7I/ZHycP+Wl/zz7zWmnVaKvz8mCqOPv1UBj/qw0Gu/Iy/lXzrTbeM+jUyDzkTn+pmxwN/io+ecBNrxv9Q5H/HY/rKKVKl5K9+/Z6Xc3Otv4P4v+jjz7SWA6DOQf1+DcT/yOeOkBnnaoOgOeqygGOvmIB7oqmc+cmHaf6yoM56ejiXPMg/+bNGyU1JVWqVK2ixXVAAcZVqVxVVq9c6dWNmpDWtm07+euvv1QHxULf1eXAqQEN1MFO0R+9R57jXjRZE5AZJ7xDnLqlAnjAmly6q423xTawDNOpHD0FGcrJARIrdiWKGv2F8xfIggUL2chi2X7Fn/ZPXtufO/wDNNiInfSnbjxjsIwdooNp7wGKSyKQmMP9pKUysMYzo+/kL2f6h5wz/hNPseGP+tcpXu9H9R95mAf8KZwj6KtMZsR/0aXPRlD3G/5UnTFcoXqJu8ztP5Fj8he7/HHga/pfFYZTQ2b/zP6b/wMdmgf7a/4n+Bfhf5j/beOP4PhLAwGH3vg//8a/vv97cMU/rP2e/w1G0LUMfR9JYwx5i39N/nOyTBg/HtaFFevoCD4bjLUj5H7UdvN6/tNHrSCLeoswfXKft5fB/ug9H0zj3+j+RwK9dLZPOx6dncaBoQa02PBwZUE2cHOzcf3n3ayY3SiyH+UWLV4sR7duI7+P/11S8TGjqpWrSOPDGstyDRIjEzLWqlNHyleoIPPmztWy2dHnkheM1uNukN9R432qZ+3dP4PX7hr2KhzIDfouUMc0vaw7d6gtRTKo03jww0sop3DUgDGyase7X50dF6LBOzH6hxL/y5SPl3Pv76H9mhn+FaeEA6ECcBAtDkVUDzx2ssQ1r5mDD1EctvjrgQllEYLClkpJw+XY5c/ok6vG/3zDHx3oHOBPYav893Hv/0bHP/U/75WqMir+ixp93ialMhP7Z/Jn8mf6x/Rvvulfs/85sj+mf03/mv41/Ztb/fvT8C9lwrB1OobwPD0cQ6vY+N/iHxb/gRxY/EtjODmO/3E524zxn4Nu/AvjGm38C9HAFXpfOpLHoT+LSkf3NMlaEnqUx8QRM3vuGi8h3bHHGa/PPvtMrut5ndSrX0/i40vI/fffL9P/mi5Tpk52ZFD6pptukPfe68Pa9F/e6fMJsqOPHz3Q2/QpIirHILg2k5d5rBmMPjlg/CdoGMkiNrxZhAoWYp4gx3/FOXHko8hLVwRnhj+tkt94zAX+WNboKw+M/wcAfx72AvhXREbV/5nh35OVXOH/QNM3+TP9Y/rX9C+ND/6b/XfeiPk/NAzYPFzgV18xRYoOmXhJxxc8cJv5f+BWjsdf5J3p3xDOTP84NBSa/vGwR6r8D/4rIouN/2vtj9Q/1v/giOEfMOC4Nl0vZG7/D+bxb7r8x/PZgYKfShD/deatpnCeIxqJxSuZwwVWeV3DipqDO19ne+yQ/v37y7gxY2TcuHEyY9p0aXlkS3nokYd1+iTr6XjccTJ1yjTZuWMn6nWzMVmPKuHc0NfYnjeDkxV5m94z68M5J3G6mcD8RUIqCuHX6Bv/M8c/eRPEv8N6EP/ElsO/hz8meBthRowxiROLo+IPhY2+ciqK/Bv/Cxx/ivDM+B+j/j9k9a/hr8DxZ/rP9D+NJE1lBv/T5M/kj46TP/5wvpb5X+njL/qW5n9Se6ik8Ce0qVbBjknmf4MPOkuQv2SIN/4t7vZXcZOZ/Snu/q+1P9z+cmIh5Sdd/1LZ8Nsu2AdVDxPUq6GsUf9Y/Il8c5GOMP1j8gcOFH39A4g7gGvnAdGer64w5+1TKJxgoDmcEYY0txH+2DQTm0oJEtm3b588+sTjcvTRR8upp54ql11xuSxdslQrprB0OPY4GTbsF1dW9/lAX2/D0WeVpONvuGXXQgo30vWaNtbPYfTJrjz1P8r7/U+uHrT8d74Tm4DNGYN0/CMlAv8qC55ABNtPOfC3EP5YXyT+tGwAf0YfXPI34z95UaD4U1YH8Ed8gqjrg0j+Z6H/UU8Q/wet/LP9PvxwVOD8V2IB/pv8G/8Nfx4HTP5M/xSw/TP9C1kz+0N3Xcc/Zn8PbfuLfrbxvw92/OoWkH/z/238A5uoZhH7cP+jmIz/rP0Z+p8rsSAR2kEtJU7wC1uJRHeFez5C4eVgNgchl+ZgFeKuvl6/a+cu2bxpiyunVaAOZPn8889Qj9aqNHiUJ/oo77Zw+tpSWAS9b2Tg8hI+2dABA8e4ZvTBJTLK+8tR/zvmKxeVmayGkVFl7EHGf9679xcr/pnfben400WHccqnZ8pLZCAniD/N7wPRKxLCn+bz8sQof0bfYz8Bh/+6efgz/mfEn/InhD/Tf4RMSP4gTJQnlSmTP+WMilQW9t/0j0qU8sr0j8cL079qi8z+ZLQ/qi9C9sdzE6lxPUXCHz00/as6xfQvAeGNIzyYEB/++FOxgnNFkvl/ygkbfzg4RNO/yqCQ/sk//7dixQpSqmQpV30Ox78VKlaUUqVRlmDGX7Edf1v7rf8N/0VO/vGheTdMVu0G5RY6wzx6BlaDdpdXaa7pv1GeQxe1MHaaiB+GnnHsr0NFVezqiZOdO3e6111Qtxr/Qqavt8rXbQ4h+tdcc43wLxb+H4rt9+FXkO13+M2If5ceugM98PGf6jkjQfxr/hD+CEOmeLVkIX8uh9GP1D8e58I6wPgPrkC9RsOfMiqEP3AzRvzR780P/X+w0jf5i97/Jn+K6LCd6Z/M9Y/iJaR/zP7Fqn9N/5j+iWZ/Tf+GqV49Mf1r+jeq/8sxP7eQ/ck//7dv375y4cUXafU+/qLFP6LR/+STT+Sii1A2i/Ffcfe/rf1ETsbxv+LJ33nwzin+soo/NG7SRJrgz/h/YPjv2/cDyf/4NCpM1359hOXFtYAb3J7eIcMyfvyRQWP8UzDiIoounL9Qju94vKvD26cyA//jj1Wkh5q1QiSgyTpTAD95pM+nhZFbcaNfqXIlKVmyZIgNxa39oYZ7B3lpv8M8KwJW8Z/odxLAtIz4T7+ml5lJckQ/LVz+jL6yEDvjf6Hgz/SvAxxNE0WRv7oZ/goFf6b/QnAz/IEVJn8OD2QE/pv/Yf5Xuo9p/mfk+DOdNxAbbyho/jcH3/iPP6rTLMffxd3+5pP/yzX1fT7nCH+gTwzrmvzwP3Maf7H4hyf0ntXkT075r0UpKMb/DPg79dSucvZZZwOh3KLYH4u/KWeCu0MNfwk6k8GXMzql0FJUd0SLMzA0NDjyAr/85ZMKKqdUJKfi2t59e8Gj9NxquHka2nwCLhemL+v6rqRBQ+YhUC/mlL6WZR0adNYDJOG3ONFXPvsNZu8Vs/bnR/876KTjHwAKcZSWW79+QZyF419Z79OnjKAU+c8ifvl0gLu0MPyzAhbjhgIh/OPEL88n0kYfTFL2Gv+D+ldxo3wBRnKDP5blH7cg/oA54k+r5hHr1pMI/jNN09NzE/8h8LJezaAHmhyGf788Lx9o+nh2afLHftcODXWh6R8A0/R/dPmn3Prynxv945fnb1D+cUKNws3wZ/gz+YOQqZxF2F8KiMkflARkxPQPtSXggH9kB7GhGwHiNqaF+V9M9i/jYrHzf9D2WrVrSds2bZURM2dMk/WJG8CINKlRs6a0adMObz9vlxnTZ8ru5N2KMd//rlGzlrRq2Ur27E2W0lguIi2Av3i8id22bVupX7++/P3337JgwQJyWvuE/K9Zo5a0bHWk7N2zV0qVcctU8GKI/8XR/7b2F8H+Z6fgD/+dnYmwP9Qd/CvO8bdDvP0J6YrJTaNK08ePbDU3bb3++jECHzDOFLlJ0CGAoCzxxI350xBF1rWAQSTVu0YDxnTS4TVGmp1iNPqUxNzw3/EcvDT+5xp/DuvELYGLP934SwUJzJK9TPMUZqb4Zx5XJP/wb/SN//mAP4Wv6d/M7Q94bPKvTCBUsFHjmf4z/W/2z+y/+T/Uhub/0R7wP0dyUcZ/5JH5v+qv5tv41/z/fPH/VXwj/N+zuneXN996Q1asWC2rVq2Uyy6/VG695TY588zu8tZbb8mSJYs1TlGufHm57tprZfny5Yrvm265RZ54/DGZP3+B7ElORkC4nXz55VcqFaVLl5a+n30qLZq3kLnz5kmnE46X/77xhrz7zrt6/aabbpbHn3gCgeP5smf3bgSo20g/jjspOtHGn7xnXI5J/0D2XD2oy+Iv2nfgnsWfvNhQzuNvwJGnzw1/kKzs4j+HoPwlUPNwejQFSbfQbCrvnHxxV9xBKNm5CdyrAkN6GsrqrA+tD9k9xSd4pYX1K3+5Q4XxOPcfPhj9vPOfXWT8zz3+UNKhPI/4J8j5RJmPPBi0183HP05wtUDxb/SN/1nhT3Fu+rfA7I/Jn8lfVvJn+t/sX0H6v6Z/TP+Y/jH/28YfUcZfOsRLtz8l8aG5555/QV5//U157733MG7DNfznrOAXXnxeer36inz08cc687p3nz7y4EMPyT/vuUeaNWuGAPHjctONN8qo0WM05vHtoG81nsE3q6+6+mqpV6eudOzYUVJSUqRH9x7y2n9fk95vvytNmzeVJ55g2RtQdrQODwcNGgS6enMIxnDYSC/BO2czNJd3EEq2+IuLmlj8qTDib4pB7gx/njQWH/lztiSkhJzAOQXFMC5Qgf+p2DGN8V2nzFw6wUnUaDqO47HWMAU3XtNxybuugWOc8o1NZNe6WFVYNpwzqMY6jT65Y/w/oPjD60KKUOCRqA7h3H+ywST+heHfoZr455F/PYR/l12vZYt/o+8YCF4a/wm0jPrXx1e6/o0Vf07DKnx9mBKbpn/T7Y/Jn0OGyZ/pH7N/kIX81L/OP8hS/5r+Mf1DuTP9a/rX9G/+6F8qXLjI9H7pKTdr2lRq1qwhP/zwgwsQe/7v4U0Pl1pYSmLoTz+r/KUgc//+32BG8IkonCadOp0kGzZukFFjRofdF6MkjH90OvFEWYYZx5dedqlcccUV0qBRQ6lQoYJUqV4N1zq5sggQ+/qfd6MT6sz/Tve/Lf6haCJIDnT8jahWjFJoAvEPi/+BH+wl8gX9dKjGPzVIzKZyi8NUVKe4sAcYVOmFfnmGZCgyZQz3eOrFjTmBZO8az71ND0jCpbCo/nGeJUmwqsBm9HPJfzLV+J+/+MOrOsRtnI9/SgP4nKZPQBTxkpoB/w7M2eOfgpAN/o2+8b/A8Gf61+TP9E+W/ofpX9O/BaZ/zf6b/jX9a/rXjRf8fdj41+xP/tsf1BiMP1RF0Hb79u2yevVq7QKf/9WqVZftSdtl7do1ofEfz5mfY8BatWrKrJkzw+IfOgsZap1blWrVNOjbsEFDadiwkVTBh+Xffvtt0EqS2lj/eOaMWeHjPxUEjjVzOf6nMrXxf/6O//1xf+i3+Ma/XByk+LafLec32DQiRAXCc+4zxH+cAsg+/nNwjb8TqNRci9FoMgLtVD6QCaGLTGQ+MsvLTuFBRubRPdqNJL2uebUsd2SoW72KATevtObF9++UnubnsdHPHf/JV+N/3vDnIVUR6mTdYROYVJzzArBMzOpRAP+6dAr47wmMyxDaE//xsOGUHa1dM2qX4ZTyFsI/DjSH0VfuKW+M//mGPxUQx1nTvxC0qPaH4mjyZ/IHDpj+cUww+we7TMNs9t/8H8UBkGD+X2j8Z/4v5tmZ/0/1GGUrOuOfSP9384ZNOsO3cpXKsm3rNlyGnofvtz5xvVSoWEEqVqqEYHES2hQnbdu1l3UMGuNs86ZNUlUDwa7JHLWVLVfWVQ8eJK5fj/WNV0mvXr2UHyzDeBLzbULZaigbHP+VLVdGK/Lph/zPUGnUwEos/mLxJ+CLUAjaH+KqoOI/Gr0jIPWPMYzCpe+oGf4PpPzTtAFxCjMFgqeLNJnH1F7ABTaoOafpVJm6VZ8QNNNM2HngcSPs0ImWpOJloJh792qFdxTShkZfeQx+KJccw/U4Fv737vOefNr3U5dfeWr895iRM/yhUBj/tR+w6L3+Avz4JZZpzIP4pyL1hEQxriesSGtjGVW1ep4l/pHf6INrym//1/hfaPjLpf5RnKPPHOS5D51QCFRmPGQfXPpfcWj4KzT8mf4z/Q99Yfpf1abHB9M/pn+IB/M/zf92vpSNP3I5/oJ/Gxx/LVy0SFauXCWPPPSIxJcoAcMTJ4c1aSJLFi2WRbh27z//qeGMxki74ILzZNiwX9XJnTTpT+nQvoMcc8wxGv/o3PkUObr10ZKQgDl3qOOXX37WpSaaNWuuirwk1jg+osUROI6TSX9Mkg4d2suxHY6BXxwnnTt31rLxXll6zyH7p6Ut/uKGgxZ/OhDxNy6z8gliSxb/K774g1ZzIkjl5BwRKFJfU7kDqDbmQSL+8wmYW1idJZnActyp+mUKNuzBU1/bcQYly1GjpunCxMzDivCnF7QE0ugIGX3jP6Cg2CCa6BAQPDjG/4LFH/GoEAyjz5kSJM69O3SGOwP+YfSdgY8F/6ySxLRWdUb0mEna7NABHhIyT8HST8UHFkrQUQqRDR0UCn2wzvEiRDZ0EBP9lP0pEl+yhLI0ZX+qa4vrDKRF0z/5w/+UfaCV4KaR0Okr0v2P+0vTKS9oOzs6iD8mmf49aPHPGy/y+Auz/4BbEH95lH9rv/V/YeA/ZR/sZEIJtcj5Yf9TU+jzwjWmDaEvEDJ7oYOY7N+Bwj9fuUxN2a82sKD4j68/SVwJ5wUp46E3wB38QWnwwDsL0k+FDxCPMtwK0v5nRj/78Y/eGG5dG3DA/b+8+l/sgyD/rf1e/xr+io78cQwV8H9TUvfLffffK73f7S0XXXKRJO/eLbNmzZGePa+Tf957D9L7yGWXXiaVKlWU0VhD+I033lBxnTtvjrzz7jsyEB+c27p5i6zBDONXX31VqlStgt4WGTr0J2nbpp0GixMTE6Uyyn/yyafy2usLZc6c+fLOO71l4MBBsnnLZlm7xpWtqmUt/mHxH2A0YvzvRv5IpLmDuSjM+Nvu3cmKaSV+AOiT7oFsv9EH/xs1auS8FPV2iE630Q1zsyXxorwGP3iNCHU/zKVjPC3iEv1LrFCTmUm7GDOOcQQVqA4va+af63zm4RZeyugb/wsTf2XKxsvgGT0cFBWN+cN/opxLTYTwrwMcIB+WoDDwHwv9edM3ym3n/ShjV15/ULafvDy6bB8Zvfw6SdqSLFd3+V4mrb9R2xJL+12jc65/fhmwWJ67d6xMWEtaxIvTYsGaCpJ+LPo3SH/54h1yx1lj9E5N/5Iz7Cl/S5MmLSpJ7x87a0J+2Z8g/9X+FUH5dxwIopY4Lj76z9pPDlj/B73WzPB/SqPP5P3/nS0t29eMyf/NTv4/f3OmzJy8Xnr1Ox19kO41Z0Y/ZGSYG12mA0ov8UDYnz/GrpFn7xknP868InRrQSRl134iz23BUun6Z+WSrXLx8YOk34gL5Yg21R2LmBVbtPaPHbZCPn97piycuUlaoY+uu6eNnHB6gyLtf7nWRG8/R015GX/llf9G3/h/qODvubv/kom/rlXPJtL/rVevruzatVu2bt2q4ujr31q1asiu5GTZkbQD6ZBRX8nirFyZslIBAeDExA36kKdEfLzsxwMtX5JLliwpderUkbXr1knKvn1h8Y8yZctJJSxpwSAyl3OKxwP0FD4w9Daffl7ljzfMukLjTz1jGjWDp0iVpn/X7gaMfv74v8Z/w9/BLn/UHfp0wg/f8pxPlemAhZSIHjsFpg++6Zniv3NQcdFbwdl7KK7qRxUqlRASdU071ktaug/UzTRkM/q6shcZYfwvEvgLGFEP/5pCrMaEf/Yk1EMA/xQ2BjQpFiHZ0jTmjex/ox/iUaz8h4qq17CSvDP4bDIUW8Hxf/2anfLig+NJAWQCuhFU2XNuKzj6JJG1/uUdRKHv3VuIt8xFTGfAXwCjHv+ZS/PGhH9WSt4crPrf5C+EEa//Tf+BIwprGihAW8WcGD+I5N/sj6qlELZ9nZZB/0WX/zf6d5fGzTBjLL/6n/UQUzHSL5r40wZ47cg/+5eGoMnjN46U5F374RNz5JC1/CUnp8hTt45GYLgtHhj3lMtvaanl9+FtH96h+V/EGgEXsO3gy8GPP9O/6MZ8l7+QjlS88KNqWcufw1H+yX+B0EcbuIXq9vi2Zs062bJ1i7uGLH78g0FcfrTOfVXJ47Hn/+5K3o0g73okQr+g8fvxNiM38gmJsm/fXlm5YiXS96v+camOfvLuXRogZv5UrKeTksKRhNOjFn9J5z/5Q7ZE43/W/hd5iT/0i8WfHNqD+IvEf0b/gzx3eDT+F2/86YfrqJSoFeMhdSpaKn1UWU6heXKq1zQljkoRT78og1yUOD2bAosmO55HrIzXdBDl5cNFN10+vZDRJ5+M/wccf4pe2hWaeQ4s9BmKgzC6CFf0WGLCv6vHFXYSwbWJ+Tg5FvxnRT9x3Xbp/+E8WbMkSarVKSeX3HCkHH5kVdmUuFuGfr1Q2hxfR4Z8tVBKloyXq+9sLY2aVsK9x8v6tTvkhy8Wysol2+TsK5vL3L82yPnXcq0s3Bfxh5ulyK5aukO+eX+WbN64R47rUlcuuOaIUEBEpTaT9q9eth3lZqNcsnTsUk/Ov/oIiQMLp09cK1s27MGT+n0y8beVUv+wCnItBnIVKpUCNZEVi7fJ0AF/y9bEZDnl7MZy8pmNcCepsnt3ioweulzGo0zjwyvKVXcc7cqA/vo1u2TIZwtk1codcuF1aAPVC2jt2rlX/hi1So47qY5Mm5QoWzbull07QHfEaqkHuj3vJt0E7cm50zbITwMXy749KXLBP1rI+F9WyK2Pd8i2/7FKpA4+/3FHa/n0nZlgbUCXoWbX2wXX/7nHH5jNrkZfB3W76V/wxcM/8VjU5T/3/Z8/+sfox+L/FEX5t/6P1f5O+HW5/Dx4qZRMwLqR3RvJaec3VuU5efRqadCkgpStWFI+eGGqnHHpYTL4s4Wyb2+KXHXrUZgxlir9P54rteqWh106UmrULqv2b9O63bJ5826ZCZt0zEm15fxrWoSWrXA21fl/f45bIz8PXAI/IUXOuqKFHNe5rnMhqJh8rR3F/k5hObzZkpaainLNpWPneqrHhnzztxzeojJs4hpZvGCLtD+hjlx645E0AlrjZJQb+cMyKVshQbpfeLgc0baGltu8caf8Mmip0EYec3IduQh+ggvUisyZlihD+y9S76hFe8zuDYwB1ixLkq/enytbYXePPaUe7CrKwf+fPnG9bNmULPOnb5J9CJrc+eSxkoDlobhFsz+0/71f/kvadKwtSxdupdnCX9b+16qlSXLe1c3l5O4N9d66nnOYPC1jZfrva+GPNIAPY/iPFf9Z+Z+m/03/Zz/+L4r2T5WI+b/m//uWhOYnqv0JWBvN4+wP8mqBWOTf4l8W/yO48HeQxz8RVnHOItftSoW3RmHQPRw//4NbvMZUOnMuN355wD9GRHCd/hdzueeN7phOJTd9Asm8zINf5+rhgGlejUbf+H+g8cfXqohY7vnwI4h/fTrsQ5Z5iF3GkDPDP/P6+Ge9noBEwz+r0nXzYqC/c/s+ueS4gfiYXpp0v7SpbF6/W64//X+SgkHq5g27pfeLU+Wt//wprTvWkh3b9sgNZ/4AHZUmO3fskVvPGaoDxQ4YQPZ6bJK8/exk2bohWSXQp78Kgd4rOg3Ugd/xp9WTfm/Nkl6P/o48rvG8V26R7V+zdLtc3mmQljuhaz35/K2Z8trjv2ve+TM2ylN3jJZxvyyXE7o1kPG/rpJn7x6HSkRWL9shN/UYIts3J2MwWldewuzc3wYvlt3J++WSE74VLunQqWt9+ev39XLtad9jMI7g8Y79cvu5Q2Xp31ul7fG15fl/jnX6B523BfX0w+um5PP86Yny79vHyHi8gnpCt/oyYdhKefruMap/Fs7eLHdc+JOULZsg9RtVlAeu/FU+7z0npv7/7I0ZUq9JRel6fpNC7//M+J9B/yJjrPjT/jT9D/vn2a0iLP8F0f+s05f/oq7/rP2qUjPo37zIv/V/OP5n/blO/nX7aDkeduxY2Mpn7hoto4YsV3v1Ve/ZwoAv7d+XfWbJYz1HStOWVSQJAdBbzxsqz90/Xlq2qyGzpiTKm/+epJ1F+/f4rSPlDzyoPOWsxjLw43ny2hN/an1qqDz5+2XwEnn42uFyWLNK0hCzlR++7jelS9nMyv4OG7RYHvnHcMxwrqzlHkEdI4YsU/0/ashSeeCq3yQpiQ9868mbT/8pAz+ZR4r6APbR60ZKbQS06zUoLzeePUTWrtohS+ZuknPa9JflWOqhA2zy56/PCNnrxXO3yJ0XDsWD1pJSHQHw1x9FGz3/n77DZZ2+xavTIh1Pqw87PAN+xkTcR5zMxgPpf4OnSxdtZfwbAWLMT1Fh1pZl0D/TJyfK8B+WyL3PHq/Xsmq/T//wllXlgZdO1Gpp/6f+vgavie9F/1TLN/9Lb5nc48EB8P+MPviOzfgPJhj+8sX/VjyZ/2vxHygV3//V72fBqaLdof2lsaLOCdO/PMls/M8SdMr4i3+0R6ycvxb/IjPwxx+3Ux4f6PiP0Y+O/wQC2X09GPMIeaAgdoB2A0f2o1eYICfuKS08xqHf0fpkUZM1g2ZM49Q+5NIUjsAxA4IC45VUAYvDdGSjT0bmnv/lypUHS+Mw83KXz23jP4CaE/zprGEA0YO2QjRP+EddIfoQgDhahyzwr+svx0B/5/a9GAh10pk9RE2rDjVlCGYPb8JM3Xjc/I5te+XVL8+Q6tXLyFkXN5Vjq30kiWt3y59j1shuzOR96ePTUCpNDmtRRa7qPFgNGY2W334GQI87pb48+MIJiqF2mMlzXtv+cvuTHaRi5dKZyn/f12fK8Zito+VQX9uOdeS8dgPktieO1TLVa5SVl/uSdpxUqV5aXrhvgsr/oL5zpWmrqvJoL6wFiz6rh4DtOswO/nnQEtmBmVev98dah2DdmZceLp0bfIYA8hJ8xCZOkrbukRe0LVhiolEFBJp/RD5fu6AAjDfbVK1mGXmpbzecgG41jy6ufIFAcuczG8vd/z5W9c9+vO7V97Xp6dpJ+4x9yFtO138c8H/76Xz5evzFsgaDYt4b25RB/xVQ/8esf6PRR7v1dvGrG3hk+jdof9iTxI3bFUX5z1P/54P+MfrABoUeIFGcHEzyb/0P+Q5JeJj/GbS/a1bskPIVS0krrIHbtFU1BH2rSXnYPu1z9rtXBfu/531t5Ry8lXPSaY2kW9Mv5Km3OmPmcWNpijd77rvyN2oStX8l40vIK59304+p1W9cXq7s/J3c859jASXYGOaBrerz3BS59dFj5Gq8ocKtUuVS8v7/TZWu5zXWPBxzRpO/PpjRfPMjHeQavDXE2ipVKSMfYBbuaecdxoqlc49Gct8zsOfo/6Xzt8osrIF82U2t5KNXpsk1dx0lPR9oq3ypUKmMPnT+qs9sPJhtII+/0kmx3qwVfYXv5I5/dZAve8+SE7s11JnAvMedeEvnF9hq2r/P35gpHeE7PPDCiXqj7egDtP1G7njiGPV/KlctLa98ClusrcGNBexPkP98EP7UraPVXyhdBrONaX/Z8EzajwxKnxOaHTfjZBXeTnq05yh56OUTpXqtsqCFi4b/mPAPNiuvzf4BTZT1gP8XTf6i4Y9OZUH4/0bf9YfqAuKU/RNF/qPz3/zfzOxfXuIPUfkPoIbwzx7KRv8a/dzHf4z/Ge0/HSXDX/7EXxNodFTPcko0jCGP6STwL7SWCxNxmU8u3XV/j87x/rlxk7oXLMmq9ApOtBDzuUCZXsUZ05EKK8zadEq20c8V/3te3xMBwN3y6ad9yUlsxv/c4U+h6rCpbCS+kebgrhd95BPdRG4G/GuGvPOf5Ek4kn7teuWlbLkEue+KYcJZPSWwpAQ3rofFgVR5LKXAgCxLlkE+DrL2Ypbx33M24xXU+pqX99362FoI+pZ08qf3TPkXDCK3yJzpG6TrYV/wVOmn4hXWFYuT5CgEpF2av09v/5IFm1EuUU477HOUgsFDyVR8xIFLSbBQg6YVURkO8L9SldKyd89+HKfJ37M3IbiM+/L0T1vMgG6Dv//+6w/M/m2o+VmGX5TviHysb+/+NOlwEl/DdfTbnlBbSpbCsdbhblr7DPfQ8HAstYHy7KdKlcsoXZZbPG+zXHnbUSjjSJxwaj3p+99AkJiciuD/fnwx/bEbRso/7moja5bvkJWLt+t6YgvnbJImzatIqVK+giy4/kdT0BJ/n85/tpdtdJei01f+s1n4R1yZ/o20Px77yBtuEf1P3vqcd72QM/7nxP4ZfeO/4c/pKdXlaggLR/4YlB0/fKVcftJgqYlZtmdceBiCt+2VuN6LagGexkkj2Be1LdVgS/Hv6GNrquhWwHIUe3bv02NmPw72JZ5TbLG1al9Lbbguo0CVjeu0lXwz5j0EfBm8ZXP3Y+mKPXtpJ3GSSftTMC13ycIt0ufFKfLRq1NZPdbCxN9e0mYhkYZYbkrfioL9rVillGzAevrcFs7dKI+82kmrp/3tcVlTPV6K+i66vqXeGGtofWxtqQybvRzLWy2eu1nOxfJT3Nh+2uSfMZOZtmTx/E0yF77Daeo7qDVCu+A7LNmOO0lzazl75fTOMvH/X310IpbMgk2Hb7MQfksKAm4rYGvr4AFyFdxHdvZv9uQNcs8lPyNwfoxcdTsC7uAf6Zv+BSP0f/b233XwgZE/h1oCxeiTF4Wt/w5V/pv/G7v8O9wF5M/iP8Uy/tXz+uulfLmy8u67fYpl+0P6txjjX9ckVofAPYZ3DhgiJ94kYPoUGiD2LmtQhQ4hvQ2EgdSCxae5j25xNgBWa9EramhYmAf403p0h1Ocp2EGsV8OOQBAXGQ6cxr9HPFfnV+w0PifR/yBhz7++EAkhFvAPIR/JOsFRXk6/l0a6BO7KEjYE8p6QPx72GcaY5nZ4T8z+lyj98X7xsvT73TRtQJLYM3ETrU/VToctMUFZu8rfd4H6LdqXwNLQMzQeyL9xHU7MOsYA1DeKwWSDcTGGVOXYIB4/wsdcck1YCeWd+AgkW3in9uHy38FzHq69Pqj5L7njwuR3blzPwKzpWXmn+ulBOtndVolykKHEK9ly5VEwHV7iMGJWD7j75kbEcAuJVPHJbm6PP4vX7RNTj23iezBh2wmjViJe3H8375lry5DwfrYlCD/+dVg3jT57+4dvzg4Eq8EL56HALa3Lca6h9yy6v+tWL5jPwLU/d6dib9ZGnDmTKqHrh4u7w85GzOaKxV4/7s2cB/Of9e6bPBH3mNj+7PDX7HU/+QNEafyoCdh+CPX88R/lNfq8yD/Rp9MJBdygX8WZfca/7OV/8zsT3HAX0kshfD4ayfJk/89WcZiqSIGbTeu3SkvYRasb198/CWUjger8FAUjFH7q3aUNtXNqyDkCNfENTsUe8RfIoK0tBu161fE6Vq9Hp8Qj9nLJeW5D7rKyWfgoSn8j/17+ZaDq8gzYxn0T3yJeKlYEW/IvH+qrsVL/zsFSzIhruro4YdvGPn+B00Aq6T9LV+utKxdsV0fytL+z5+xCVdFKlYqje8SJOkx82/CMlbb8eZOvYYVpEad8rhGu+nkb8O6XWw9mwWbXUYuvr6VPPA8fAduSNy5PQUPhUvJNKwLXKo0ZwWDdjbyx4/CrsTaxg9Mwkeh0J6dSfuwdNVEue+F46XHJU01zafPhnEcwXxk2p9jV+vSUY/2OknOxfrEmoxLfvtjoW/6Hwwrov4ve9l1qul/3/8N4r+gxx8HPf+JHjTC/F+Lv1j8ycXtVKV6DoY//gmO/ygvIf+DCsDif2QCXAsXf/BxdKjG3+AKsNcBDQaEqDy5o8fHH6KDJ+6Spqnz4LFIg0haxl3iTD76Flqev+Qhf1mNq9AdIpX0UhVsvGj0jf8OZEUefwpo4prA9+/ZDQipNDLFP2UJeFeRyoB/XvLrYj5fXCgbOHGXVIRWY1DH2bHdLmiC5RPKyLd956tM7dUveEOOWJZ/3ALyd/KZDTErZ5N+pIZLUnz8ynQdKDKbFvHod+7RUH4asEjWr94lCVjWYSg+onNFp8HCL4crIa/uyPbzldaf+i/ELKVdmN1cAuUWyxVYU3iPX46FQ+3noZP/Tmc2kHG/rtByHDy+hxlRv49YJZ3PaCBzsK7j9D8wUATNSfhg0DIEctufWAezl+rKQgSS50zZoAPOwVj+gZvjP+4sSvvJeP/VXlZ4xgWHy7DvFss8zHxaA54O/gjrNOIWs8Jf1eplZcisK2TIjCvlxxlXyDsDe2BAXUp+wDlnORVG//t9G8l/sC42+sop078+/rTTwblY5S/P/KdIo5Jw+k4ecBv4TznRzkQeZsYJ/msx79TVgJOQzig8/aP3pndl9I3/DpiEZcz6h5kBoqKM/6H9/9a1/PnRujMvaipdzm6Ej67igSrvnR4zfn39i5ZosvueAfQI/vG/bpoPR/idPTVRFsBmpWBm7aBP5ktLfCCuWu0yuMRKnf45pXsj+Rofft0NWiVKlJAXsb7xM3eNy1b+aXu/+mCO7Ny5Dx/aKyEvPPi7PHP3WGf/Q7qDNxPuf5wI2/vTwL8lGeX2wk4/dcso2P0dcgrqG/H9Elm/Em/KYBmmAR/MlToNK+na/SfBPxiBD91tXL8T5fbLUHwYjy1g/5/cowG+IQDfYS18ANzH0P6L5UqsUZyMD9A6poXTT/f/eWs+ltKk9/dnyZDpV8iP0y+Hrb1Kg8xvDejuAsQeb33+k7hPPxEf5v3nZb/Iowjwn3JWI0naske2w9fZj6B5Tuhr/ym7WDMIhnjoTrFHEgn793xo4d/ajw62/j80/Q8KLwAebn9y4P/pAC+j/FNTWPwji/GvEyjV1cb/gwt/vo+jnWf49zRIuP0/lOXffT0Czg6frHHzfDAnzBpxgmMH55JKlT4RlvXSTDxO3+gcIxn5tRZXFRNwjhOWwz+3tAQq0HMU0LpwYvTzxn/2j/E/b/gDD0O4BC8Vwh7+AX7FqDI5K/wjg5ZzVQHW7BV3ko5/nrv+ihX/QfrnXtUcXzFfhA/LfIOBZBzWB2wghx9ZRZYjgNqgCZZW4Bagj0NtF4OZL390hvz3iYmyDTNvz8csG84wKonZPXv2YP6R1/6Lex4hi/CK5zlHf4NBYQUph7UZn//4VF22Iqv2X9zzSFnsleO6wuUwK+p5rBlcRtcU5C1Qzt0yFKpHeFvg5QV4dXXe1E3S46ivpFadctIMa0A+h1lRlbGm8pNY3/G2c3+USgiGp2Kph9f6nSFNmlbW9vy7Txe546KfscxEvLTuUEs4k9nXP15TkM/rD5B29LUXcJImJ57WQM69vBk+wvMzlolIkE7dG+B12m3aRLLM8c3vP5z5Nx3ofyZpPuyZ06tdE7VkAfS/w4y7Hd6n22Kj7/OfN8v7ixV/xUb/+3wBa2Lpf8d77mPjv7N/qDkP8p+X/jf66fKfE/wH9a/xH3AH86j70rdDC/9nX9FMH1ye2fIrzH5NkFJl4+X1L890SpP6HwzQ9pMPygS3V5ZwRxEnk1T/a3ZpekQ1BDB/xZso+6VqjXLy9sDuni/NApjRA53wMNYAfuKmkdKteT+s219OGmOZiJe4jj8NWhT7o6Sxe/iVE+WJG0fKGV65Riin6/9H2D/KP2/L1z8P4bsDj/QcLqc3/wpvECVI13OaSBd8WC8FtnbRvC1yNnyAyrC9VWqWlg+GnqNlL772SDyg3SQXHNNfA9In4AN1bDCrvaRnS/gOW+Tc1t/otwXUd/joVClTtoTjh9r/dPo5sT/uvlE2YH9x5m2O/lfvzcGM573y2PUjvHTeVZq8+sUZcjaW0jD9Z/pPPUKzvypOscpfdvrHl3/zf9PHf6qAVP+qMVD95/QPFJinhmPlf7Hxv8E0amxualG98ZO1H/YNtlvNdxb2zx//OuaBifmIP+0T4vYA0T/Q7S/O9OMaNWqk85X4gICC6dwqOl2ewiM6sDk/1V3182huIDcOyHFuGjJ6/qy/AAXLptfr6tc0Ak41gbtu9IN8yhn/77zrdsx04ZrEnxr/c4m/chjIfDsDAzfFa874H4l/VkLp8WUiO/xTHhxd/zd7+lvwNXUGYkvh1dhY6K/nV8sXbJVOCCpz27B+l3TD2oG/r7sBXypHgBVp6feZhuUb0mTH9j3C2bPcYpX/vXtS8IrpPqlWw187MFivax/rU4PnyT/P9yTvx/INeDWVH8dTzjn9w/WQt+CjfDXw8Rk/6O73USreqU3avBeD7nRafiOy4/+sKesRwC4pzVtXI3kNvH/65gwZMOGSMPp6EbtY2x8r/cj2R/I/L/o3M/ytWLxDbj9rrDYpSJ/dYPpXpHGLitLnx86HbP/78k0ABPuf54WBP6Ofuf4z/gftRPb2TycfELUAciz2L8jfWPHPdf63bYEtw8dP86L/v3pvNpZHWiVvDOgh22C3q9bADGLckO//Rsrf9qS9WL84TspVKMlLusVCnx+15caP7mVn/4L0kzDbtiz8n5KlGMxlPzj+74ZN5mzhKnhgG0mfH8GFaZZy5flwNtz/51tNu5L2SBV8G4GbL/f+r6Zl0X6fPvP7WyT9wuh/o+9z/9Dwfwx/xdv+PH/3X/L7r+sU1EH9R1wUd/9XP1IJPgT1v6//GHzMif4lby3+46wYwebrHf9X0wL2ryjj73qsSVyubFnp07tPhvG3ogWdHWn/rf8PLfxjJjEgqhqT0MWDel8h4JgKg3s+PMDCX3gS78JeBLVzI1k0CHHNruVSsfc+X4UjryanaVgblA7LMd3o55X/rlfIVWxUPvgx/ucQf8q83OCfPIeLoXh2/GdVTj44VGNPOPzHA//uaTIzpONf01yWmOWPM21ZhLXEQr8KBqZPdh4h197VVmo3KC8DP54rF153JALE/Hgdqoigzw/BVdMAsZP/1SuSZBE+WqPZAiLLey+NAeYJXTmjSHTdQa496FoXe/vLlOFH9hIytL8EvgpfrXY51TOR+ocD6coYiFJ95ZT/JdDguy7+RW57or2u/ciP1t3572NlJT5ItwTLcnBzLHHt51IVnHXNGchsW7r+Y8bC7//c0C+dUF5uvvlm9HWczJwxQ/74809tyXnnni9169bBBw73yqeff64OYbPmzeXULqfiusjwkSNk6dIlYHGa3HjjjVhfOl7WrF0rPw0dqv1ywomdpHXro8CUOBkwoL8kJSVJ5arV5LJLLkXpNJk+c6ZMBi3y8PzzLpDatWtj9nqyfP75F3q9ebMW0rXrqdqFI0aNlKWLFyuPb7wBtPDa9ao1a+Tnn0EL9E/q1ElatWqlgO3/zTeStH27VKtWQy6+5CKlP2PGNJk8eYpK3YXnXyC1atXEx5/2ghbaBfotmh8hXbp0Qd40GT7CtYv3ffOttyAYVBr4W+ocYtxZsP8zt3/MeHD0f37qn9zgz+jnn/43/jurqrq/gOQvAUsmVK8JmwQRz5v8swJ8fBU+NAPEzoY6C0n9GGn/+dCWm69/ZmHZpc0bdqlOdGVV1el1rhHc6hh8LA/6jMFhf3P4iM3+8i0jf83BoP9fFva4LB6kRmt/aXxLgPfCVkTqP37AtZR+PDc6/R0Igv81fg0Lag28V6WPyvgguGPnelK2Ah5+s27sffrbtyXLtAkI8mg+rzQA4HyXNDkWH+Yth3LcctL+SP7DTKTzOkA/0v/Qu+eugPAX2X6jz151feP6F8fGf8NfjPJH/8/fLP5AuwP5wRp/KVhSiOv2cT1r6lryhmMEvmkaj/EXdvyvW0b5I0950eMtMjCPxR9yGH8g08g38Dxn9qdg+U8vi7qWy/5Htz8FS59o8u2/0Y9m/wqe/wn6lAjghMrAHpDgFy9UmQIYClwX5HLTzH3xd44ZlQxTCCMe64nuXBkNILMSZuIv8jCbqhScM0k/qsHLesXo55b/YKG3kdnGf1Vuqm3BD7IkJvwha47xD8H1cO06QInpYST+KSPEP3Pwfhz+vSUYco3/2Ohz1mzfXy+UUUOWyUys83vJDa3k7CvxNXM4WCq/2dDnh3vmTN2IG3fYYiNU5pHCGU9+kNhjNluI9rHByKgsAZUD2H7ld4B+q2NqyYt9u8qEX1fquovPvt9Fv9Q+HR/Lmf1XIu7eu+8QXwQD11IIEtfHlaD+i43/kfT1HCTiY+R/5vo3Z/S1XcoH9rrTvy5AwDNcDeHf6z+mkRXqPaLd6ES2n2W48UdrYj/rxl/m8boe1bor2CtdvawXM6Xv8Zz44R+de5++q9vRIDkeRaePVOKPm95AOH3eIa+G2z/SQaqWY3kWzs7+oQyKeJQ8Yu6sKOP/QOGPnFG2grnkb2Hj3+gb/wsbf1wOqUpVPMwk5nOB/+WLt8kKLCfl3qQJt7/NW6XIUfgordM4qFyly50VVf2TjDWXZ8OXcPKPW8bt+v4/j9seV1ODxLwe1L97dqXq2s60P/zv+x/MxhYffVxtb/Z10W6/NotYwIHpv9j8z3T779ljr/8pUWZ/Hf4pLQeD/B8o/FPgqBks/iAaGN6fmqJ+/KWXXCLdTu8mbdu2kwb1G0g8ljFMTNwgc+bOkTFjRst3332Ph5SbJD6Bq5Pig3ccs4Tkj4iz+I/aIgU2d05HRdpfgu9gw18aFS/6PHP9a/1/yOO/UaPGHnRpYNjhbh94gcylIFcqIgOqZlkCCtd/MqfAB5CYpptLQAEcMB2lvCvuOkHnKWxHkQW8S/rDpwcslb6hiNHPhP+NGjeB4k6VZctWOIYZ/+l95wh/XDdvMJebIOiAzZzhj0EzlMgP/Bt9438B4W8llpu4jctNmP6Nan+acLmJoZ0NfwWEv5A1zwp/pv8Mf4Y/8z9y5P+b/2X+p/nfNv6g84Atk/HvC/f8JROG4U2ErPwPrSCn4z8ONw+O+AdnY6ampUjKvhS54cYb5YEHHpQaNaprq4M7stDjpia/+/Y78vzLL+mwmm93MtRu8R9yyYfbwdH/esM5wP+VV16lLez/9TcWf8sk/ubUzaHZ/8QLHqr5QPd/OUZhENcL0vp6F79M87LjBE9LvGv8CRko1qrl3S9VDa/rH0nwINU90XOV+XT9X6OfU/6vWL4sPUAM9hr/iV/Hh7zjj4BlXWQrKnUwlV6PT5A9u/fJSw9OkHX4CnhO8e8qZWWuQj5K4cb95PGrlZZSDghZkP78GYny9J1j5PEbR8qSuZuypD8HX1b/8KW/PJ6AAOTPbdHph+MvevsT122XFZjhxKvuSZpfJxPC+T9m6HL5tu+8bOmTl2tW7ojQP9Hp+/onK/rJe/bLzD83ePeot8WbDWs/naZfBiyWh6/7TXq/MEVWr0Bfhum/cPrffTpfxvy0HPU4/ZcVfb/BLk90+uzx2ZPXy258YZ6b9kgU+iuXJsl/H5soD139m/w+fKXS56tiL94/Plv+R6Ofjjb/yP/FPYTR19tCGu8feVy2UPt5lfXnFP8BakogiP+iRZ+twxal/b3QH3t2788V/1nlSw+Ol7XQHdyitX8wsDb2Z+/BX4B+cnIKcL1O7S/vLiv5W43lU/7voQnaR+hW11mZyP/IH5bJg9f8Ji8/MkF2bNujZYJGPlr/Z0efBF0eHIH+4M8hP0O8Njm0s/mh9s+ELHzwf1MVaywXpD917OoM+ItGfy8GQI/8YzjWTNXp72H09SSi/fv2pshD1/6mbxSQReH407tQvuW2/d99hn6EDsyM/3uhpx78x29sreNIQP5mY6kB1Q24jezov/fiVJ1pSUKOlutwxyPHf7Z/5aLt8s5zk/HRst9k+HdLILvp/M+v9s+ZnCgfvDwVLQrv/yD/X3pgnKxblRH/69ftkBV/b9Wswf6P1n5nW+Zmq3+I576vTZd7rxgmX/eeo7z2uK3H0eRPez4T+xtN/+8ljtiPWfCfMr9uxc4M9Nev3SHLF23L0P/R2j+a9vTTOXrJ9S3ungra3yLob96wWx6GPDhMIFME/lkst+3ftzdVHr7m1yzpU4+Ng82MpM/vEMz4w1sjVFueEf9++2mX/w+887KBx5nb3+fvHStP3TJa/nXbKHn2nnGKI+WTE4d8af9LDxG7O7y6M/J/9p/r5UPosWj4nzxmLVmOTaXNO+JxePuVt9eNgF7ibC7CCnlctgztX74oCe0drf7gn9CTjtfMnLn8ZUdfERXA//efzpMxPy7X+4zG/1nQ3R/+31+80Qz0p4wZdC3jAABAAElEQVRb46WheBb420MZgi+Who8nRtIPtn/Uj0vkX7eOkn/dwr+R8uTNo2XE90u9e8tIn3VF4i+W9n9HewV5y4z//I7Gw5D5aPLH714k70rRdmRGfyU+lvwudDH9z+HfLdV5VVnZn03rdssb//lT7rvqZ70vrRegiEbfb7DLE3v7Z09FP74EG0xuBvo/yP+XHhwr61dnxH8i3jhcvhi6W6EXHX/bN++TL3vPlgeuHiYDPpyjvkYs+mcM3oL89pN5Xh+nSh/465s37sZ95rz9vLNY+t8xATnBjGD7ffyzFvIpp/w/UPRTMWZIiC8pH3/8sbz44guhALHPf7aHm7bVHer+rnvuluG//irNmzXHLOQUcBy4VoAcXO3XzoL+OVD8P9jof9P/a/kGy/odKvg/2Piv9wsJPJD85/riumHVGXegCheH0AC8sTTMBlZdwGPvjnnuXA+vCH5YjeZjEsvCoeGrvG5z64rQ+KVnpKBqpZrF6Bv/HVZo8HF0oPAH4uH0nbOqsuAhfAaWJKhSpYyUwbp8J5/ZUCpiLcCc4p/Yj4Z/Bpyf+ycGQ6H2Z6S/A1/wfuLmUdLj0qb6NfJ78NX0PXBWfWmLlL9a9SpIu851Ic/p8pcZfTY+u/aTzttPT5H5MxCcdp2Waft//PpveRRfG1+51AVf/YzR6JOXFbB0RSz0ff2TFf3fEAAZ8tVCggkzs6B6orR/LAav330xX+759/HSpGkVeeAqDnhZxNd/4fxv0aa6NGleBTU6bmdFPyv9F2z/Q9eN1MGEsjIK/8mzBzGIaHdiXbnjXx3k2bvHybIF27BOWLy0xHqUv36LQI+2Umtw9456sqJPnvAetCCKmf719G8U/rOng/LP8xmTEvEKeWmsx+2vgUmOehuxkw3/yfuTzmwkFbx1REP8D9BfhkAZg8iR9H8bvFgoV9yywh+Xh7ntvKEye8rGTPHvVzDrjw3y4at/yc0Pt5ey5Uti4D3as//h+CdN3k9u8X9k6xrS+Igqir1o+NuKD3vNn7UZBMLlby0GpM/dO4Hks6S/Yd0uuQ+BwJ8G/u3k2CuRmfwz/72XD5NhA5cgqAxuBvjv/J+8t/+Io2tIwxZocxT9Q/5j3CZTx3qBowj6DyK4x0BDJP6C/Geg4o1//yHvPjtZtsM2ROp/cizYfgZhmrasJnc+1VG+xkfVxv2yPF3+I+inIdAeib9Y+r9mvXJyzCn1lPuR9Fkh+37G5A2ye8d+zRPE/1v/mSzzZ27OFn+UgUeuHy6raVs8XLjuzih/vV/8S5K2Jsujr3aSccNWyMC+8/UetCAKBemDBY6HvM8ctL9kiXg5/cLDs+T/zD8R9MdyC2x/EP/vPD1VFsCeZoe/H7/5Wx5Dm1ct3aFN5a1yy6r9z941TsbjwWJm+GP53La/BF5NPuOiw7Okv2zhNlmzemcG+sMGL5Efv3J6LCv6c6ZskFvP/0lmQY9xywp/lOffR66RMy8+TP2j0y84TEsE8e/jL8j/rOiTXqT8dfZ0d2b854eFF87ZwtvFli5/6/AQ/IX7xmfo/0j6G9bvxgONX/BBXegx3Hwk/aD878FDw5vPGSrnXNZUrr2njTwL/3ET1rDOyv5H4i+SfqT+Jf0W0GONoccy4/+2zXtkga+7IUQ+/XWrdkJ3o82Z6D9yiPQ3UndfxjYv8oKlaHcm8tesVTXt3+7wgbud20RGDV2G71OUYVVZyp8P1Fjb36I1/D3V3ZQxtjwcf6lYz3UygvLR5O+RniNllz78T+9/P6NPnw+V2Bb6n1+/D1380zJntyLsn9//T90+WmrVLCs33NdeXn9qksyZ5mQiGn2f/0H8RdLXc7Qp2P816pWX9lgXXGlmwv9Z1N34qGUk/t962tPdgf6PpP8eHp6sxQOWB1/uJMuwjM57L/8VRj+a/h0CvffIDRhHLHP+EPF/3tUt5H1MfuEWU/uZK5QxXP+G2o8M4fS9XkfXR+t/JR4r/QD+yROtz2NgYdBPwQxiPnDq92U/Ofucc8Lo+/rE5yXlX4+VGXoorY46SvrjmyPNmjaFXHo37i6hLicXehqD/3sg2h/UP0a/8PFn/IeUhATl4OE/lwTWTTvQawFXiXKJUGOesaLmdM3yriEDnRd/o/5zgucYoQaGCgb/dU1JLeZq5gCajxqZZPQdB43/wMRBgr/Xn5wkF/Q8QvG/YOYm4VfA/569SYZ8vQizUSfLg5jtObT/IrQmTRYi/bsv5sl/UebJW8bIlPEIBgD/C2ZuEM5SUPxj1+/dmRj4bZNv3psrG9fuko9fnab5osnfhN9WShusv3dC1wbSAwODVsfUkIm/rVL5Ux5S7CBcpM//27ckCwNOdAU/emWaTBq5Sh6/aYS8iMHKJswy4k0wQDTyh6Xy8LUjdNbxHny9nPf54cvTZCOe1vN4zbIk+eqd2Rocnj5xnQz8aK4sxsfsuDmtwL2jSfpj4PAyUHv1HfiomWbwNEuk/IM+8b9g5kZJ3p0iI79bpgP5Z+8ZqzNjZk3doPRHoK7fBi/FDJLR8n8P/y6rlrhZaL98u1imTWSQxdF/GTOSkzHLm7N+J49ZIyP/t8TTMxnpJ6Pv7n3ueGnUvJKu0bx2xQ7ZtBbt5Yb7jOT/+uU7ZcO6nbIfsxXfe2Gq/IAgNGdfcqb2fnzV3U//BjMkODvx+y8WoI40nXH6+lOTHRtQ74ThK3Q95GEI+G3dvFt6PTFRUvangChenXW5QvR5j3c+3kG6nd9YmrWsLnUbVgBWkhR/Z11yuLwPpzuNs4289msXgBV+/5v+ZT+yQ/PP/lAHnH/tEbIFstH7+Slej8XJq4/9LqsxkCH+hwGXM7D+dxqcc85G+tetY2UUZuumYpYU7d9C6A72LW+u/8cOLwM+mid9npuiWGD/7UjaJ5+8MUP+dfNImTctUfYgwPT9ZwswMF2jM4/YKm7avED/J2Hm5DP3jJEb7m+n+Au2n7gOs7+4+P2XC+SaO1vLkW1ryD//3REBmUQEHDGbGNfYFpUF3A8HE1s2Jmubffv/6uMTZc1yymKcazMC6CzDNxieuXssZgvNll07oE/A/3WYEbgBsyZJf9KIVZgBNhKD3T9k4Ke+LgG9/WkI2i6WR3sOh/5YqnV902c29OIO6MXpqMdtPn2e+e3/9x2jpfulzaRytdKZ4j/Y/qfvGCPdL28mlarzo1/gC2qKlD+//W8hELtjG4Kw2AZiRhPXM+e2YNbG0MMov82U/53bkRdVrkegf+N6zh6Nx8OdrfLS/ePkqdtHybBBi7FGPNqHK9R/0yet0+D8x69M11nQvwxaJNs2JzvdAH2Tmf/FQTaWF5RTzmrCmtx/MCSa/CfBFvS4pKnajSbNKmugZSRmB2bmf/zvy4Xi698p41bLV++6WbjE7ZsI5nJbjwAgA9RvIkCgM4NxC9u27EEAAEEyHO9IStZZXwyajMRsv497wbahveyzNZwh+sjv8uJD44UPCBbM2CwzJq6XQZ84PETDH2ny4d6vCDJedXtrxYff/5m1//gu9fCR0mOlfqOK0rpDTVnuzVRWuVCMay+g5jj5od9CmQP8Eye01/0w643He5L3ydvPTCF57dv+789VfM8GzkmfDxk4e5Bt3p60R2cIPnLdcLU/n2AWs69/VsOO/h9m69NObUN/zIcemIa+H/jJHNjTrZnijwEkzjZkm7lFw78SB31ilv0/4MO50qx1VU9AMto/v/3TMKP3x68XotY4tX8vPcBZu87+fYDZocThru17ZOCH81ybwR/S52z9mV77WXbAR9BjeLDRHx/GfefZP/W1Ztoffqyu7xuzdObn3GkbYA/3qh7jDNMR/6OMp/M/KH/bt+2TZzAz+Ib726B2p3+08Zm0nz5Eu+NrSceu9aTTGQ2kU7eGmeq/rdBjnI1I/Uv6rz4O3Y03L0ifD16d7hYEIJdjZvIo6G7cJz/yhE39PuhibhOpx26CHvvXnzKoL3CL4DD5vx/2/BfoscduoB5bgpzx8O/mSOIa6LFeeLMLKT7/I9v/H+olBEBVjzEj+yKT9v+Kuk86HW09vZG0al9d+nx3lpQsyfk/BAJpsB9Rh4csPlCiTDJpEN7w+h33T/rk3RAE7dn+uaq7xyh+dlB3gz51NwO53Njmx29gm//QOpaoHxjn2ow3sxjQ+xW+Del/g+AnfaaPes1QmqzLl/9g+6m7e1zWXKpUY7CX9+7w5+vfYPsbNa0sJ5/RSDp3byQz/9ogF/VsKcedzIdSLIf/aFyw/W9i9u122FK2mR9t/n3ECj1eOHuj/ADcs/3U3XwAP/CDucA6dTfbvEMSqbtxvGzBFnn5gQk6Y5u62c1cBjFsMyC/T+LB6oevUBfj7TTY/q2bdslrj03COd42CvDfb38SdORZlzVTe0X/szt8uVE/rvB6CZVGtH9z4i68BbJNrrn7aGl3Qm25+vajZSiCp9y0et2nt//7fvPxgBi6CW2bgg9Fftl7ruZIxttPb0M2WSZxzU59q+SNZ/7w3uqIkx2b98pyBG9Jn/7Hu5CRR+DLjvx+iXyCPvS3VXg4Rz+cbwBu48NdPOSahnHBIPB30Tw85PP6IhJ/fLh+xxPHqC6+/OZWMjoL+0P9P+bn5ZCfxXLN7UcBNq6lvIcGTSrJUthT/41Gx4X09megr9//YLOQhzKBOly/IA3n2DMlU/4H8YeM4fqXRVHWp6n4Ix38j2z/gaDPG9kHH+K1Xr3k5JNO4s1q+91OT7FLk6lTpspHH3zoJTj5cyeOX7Vr1ZY333wLde2Dj8oxh9uUfUW4/UH5OxD8N/rEibPsxn8qhYNH/8T7yswJOWdTQc3hVS6nPNCpqvy4c5OOsfKTGmB2Ob94SLWom+puzjrBgfvvHSMHdYk+eXJlNTLtrLjWRdAYfXLR+F/U8cfZSNsQgKlVt7zif9SQJZKEAdT61bvkP7ePlMaYjdrz3jZwnrB0wrIdmv7MHWOlFWagXnbTkULnf/nf2zAY2SmTR69x+MdAa9wvKxBISEYgsIlUqVFazr2mheIhmvytgrPe4LBKIfmrh6DhWn1tN0L+KGOwTmtX7pRJCCyTtyN+XCr93pkl12HGSYmEODj5kyCfqRogZoDqTsxU3QTn9gU4w8QjBzfqMON4A5zlUb8sl4bNKkmL1tXk1POaSP0mFZGPGxVAOP3O3RvLmwN6SI3a5SHf1BNO/un4+UpE1QBnK+DyyCHLhUGM6VPWquN5FgYMnLHzIF5n5b3MwAC815MT5RLwkV90v/3in3QQypndSzGz1qfP4HupMiXkFNBv2b6mtD+pTpj+CdLnQKxl2+pKfxReg69Wq4xUr4tBCpsDmpH8n45XKhfN24LBUJr0xuvUCxEguv2xYzDoWCk/9l8IxwnpcKpXLkmSu548Tv73xUJhoGU/Zvv9+NUCbTbpz5u2CX8b5TgEL8rjg3hX3doKH4zgrFTyKFz/lilXQrqccxhmJm2Sf2J2Eb/83rFrfe3/suUSpHqtcmHtD+lfr/+Lo/6tWaNGLuwPOz0j/5lGLHBP+8cAbBICqDXrl5dqmL30v34LMCDcg8D9Vvny3dkyFjLCmj59fYZwFv+b/5miszVvuO9ondH3IR7UEAh8KEO893tnpoxG8Pjmh46RRejjPi9Nkf1qL+PlezzoOO7kOtL2hLp46DBcEsrEy8k9GknLdjXkGLwdELK/SjFd/ipWLi0DJlwqRx9bK4P9DeLfl791CPI2OKyytl/iU6V2g/KquyLxz/ZXqck2L5StGOSuxoOtL6FPxmIgR+58hoB2rfrlNAD8ysMThYNAChNniJGPMzBoXTJvK4IQG+Ql6JiLb24pjaFPnrtzrKyDDmWesb8tkxIIclx+a2tdUoevtXY7/3CpXL2MnHN1c5UhZAzpPx77+qf3t2fJBf+g7kRKJvgPtv/twd3l/Kuae3Kedf9z9tMfozFrDNk+6TUds1GxhA7udygeDnKbiMDDK49MlCvQpnisX3bf5dBbkPXpmD26ePZmDLj3yJ2X/IIBfl0554oW0uvRiZhN64KRmzFzcOKINXItAgAjhy6WnxBo6dilAd5SKS1X3eZ0g48/0ufm+193P9VBHnjhBClVmlzARfc/avsrIQBz4wPtUBgBHQwaB+Mtik7d8DFOVg6Mk/9B/cOA/Y/fLNBr32L27YevIQiCMz58S0Tgh4Hw67p9L8d2ri8dOtWWW875SZdhYuB40m9YHgTt56x0Pty4/r420g8zl/nxVGUiaA5AMPii646QPZiVxoBTo6aVpHnrKtIVswPrNa7k3RdvLl3+2H7KwBsDu8MOlwv0XTr+yaJg/3c5q5EOap++a6wMR1Dy6juORg7vNjz747c/BRH3If0ZfImX7z6ZLx+jzWlg9p9o83oE+Ej/dsxsjS8VB5veUnohEDRlwjrZjwd1P/RDOVx/6la0eXeqXI+HNP2gE/ig0vEWgTk8YLi455GYIe61+fBKckSrqtL1nMOlfuMKYfwPyt9JPRrK6/3PlBrwPUjD739UjI0tDm//8oVJ8jOClLc+0h68IA8zt781a5WVvq/P1DyUv/54ALwIAWu+tfQ/PAitjA/v3YY2x8FEXcI2P44248FsCgJiP8DGkf6XvaHHYMNvebgdAqWb5X3M3mYcgaS/g6wce1JtaXtibQScRkjJ0gka4DsSH907BvY5M/xVqlRK+k+4WNp0qI27d/o3Ev9IxubaP3/6JpkJHXPH+T/Lhe0GynfQU5H2z5f/qtDdfDi2FQ/6VsNef/nOHOixZcr/vm9OB7Yq4I2pyXhgvRzYbae6+z0EzEl/JB7ubIMNmIuP3DJIdslNrTDLtqJw1vY6YIR3M37YSklIKCGXQQc+jQCo6jHMbK5Wo5yce9URetesS2fLsnEB+XsHeumCa470+MKL4fhnbr//uWTBfjD6ypMHyQXtB6gurlildBj+g+OvRMzs/XM0H6oLsD0ND/uxdAlI/PgN9VgaZmKvkP+Dbrr85qOwBin0GHwO0qfu/hvBYH7YV9t8SyvMsq2ENvu6O1XG48FZAnT3FfBn/gO/d/2aXXIa/MSqVcvIedCzbK/Pf9IPtv8d6O7zr2EegIYMBM0g/qP1/4pFW2UI7O8/n+mI/OH4D8r/evjMk0c53d33tRkIZM4nAddm2NpJw1dBd09Cm1uKlEiTe690PudM6GdOhNiZhAf1F/8sbY6vLeegHb0e+0P5AfbIpkTq7tWYxd0aAc9lOhO6I/y6ChXLyJUMbMaVwK3x7sPlrzKCpdc/0Fb7PwXLbHz3+UIE+uHXZdL+1cuTpE7jisoz3nudJhWw1F0SD7GRYeHtT93v2kf8D/54nj6YwKFMwQPmRNhaPri59vTvpcNJdeVYvKWmuhuTQ9au2Y72cNJJvPwbS3pwSa0b7m8v/fCgdjjGO+wzbgPwQOTi66G7fT0GO34ExgXU3fVxn0H+B9t/66PH4AOTMFasA/r/xCzsD/v/ZOi9N/ufBb8cYy6PhyxL/Hc8pS6WX+O9Zmx/BvpQRLz34hZ/4EOLlH37pUeP7nLV1VdTAMm+0KZBOz2Lkw8+fF/e//A97xryEba6c54mT9u1bycPPvSQ7MfkB6dckahVhuPP+SIW/4m0P8UNf9Z+yEdA/x9s/Q/Pg6IMQVZrTBUMzcs1o2hNQgpZxV31AHWBczhdGvNrefJBc/DAKZdUr05WGVJM0DKsGsunuySj7/hn/FdUFGX8EcZ8Ql4PARRaRcpCOv7TpCleTTvnyuaY5VsHXxyvKat1vdE0OerYmnLWFc0RHKiDAXkDGY11RrmeLMuHy59IDQSVSpUsIbU5EIyQPxUjpO7EjJ5SpUqE6HPAtQ+zWFmj2nRP/pwzh5QI+eOg5ch2uNfLm2PWIwc0Tv6vvedoaXJENQwqO8hwXd/NOVV+WwlR3nN5vI5eHsGLmnXKYcmNUq68k+gw+nF4FZVtYCH3ZXZ3GpJ/nIa3n/Q0s5wGR/M4BMHokHPdMa0GVXEWXPvj62DA0UJKIBCzcPYWpc+qQu1Hw/kF3moI9lasXFKq4vW8qPonQH/iqJXyGmbz9up3pnNuo+g/spGb8gH3wnu67dFj9TXMzmc1llWYhaQaFLTvfLKDNDmyilx521EaaM/Qfq//OWAsif5ugEABZxxkhX8ua3IGXmfetH4XBnlY409vIV7qNawofwOXofZn0/8h/msF7P1DS/+fekpXnRFRt0E910kR+M+8/exSZM7E/mk1qJGDxrrguc//UzGDc9KoVTIeA8ULMLv4D7zuvBFBv/3o47oNy0OWlkAH1EIfbVFd8AsevATtH9fEvvHhtpjFW13uefp4xW4c7oHSfD4Cnq3x1sBlN7aSLRiMkmaN2sR1aWGQI6h/gv3PfCr3yBEp/6H2M49nf7dDp5SETvHbz1fnGUR0OoT34lWDX+K/C/DONxImILB54T+OlEkInm5ITJYUOEN161fU4NRRHWvpOquVMKuXssG3FhgwIv1fwZOzLm8qHU6sJxdf11JadqjBm1H67Y+vK3xNvEOnOjpjasXiJATby0uZ0iWkDgLzpE+l4vPfcUo5KnH6wVJcQR7fp8mq/fEYwGtNrtJQ+/UmeT/KSEeLrzVPwIB0OWYvUb/Pn4FlPDBSnYC3OLqc3Uh+GrREWqPNy/7eLpUQpFmBQf0mzP7SG4Vem4WAQ20sw9DjimZyfNe6aH8zbQczlCobL7c93l5atK0pp5/fFGvybtMHECUQiKyP4D2b5eMvsv38kAw5F+x/nHr3joMo+E/GrFguZdG2Yx058yK8PqqVZtQ/p5zNfna6Zgl0TCs8nFg0axNmxq+Q0887TGe+NYXN4NsQ27fvk4aHVcQDEbd2NP2/5F17ZSJk446njsMsx5p4TbqtstbH//X3tpUWR1WXS/Hgj2vylsEDMwYQatYuJ3wAFuR/sP1cakf7n5ECHMXUfhQ4BcHlWvUrYG1sN6uOBBQ/gfZ36QF5Ho42oNZF8zfjgUxNWYQ3gsZhRinbzCBb4v+z9x0AlhVV2tU9OQ8TYYYJIFFgUMLASBoQlwxLVEAJSkZd3AVWV11WxfQvKLgCBoQBEypBARUUFZUoaUCRJGGAYQAHZmACk+j+v+87Vffd9/q97tfdr+M7NdPv3lu3qk7Vqe+cOnVu3bpwfnGrmBeeXoYHMZOx8pRvDgksYRUc3ndDNk7/7+3R5gnhxP/YFlW0e+yX48GDTbZaDzK9JbDyZhiO8XQ4xqkJ6w8LQ0ZgRXsF/TMwtplVpQNE7Ufnqv4oON///DDRf595ezjvkt1NrnP0y8n/1I1HaVXw4ldX462kheFfj4Ueg0xzmwrK+qtw+v8Tqw7Z5hfxLQK2+bdYLUneJ/q/hB478ex3hc23mRg+dt6OIeAhtAQRB+rFbaDHjjjxnWExtkJgf7G9o0ZDj40fVhF/xK6ciqJEamw7fkSVpRe3/914oPb5y+aGK245KHzv1oPC1zGmp7c1mAsZCvjDpfr69wvDnb9/QQ+X7oHzdPHLq/C2B/QYdDdXMFJ3/+PvS9DmiRrLC/Sbw29/vkCrQbeDrvpX6DE+vE7zn23x0GTvQ2eG7XfdQLYfVzxOxEONgUMagcFhaks5/DG/vX4OLrHBCDzk8Z9v/7Ila/QA45s/3z9c/YdD4PR9PDzP/a2VFw1WxlgQLudCj93x2+e1WnSrd08Kj8+n7YC3m7CQYPf9Z8LJ+YweLrKMUXBkvggb8XWOPcjLUmgb7osVsNTPhx73zrDVdngQiX/E37vnrA/dvTH0+gZ4IDAJqzyXoq0j9NB+Mo6l/M+3nw/W0vgjHrJUVduwXq79117xRDj8hC2B8cYi/JNOvv17HrwRxucX9SbHlnjz7u/z/6m63PEb6m60GSuDt95xYngO8jx6zFC9pfa6cGrcp+7eAPXfH7p7ztyp6nPeIZGhQweGU6i7Z00I74V9tgAyPW7CMD1E2hD6kD7ivPyXyt/qVU3h37FSd1usgN/7MIwJFeT/LejXIcBOwh/nAFjQCa6X13+mu+FABeOefnyJHiw/he1A/oC3MPY6aEbg3uYbbzYObwmsDssx/lN3/+k30HukD/7xmyt3UY99dgfp7o98Ylv1f6J/Ih76bbrVhHAE9Rh1N/UY9AMXhQzDVnx5/pdrP99q/Bu2rTjrCzsjLQiyv1nZkvYnXd/IJAiJPqGxwbTRtnIfOfP6j/VvQZ8ZEJ/xX9dRf7VC3zjM3/inB26GyYL+YblMgRD515v8H2/jQehpp5+m6hmndaqf1BJeaAyL9Y83cbB2pfYz/uMf+3gYNnQo7J/IP8T15vaXw5+GxFT/ft7/3v4om3Uq/53pf+hdcE384xCM0/QUMwqNtCqSpKdN5uxgBkZavKln5MW1Ak7MJo0dA63MQSBe4R7vWxlOH0wTY4z/O+6wXTj//C+Ez3/h8+HdeGKX5zN56/wnsww7XYs/cZsct/98Co2rFSvexoqtgSXxhu3pWomHW8D3IBhzfILLMGVDPv23NHTsrFyxRvjnq5oJ/2tW2/2C/DEn8xfTZ/9PWn9EWILVy3arGa9/r9SrWyBhQfIVz3GgSJOOYIbr6XjiT/kbBAfE29ymIOJvCl7FJX06Vlk3OomYk+2g/K+BIzo5O1WeqsYzMw8q0le9CvRblf9YT64oUwNxPRAOK+MVeIlXzCxgRSNWxS3Hnm+kz1d9SV/1xqqavP5R+8mTmLOUPvfA++In7grfunF/7NU51vihxKy4Gqn2qxlWMGJBHxOokWO5H3WTJilcdcdsY8cjHsYywzisulyJV2ZVDq1TBNJfq1e1WApKFeOsduX6nxP+xXA2bYD+OQD7sB175iy8qouVMKpaM/bFbdDr/CpGBFCP1FjSqzP9e8+9d4fjjz8uvPSSrZZC92Tyl/jf9vjDlOxxMTnrf+J/JfZRHQz5Tvyfe+B0TLpf0Gokbu/wBJxoXFm7F1Z/8+NM/8THXPi6Nh0tyzGhP/RDm0XdoN7XCkROTBmGjxyABy9w+qEzKXNjgCVVAz+NcLrogbRQFuuF+NbkTzCoov0T1x+pVc0Jf0uxwnmD6SPLtp/13PPAGXIq8COKJ/z7LG2dwY+z7XnATOH5Ra5uw+ootplOtQ+c9k6tOGJ9iH+uxB8zhrKDdiByvfHDWSzuNeEV67SSv1l8fpt6J+rfpH+yfmmj/SqzivabJ8Xoi71iXHH/8/X1+7D9AFcu7YwVX5tiL8nfYYXoWGxVMQZ71PNVYL4xwNWmbPfRp26NbW/wqjG7Cj9sx2jojKR/1kPfsl2c4o8cPVSrj9n+IXA6rMXHYWLHI79hQbXJBJuF8n/r/V+u/SuwEv6UA24OW8waF/7zgveI/5XaPx5vVlCXEc8bb7EenNsb4oHIwsCPY83BA88FzyxF/iaskrR+3nmvDcPYSWyjKAMDTZhMDsJ4aFNR6uzUftY+9fUQpOHrq2w/8woX+I2N7HT/c9XzSDig98SqxvMu2U3bOiXuqb/lSbP+H49VtSMxBv75FrZ5bNh5j6lydN+LFXg7AwPPA9scO4nrl7HKfcL6Q+HgSathgx7Y0kkyGI4rhrFYRZnGf12j36l/huBtF25JkOiTZUn+LK5y+8WfVvr/tl88p1exv4KPvZ2OFcArlq8JZx76a5IHDY4PpGboSfTnwll2120LwrN41fworAS9Fw9OubKWK0H5MSo64rgylG9N0cG7LR6GWwk2/hPfYzAeEvAj8G2BodivXW1CPUezzaIN33E0n0rpW90grErIq1z7eYnQlvy/E9vlzNpxEtoX5JCdhoev3Os5z/98++dSj0GH3X3bS+FErLDnm0HEOvUbncvcJuHNxavVz29Cdx/yoS2A0yibcDDwFe7RwEpq53p424HtJ/2xWH3NAEiHQXgDRNsM8RrtKsd/pWXicu1vRf/RxpiLhznj4WynHtplnw3DHbc8z+IUWGS+/bv+y4baRoW6e2es4twU25H8/hcLoIOHYsU4HnwA32vXrNOH+bj6+ehTtsI+2rSzjP/r1pruZgT7n/ovtd/k2dpPO1kyXUI/z3/hmJlz8idogocsXX+kU6b9xBu/OXHESVhxjZTKgmPiP08Z2P5dILcPQH6pu7lal2/CcXU/bTWu6H0eW5fZeLVMupvjFduc6PPjpnSYJ/wxH+mx/iNGD8SCBXPeJt2tNpA2/7XSfm7pdMoBN4XNZ00Mn7xgF+ACiSv0/3g8OFuCrSAsNIc3/rkqrI8xutL4Lz2Glfh3/Or5sBHs2p3x9tm9eGB33x+hu983Df1M3d2s9r6y8C1tXzduEuWXFGDvYyzjg7rB3LoE/OfD3tR+3ie+2X6+tUdskx/KipPUfpZU2n7m/crZd4WH7nopfOfmA7DgZBBSma5srf1EQ6FgMV+0ly+3j+ySvkIb9NvCn/GfhcU/kkL7Gaz9bCUjLb4S/yM36D0tkr/ups++2WLLLcLOO+2sNkj/6EzSlzotu9cCf7xjzU8HPBgZEg4+6OD4ETvT/y35LzT0ePt7mv9Ov2fx7/zvHP/17FY6gEoQ//WKhtSFPaHH0hwpBlNsvB8Vi9LgWrrdJgAxSgfqFCoNqVP8sNwUF5qQCRcYSvCPsTh3+mH8uPHYM+jCcO1114Ubbvh5+L9vfDOshzjxLQ585fh/+ulnhBNPOEF8TD+J185/YKtD+JN5J4Ab/3GKcrbYZnx4Fqu8GMhbw7+dKzL/g4xMcw+MsrX4uAhfzbwTH83h5IqGEfe/I/6XYdL+D6xOZODriWthhDOnpCqTP8SoHc3aouAurAThvsErsLrgATguuGKJxLTqFrlZAn9Inw+Gk6RpII/yxwLz8sctLyin92BF5Duw9y1XuHLFMPeNJG3uFZnwxz3v6ERmvJWuAy8UiugjJlEi/ZXL3sYfJh0l9FN9lRdGY9Z+1j/i/85bF6ht2r8Se+htgW08RsCJsQh1RIbA1wP5cQaWMRi8pJNC7S+nf0D/DpR3OV65nPebg7XHWdJ/3F942VIu00j6j3VAoaX6L99+3sbfYqz0/fv8xbrgXrTb4BVbGtvLMFFfgVf8qP/Iy9R+Tr65ElztJ1gV2Hqcg/4bqMcxu16PD4VgTz3Q556OXJ3ElKwTV6NtgVUsioi5xUP8ME3F9uNuvv+L6ef4Lzpm+Kf+j2R6pf7ng4LXXoc88cEBKjp12oZh2JBhYcLEieF9e+8ddpmzm1brtj7+FPhPXpLP+gP/N4Mj4jnoAJbNuB3xgS5+zZ57jc7cdIww+T1sR/BeOFe4ymgnOM74cZrjPj4LE7EpkPU3wgA8+FD/A9dcNa89zAGBP2JPQso0ey71fyn9gZBLfvk+0be0yoIfC6n/ea+i/kPlU//PnjtFK8SI/39gT80G4I7OLTpz38Q+vPn2s+wd8ZrnI2jzS8+zzWOxZcsE7TW718EzVYH3YiUwJ8zceucIvJ7+4B0vw5lir5gS/1zJ9FtsO8DVStwXkU7HYvwVt38gZISvVOfx11r7VQlUlGkq4j/X/lL743XsV1rK/5GYcE/F6sJr5z0W5sBZyj3huZ/yXgdtLDpc/cwPGR6PfubbGg9CL49BmxP/uUXMo9BP/1y0Ch9sW4utf55DBWFPoZKl9DlpJv1BWD29FuNGKf/ZvhbtZ2QMqf9L28+9y08/5BZsd7EpPoK5I8pQStHnR+/eBq4sFPhPR9rF590DHE8Vfq/Bnp0b4+ODQ+Ec2Bsr9N6EfjruzG3Ccejrhdi2ZBDeIGGppM3X3jeBQ4arU/mAgw/kMvuvAv/5ujpxV8p/8SCnf1u0nxExlLb/LHyccD62JeL489gDr2HrA37ItUE6lR+XKuX/3AM3Chf/91/C7L2mhZ3gDP/pdx4N74DDmKvZuWp0zeomvRp/PFbT0XlEx7sKB/1RePix6Vbjwl3cbgP0fvmzf+BW5AkrVmb8HYgHQBxz0vhD7lVsf2xna+3fdZ/p4erb/jV86sJdw7kXzAnDgMtz8dE+tr/S+MsHPFdf9IgcaFu+axK2hXkDH8Z6DR9MXR/8Wl865+BjNlE/j4IzkfsuC5hWU+kxbpOCLtI+viuxnynbkfDPppN+s9qPB+mDBsYH0eXwX9r+KANt9P8l2M/9Suz/TFrcP3cR8LjVDhOE6zeBb9JP/Gf/83V16rEXn3sjcI9ujqPU3Xthe5th0F87v3d62Birvk8AtufsNUVvkTTCrmBgj1Lf3YatgvhK/qt4GHgf9lhmIBkG9pH0j1LTvsNYTz8f+VAB/8zHnIX+xxkK0l+Z9u8EvcJvRPCBA3n/0F2LUOdxorEEjsRS/Td8xBC8fTQyXIsHzXOQlw92LsQ2XnthlTzxR5kePGww2rwt9NhW2EoFegz9nejvqTY/K/uTD0Dv+/MitdN+rPZsv/CJYyPleY3NG0v5b1KBqrLi+J/kpLj9se3kQa793Dd37MQh2haEtBJ9tpn0VR4ObD+39OJDz+ux7cnOe0wPO89Fmz/7F23vxqQcqzVefXxbjFfQ3Xe+At1Nh7/Zfzuh77ln8WK0dyXsbm43YgSslXn6PCd9Olc5ZpXyP+GPa0jOOBQfHMTbh6f/1/ZZ+5EVId//uEKhG20+JryGhxYv4eOHtHFuw3ZV78bbiUy7DGO0Hjgpr9FnJfY8YEb42nn3qr0cr7iP+sZ484N6jFs40Un9wY9uHT708W2ku7kgQwHt5tswm+JDs3fqrYoQbsEe+nn+q+VqOGuAgB/ashxD2P48/1O/sv8v+sx92sP4G9hehA/ElTTX/4oo037ygABX2Tjl5QJsN7I5ZDbRt7yF9jO+Ev9bt//6rv1LHpBH5LXaj6td3rMLo+0GFbICMWbc1K+dxns8MF1MEbOknLy72667Ijcf4FtKxqXAohL9Uv2f8F8v/O/L7d9n3/3CPvvuC/3TcvxlX0NN8FdI4VkK3v/9B/94ph87WL0qHWxGHcTfOhq/VMzU0HoixhwM/OU9XeCAa2oFxhZOmcUo4NXbZr4zqRAz6bw+6e+2227h0EMPCy88/3xYtAhPuO+6G4Py6PDlr3w1PDR/vrg7/+H5YQ+k+/nPf946/9E3xv/IXed/gmLV+BN0+ewig2Z5/I+fPEyrwzih42RW+C/hvzrPukL0x8DYOnKna7GfH/YTxcc2uCJt9ep1Wv36gV1v0ATuHfiCMvONw9YIXBV72sE3Y2XrAWgHKlQif/wy/Zy9poeDt/sZVtoN0IfhNpg+Gisf1oTdN7wq3L/kJK3iYRUK8kcZNtlMzLG2mvyx/bfglVl+bOsNGJzfxH6PZMUx2FPt0x/+PVYfj8GWCGMUx3JnzZ4cvoKPVtBBy9faMvlnJoo5jwiJPicBpM9w6Zfu17qBf/8Sn2yXyn9MhAJUVGo/0vF0EVasHbnztfqgxnmX7oHXVQfL4XHaIb8KD2Cywtc5J2AvQQaukDkfH4ni15rP+PR2JkO6EyuHw0WYKPAjcIdu99Os3lfCYUzHOPcWvubPhxXxX9nxE2udtbOZjYsD5jA8ADjvjD/CEdiAVSaDw/9hX2Zi5XC8lnfknOu1ungy6mQ8asCHdtYPx+52Q7jm7sP0mqLRKLR/HFatnPSf7w4n7XczXlUdgFXjI/Fq7OaWHW3g6/ibcFKY+J6OKCjxn2dZ/1vO2JRS/qNayE+NQi6Vwx+Lz4hlrGQmu1D+GJ/R70b9P2XDqeHmm28OM2fOhGOqOZxz9jlYpRnCznPmhKee/EeYM2fncP3114ezsa8a26H2qLFZdyK+cvsnYKUhP7BIxz77lU7bTfDa5VCsAmaYg48IPYatCDbF9jNs/2mf3B4f9vpLmHfxw3oV/azzd1I6MRjMOhKT0k/iQz+H7/SzsOu/TMcrm1h5OQg9IJZCsiQ7uEZhrOZmwPWXPnFHmIitC8749A4qq5L82QoythDtgZ6yEDtHB2v/v2Jbi48dcWs4bMefhVVwgJ3/7d1Fi3s1XnL+feHHdxwuMBk24OyAg4ft48MPhp3hTOODEX4Nngzd/wObYPuWe8Nx77sxrMWKpAOwtcQIOBqMZDMmtxtgm4Fx4YjZ12HLg0lhYziaKTd6iKISI/+Rg+2XXsQei6ce/MvwbehFElGKrCliljEIpzG6BP+V268MUZ3zq+27bzgPevQj0M1Y5RT5z8L2hCPlyq/Nx17so7WS9kv4wBcdReT//kdbm4//F7QZqxDpiB2BlZXm+INTDE7VM7F35of2vAEP4dbTlgrDseKUYlM6/iT5exf07LEYI35812FhPF5hTvwv334xTvxPDMjkT/LfgO0hFoT59y7SylA61Bi4BcP539kznHzgzeFMvFq82z7TEVvAP7fZuAj7Bc+BY2UynEvcW/m9eKWcPN4cD03fA7x/cK9fyEEwBbppFhwX6aN+pP8JfBj0M6f8Hl+xHxK40nPYCJMTq2OmSVVvlrkN8PDVs+/ECuZB2uogz/+y7Vd/F/d/afvP/uqc8LXP3qO3UriCVzIIYped/4AcMNzTmfobXa1Ap9FF2K9/FzjR+Jr8MjzcY9/zdiMcKf/xxTnhLOxbSqcft1jhNkWsmwKOZ50/Wx9Y/daXH8AWHROBI74dgPKZJulJ0bL2b4PVr1/Bdwz48JjjaZ7/pe0nDeZSdv0wNQpmubzGKcsZMcrGa35sja/yT8cDLLav0vi7DV53X/zyW+G4szbUpJD7BVO+tWsUFOgnzt9ZbeYDYi50v+CHe6emiP4RJ2+pj5kdBj22G/TYiNGDsLc4aqpGU/+w5gix/XSkfxHjM7/vcDo+Kpjnf4v2I3PSf1ZMlJCS9h+PV+I/e+rt4e59bsKHE5eGs//fHPTRQKwKfy5c8qUHwjV/wnhunNOBupvbnQyhHkP/z4HD9O/Y15grTVn0adg/lR/guxp7rVMvnPXFqLvJf+hTOumY9vDZ12K/2klhI9hxQ7GKeiUfBiNk8icdAvsOYwe3GjsNeoz2nfUkDiSWw1++/dL/uM3CyMPS9tMW223fGeH9u1yv/uUDP64a5UrY3aZBj70Oe1Bvp1hOlk2H8BVfe1h67D1oM8eTvQ6ZqWrsD6clP7R8vHT3urA/tsUZyYddqCOraW0ej/HqOtiB1uYh2GpgJR6CK5AMEyKw/VzRSgyeegh09y/Y5nhThyj/PK/QfhIuN//8B7b92RS2MEPCP/tot+ls80dgA+ONONwzCk2BW05wP+KpG40s6G7wgdU9AOPV16Djjt/7xrAaq6gPhO7mW2JEGfnPVdFn4oOuH9zz5/h4MHQ33uYbhjZHKGf0VZfIZr5dcPTusOvuPDyMhzO7dPzldwj44Or5f7wJ+wC6GPl2gy7+4nf3VIvIEtJO7R8wYEA4+8tzwgd2uU7fOiDu9sOHqxlOPuCXqN/2kjs1SLzFeIU2fx027hw84JuMLbK4rRT7mWEz6e5p4TjobsrBFOxxPAvbD3HbEXKURXzi87PDp6G7v/PlIXoQPDSO96ysSPAHcmD8D9iyY1L4Mj7KSdnfHdvU5PnP9r8OB/68i+bDbh8U9pz5fWQOWP0+JNz0yAfa7H+yohBIszk8jS28Djtxi0gfCVQfpIppi+gzWn2TLyiHP9wTu3G00ov5Xyp/IhKLSvhj/SSjpfQh8z3h/3g7Ks3NNtvMWKP2s5YpWIRwrPbHfk23cRQGaTuiTQX9E7CP9bbhgh/tHLbANlJcDCFhYLtZZMYXXjKC8w+cxXhEZEHJGQ/5T/nSTbuHmy3o54goMa5ZOMvJ3bJLRnQf/dV4SLLgyWVYbPVKuOn7z8GmxWDZQ/2f4b+D9Kesvz70KPQ3mYrCCv0fmUwGI/RW/He2/Xn9W6/tb5g2fTr6PXZ4/kBtyWv7SSkYoXNjvi4LPyUCqpRR+ySlq8QSZhQOGlIcqfQ6ob/1NluFiy/6RvjEWZ/QayBfgWP4iCMOCw8+9BClTdyYPHlyuAmOjkMOOQSvTb+UOGTsw2+e/6efcToMwrfCvCvnWeYouM5/AKpK/A3FnpDXP7JPNohpZUMF/H8bk41JmCwfin32ImTVL9lP5D/l6s+/WRB+jo/Z/L8r94Rj+G3tP0jHjbQtDkvxGvpYvCaYOl7VxdVbWJkyFBNL69DibiVN9v9bMMqHwHjlR55S4AdFPoXX1hgk1yiQCjzJn+qbo29KvyEcvdt14Uvf2yvwAzZc/ZVvP1ct0ik+bIQ5hBL9tXB0Dx5M4yBRj8dc+8nQUvp8RfnPt7wYjj09fZletVI5qf15+tYWTEoxcZkG58yB2Kd4CHjD1Zgxp4y75VjNxbpThiwPt9OAMx6NtK99Rz6WaX8p//l6IVcJnvPV98SysmJFM8lfom8UA/bgXBv22fxH4Y/PH68Pg3BVWb79dLCQjzT4Wc/E/1X42vvQ6DBiWeXaz33F+DGk4cif6N+DffZuxR63531z91SFrKKl/f/808vDqfv9CUyIhPup/t1o5kbh9ttvDzNx5EqHiy6+OGz3rneFfffbD6uAVob99ts3XHLJpWGzTTfVa/3iE1LO3HxUuOym3cTHcvyPsFL/XwodsEHUASk+64AYUcr/5fjIF1/dz8s/+/9O7IvIVUL8CCQ/YHYCJuc3zj8qyhURFnEbCTBmLV95Bh2u9q+WPtMJr1n/F/CnwnCTH+Ecw9fj4/jPV4v5QbFz4WRLdFhGwp/Ki/XKDjEh279q1Rp9pIr7h+fpc7Uy90LcDiviKQSH7fCT8J1fHoitdGzbiUQ/MsHqDQKr8EbGML7einPSbot+Of1Tyv/U/yws6R86fz/1NepRUiimw5jW6PMND+4Tz1eQ8/TZ/7/H6uGD8PE9tvn8j/8pvPs9U7SSLPE/0c+3n6sU+ep+R/ifp5/nvxQPIoi/1H6ukN52+0lyHuTpV9N+vr3BhyZcjZcqmvB/HT4ketAHNpMTmQ8huZf1eZfsoXR5+nn+81V/PgC11/Lbx/9S+nn9yw/t0YGR2r8Ar9bfcSvGojO2EpFy/G+t/Xwjhg91igL4yo+nHog2c1uaX6PN92LfW+4PTOxUwh+dU0Pw8EXz4Srtb5VXRJwELCLxP99+pu/o+BuL1dZGw+AIZVl5+vxo2UZYYT4V2yK9jv3H6XC7+ZH3ozqsCe2AmD6nf9bR2wwQ6IE7Cmsv//P0rdX4BSF+lItbXjRqVTvsALz1RCeg9FiOfiX8leJ/JVb+D0d5DKSZ5P9p6LElS1fZynTQPWyHn+IV+gP1vYZK/Gf/8yHjUOiIaunn25mnn4/n1kb8cC73uLZ6NoQvnQ09htXklfjfGn1ulTMY8swHDHk6T2N/5iXYjoir8cnrQ1Ob8YBegR2NUNr+t1A/rs6uhH8SqUX/84Oon7oQWzfEAlvDX2n7V+OtAraZMsjs8UeYvw2rhw/GtzAY/fmP/1kffDsAexTH5jKxhVz7Of4NwarsjvA/T580Ex1uH8D5ARdopPhrsUJ6W+ydvSkcvylhte2nA38N5EPbw0QiCf/XX/2EdDe3zqEe41uGn7t09wz/iX5qOo9r0M+DMC/QB5rQoe3hf3v6fxnkjh8Q/cEf/lUP7rI65PifH//O/+iDsLVeNpCx4/up/Zv6n9il/bsWH627/LvfCQcceGBkUXO4/4EHwmmnnApZNNnWjdiZOpQZf04+5ZRwCv4YyOIlS+AEfeCUsDX2aucDmSxU4D+jVTY7Wfy3g9UAcbjZnv5nWSovIxxPehH9N4DRS/7nsXDHr1/KdUtqP2RD/I+tyB/K8D82S21O409R05mgiCG4EEPJYRt/lT7jf9v0TzjhxDB8+PBw2aWXZvUnie6ibw0qbpbT717+D+Qy8qz30fOUXQMSHDC4x1cEC51CdY/XbwBgDaIJlDGLEuK8gTsdoyDCku4rPMOJKVgSzvm6GW8g1CP9vfbcO/z2ttvCI399JDzyt4fDqaeeSk6o58n/qVOnhiuuuDJ87nP/ExZGB7EJpfO/p/BnCDb+8yvt/PoxP+6ScCwwx5+E/4R7yksjVhwNw2uKUtUZ/rGv1wQ6NaN85ORvBfY95Uov3YpiQ4XP9p9y7rvkDB3Oj9zwXgzcO5grC/L0KWaiqTRxqMjRL5W/kXQQMy3eI0nyz1fI+MeS8vyng/ima57SHqxZFUUHH+vDx0z2OeIdYk8p/TdeW6MvpLPupfQr6Z8C/xtsEhQJpvTUR3IQq+qgiBvk/wDw/JF7XsYX7Z8jschrEuaegYPDSeClNRgZc/x/FSuqPvSxWbqFpDFJcfsZmegjiQKdGuQ/yx8BBzFDvv0j8aEeZWKhuJPaTyPrsi88EFbAwWQhDuwoar8jNxY/OVnjBDCvf6/Ba9CfhfMhH1rrf6XL+r96/vc1/UP+czLK4Y1CdONNN8FBjA8gItx/34Ny0k+cNCksevkldoMF9n88zeO/XP+fiBVrfIWdK7o1FqZ8OFbiP7duERYy/lv/D8Eqr48feUvYDh/7ue+Ol8JHzn03CxE20vhr9Srgj9vSzM9wLbip7qwrXw0+6ZzthP+8/M+/9xVtKaHUSEhtwBaPxj6WJ5Mm2j+aDmK2JdJ/ZdFyvI66jcXhNy//jCzFv2UtyF9azWX1L+ifyfh42Nn4cNq7sRULV8JzNRw/VmbpCvRL289X2C/53H1GNyVWW7Ca6tzt0BZMnKP9Qfnnx/6u+PrDrBbahIRJoeL0VKzOHzUWk5tUDvsf8XR47ovVc5TlUvrVtH8oHuIk/ZPnP/v/lp89Hf786xfwMaMGfBzpDXy0hysTYwUifatrof+5hcUlX3zA9rKnRkUbxHdk2w86dqvt8bGsXGD7Lz3/QexDi+1pEJ+ax/bvd/hG0CWT47hl+EsJNtpkrJwMSt8G/oR5JEz9z9W1Q+Krynn+s/188HHqQb8MM7Ba/P4/LwwXfP991hcgnPSfqp9rP/covvmaJ/FxwNcIVGtEHP+2xgrXfbiCLkef+W/68VPYUxbpcYNI5X1m3QofE9tXK+7wZgccK3r/mBVDgmVwdh3+YYzjDDn6Cf9t9X8LBzGKYfv5kcZTsFp0I7yB8xfI9IXf35t3VLOC/VvcfjqI03jKtErNzkAjtsZqrX0xDpTi78ZuH38bMyck+Zv6H7XUalzqse2xNcV9f1qEt18wtiJI5+msZfvpHJ6PrZd+h1WVxeU1aHz+yDnvZvN5S79s//x7FoXfxvSKRgKm4evx1GPk/0g9nNVd0X8F2wR88KM2nlfif2v9bw5ioqp4/sOPsv0HPjrGD7bxw3TUY5OmcLUw4WTzn3Lt58eHtXqUtQMT8/J0CvQS96hP9hfbthh67EqswCT9vPyzhad8kumH2AMaXDMfy6QDnvqhHH0WQ65Wkj/inytliX9Lab+kz49v/scHf6uP8XH/4m2ou5ODGMlK5T/RX7FsXfjm5/j2gnUY0cA6sK6nfnI7vRWW4Qn0+eE4rnZW5zJplH+2/2SkH423tLL0uM0gG/iojZWnNf5Xav8QPKi3wD4pzH/Z/7di25g7b3lBt1/E1lJnYZVtZE/ME3Pmxh+Of5fgjTQ+ZECB6jtVDqf7H7FxeCc/2JoKifrnMuj6FVgRnZd/pqEduDV0N3Wt9BjiUvu5gl0OYlShEv9JV31RYn9wLBo6AA/3yui/THdDj90vPfY+sl9NYZ0S/TwDuIDjxh9hXvDIa1nX6T7aT9297xGbtBh/bobuZvpCeab/+IFY6m6QQiiWvx9f+mj46H/vWOwgRqqK7ZeQIUHWfraDjWDZCGXan/Q/bol7pfKvBiqzEugs0SevKWbEoQVKMs67kb41jw8B0ryCVWA9GsL2O/AtNMof+WDYvP/BBxEXwna4p9rqJpPFuvOm0nOhwjpEM744pPZ3RP6y/m+n/ZGvQW+iz/3OP3nxu8JX0RF/+hUeUHRz/3cWf0QucdxX8d/Z9vd1+a9J+6dNmwE5BxSIBiuR+iNTBNz5kLsy8XYKPNcADwXBr7DryXC6iaPuJ92hjJajkKRwbQYSrhlVAe3qRAAAQABJREFUJ/TPOuvfwvLlK8Lll18uA+nqq+eFiy66CNtMPBQ233Tz8B089TvvvPPCH2+/HcLZNv9PO/M0W0k8b55YLO46/w1uZIYh0q71Kw7ZGUYl4p/7K17/131kKAj/uGtiQGOFJaigLPeCp5aGDTYcgSeoXCka71lCXaWxk6+/cfUoX08rhBx9lC5ZYlQO/2uweveVF5ahrJb0p8wYqddcaanZXl+V6VvVCvSsDoVrK785vIx9zibwy9uc6EfstNb+JP+LF70l54XKzbWf+3fyNcNq6Stdrv0sr5T+ktdWoX4NeA1wiPGsyvZz3zXmLQRr/wA47qfMwEf8SJxRbdBP+S03fsvQ59td3JeTX7VWYGIVHpmaRdp14j+TLMQWF/wYSyn/x2MLEq1+U95UGicweN3ub3jlcht75TIyzKglcjn6L6SVxLn69Ef9O3OjjaQ7Z240E295NUu3vvDCC+HCCy8UB+lgffrpZwK3/FmwAA67OP7N3GJUuPRGrCSOvOOhnPyRpcTMc3hNdANsG6JXlVmyZajIfyaxYCXwPPU/V4E99bfXtb8vHRwMbdFfjm1hluCjSqX6hw+kNsSqZIVc/3OlPffaTQjifdLnfqhc/VcL/LPxal3koS4sRtWxH2s/5x+cGI7Dx9H4Mc5q6K/BCv9F0FVJ/+T131S8LssV+nn63Dv25RfeBNlUIdbA6E+FHm3Eq+i1lH8Wnaevi0jP2g45h4OB9ZqpLYbK63+mzfc/nRL6yGhWe1CB/hk/YXhBN1gGUXsJOkjpWZkc/YIuMX4k/ClJDfQfyynX/qX44NJL2PeVW5TYA8e26XNP2ZVylrBMNYSNkYOEH9Qr1b/cC57OmFL63Hph/KS4ylElKEU8q47/efqWG79l9D+J6z6ax33zFz63DG0ehzdu+FZQClYCr0r5v3gR22wTeutO1g9txupnbrlieYgNo9+d46+I48dqb/Tz8seKrsZK/ych0zPxZsQoOC6VOOZI+VMJ1paGsALjs76lUII/buVh4zNzkKoFG8/xwK+E/3yjinpM9SPTGJRNMXadRVqCUv7H2bBSMYXdL6ZvpeE30uc4nOkxbJ2h+23Qp31Hm6scfb5RQtskT9/03rJc7Qv0p8wYoYfhMUNV9IkghnL0460i+nn+s330LPGBzLiJwwsOYqtwRfp8O4u6m1RL6XMLrQGUEfNGkAL2bmb6FbEeoqp4nm0I3T0Ab9GU4o9Fq/Q2+F9KX5lK8Jfnf2o/5ZlvBG602Rg4IyGbmD+ke7GiLehT3/N7JIWgGmILimFhOBYNlI4/tB+pu0vpj4MO4xY8lhu/JfivRD/Pb6uDlcDzavr/DeqxBdjSDLqbK4qroU9dzG9oKHHMQXp8k4rjfSn//wldrw8F5vqf7R+OB6vc3ivjMeIS/cexpdeW204q3DOG2X2eMzBxzPHFj2El8a3RUSdm4U6c/ylJvv+RD+ytav7dm/0ftH/XrVsbPv3pz4QzzzyTzEAwDhadxahTsbr4gQcfCPffz4c55YMlbQ6P/+PB8NBLX8I3OrDHNd8gaoP/hdLy9Ltu/BU9ksq11+rQ/fSXvbkunPy+P+Lj0NySJ0e/l+PvuBNODCOw3cSll11qrMtqjzZQ/7j/r9/7P20lcU6hcsLMgYNPbROUdQYwmxIAMPCklIMjveyKk3JIFzbsKHMGq0TAxIOvodCZQhpUxCqDaYW7/k//lltugRP4f7Ba+HtQrsPCjrN3ZOvD5EmTwxVXfg/K/KNhPhzGDGItGdMa/5WS/Gdw/nPYaTf+jNHAY8QfCsg4ijj7+gHZa/jfCKuiCGGlUV6csY8QQ/rMwnvc0y/t24lLxRXhn5HMxoAMif5gfD192jtGIxI3S+gHyR+qRAIMrdAvJLAzZilHf328Os9gJq+1IxUvIwiDgdGx9if5n8DXwxvoDGZqy8djqpIK1ZWdVaKvu7iZ2k9mlNLXl8MlB+AxjtW2nyuM0ypjo4/So/4xplvd8vwvR98aVdx+5UyNJTbQV3TQpf63kpnAQmvtnzoD+dTuxEfmwbn6304T/th+Pv3X6hERQ8nkDfKT+1XTZxb+MaCIjP8ogHW1EmPZukDZvV7/qzVqj52lBlqUrZrgHfCKjEq3gYms/bjH9jNUwv8MrK4hr43ZkUcsk/94adnxmwhYXDn542v6W+N1Uet/Uc3yV6I/Ak6Ykfq4DomRGunYsRx97ivJPJjb5vDP+sdsyNqe9lcrf5XaT1pbbGt7GKvaVdAfjNWW4jvSSoRZeTXW2s325/nPSe30d2C/9xiYqrj9JFq42R3t33Cj0Tn+g3YV9KkblI4ynvS/suban5P/DZGebS0N4hKyJP0n0vpBSrICvCQHeZHyV8Jfe/p/7LghYew4TuhJozr6E9anUxSJ2b+58Sdrf6qgqtscJmAlepgsCrEFyF4SeLec/CkZbtay/WPHDUWb6RAphLboT0SbsWEAMjAlQ679vKTez+nf7hx/janF9Fkli0d9Ubch2F6D+yvHLtFtS2Cn5do/Em8+cP9XhpbjH3BY0v/8UCBXDVcj/0aVtbFQjr4qy9u42ZH+x6I36DE+qFWr8Yt/ZIeRjPF2kegPhoNzembf4V5MnG9/ys/2c7us6e8YIx5n+FfJER/U/zn5b4t+p+UfbdxMHwyrnv4gOIGnoQ3F+pf5Y/vRhDz/+TBJPCrp/6z9iUHK3z3tn4pFBe2lz/3rU2CVi9vPRse7PEVb+ZAgAwRvlrQ/L//K2cXtHzNhcBgzDm+riE7r8s96E/+T8m8FxebxwPaX0/8T4zZTefxbNsQ0QNJz+j+1f/NtJ5rYdKb9zMs/hsh/jX/gueqqaJxRtkSnpP0pf87+YvutYioVP0xkgWUWjT8pP293AX3auvwI8fyH7W0qa1OsH9qoupJ2qiKxppCOvIHzrP1IqrQNYeHLj+OBrW3pk6VBWpbJYlIJhcItrqj9pJVoI0Ne/lP+Uv2f+r899oeaZC0p5n830ece3Icchw/DXvxkMX22vVz7ew3+2Cn4Y2ewnsBBEf9T/Xsp/tm9BQaXwV+qP5OxqeI7InsN/1kt8p91Yh27n/96LEjFnBhprw8kzvHRGgMVtZ0lwJgqYD42IOanQtI/ZUE045U7y8/7NFBEh9YVktQb/ccfeyL85b77w7XXXR9uuP6G8NrixWBCQzjttNMwuE4O3/veFeGBBx7E30Ph/R/Ahv7kUCv8pwwzDctw/pMDxo6a4Q/Mb43/RfhXHxDfFIsa4d/pO/9bkf8ux18b+qeIvjRQjeWvI/RRhdblj3UsGX8os5Bf6VJpkTj+ufy5/PWk/Dn+HH+OP+hlqmbYVPqvmQQieEE7Cwyi7eX2l0Yutz8JC+KCyOCDBp3iHFftnX+6/s34V5fyR8xUq3+FMIGudvjrJH1+D+IPt/9BAqBmUGXqBD8SEZMTJuCZnOSgKZ3KyCL6itDPojceDKPwgG8gn3owvevfVsefOXtPBpc6oH+K+M/Osz6iXrMLHiP/RcEua6X/qEb7Mv7Jp1T/vsj/YvlT50tGu6v/9U4TP+wksOGXj+cz4gKh4EcI2gmPCukpFFJrYo0S+MAPefSEB23Rii2mbQYZXuNPdFCYvNNEH87rkf5FX7swHHP00WH/A/YPzzzzLNjSjD2IPxc2fcemYYfttwvbx7+fXHONeN86/8lX539vwB8VM/EvvEe5yPBvvSTMdxX+nb7zvyfx12v0P2QtG3+gQUvHH+nTLhh/XP5c/npS/hx/jj/Hn9tfbn/mxv80/3T7m7PE+p1/oOld3f5eY/+ym+P8syEMCCuWLQ9Xxe0o6VCQ/Ut24MScwrzAJfLZhiJilkUyPjuzk6ef+1t4e8g/8HFQvAESv0Wghy8+/604/98IH8bmSlUys6vm/70Rf5n/Q5Dy9ve1/sdGMjkFAKViL1mwN01VENTmxG3CWza4r4k1Vlgh3vocKoYnAj4higm5FE8sGOmTF19vjCCtXh9gOiSJWXGGUGf0V69aZTwEI6TQO9j+yy69zPivPnH+1wR/cZUhwU388zNofMU/j39hFvgu4J8ygT2kK+GfEBf+lbN1/Dv9qByc/7XEHxVOf9e/C557NsyYMUM6kSD6N+wBz8BxiPK3Fnu08T7HH4Z01PijCyRy+XP5AwwImFrKn+t/k8Mkd2IxLxjy9o/Ln8ufy5/rH9e/Pv7Uav5F2w46pb/bv6XzX05I+a2Gi77xjXD00ceEQUPwcV8NuPaTP+f81Tw7hVgbo+NILf9PQ7j3sR+HKZuMwjd5GuEpQkByeox8/tv6/J9b7qxevU4MI4cjV8nBYvunl/jf5l01Dz4Pq6n7/4r9P+w7Lu6kTW/475/+z/g+LVtLe8Q2y1eL2XiKfHbkFRWsAUa/WDnMwJRcgZytKLZo3kAgCZ1wDmB/jMO5sJfS4liv9M8959zw6KOP1m37EwR6Vf9zOQ6RnfBPaeAkVq/WCPGhqQX+rSWGdmXHTzn8UxDawL/Td/53Gf5c/7r8uf5p1f5w/ev6t8v0r4//rn9d/7r+hYrNhaL5j48/4EyN518oUT6IOvQ/NDY2hldeeTmce+45VL0VQnP4zne+jY/WPUDWx2BzXU1YEcM58O/v+GEYMPrxMGa9oaFRHwpGifL/WJZcVkT4/Dcx0/1f9St/lIy+2v+U4CT/emIgAacWwR/PTUXgwrSrFAxvc0Ulo5hG7mOUhCiLwKEQWII5mC0B7+CJE9JyP3oFFojAJxYsIhGx4ngTf/2Y/iuvvoKnS/hKfZ22X/3dG/o/4TRCjkas0AvsmRw085sVqm4e/1pzXxgLieBcYE5bld8m/p1+sfw7/7sXf65/HH/UXK7/xAPX/z7++fjPN9Pc/nH7j4OC279u//fj+U8/tn/pPxkAR/FPf/pTbGv5ebNz5WzJTVXT/DPagHabcl8Id99/U3hh1U/DtE1G2wfZcdvnv+BULeb//Rh/wpIchMSS+//6kv/TnMQZOOnOxSAQlYepB3v5QI+K6NRFJJ2ZdHzJaFAiRtrgIWdu4QJpcAu3Y8mER/T34oyO35hAJHHNGKdvbDHuOP8NjgBfV+MvoTThX0e+bsz+AHEcieVS/GsCEfOYFOBCnRd7EICuCv8pVSzL5MDpO/+7CX+ufyW22fgjOXT5c/nrJvlz/e/yB6i5/qG8JT64/nX9SzS4/e3zj07Ov2Df1rP/obFxQBgwcED49rcvCx8984ywfMUKCpZCmr7ajNXi4uyVsENoDr++/fLw1LLvhU22HBdGjxqCVcTwjSKRz3/FBGOaLBhwTMyLHKx2/u/zr2L7L+LO8NcN/h/nf1n+w9PLLpCY4xgHYnZOslSRzdb3AvCUBSbHPfvXEMaNGx9OOvkjiEzOTGUOUzeYGnbbbdcwahQ262Ymuc5REj4iQCebgmh0jr7qE9vAkiygfDSFdWJw+s7/6vBHPkXU5PDPJ6Xm5I2QyuG/CH8R1hKUNvGHxHn8K6/Td/53F/6kGCOgO67/i/CP0iz0L/3r8u/6z/V/HNwwROXtvyL5j0l8/KtG/yGNj/8AEwEF/SLsuP3j9k932T8uf3Wnf+jJqHP/Q0PDQOxPPCjccMMNYaedZ4dLL70kLF++nK4dC1THCukE+w8/8Osw78Yzwopht4TN3gkH8XpDQsMAeoXITybmD/w/WSE48flv5AuHefCHf3xIUef48/b3Pf8nPlyXJJuCjvN4KUzrApsx08MuDRCNOSZF4Ks3EydODGee8dFw+Xcv19piPqm64sorwuwdZ4cnn3wybLrJpuEjJ58U7r7zTqzIbA6zZm0V/vrXR6FSGk14EkEpmvbTN8Vklba1zeasNqOTteQnx+yJF+k3ysFHBef0pbyc/wQJQgR1Gfw35fAvduXwX4Q/xNvDE6AulkPnQhH+IDQ2uFKmWFCOIM9zl+aYaApOv6B/xB/nvxBL/dse/HGLlEbs8SP8uf4rlj/Jv8uf6x+Jltn0YobrXx9/fPxJ9r+PvwVTsb3jr+Yfbv+5/Qsh0tuIbv936/zH7d/o/+DktGFwePONN8P5538xfP7zXwh77L57OOT9u4QpU9bHN5sHhLdWvxGWrnghLF/3aBg9oSnMmDUyjB49NgwePgBzCJukuv5r3/zL/E/0BtAH4P6nIv9HK/Ov1vyPRfPfyFl5VaIfhQ6VIv+L+/9s/G0H/rTdhMYqZDL3KthKHQJO05WqoHOyGvBmFHsG/62DzOWQ7p180slh0sTJYY89dg8HH3xQuOCCC8LFF1+M1xwGMkuYO/e9YeTIkYWyU5mdoB/wwb1En0dzrqmiqrDtqaYqi0GWJrYNF51tf0/T3367d4ftttsutqP+2t81/CeKIkZwoKpRjGBVjP/y9IkySBTAlfCnhxgUGpUXy66IP6fv/I8YEV5qhD+gmCHjbUX85dJE+sxXTv+Xxz/rjr8c/kmZowVD76fv8pf1US3x5/pPYpHxljJBUWlh/zj+Mh45/qAva6T/Xf5c/iRPUjpUPK5/XP/Wz/jTZ+zPnI0cx79MVqnD8Z8HKbMO+D+4TQQ/ZjcQfpmBAweFO++6Ozy75ObwxpAbwpJBPw1vj70tTNrs6fDO2SPDO945PkycNDQMHT4Yc1m+fF4Nfaubz39L5v+OPwIDXGhr/Mml6QL8O/3q+S8nsR4MwSuMZxvqwLQdhE3oYxzusFhdcTUaO04RYLe8ynbzqKOOCD/80Q/Dq6+8KmXC85Ejhoe5e8xV5h98//vh5JNOQuJC6Cx9bYzDiuGPnc9/nGIlZZacGIxiI/IAYS36Ov3ZO+8cZm07q27b3xX9bzgyUEXYRFwRMMX4L0+fWENOZeZDDMoJ43SGk0Iohz+nb1JMbjn/BZtuxR/RWa3+L49/9FoR/lFgO/Df0/Rd/lz+Ev5d/3S//nH5c/lz+aPmcfvH9a/rX7oakkbsjvlXT9uf3UWfC5gGDGjEIr7GMGnyiDB909FhxqbrhWkbjQoTNxgRRo0eHIYMGaDtJejwoSx2B//rffzvrv5Xd2qYKe//O+GEE8MZp59Bt4X+qu9/pOzD87/ewn+bNCf9H6+q8j/Vjv9wEqvb9eotXyskGPSLR03NUgowUrTUBUcktdQ48oR/9H9xtZgyNoQpG04L/3jqSSsHkatWrQoLFy4M02ZMU0tfX7okvPLqq9h2YttYmJVIGp2lzyrYegtjaoMqRTJsC+uJ/zgm49Ma4/TBmZr0f1/nPx92CMb4bS7Bv0x1QMXQgiNP+Iglh/+i9jNtwh/L5Tn/I74UfyyK+Hf6zv+ewB/g5/Kv8UciytHC5d/1n3Q29T51s+t/Dmj6T3Xh4x8HbR//3f5x+w+Dps3/3P7NzT+pK93+j2NF757/aDyT/VeYf3DhQ3v9H0X41xjJGI6ZLAsnuCw3/1OaXkC/EY7iQYMHhCGD4TSmY3ggHMjYeiL7JoeP/zSBFGo5/+8t/V/R/0bgEsWl/U9mVBr/mCPpvz6C/4rth2zWc/uxvQyfz1F/YR0xPqPLfuc1f3itu3RyxTjxi6kQoThmIAig/SZPnBSGDhkSli59M97XQuWw5PUlYdKEySqUya+55sfh2GOPDQMaoIhqSJ8roVWdrH5Gn/VsaOIda5/VHLEAuNOvXf/3df5j02zhR7jGT8I/nbfUhcK8bgJLOEbdQXQJ/0XtRwbKlLKprMr4k55lWqfv/DeYCV/dhT9Cuhb6vwj/lI+Ef5TfN/QvJVms71b+u/xHrLj+c/y5/NG0cP0jm8nmH25/uf3p9rfphKL5NxUFDRb8cP5dZH/5/KNgf0qXgFHwNYhd0rCIBI98/l+Y/4sfBjMff7px/KEY9+b5lz3YMGAU6R9EVdQ/aFTfm/+V9/9ASUhj8Kce2z+QjZbi5L42YAbPDbS8NObgYE8M4Mey++mXRwQ+McDf203r7JLl4Japn6D9iN9atRIRiGQ8JoP8uubRx3wg/OAHP2yTPl+H+PCJH0ZelIsK02hkJXlgr7FYhRinjwKwTvbf2oF0bJ1VAXlwogFCx0I5zMZAGokWuUA+9Vb6s3eaHdauWRMGDqLTnSyxttVL+9mnCuijjrZ/EJ6ahoYXhcUIARUWu11Y4k2SSqpEeCI2GIMbPFoC8j9es2LxXB9/wbnlYzxxxSuEEvljFAtx+mIDmUnGiVfOfyIm6jMcq8VfUpTV4M9wl8MfZ2ll9L9Rz+EfydhLncV/z9BP+FIjcJFrv+NPzEnI6wj+XP+ZAqtG/kyMHH+mB8ANlz+XPx//3f6RKkijEPVj9faPjz/1Pf64/dtW/6eZldu/XWV/ffjDJ4W3176d+WjMV0OlBj3G7qGdw0vMPXqD/2mH2bOx3chg+JfWaj6U6kR7jHO8VG+rtMXVm//pO5d/t3i+22fnv5yZmKltdrfNPzDtjwGvVzBITSQA4FqxcBDE28SEUvEONohQAvvyccCK4aVh3dtvh7FjxxBDMXPA9VhtOWGFCVdh23fNCg89OJ+pLLRBP1Vflbdaoi5JsChQJIc66Yh4HM15iBYo0hqs30walSMrR22KjgFyIkpBLNPYh1i1XFe9hH56glyv7Sf+atP/7HXiRZ0sXLKfCfMkKLyVEiT8N+oZPnGBF3MEOhquCMpsyaVQec3icdNeZUqlIr4E/ymv0wdvnP+1wx/hWAX+hFeDq/E/Ypl5y+GfscK/gFsG/5aAv32CvsufusrY4PJXO/lz/V+V/Lv8ufyRA27/gAmuf13/mjqweUWcoPj8A4IBBVH1/Cvx0O3fCvNPekdooCTF6/q31uNPX/M/pfbTt0RgGDTiw4Re4v+qnf8HvdMB/x/1D0N/mv/m5/8DTSOggc10cAEE8LYpAdBgTw3AAMQRHPohP3gPP3KI4Zz3+Pf22+vCs08/HbaZtU246667ZNyst97YMGP6jLBgwQIrB060DdbfIIwaOSr87bFHVQ6ytkq/CassvwtvvYJh1SBLokKxaqP6avVzTKN64lyODfMiqs72RJltJV0WwmJS+2ORjBM/YoOVSglj+1O5vNGz9AcNHBxWvrUyXHXlleg7Ah1Vip3Cvuzv7a8F/4cNGxQO+rd/aRv/kbcZ/gusBgqagKIc/2nDJP4LjOwLqltzajdR1qxzcEQ+4a0N+XP6wrbzP+rfduHP9HhL/FHXJf3XBv5K9X+OPlfDY/+igv7J4z+vf1vgv3fQp4iSQ5RZiWvS//nxL91jSilaJWVytMrl3/VfBfwLUMCK638f/1roP9oDPv67/YMxhTZhGmN8/AE/SuafiTc+/rr90W77y+3f8vaH2d8AFKXK9U/SMV2gfy+/4nth7VucGFHX89C7/U9r164Lw4cNc/8b5ncKCRu4UNfxGvacerGPz38r2V8cgdFaOAjiJF5tJgP4F60V3dM1foBvBunnlJiGDeLooJx31VXh+A8dH6ZMmRIaBwwIZ33iE+Ghhx8KDz7wgOiQnR/+yInhW5ddhn0qWVIN6FOxRfrWWSwXAfXRNW7SMcJ2KibVt7/QT+1J7VWj66j9Xdz/VOgKBFk5/Cf6hi7gTKgW/lK+Av4Qk/orwx9QSRrCqXIIt0n+nL7zP+Go8/gjzqK+zPDXSf2f8N9P9Y/Ln8tf7eTP9X9L/ePjn4//bv+4/ScTWKqWI47bv5xwmL0mpvj8owbzL+MnWen+B6IKnGjD/+P2L7WRscrnX8aKIv9fP5//ten/7Oftx0piDsbYYhpyQFGwYUnbaOua99Nybt2NDgZ6nU3ByP3FZEp/zTU/CVtttXW4489/CstXrAyPPfZ4OOecc/FNLnuKN3vHneQwXrZyhT2xYr7O0oe2p9tDosx2oBFwe9h1rJfVj6nYQow1ONhZ36f/rUsvVfvVsDpsf0MN+h8QVCAmiJz4OMEiASjel2utHP5L6BuwrED+xqJVbsJcHn+aNKt8w6TTd/53Ff6S1svjz/WvjX8Udpd/13+uf13/dpX+9fHfTKr8+OP2DyxLt/9kJ/v46+NvV46/bv/aCJTXv8n+d/u36+3/voa/hx9+WAO2+UeAnSr8H/Xmf6uF/6lT/tcS/1Ot+Y+VxNE6MdsNzlMqEXO42hnP8aeU5u7irxxmPAI06ZxFrFu3NnzqU58MW20zK+w5d8/w/vcfGZ595hneglO4Oeyww/bhlltvBdasrNrQR+VSII5x3oRfcwgXakf6KTj9xAsc0yn51qH+r2f+UwaK20+MEXWl+GuM+JNc5fCfnXaI/07f+d8+/BGfrv+S0uus/nP5c/lrn/y5/i/WPz7+USNbaL/95frH9Y/rnyQ/MLoV3P72+Ufp/Mvn/8nmLR5/C/N/bJjW7vm/jz/tHX+ooPrK/Gv+Q/PDg/hr3f9XPP64/61/+R+xhSR240Wv0tUr8DbxaOf0SDfDS03likOR0yt+Z0tjslzKmf4hRJrDWytXhteWvIZzXDOKPyjwqquvtkucM0tX0Vct5JQrpi+arI7Td/7XBH+Qjfws19BNhAFiEW0R/9wPKhOTDH/Y9pyiEe80tFv+nL7zP0MVES3stYY/pcjw1zX6nzRK8Z/pXKtcP9E/Ln8uf+2TPwloJn+u/3388/Hf7R/TIW7/kQ/GC6hImAxtzT99/PXxt7rxt3/an7T40f6MBbK8NQtov/0NWfL5Z5frH59/kcXu/6PI9gX/Z2PBcSXootJUOtysIcqKRmpeqF/ZKt1r4vsKMWgzdK6XVsCReViQ9ryE+ZcVFsLKFStwG8pIdJA0goVUGTpCn2QaqqRPKk7f+V8Rf3go1l78a9W6HMJEMPFPQJbHf0v8WXJSZdB3Otopf04fawac/8JP+/GXHlxE/OHQfvwTt1LyqAPxz0LwV0b/k0qv1r8u/x3of5c/1z95+edAVq38S2MwA/6oR3jWPvvTxz+XP5c/lz8pELe/TaG6/m1pf2KI6fX2p+rY3vGP42Ze/lkI/tptf2Mc8fG3m+0Pn38ZcimZBtv223+1wr/Tp9oo5T9UgnVRepLPK03i4dlVt1nf2byf3l5LjpL4hDeEJ554Iuy002w5e9XL6mnkZTr7UTksJl5CeSXBEDVl6yh9kcMPnc1ZACGnD244/8mETuIv4goHPbEvwb9wDaFoL/4Mq9Xg3+mLV87/muLPYFwN/iJSK/Cfd4nQ9uK/79B3+RMCKvQ/ucPRvL39rzJlTCQkpGOp/eH8d/4LZDXVf44/cqAa/e/yJ6y4/nP5KzP/9fGvb47/OWtD4u3+hxxH5D9J/h/X/12h/3PcdvyBAy5/OUQUyZ/gUdH/yruU0PbOv3LURKA1/sdHVvzQG/zFKTlLgAeYftdmvH4gNcFzO9Ovud5YueawZs0amZtKxzKYl05mepEVsNcNjnQ+FxJyaqlClaKj9K38XLGMcPrO/47iD/nwP4d/rlMidokxwzN/M/zjnEFZ7LQq/LGssvh3+s7/bsAfEVwWf4gtxn9EfQX8J8i3F/+9lr7LX0n/u/6jvnf97+Nf1ISyAnz8N1uIep+hvfqfvCw7/rj+df3bDfaP468O5Y9aKlNUFdqPBG7/QqFn/h+3/7rC/uu18596x7+3v4X+w57EsvHMgRs1KL/srABtSUevFunyHPeTccz7zXqdwZJq0apSmCLWpIraFv+1p7GKtJLpQMZjaVFx+sY/OdCd/2AGF7v3QfypG1nvHP7jeSn+JYV5/EvGkK8z/e/0wQHnfzX4c/3bBeOPy5/Ln+sfYMDHP7EAQ5FWZ1DVcKyXSRMtm1L718f/zs8/XP+6/nX96/q3tfEHeylohlCqf8k1OTA4B+uj809WHXVPY063+19I3uUPPGjb/vH5F40i9/9RF/UF/2djUibSkVpNDDVjX6lDE6BUpXz4Y4uOm6iGZPBCHLR/jRKYfsB6YTmRcV8M4C8NYDqT44bozCvPtAhTOeMPStvpg0cd5P8Zp58eTjjxRDLZ+S/M9QD+hPgS/hPcZfCvFfa8hyD8NyGfxIir+Tsof04fvHP+F+nfCvhz/ctBh3/xkI0/lEmXvw6N/65/XP+4/oUUQIfYf4zpPGlp//r4D76QN9S2PHX7x+0/t38hDW7/d6n9BTuP+sbt36h/3f7tkfGnL+HvxONPCPQvUTdRRbv/r/78n+h5mrUwZOWlAgM4UPGjdGnTc5zS6uUh++OTuBjH9MqPGLpoFJgfSZpimRr7Mpe5Fd3M1Ezu9I1/neA/+4I95/zvWvzRhCMFc+iaTBTwb/ynZEh+cEKDRIKgjLFulAvFxt5qB/6dvvO/pvhjYe3An2gji31NuxT/xHXEeJ/V/5TWyuOfy5/LX03lD7LUHvlz/Dn+HH8cfyg4peOP218cf93+BDSi/eH2N+UEiNDAEW2zep5/kAX59uuaesT9H+b/cfu3W+3/PoI/jimsavbn/j9xQ91XB/5PfBMTEGBrNZLgNK0iTg5e3ud/AQNHeXaNPSk+uSfNeCP/0ut1KlheMSqheAUavG9lOP1a8N946/wnjhFqgj8WhL7J4V9X6WFHisexMv5ZBqoDr3D78c+cTt/5DwzwP1dBEBHdhr+IPRE3+kJk3eh/lz8BL9f/3Ys/57/zP+ogHLpf/zn+HH+OP2HA5c/1T7fbnz2tf6Ps5+wf1cjtX7IBgUqB/33+2zXz/96DP/qV3P/H/gAf6kb+C/hrjM+eDQSI1ytyYoetEA7Yx4fJ075qXEVm7FIi3ubdzAFssdIfeuIvVzB+WK7K4U8TMuFI16bTN25KCHHaMf6zB4oDS6VwO/8p2MbXxJPq8GdPmAv4Rxkqp4B/8lY6QzjmRaEPSIsYZxQXNpTFPzJXxr/TJwec/0n/ghXCUQ3xB/5Wxl+963+XP5c/1z+uf7tQ//r438r44/rX9a/rX9e/Xah/3f51/SuvFKbqXATJ+bq9foBZezeMP30Ff7RT4sI79/8V5t908dSD/xPeWpkicijiFMIiWUHzjRkEhQED7gSuiCRnFJCYIUZoLWuKikfe5qv1okDnMsvnPXovs+D0M5aQPx3hP4TY+Q/mkZEImZ7HebvwZ88uVAaBTZQW8I+YEvwLxRHKef6nerCgjD7LY/+yjgn/ypvDv9MXz8k353834E98zuGP+AQmDdKl9OtE/4snjj+Xv1L8gyOu/3P6OT5e8vFPGsPHfwwetG0Y0hGnbv+QHWSI239u/wIFhILb/2ACQnfPf0gyz39Vwu3fjCU+/8zZN91g//UR/HFSSPum1P5V9cvYf5Ix3cyN/+7/a+n/6SP9j+0mqKuhJqQpcIEjdAUi7Y7pcVOk+WQmQkyYAlIqMYqgZajsMR8uub1EGhuzE4HP6Xee/2K287+z+CNO41+1+Gd6CyAe6WtmhHM+lZQsIQElgfhX+iQIMUvW/0oX01Qpf04/sp/Mx3+FqH+c/y3xJ/5k+DMtnuEvgr+e9X9kAbBEMMVRTiv+cImb6X4a/3htwfHn8heh4PpHutj1b0v9K32R6V8bsjL9C/gk/eL6x/Wvjz8+/sqkdfsjzpsK+rGj9pdG6Ez/WimZ/o3Kt27tXxhwPv4Yxrpq/O2L+JPvjhUHOBI+kvypPfopzH/c/weGyHzpH/5PfGjRjDH1MyY32RXWURMcvGbgvId32WzOnwmW7CbPGRSJA13POE/7sBJQVk5MwO0mUDb/nD45Y9whk7Mr53+vwp/1UEv8x54T/NNPwr99uJF9WsC/0mf4pwhkPS4hy65K+t/oOP1S/WN8SZy3o/MfXIF6LYc/cSjDn+tfl79M47j+aWX8df1LzeHjj48/xfa/j79mc+R/3f6obH8IL5n94fav2x9ERNQiXT3+0ufAkOHP7V/HXzfiLznI+hj+6L1w/x8VR0v7l7FZiOoljf/9xf/Z2EzAMlBW6LuN+lqeYJ3TLJbPQb9yeIkZuKn0kTO4m0IT15vzP/5YRMHVHAvXl7zs3Ol3nv9PP/10eOmlRYn9wfnfcfwJsOIk8In/RL9JACOJZPxD8bpJ/ONfFuJpu/jfXNz/Tj9x0/nfLfhz/W+A43BEUeRRwfHXLfhz/ZfBzfEHVrj8GR7ICPx3+8Ptr4KN6fan298+/6jp/Mvt35z9gQmsj7/dO/72BfxB4My1UWb8MWGMPLNDu/wffaH9aFY9t3+gniRF55aMUniJ6S+nt5j6grd0RjDoAoDBSmG+StiUEig+XZi3XZkNMxmLeclUWL6s/U1IQw/3mJ8BN1kfp09eV8//3/zmN+Cd8z+hVSqN7MhCAlgr+BOGc/gDClMRfCJkX59DgVSYefyThvIijRSm4Z9ZUn5LYJVhXBH+U34ecTPDv9PP+Of8BzD09UNipMb4I3aTeOTx1w79k+HfTvCLAgn0LCQCFl2E/95EH4/LXf7i+Ov6J4Ow658u1D/UEUk95PWP48/xF8cPlz+Xvy6zf1z/1Lf+7U32Z37862n728ffLht/9YY+l+aij3u7/+uqeVeiogAmfRuUldL5Z5If9z+xQ8WrPjv/raB/9OlQPh9II0Vzhlo2OK5yROPl/0IMgS3MIM7y8TrmR177Z8Xpi5E6xcSTxencHMSiw08DIqvTj/wDf5z/Sev0IvwBvAm/beJfMsB+pFiwXw3fKb+khq9VUc6qxb/Td/5THBja0r9dgT9q6GrpawRgPWuI/+6izzpTLll5/aVV/u1of1fw3+W/evw5/4VcyquPPz7+QpFRe2by4/YHuOH2l41zbn9CSZp82Hjv47/bP8n247He/B8cJ8q03+3PbPz0+RcUpv7LkoCM8AJ/tDplezPeLmtmf9KCUaEs1+l3N/+x8TAWqakH2NEIXE3FWmR/6v6s45VGP7ZiUqmlWJADeZuQTyuMUQSfmFhSkOG1SPCE6hdHgsvpO//7Ef6oGIl/4b0U/1FuuhL/Tt/535P4q3f97/Ln8teT8uf4c/w5/tz+cvsTGHD7u3j+Xe/zD8zL5Ndw/0OX+V/c/uhZ+6Pe51/efsMf3astxr8O6j89KouuXJYqjz1fODU3Lu7QiYsfxsnJmz01gLpVxhiP80bsNcznCI2KRxHxvl4XwyXfmGbRLIsUipLh2uk7/4mpXoE/rrIgQvGfqGatSvFvAM7j31BN/PMs3c/wzzjh3+6zVIZ0LMK/0zfOgDnOfyKklvhz/dvm+OPy5/JHzez6x/WvRuha6l8f/13/Fuw+ju4K+fmXjz9gietfH39qaP9T0DT/cvvX9W9P6l/HX5v402OMgv4nx0r9L+5/pNWQ9z91jf81vU9BaugEc8dIfOAMpmu4ITvyClXS01newzlWDjPoKr3CpWtF8wYCSeiEPjD7YxzOrZNjWhycvvOfuOoV+ONyHCI74Z/SQCNeT0AM/00t8K/KR7QrO37K4Z+C0Ab+nb7zv8vw5/rX5c/1T6v2h+tf179dpn99/Hf96/rX9S9UbC4UzX99/AFnajz/QonyQbj/ocL80+a1uun4qz3+OOxr6Pf5V5vjf/K7ZEf3P/aU/5UeLOkEHpoxasudCyCrExnHE/4ZutOV9rtjFNMrF0pCf1oEDoXAEmK5SsA7eC6AtFh4bIEkEJy+879H8ZdwGiFPI1boBdBNDpoDvlmHVMQqYnTf1tznfMHCcuGHObW5CjPF6Ar4d/rSJ2Iweev87178uf53/FFDUcG5/Ln+cf3bvfrXx3/Xv65/ffzx8bdn7I96t3+he4rm3z7+d+/4X+/48/YXy5/kMQ4GPeh/NSdx1jm26bSWdds8UdU01xY8unTqUnEgPR1fVCm2tYS0CW/hPn+jJ81iNNmKJeOOOdfodrNVyUyenKNOn9xrL/+PPfaD4dhjjnX+g3edwh84WMR/AT/u8ULw4xpQbYF/OZBNSFgB/JXinylUMlEfn7eUwX9KFcsyHDh9PdR2/nc9/qC7i/BPeRJieaxD/S85dPlz+Yv4Bx5c/4MHJfafj380CogRBh//xQyyQbygzLj94/afLAu3f93+77n5D+zbVudf9W7/+vyzeP7T3fZ/L8TfzJkzwoyZMzGW1+H8jyaMNAaP9dt+rv8VI2TTJUcMeZI8lVIcTIMU+K/FkLhn/6B0oyAVmKnM5lBW2SwKifhHJd2MVZWcaSkZM9uf0ydDoiMy441OwHbyqDL/R48ZFQYNGhi5bXlYlPHW+V89/sBn+0+mkYEItg7YjHxcqisq4D/CWn3VJv/ZnyzM/iAado5Lxjh9cYGM0Dps538EF9lSSf+2C38JYyxQbh4cO6Z/EoZTj7HP+pP+4XsAjr9a4w/luf6T7En+xF5IkP2PvMFt13+u/13/uP7lmMrAQbYm47/rXx9/CCb7q4v5B2TI/Q+t+V/M+CAiTDZ04uNvl4y/icdR/sjqXjj/mjt3z3DAfvuysvrv/j+yooL/h12oAF616f9Bwvz8R/l65/x7oHpeFSRYDQi8lE9Xhgm+F8gnHHLsYrKMJBpXcOCr9+bvZWTafZUMREkWxTPxiyuOm1BooxhMt2cjyow0mdlyZdVx+mQFmVgF/9UJaW2387/j+AO7I27z+GvK4V/3SQChBf4Rb+oDxcRy2IfUFxn+kYkuJ63GyuM/nTt98db5X5D/WuGPW6Tw46LCn+vfqsefWvFf45/Lv+s/1/8+/sFmK7J/ffzHuA/jx+0ft3/AAbf/am//1bv9MWvVyLDZxA1lf1y1+EVgrClMHTQsvG/MJCIu3Lt8aXhs1TLJ3+Fjp4ZRAwaFJetWh5+/8bL8H7OGjQ7bjRwjV8Uvl74SFq9dHYYMaAwfGDdN+f+xakW4Y/lrKCmEvUZPDDOGDIM6awjzFj+P+WBz2GDQ0LDP6AmifzdoPbHqTaRsCEeuNzWMQDmvr1sXbly6SPRnDRsTthu+Hs6bwk1vvBJeW7s2DG0ErfFTRf8p0LprGWhBX+45elKYMXioVCdpcb45DbT3Rh1I/07U6alVy+V/OWr8lDCicWB4bd3acJNoNYTdR00IGyP92MUFd5DLXxfJn/ZYpQ+gr/i/UFeNyfxx/189+j+13YTsUz0vMu8XGUEnt61gFTZwLte4Bm+hBmkMPPSM5e4hORWTNBnVJQpvQIEsOcIMZ7myce70yRGuVyOXwJt28j/1k/HR+V8b/LEU6w8eiH/FMIrAx//W8c+eRI/m8K8NWphJ5cWymUqnpf3v9J3/ESPCS43wR+AiZLytiL9cmkif+YTVqvDPuuMvh39SpoOaoffTd/nL+qiW+HP9J7HIeEuZoKi0GP8dfxmPHH/QlzXS/y5/Ln+SJykdKh7XP65/62L8aY/9WTRH69D4Q1AVz//aQ789/hd+8JDB7Aja1kap3fRjAeZ/cPujS+wP9U1fmP/k60gs5DBWF/O/XPuj/GcyVmftx6MjMIM6BVqpEY2XaiMTqOAioJnGVB4Zh8DVaEijlZRcIqlI3uAp9nDEEc9JTGmpKMbEdDjlU7V82U6f7Ok4/7W3M/ksFjv/O4w/oZeDrSlFPu1jEIR1FlFbFf6tHMtsNeLefBSOavBPpez0nf+1xR9K44Dn+rf8+CNhdfl3/ef638cfH3/d/nD7o7b2h9u/bv9XZ392xfjz8NBl4c5/YlVwzv5duHZVuOq15zXJ4/SMgfbPdUsWIo7yb5H8nf/W0vAw/hjHmSD9H6vgWJ33+guIUzRibf59+7LFodkWCtsN3Fm49q0w75+2qjjv/7h2KWnhf47+wyvfAC2uaiYt3Q5vNb0drsJK4Tz9Zvhffr98cQjLjQzpM/3CNatAC/Xi5DWVgPNrX1tY1H7e/TPy/3nF4nDexPG89PlvV87/0TnWR+oY8bt3+79QT9SZmOKfal2V/8P9f3rmQobpIQ5OeF6l/4fczuuInuQ/tKC6HQoKyg1oNSDgF8onfXAivRZHMFtqHHnCP/q/kJcKjnltvYOdUxkz6JkU0zINjtZ4nDAuluj0nf89jT8624lY/nLwzeOfGI7/CVrDP22ISvhn8oR/lhsFpBz+KQbEv9N3/vcE/oRn1/8Y/+K45fLv+s/1v49/GLM57nNs9vHf7R+3/2QC01xw+5dGu9v//WL+Izy7/evzzx6a//d6/EWvCH1+VHuqL0/4V8n/wdvJ/4GE9HuwmHL+D9xx/2Mv1j+N9lSN/Ye1v/iMeexLdSiv+Y8WAZ0X/EFb2KV2Hk95rZXFODJ/4T5HUSVF2Vay3Wch+Mu86rxy+s7/nsUfNm0SfgVx/CT803lLXdgC/0woQJfBPzKklTiUmdbwLz1Li9PpO/8NZsJad+GPMHb9y/HHxJn8oKx3F/9d/qOudP3n+q8H9J/Ln8ufbDXXP65/XP/Q9Omf9o8e+sXGsZW09xDH9rr9y/mn27/mpepe/Pd2/Jlj13ji/j/qD6AEncZ+04CJn/7s/2yUA4uN5ZJotF0+L14yLjmHk+TwvhJYquQSNkcyf83cjllTKSrUVlIW5+PyY6cfed4J/pOP4qXzP8Oc4VQo7hD+iOEi/OtaUbzBK/zasQj/7Ave0y2nb8yAPiFf9DixwLfW5D8xURw0Novtbeof539iHY4dx5/xPT4cJP8ZgWOb/I80O4v/nqafmGj10FV17Xf8JdbhKO6Jby7/4IXrP8NGHDdd/1e2f5MQuf4BJ3z8FxyqGn99/Emig6OPP8YMDj0+/rRn/DW9W2/2ry2SMmWDXxjxPv6QD5Ej1cx/aqR/exP+1HxWqJr295P5X2/iv/DXg/y3pb6UAbxeySA1gQrZJD/KB3y/8XZcSWw1llMY2Rq5ChIBu/RYfvwakxWtsVqlGwmVwUGL6bPg9MWKjvD/W5d+K8ybN8/5X0P8STDRI4Is8R+BKlwL3RxA7cEK8c90wr8cAWXwbwlUIB+MtIV/p28Md/6DD7XEH4qrBn/1rv9d/lz+yAHXP2BCLfUPGFqN/nH5c/lz+XP94/rX9W/Nxh9TqVWNP7Wwf8euNzYMHIjPPmG+Jxzrp7rxrxb00xhaPX3OaTlAg1Gxrjr4+F+7+T9YW4390zP9z663/k/0f/qTn4Qrr5jn/r8oD+y7JCB5/w9j+6v/E74vthrQiGvKbVWk8SHtRZz0hpJGb5meMWV5YilYDavbkaHRh2Y3mRmOYfEYBZJek566OH3nfx/CX8R2Kf4xjgLbreCf2oX4lwCU4p+3TDm3KX9OH5ymQgYjM57Jj+H8rwZ/kXuufzs4/rj8ufy5/nH96+OPj79uf9Do5X9O9dz+qsb+cvtfo2ex/dmN8x9Q5+yhmH7XzD9v+fUtYafZs01AKCW93v/B2SfrCRapugQrLvCfZ/px+5ecAEvAkY7o/5i7O/BHpazuSp3XAfy99daq8Naqtwr97/6/sv1PFjf3U/8nupwaACuA6bDFadQBAgX3YqVm0D2e8ZLWAILOU2Kk4WkD0ic8KlG6xk29mg86SgFaSq+ycOb0M/7vtOOO4YILLghf+cpXw8yNNyannf/EJjlB0PQA/ji4K7RF39DNLhO+88vxC/hHSS3wD6kgDZRPEgykmOTP6Tv/BYqa4I84c/1LVnIPYklcG+OPy5/LX+3kj5ArlT/X/z7+US/rv6BGifPxn1raxisxpSbjH0py+ZOdWRj/XP+4/qkX/WP6JNl/55xzbjjqqA+0Ov/qjP8j6a3C/K+YvjR+G/ZnZ+iDWhxX0OIO+l/c/hUXbXBuzf8AraqU7GLxXb+d5n9P97/Tt/7vKf9TT/NfzwVYCfxXMFinT27FOHCH9/n0IzNkbUkkLdkkGpmAsCgTl8hcXPNMT6lMfPQl+XgqBe30Q5g4cWL43//933D55d8Nv7n1lvCDH/5Ajnfy3fnfc/gTxgXg6vBvUlNAvJ0l/NtdfccxjiHs3Nbw7/QN/+QDdYbY1or+cf6TA5XwZ6DL48/1v8uf6x/TGiYdxfaP61/Xv5IPH398/HX7w+0vmVe0rxDKzH/jDd6MVljeGrO7efvL7f/utL8K9u9mm28W3vOe94RNN90kzNp6mzBu3LgwZPDgMGPG9DB65Mgwd+7cMGXKFHRPQxgyaHDYdpttw9w954aZM2agQwv9P3TI4LDHHnuEvd67V5g0cZL6PPk/mGojLPbab//9w9bbbI2rAv14Cgi13v6env+7/VNL+6fv9X9P48/p96z/zzbMicYvh68mrP6lQUzlZnDGa7m80YgBD4qRcbzHM53LeqavmbEIiGR8E35t3TDPGIN4FRzPpWR5TmI4WnTd0N99113DoYceHp5/fkFYtGhRuOfuu8PadevCWf/+7+Hxx58IL7zwYhgzanQYMXxEWLZihfO/q/EnhHYE/wQ28J+Mhohjkw+aCgX8NwL//AqmkuTwr7gO49/pO/+rx1+EOXR80vD1qX9r136XP5e/6uXP9b+Pfz7+Q2fmxh+3fyATbv/JNGn//NPHXx9/qxt/5X8QyjBlg/45++yzw+ZwFG+wwQZh1112CV+/6OLwxFNPhh9cdXVYtXqVdNQFF1wYVq9ZG379q5vDCy++CDltDNvOmhU+89nPhh//6Edh+Mjh4Z577gl//esjYc3qNWHy5MlhfziENevDXO+jZ54Zps+cEZ568ik4kncLn/nMf4cfIV/t7E/a8Wh/Tfwv3IINuohTAoqVeNWW/4cJq+O/z3/JVQu9s/874v+oJf6cfvvlr+v5P5BbRFAZpFW+DU0gKscvHFzSEubk0qtJsmTiNe7RzmMSusIym08xlkbLpJMDmEekz5qEa0Y11iH9WVtvHf7nvM/BIfyJ8M4ttwxf+fKXw2FHHB4eevCh8NLCl8I++/xLOP2MM8K3v/udsHzlMgxM6CN66p3/YEJX4g8sbjf+7SkwcW2BEmFXpfinjPAOUxD8hn97lNJx+XP6yaghW427zn9yoiX+qKmjSZnhz/W/SaxhxuUffGjX+O/6x/VPGvGodXz8S9xoqX/tjo//Gpzc/gEQGuFg0fwpWoY+/vj44+MvbTGbH2XzvYrz3+rtD825ULJcqrB/Tz7llPD9q68Kt//h9nDFlVeI5swZM8P0GdPCMcccG+68604qKsXvNXcvzMVX4rwpnHnGR8P7jzpSTuL37b13WLRwYTj26GNt6IvjH61qzu9WrV4ddtttt4DtSsPHPnpmOPzwI5SPD8Z4v3f5P8BLn/92i/3bO/uffqb26l9Jqvv/TE1IVySdVWr/UZUwWdI/vU/+y/d/o8CKikcNJz+kfaUPUWwRW8JjPGUCXjbpfRlFQ20iN1Z6WsCReejQ5A2klgM5FoJY3IYyYhKeI63l5JVl6+/093zvXuG2234b/vrII+EnP/lpeObZZ9nyrP0vvrgw/OIXN4aDDjwoTNlgKlmoQLaW4//Q4cPDiJHDLBETO/8NSB3BHyS4/fiDcMmxwi4g/62fqsN/6t7Y/07f+Y9hRCLPH8qyLuy0nPzrsUmH8Vd/+rfV8cflz+WvW+Uvibfrf46eXJTk42936n/Hnw2vLn8uf65/+rX+hYhTyovtvxL9JzXQEO7Cm72yu6P9vQJv8w7CthKT118/LFm6JAwebPPtJ598Et8Oekc49z/P1ipiZUrzbzg+5s27Er4SGfLhb3//e5g4aUIJ/d5kf2Me6+NvN9sfvan/IR+SkfbaH9SbcZJKoUn474j/xel3AH9dy3+oBOtcW8mY9CKfzuFPVgN/Yr+npZCMwNJWAkqn+KGzNwt0ArNY+1E5vBsv4TxOgsFE9Ue/ARvIL178Wmx7c3gRr7HQkz5s2LAwctSo8Ohjj4Yrr/heeHj+w2Hv970P6Vrn/wnHHx+OPPL9Sqcf538N8VcAuV4RMbhm+BeugeH24t86qxr8O33DNPUH+OX8N+hE/dtR/Bkbq8FfRCoIleM/77IO7cV/36Hv8icEVOh/coejeXv7X2VKmBMS0pFjXd7+cP47/wWysvrH8efy5/rH9a+PP3Gc5GBRxfxPY0odj78FayNxojgm7//gXsVcaXzHH/8YLv3mJeGkk04Ka9askv/jscceC8cec3TYaqttwp/+9CesTj65wH8UvW7d25n/Yx22oxg4cFAf89CyyY8AAEAASURBVH+4/SWEgA3l5j8dtT8KaEtn6Vhq/0Z8VqDPu6xDe/VfjpoIVPL/nXDiieH00083v2+Z+XdX01fj2L4ear/T58pnQwtO4C9WoMGBE3iA2THNeApGEPInnukaz5yUOv0oS7pgXhTCbRIs2L42nPyJXixQ5dUh/Vtu/TU2uX8vnr4MCMOHDQ877rgjuNkQdtppp/DNb35T/G8cMCBsudWW4V7sdxTZVZH/vO/8N2UpvHUGf8BtMf65ThP8xU85/Ef4tpv/LKss/p2+81/CnPRv1+CP0lIWf4gtxn9EfQX8m37vR/rH5a+k/7sGf67/Ksif48/x1w363+XP5a/s+O/6x/VPf9U/nKWpbbRaC/JPP0WR/0O3cZ82L/wfZ2Lrx4YBjWHOLruGw484Inz9a1+Dk3htMn3D/fffH47DQq0Pw6H2X5/6rzB6zBhgCNJVxv9BF4gmlDn6LKiIfhH/JaXKE8+Uvcv8Ly7/3SL/efz1qv5vMf+j/Q9BqJf5X4v2d7P89UL63BJHQQ7cqEG5S5ZFmqKjsqTkmFqN9xil5eSWVMpPKUwRS8EiD4vkq/hGx0qmAtXTTmStR/qPP/54uO/+v4Trrr0u/PznN4TFr2FVMdh6++1/CC/ig3U/wxYU1193Xbj11lvDE088ocGqNf6T19Yr7CHnv1gAhghn3YU/iQF7Icf/eF6Kf41ClImEfwhBp+XP6ZObzv8q8Ffv+rdL2u/y5/Ln+sf1bxX618f/Evvf7R+3/zSBBC6gQzs0//Tx18fftsZf7KWgGULO//DKqy+HGTNnSv4GDhwgHjKNAn0e0E3DR47UYq4hgweF0fiY/BFHHgkV3iT/Bz96N2LECLozwptv8vtBIQzCamH5TMrM/zg/7BL7k6KD1vXY/F8ME3dtCozTVBef/7r/i3LBRyFCSE7+LB5Y6az+72n892P6jcmZqz5CJ0q0+ZW01KlqPH9s0TFUY1SASKn9a5Qgpi88dWB2ewIBxUVnctyXh/TkmRZhggN/VMYqpn7of+3Cr4djjj467HfA/uHZZ54hE8TjT3/mv8JxJ3woHH7kEeH/vvHNyJfW+W+8I8ed/+mpV7fjTwJTwn+CG1qwFP96wsx7CMJ/E/J1Fv9OvyX+nf9l8ef6F7InwYuHbPyhTHJ868D45/Ln8lc6/rr+Kat/fPyL+sfHf7d/CAW3/9z+dfsf2rAT8/9q7C/YeRyS8/bv7373u3AUnL733HV3+OQn/0v2H21AFUenFk6/+91vhw3W3yA8NH9+uPU3t4Ybb7oxTJiAvYVR3YMPPijMR/ydd92F7wjdgDn7/4XXXn/NspcZ/zkfzNOXGZrZn51oP03XUvuDtSgz/6xMn4W4/dvV9n9l/vd0/5enz0cP7v+rX//nQGpNqQZqQ/2HYpRDF7hAHJUYNaYOPEXg3izNVKBUKDpSPfE8ptNH7ZpDEzazlvNL2IslgAZ9xvylsHAvlXqlv3r1KvGM/BUTxMPGsGrlanGIcdXwn5nJ/eiiBGvFUed/e/EX+V8J/8ZV4p+iQty2jn8aEXL+V8I/S2gH/p2+VJTzv1b4q3P922L8obhyPKsw/rn8ufxB9Fz/1Er/+Pjn47/bP5AC6NUq5l8+/vj44+NPJ8bfKEB5/8Ott/427LjDjlgtPCy8+so/Na+bMX0mJBIB6Tn/fuaZZ8Puu+8e1hu3Xli6dCke6rwdbvzFTZLbb3/7u+H7V/8gTJg0Ed8ZWhxW4gN3NmlvDrPnzIatgALi/O+OO+4Ic+bMAQ2GXuj/QK3c/u1G+7+PzL+kc4RZ+3H/X/L7pCOlmef90/8JNxogQOUpTYbTtIpK3l3CA3/8D8cwQzOAbRkK8eaeRKwl0YmSWcHkoIwgkWFuJLT9ekgdmeqc/rnnnhMe/ftjZG8H+U94iu0qgx3h/Bc3jR8dwh+zEtB5nCf8x3u6RQTTPV+O/0yHeKffAfkn55z/PYe/yPsc/tUjdaP/HX8uf65/ek7/uPy5/Ln8ufwBA/yvhUk42sTGbEPdcvvb5x+dm38tX7E8vPrqYg44rc6/X3/99fC2/CANYe3aNRkuV761Ijy/YEFYuRwOYhXSH+bfbIjrX+tk/Ha7/om87wXzL/r13P/H/gAf6mb+W8BfI1dDqvFUfvivJ1+K4UphuL6wjw9TpH1l7CmCEugHt3lXTrJCrIqS05jOMz5MY7kqhz9NyIQjXZtOvzm88sorYdWqVeJJx/jPHigOidfO/47ij9gkcBP+cSoc67GGmE3ems0a8c+IGMh/YpxRXNhdFv/IXBn/Tt/5T+B0If6EcCHVjADilcpaod71v8ufy18Xy5/rfx//ZBXDVGhhf7v+cf3j+qdL7R/Xv/Wtf93+re/+72n57yv4I5/iwkP3/xX8P5wm14P/E95amWJy6OIUxqp8W2i+MYOgMGDAncUVkXIgiD12FiPo8OV/hszPgHNkMQooh/G6x0cTWXD6ZJtYQv50gP+/+tWvwu//cLvzv7P4s2cXEZml+EfflOBfKC6D/yQHLCjDP+WpFP/Km8O/08/pF+c/4VHQv12APyE9h78O6h8W02/0v3hiLepy/rv8g9E5/Ln+c/3n8hc54OOf698uHv99/PHxp57GX/S2+x8IeQl+HGfc/qLbQCzpbvtTPZDjfy+cf63G4sUlWEHP+V2p/0PVj1DqN/M/tMeaVGp/1W/7sd1EboIvaYkbT9BbCXaJYXrigkvcj0nSnTB+/Phw0sknKW3krl6vnzplath9193xNdBRuId8LMO4HyWSWaz8DGAdoK/C9YPCY/l8vV/nGBFYJEN/pr8Ar7osWPBc3bZfHcwO72z/EyfxT956FKgiW8F/wpeIR/ryDOOcqzIx7igQicS/0idBwDWzZPjHudOPPKpS/zj/DV/V4s/ASNQhuP4tlj+AyeXP5U86xfUPFYTkg6/LiCc5+Yh3LN6UiVSQTqP95eOfj/9u/0giICdu/7n9G8dWt/9NKHpg/iPCGf/d/1A8/9RM1MZ0t38AldrbP30Nfz/+8Y/DNddcY5goY/+ZIPM3CjPO6s3/Zjzov+3Ht3tMTaihcaUkY7iOmo5VneOSdj+BQGOH+sMmUiFMnDgxnHnmmbrLyIEDB4bv/+Dq8Lvf/y78x7lnh7/ce294zy7vieU0hK233hqFwXRE2Zp8dJK+EY6/qhSrbhXkxyAYRVG3dsQETt/53078GX5a4t/ii1CY4a8pGiN5/Cl9hj92A2NiKa3In6Vw+qX6J3KuqAOS/Dv/E2pc/xknOq7/Eycdf8Xjv8tfkerRhesfoAKi5vo3aY2C/lWMj//R/nT7x+0/SoTJCSeZ2VXJ/NNSuP3r9kcn7A/O+Rgy/QtuVjn/quT/sALjbyw+jf/9yf/g8sc+7rz+EVIcf3H8d/nrC/qnsZmAZaAWoO/WtAGucaJzDkuIZxr8yuGlC9xU+qgZdT+Ek046OUyYODnsMXePcMghB4f/vfDCcPFFF8l5zAL32nPPMHLUcCsfeWpNn9Vo4jsl/I8/NoG1thCP+pKYnTv92vY/+dyX+Z9BhSf4T/SbBLBlZfCPuCzE03a1v7mY/04/cdP53y34q7H+Z++1C/+9jL7Ln8ufccD1T7foHx//MrjptSPALotw+yNaX8nGcvurxfzL7c8kMDTPFdplf7j+ydRNXeqfXmZ/dtb/ws5sF/6L2g8B8vHH5IGM6I7xt4j/UGGJ/x30v3Wu/52+8z/B3/DPQdVWEnNw5R+FInEJR/6LZllBeXALB6Sl40w4TumZGeGoo44IP/7RD8MrL7+iPD/64Q/DyJEj4TSeq/tX/+AH4eSTT4nloXzm7xR9FMv8kT6P2aVVKSVgIqXiCmlL7vSd/xXwB4DwH4HSrIcKgg8uS/DP6AQ44c3wJ7GoBn+kwfz842lOnpw+Gej871L8uf4tyB+Wi7j8JaVF7ePy5/rH9W+X6l8N+j7+u/3j9p9Ewe1fAIHBx99usT/c/i3Yvz7/7H773/FXHn/gC/+17X+Eqkz+l6g3s8s0lbEE8S7neEihe+7/q8b/10hmsSMip+EDI4vTX1zlyBTiPG8hrf7LTSzGM4p5Ghobw7Rp08JTTz6lIvjF5lXY+Hrhiy+E6dOnKe3SJUvlQN5m222RBuUjb+foszKsACqIuts/u9QXo3UKuMX6q9Z8rYntdPrO/2rwB/Ak/LTEfwn+hEHii7AkLg3fKX+H8Of0nf9Rf/UI/qihq6UvDSzQ1w7/3UWfMltu/HP5q77/Xf8Bra7/qS98/PPx3+0ft/84v0v2g9u/4EZ7559uf2T4cfuX803+lyTR0uBAawa3bC/G22X7x1/KKXOnv/SWazvsf7f/am//ocSkP9vEP9J2vP8BpXL97/Trmv/YeDi+nkBlw8DVVDrntcUllWHoUyrdMzgWADxh/MQwePCQsGTpUmWVxx4plyx5I0yaOEn45o1rfnJN+NAHjwkD4FSuDX2JhQbfJpTfFKue6Ae8UqQHNmoOfpBc3nEq15q03+kTFTR+6p3/HJiJP+FNCpeMifgjkyhTXYg/p///2XsTMMuq8lz4q+puhmaWqQVsUBNFpVtldmQyv8ONISY3akChETDBa54/3AQ1GqPJk1zjvZo/cG8giQOTCBijJjdR1AAiisygERkEkXme6abHqv9932+tM1RXVZ8auqvq7HdXnT2svdb69vrW+417n33M/5nEn+Xf+JtJ/Fn/GX/Gn/0P+1/AgP1Pedz2vx1/OP5Pm+D4s7/j76bHXx5/+v9KM420/4D+ZOR/PptlipM7TA+zJ36URkURibLGUAzyjqYSq0zuZk3WpQJWJ8NrsRNI/pYeuUH9wfnz4rmVz+GHTNQs1g2ti69/7etx1O/+Ln7k7ksbpB8D8+KE448DnXp92VGhkpdLhoAWLzWT1+X6dG2smRfJa9UL5Us5h8MBsA13s1r7WBTVKcc5O+m/7nWvj9VrVsc1V13dyPHnnE1t/jdbMA84uBddEQX4lKfMiQ3ifwD41/x34J9wIeYq/ikxRA7hLywJdolJVkUOXXUJJy46XbZZUPFl+uZ/fstiuvFHYFL/EX3j4q9X/d+Ff5po9IuOR8U/ykl6VtMnU3j1lv+cROs/63/bP2g123/7P/DP7P+lbZQPQVNp/7e4U/KY7P/P4vinOLyz2v+U50zvucf8S5f8TYP/bf93o/r/xx93QqxZu67kDGhPQA4KZLbmn16290txjQNxy6034zJrfiIDOUEFly/INjj/9rnPfR5zSImdBvmbafkfhX75PgFnmliFI5x7afzRYIBKSFuuUUww8JhrZr24ZRn2H3viiVi3bl1st/325QQ3g7HD9tvFfffcq+QBq8KMxNJXvTKuu+H6rFfW49NHJRLlR/QpYDjARZF+Om88V65TF8ujFD8acp1he4JdTUulAn6NlRV1klvWzTrVEUAnLMxes5OZp8+LUgaS19bA8U/b/Hfgn48jcZ4r/slX0tENkMT/UMV/4T/hwIUttWiHIpYlwj7qEJH8r/VL7W75M33xzfwn1oq+mTb88SbfBvBXcd/aFr1CEOt6sF4P/zzHs2UZE/9zgL7lTzNp+dsY8gc52ZD8GX/GH/Vs1b+0AtOm/40/y98G7L/1j/VPv+kfzKhiMOQfNij/Ve+2tk3wf+nrcMHa8g8+TL/9FYMR+GfqiAESPjyutGZZ/mnbbbaJnXbaEX5IwiIBQpzgmnMQ6ZdATvJckZMytCbl35QHzRnFuu6Mlv+ZW/pHTxJrconVAl7lAeoYdTKdSiKFYKEiYVKWX2cSNrjCuNetG4o77rgjli5dEldccQXZFNsjQbzXni+Mu+6+h41QMhCLFu2KH7PbJm7+6c+yM3U4Nv1hKKzPff4LqMuLLPS5g75yrd1yLbmPdWth95lDLeDGMdsNYkWc54CykMcaP8+VU1mBB1mYl5tnW3VQmLxoNcJOLqy/MekvWLAgVuBJ7TPPPEuXqPFU4thubPrsn0RmavzTQX+LLebF2//wzTnn6rBgA4CoOCciiBkuLfxjX08Qt3WBzrdXxFy5x1Twz364OxJ/rCk8mb7YJ9k0/6cNfwJdcnZ0/IHX5PmE9D/6E2qB/9HlP3Wu9N+G8D8b6HM8lj/LHzhAWeDK+h8SLrtn+2f7L9UAPECv0//Hof0f+HP2/+jWjrLY/7X/Pzvin2LEgNEx4q/Z4H/OpP8tztj/3Zj+/xe/+PlYtXJd2k3oS/mY8jOT+TwWfZ5DEU/V9Uzkn9auXRMLFy50/k3TkJOS05Wz05qjfol/K/4wXo6N2KNrI6SqAOgkA5gL5ZIA5T0OLgjzM9MJXct66RXxtcJ0A1iJ9c8++5w45r3HxG677xaDg/Pi5JNPjhtuvD6uu+46nKVTORzHH/+++PszToeAJAVKyqTpq4s2/ZaE1XJQleDp6pI+yWqvT+h38r+J4xfyCv6mNH6ggrBp4V+gLO94IfhxTCx14Z/HbKW6aKweWhfDArRhDfWMatjH7qj4q7VKX3kdpq+b2ua/MLZR8QdgCqUVf4neAu0x9D8bsFUL8ixoHWQPKOoJ/7ONvvhg+bP8EcbW/xTrjap/qpaQ3EFnWP6kSy1/lj/rH+tf698p2h/4l+PGX7PN/6Ta0xUX/QcRkKsNI9zKv0yn/237S/bOXPw/W/EnP6yB8R/FblPK3yydf6V4yQjpmhoIkTc1UybFQZQo0s+bcTiXf1C6OsUVSyIuvPDCuOzy78fll10eN954Q+y9997xoVNOwVeTATIw4YADDorrrr0+li9fXmhk2ynRF+Wkj0vAgt6oUFVOMqDBD+gP45a/HpNXtaQ95fHPNH3NVYPHP238J04KajrwzydlMslVIDUS/5V+ghiVesEf6pR5E/7U1vTN/02FP8K0T/RflT/qdC29yB8q9jh+y7/1n/W/DFQqJ9s/aBz+Ff+36p/CItv/XvQv6nTqX/HO/g+hRKucvNGOntS2/inCReZY/wAj1j8T1r/S130Y/0tjEA916UX/phyltiEnuaTysf6pvCFPmI7fGP5vpUFuV/4jaZVT0KX/eWuD18H/mm8bVf5RK5fJzr/pm/+CYBf+kCRO9ZCnEogEmsCoc4CjqmQ95FlbS/3qXVbIe1tr8ANqH/nIn8QSvHLi0EMPjXe9691x+y/u1NOT/IraAQfsFxd9+yLMRclPTwd99ZH0OY5UcvUy9ZMjLfqDA8wes04f0dcENXj80zb/gEbBdyf++YOLVY3X80RXC/+VvoDXjT8693zTMeWG+B8cBP7k5KrTkQRN3/wntLr077Tirx/1X5W/5Ny06/9p5b/l3/rP+j/taaejlgbX9s/2b+PaP+tf61/r3+bqX/u/jC7w13v+w/7vNMb/xt+E8bfB/ONGjv+aTh+aoiYkeL9EXrsSWrCjYH0ec8NUV6suucYclxxaps+yXtvPH4gVK5bH448/ps7ru8tYna+j4FLbcD/bTZ5+/QWlTvrolT2vR78m+/qJfh1LU8e/ceaf6d3ENTcl1ZtYHYH/0ekL2UoMV/xT2PQUu/orfY+Jf9M3/zcC/oBkLi3ejom/jjoF/2wnHdMT/nnt+KBBxT8pzx39a/lrYaTMvziiacVM4r/af+u/Dt8IGCefcoFH1YF/63+qAwKnQ7dQJxBTel5HO8X/tPxZ/hIP9r8oL3rUIGWlJ/tLmbL+sf5t+1+2P5SItM0t3UopGdX+dNgonB8v/zG6/8NO8emw/6Q8d+jb/rYwUuZ/WvzfuYg/XHPz8N90+W+Pn3ZDTjmfbhwsAK6vY0iFlkq1qLysgbshVKxMJLOx3i3MavhQsPhHWCmKZPlwBlEsWv7sctVBaWvR08lToB+DItwTfVxa39GfCP/7cfwbY/4TxwSvkEy24VNM/Aj8j06fDQouhX/KiTrpCX+mX7lt/hfYbFL8AakF7aTO/fzoqCf8o2YX/tFBGQix3bnMRv1v+bP8Vf+nwHaTyp/xZ/wZf5Q823/rn+p/2P8mFqIn/wv1uvwvWJQCpF78r6bbH7K56t/cTwz2zn/U7OI/epkA/2eGPqnisnHdTZ//mR6/5kGAEeJmNv5CuNa0+G9W8Z8yWT4zoX/mV83F9/YODSBnjK2e6UXilW76IBUdk1yI5BnMMzHMC1Zgj+2tN98aBx14gMqZCqZi5UCyTjr6LOFXFtSWJyv4WwVoNUn6esAZ/YhGQ+mfcfrfafwJJPN/svhjsl2vhAB6h0fBv2x+J/5JiKAfDX/EO/vhzKBf3FYZE/+sR7kbhvyZ/tj6x/wvOpSQI/YmiD/BjG3UkAAl7lhg/Zv2J+3WWPbP+CuQIYIIG36s/8SU9fwPihfkyvrf9s/23/6P/T/7vy13a4T/Zf9/08Q/9n+Luz8Cf9X/V/wLl87+78aN/+kTynluKYTZG3+dfdbZyEmMnf8b0//nCDE++b8Yr/N/ChMy3J5D88/872BOJNUEniPGzygTvlDZWvGYf4wIaxlyWVhQC1vu8vzq1WsAJL4TNxOU7fN6UFn1BogS7HFdWxJgU6WfHeL6TN/8nyL+Ygz803gyF0Igd+GfAiBAj4I/NKBMqRnqjYd/9q26pi92kq3kddU/5v/GxR/5PVn9Pyb+0WkL/+h/PPzPHvopzrwe48/yZ/2T/p/178bVv7b/xVbY/7H/k6bX9hdOiO3PNNsfJK2cfyjOLR1cGJ7O/IuOLX/kzCbVP6Tn+Gty+cf+ij8nnn/dFOMfZNJLilN3C8p+VRQ1OcwKRDK2eoIoW2BdVS47oUJPdxc1Sz024gGat+6a8DDbqY3pJzfMf+GkICMV9QziL3Fbbo7Ui8J2g/gnzgl5tZk8/msn6sH0xQ4KivkvdCU8ih6l5m3p32nCX+KuA/8s6IX/KblTxv9M008Gd4y/sN34K4wQHFIxbQz8mf9ksPGXekBo6E3/TJP+M/6MP8uf9Y/1D/VA8/TvTPufM0O/JtHrfFv+Z0r+Z2b+26Ju+iP8HzKkQfFv5/zno47UCXyvLxapCdTIYLiABrnfcro8SZkcU1IYzQbLE5N8lrjmwpOIulSCWb0nCfXBpDHrtxbTFyvMf4BkFuCvOkaCLPHfhjL21sc/6wn//E46zq+H/6wggeKNmQ3h3/ST4eY/+DCd+CM6e8Bf0/W/5c/yRw5Y/4AJ06l/wNBe9I/lz/Jn+bP+sf61/p02+5MqtSf700z/l0lhGmgwSoJn/TPt+ges7cX/aSb+CL3En8efyqqFvyKPxE4V0E2Vf0Xui1QxNUxuMXnAFS+IG10RDvKUymq2TPeYWm3yFN9domQa23NBcKFdksgOucaCZ4nRdkhPfbDE9M3/BNlM4W/NSuBQ/1gRtNyMhv+C7ZH4B9TRZBz8sy/gPYV8JP55qsfxmz44zSniZFWeSdWY/xvA36qVa8k1cc/6d337s3ol3xxJOQWLJK7kFg4SZirTOZXinPEnnpBL1n9khfX/mP6f7R/0iO2//R8oSxiRbvtLaFRfhoYHVbgRs2x/bH8Fh1wRG1js/07c/1q9Zh3FStzrlj/nH1L/0Pu1/tmo+tf4s/wBYHNJ/8Cnp3OCJ4CZsE1/RDCmMuW76GiZdE7HWDEaxEKfRsKUR9rlD3RICWvF8+VY/WIFOioBLTVXX1lu+uY/QUFccNnU+FuHGxx33f7MqPQh0XlRvLjx8I/WqplTKfyrocaFlfCPkvXwj3bjyJ/pm/8VR1PB3123rUiEroc/63/K3/13L4+VK9aK1URctX+WP8vfdMif9T/9Pyzr6R/bP9v/dJqED+pefkr8Yf1r/Uu1IeVh/1usGDX+dvwxbvx1z+32fyeTf7H+nU79Szvn/Bft/IDzf2nUZnn+VQ9+0EHFv5Z00upPDpUyWCSe190mVFCdfCSAnlw1TS0Fza4yXZadcp2fPMNe9Tt2SUwJMtMnVwpvwS1NTBaJ7+Pxf7/99o19993P/Ce/ALFEWSKuFKlMd0kTvaPi70fffaic7ea/MK7uEvwbwn9OW9KvV9E+yrOd+KdwjYd/00/9Qz5wgsx/4pyI4nZ9/VtO8GTBfcrElRc/iDJxb1T8s12e7cY/9f54+id1fdIgQV7ZXNX/V0IHcASd+tfyZ/mTfrb+kYKw/qWKmLj+TW2Mtlhs/8GENDbY2v+x/yexGNX/sP21/Z2q/f3ZDU/GA/csbymdTv3r/If176bTv46/qOktfy1VBPM2vvzNdPyNWLhE9Zw5LEO6e58hPuGcKQgcq2Y6xlxjWKyuAXaF1CjmmSG15F6tifIqiSjNr1Jhx/TFAnKCy2T4f+BBB8fSpUuyA/N/0vj7l3N+Gc88wycJJ4J/ykBHSomQx0LU8y/3VIT3eqf8sLQT/zXeZK2Jz7/pm/8bxt9N1z0eP/zuAwnEEfijCq7LxPHH1Ec3feJ7rur/r51zF67e8k9ISE+JF+PZf+sf659u+acusf2z/bf/Qw3ajn/s/9n/pW6UXW05/fCfpuR/2f72Yn+/fuYvnH/YYP6Fr2BLr8/+38bzf6UDWkIPTk9J/jdu/HXcsuPipJM+4PwfXNx6k5/TVa06E7z9FP+OJv+DfEUEfzOuMmBgKFlAIPPBmWE8E87kLh8N73T66g/ZtVRKC+gsSRaSgRI1FtE0osNS0t43/enhP1msxfyfLP6eenx1/N3HfwouJph7wz+w3lL4nACBXTMxEv/DBf/lZMoCEsxTkz/TN/9byndU/C1/Zk2c8ec3t3UuAVh1sfVvl/zd8ZMn4/Of+lkV0R7sn+XP8je+/KVJgO9j/V8sa6f+sf2z/afHlTI08fjD+tf61/pXDotWjj8qL2r89Y2z74wfXIRviFWflxXqvv3fDv8XunTC+R/r34nqX0noHMKfvunj/F9j85+D7cAljQt0JpiBd1RKkaYyLf4b9SpOZqJ3SM+LsxKfGkPxYDXU2LIiO9I7R+D+tTpj3zwNxcIq3C/CkkfZzPQnxn/ysP2Utvk/Ffx9/5v3x6f/8Mfx9BNrAE6BNbdld3T8j+Q/KveM/9o9pQHNcMdq4vg3/W78m/8Vf3fe8lR89Lhr4hfYCl9YWf+Ob3++fuZdcfpf3GT5t/6jsFQFrV3r/9H8P9sf2x85+bQuKS/2f3qMf6p6sf8n/8T+r/3/CecfxrY/F/zdz+Mf/goPSJQkhnIOzj8oPBAvuvIv4KPlbxPLX/pTjPql/7CZePzPvEGn/WUn+Dj/Jrl3/pHISnwQZRON/+fXxryTDxWRXenJYQbSOFav7Bi463xiUk8Y4zxoq4oq8mKwsD2VD7Y8y/P8sHO+tgLfach+y4XnKdOfLP/JWCaKW4v5PyX8Xfat++O6HzwcR75nrzjwTYti8a9uFVtsPm9U/CeEJ87/lkCUSRtb/jCvRchGkz/TL9pjgvjvZ/4vf3ZN3HHT0/GDbz8Q/3be3UKY9S/YMAH782/n/jKuu+yReOtRi+OAN+4ce7xw65jXoWL51RraR8uf5W8y9ref9U8v/p/Hn3Ij5SzVNJb/a/tv/yeDLPt/jCfLYvtr/2MU/2toaCgeuve5uOGHj8dFX7krbocfTLdNrtsE/D8+Udu0/AclSxLWlf+x/ZlO+yMgzqH8F4RACpfh9Wj2x/m/1C39nH+bL60AAOBLf9ilisiEV1WQw1CWeCeFkrp6YhXnEza5FoKKcmH+N5UM6lPJ4nt0mVfGu27YjkljoY2tcI5rrUx/KvznTBQ2mv+C1tTx9+zTa+O8M26PL+FO9Gj4F7/B+MR38r+Nf1wEv56Bgor/TALXWdJFYq4gE6UobxDwIGtKutj/GPJn+uCv+b9B/BFp1LXWvxO3Pw/cuyK+8Nc3x5mfvmU9+2f5s/xZ/1T7RqtFHy63GQjZ/tn+V3zQ14f+FUrk2cgm2f+x/2f/V6IA2UgZoQalpNj/T75MNf5BL+rI/u+G/V+xCgGr8FdzPki6jxb/MqbgQrvPpdv+bzj+Jg350Fp15H/6nj6YVYR71PGDK/nNcPAH9cbCf+W/mD8J/rN9b/Tz12V4zc7/pZZO5Od64/N/duRfNc586jcldjBRTFR03E1LsS7mK9vocfZkk4y9gIc++C9Q5T6TwwyoqAq4GWbmjGXYz3LWR1nCttRSRdMvylpzAf6Mxv9W3t38B4cSc8ZfkTOKmuXP+sf6FwbF9sf21/6H/S/7n/a/HX84/nL86fgbbiEW5x+mmH8RF+VdKo2j+LvE4iPjT+YyuuyPchzNoW//a8T8W/5mtf4ZrMk05WjLsyD8sTplcBlUU3Yp7Njnmnfk2IYLXx2R9yNwoLL2XQc5ICykAmAyGU9Esh+25Z0p7aDI9MEDJuPJnknyP9uS4+a/kuiEHbiR+8af5Y+iYf1j/Wv7Y/tr/8P+l/1P+9/EgOMPx19Tj7/gXTr+ZcDl+LPEnHM1/uQk0keeRP5HEfeI/AOVyyj5n3xNmwCTZghPK08l/0HkJcfnBv255n9ljs/5P2YQmpj/nLfddtt/UuJaXnyNh5tTYMkRntCH6bYU6iziSdRTEZ/OShi1nnOlcsAyjD5LFRxlmcq5gjKSsKg1Dk2/cmXC/L/22mvjhhtvAEfLLJn/yUvjz/JHJPB70NY/ZIIWam/rX9sf21/6JMVm2v+oWmHC/of9P/u/tCn2P+1/K8pz/JG61PGH4w8iYY7EH4f8l91i9xdtM6b9rxmc3ELXaafmf5BcrjFWkf8c9zjjV/3e/a9+oH/BGXfE2rVpLeeC/81Xxt57373x0AMPSqdxDmrSuHv+bf/71f+BGQNgi7ATBQP1LpJu7SSYWUWPyOP8sJDBBizM8mHdQURbVueCnQRQEWvcmOLXOcoRzvF89mH6YJoYI0ti/ht/iQcJEwWKQpZyRtGy/FFYUndUvlj/8A661C4hoh3rXzFC7IB5sv2x/bX/kdJg/8v+p/1vxx/QBoy+HH84/qJhcPxJLjj/UZ4iVk6iO/7UUQYW4BSD0qpBxoo/yFHwdFL+N1s2mX4Ze+UzX9FBjoj/my7+veGG6+OG6/EA4gzRLyAz/RnkP39aLsHHi8D/QL0LBKOhezz49Q3WqO+V4S8cZgs1049z4WwrAMvSFG/muQRnrNiv+uFqCAYJ28y8swD7pi+emP+yTkCE8Wf5o+Kw/pHeVGKDetT6Ny2GzIbtT3lKpWrN5IpMCe/V2v7St7D/Yf/L/qf9b+gC6kTHH46/HH/SR2CEkd6U42/wgf6S8x/FhSQ2OuMv8EZ+VDv+oM+ZOWPVxEFpio1QRX5if0jtRsn/oPHY+GsAfYx+7PE7/yFUOf6XLM1k/hXegqYinScIc8nVSswp6ExKZGICcOYdIZTlUjRCKaDB4T+Xlp7FPpokBSY32D/ryFPDVovpt1hC/oCfydJUxua/8Wf5oyxY/1j/Vt1Iw0GticX2p7AB/KgsKVuesP21/yEPy/6X/U/oBfvfUIqOP2QzcuX4i+ZSkKB8OP5y/CnBaGD8nfeOim4YOX7Ixoj8j1zvUfzv6oeyo5b/CVStl/9R2w790zT64nTH+K1/rH9nof3Rm/haCV5Zy/LFE1pLCjaBrDs+3OpfOqCc4dmytEanrxeoIbQCu+TC10u0fLO6w8AF50y/g7HYha5MbwWcMf8FnsRRB5uMPyGDSCmL5S+FBbqGnokUi/WP9W+Kh+2P7W91O1qOiP2PVJOdjp39D/tfVJn2/+VE2P8GGxz/Of6gTnD8JRzQp+7L+BOj4tj46VX/qy7r05OQssRuib/4VLZyGShiJEb/S/WrI1aatPI/qtff9DFEDLAwyv6nINOa/wI+57+AkVnkf+Hd2QRsAW25U6QjPObNwLqckdyzHoWd15+KhIjvWIrGGGDqGfv1PcRUqNlPqcDXTaBvOR+mDwYWLpv/4oS4YfxZ/qx/qmaw/pWZsf2x/bX/Yf/L/qc86eI2tjzw4l7b/wZjwAvHHwq/4UM4/kpRKQLi+NPxt/MPE8q/pPys73+PNEG0RdX+DJVkaKf+Uf2W/PESWFJ6GSf/kTXmPn3Z6tb44c33OH7m3ckn+//2/ze1/z84TMAm/vQIa5Fr4BFiKckkLCHMqsSkMf50gJPM9eaBztbVEMv4jw+7YKtcylZvMs990zf/hQ3CQXiqUEGBIGL8Udz4SUmy/Fn/EAsQDutf2x/bXwpD12L/g84X/vGhCbX/JUcCnChb+59gRfLC/rf9bylPwsH+d+shP8e/AIRUhOMvxl78pCXt5/irOAwaa84/Zz8RMMb4C2fUJJkUE/K/hrv1bzXRAh8uoe/pO/8m6GjebX9mpf3JJ4mrFqRQ1iwxtvwraeGWf80MsW7C8Qz1SG3bkm62wYJzraIsERhYzCeU8xzqkl7tg7umLz4RLb3y/6QPnBTLlh2b7dDK/AcrCDR+tIgj2mOR8Wf5S2xY/1j/QiPY/iQPyArb32Iyere/bYPLpra/9j8EA/sf9r9Sl6SC0L79T/vfjj8cf8z6+AMXyD8asWHdVC2qbGT+h8XV4Evfp/8jN7IX/U8ao/nfot4A+mTUaOOfQP6nxX9N0fT6n8chr8T8kqDA/kfOf732doX25fQy/7N8/M5/DuPesTDK2ZSkAwN11rktd3lwTslggoSTqn/e42E7HnCL+mibf3moX0zVLhUNdrSPVvxagTLN6B9Ns5+sYPrkQ/30xn9OifkPnhl/lj9xIMXB+keKQfrV+pc6klrS9sf21/6H/S/6C/Y/7X/TJpT4BfbB8UeNPbjtLf5w/Ffw4/hD/hWRgx3Awv5nsmKu5D94naPIP4KHGj9sMP8jGaAencb5bzp9WigJFeUKMqX/TZd/az0MKjBvevqy0DM4/qbTx4uH8Z5xITAVOl9+mU4Tj7OM86M5qhNFsOAcYZoMzBMMPodQPlSa6o6pqoIMyjKZyR26H9gSfdg3ffIPvOAyKf5nU/Pf+LP8Wf9Y/0If0rTI4eW+7Y/tr/0P+1/0k9LntP8JPtj/dvzh+Mvxp+P/tAs0D5OKvxm/Q506/6EbA4w/5G+O9L+TS9K5G8v+8sZEk+k7/nf8P93xv24Vp4qDBEOoaS9wPwkHFGMc4H8IK5YpyKBjWcrz7kYpR71BfC2BieNB7GvRlnen2Ab98Bi77Kv0ovJa3fTNf+PP8pfawfrH+heWAf+2P7a/1An2P+g/2f+y/5l60f43wwfHH9KLgITjL8efjr+df5iW/Au/ZVPyPJSqlp7t8D9U3KV/0zchfe7V8638D8twgueyJgtKNe105D/6mv7cyn8xDrX/3dz4o36fKIUVt8KoDiS2UAaExkBryyMIt+4O8Rz2ceeMi46wn+d4XBbtkESWsKk+/BoTFUkSq7VBy/STJWTOBPhPppr/xp9ks0pbFTvLX+WI9Y/1r+0PTa/tr/0P+1/2P1uut3bsfzv+mFT8QWXq+MPxh+MP6dG5m//IvI6SM+VxxFb+BzLO/M6wMtBZb2i9/E/akw2PH/oC/+Pa376mP7f8b8bPA5gszqvzf7SQif+m5D+ZQZLAcjNcgEABlhCzrB5kdF2P9LUCFhE4gg960k2mlobACS3sIQGWFViI+xKox/ehayE9LKZf+DRR/pOZ5r/xR9mz/EmXtFfWP9a/tj9SCzLQlAzbX/sf9r/sfxYraf9bjHD8Mcn4g06n4w/HH44/5nb8Jc8Qq5p/wFbRE5PDKsSPWGGOeZqvdaj5H706gpkkOZnYdi1sqRpsVM6M4X+ipmo0lf4szb/ptX3O/wn4BZpd+Bdq+9j+UbQhvFU4mU4AL4osc5+Sn4fI6DKpi0I6U3oaCWfyqw0sTOUhzdE+yB5wuvSMM6lcSLE+eWz66/N/2bJl8ZY3v7kn/kuBm//CrvFHqW2BwfJHblj/WP9KO8jqlG+z2P7Y/lJXpoKQjwNHmCX2f8SVtKfy2Hhs/8/+L4XD/r/jH8d/jn8zK+j4n7aRSlFrrOhBtA54cu7EHxhHl/8jp6i841VfFcixjNR/Nf+gwaqHkeNnDfUsbyLzjaP437WW6IKVTaM/W/1PzYP9v6b6f8x/U41JhPM7Q1nSipQkuKwDIce/bgZBevMPQXcRZLbSrjQFKjKhXEr4lQVVhBAM40eEqGSyGlvkJ0vQiFV5skZqDaT/qle/Oj72px+N3XfbnYzAHzkCDuF/NP7f8Yvb44H770++kXesaP6DD0ISoERQ4WP8Wf6sf6x/bX9kJdLGUkfa/tv/ICTsf9FloEQ02f/0+D3/xr+kgEDAH/fHjr9SYzj+rRwTrxx/AjPJkbkTf+J687/L/uWvw6SHlKIwRv6nVOlt/ilP5E9+mDiuxFnSqX/6k34dYxk/x2z/q0Kga/6tf4kRygvYo90x5E8Y4goVp1P/Ll68WDKZwipJFSleRt4txe8l8g6HAmtUZZXSgjKe8XYW1lM83e6JU4wnjlHG66bAs2d+cvJRqKW7Vb/Tf/0b3hi//Y7fjLvvviceePCBuOKKH2p/4cKFce6XvhS33npL/Py22+PMM79g/ht/lj/rH2hJ6MiqZHFk/Wv7Y/tL58H+B3VDVQ3dnpT9L/uf9r8dfzj+cvzp+Nv5h7HzL392xv5x8BG70qGCNzE9+R9meZBBaud/ELQo/wPHdVPkf2Yb/d9aelGsWkmObJrx0ze2/9OBP3GDPDH/e5U/+k6ZnS7pWx7zrg4TEK1OtK/UdNZlZIr/DFBxsrzBWVlutudJTIM+KOQ7TXiUpVx39I39bJfqW+dQpZ/p77PPPvHnn/xEnHnWWXH/A/fFX/3Vp2LHnXYWfD/xZ5+Ivz/j9Hj80cfFL/KDzKOq1a7YSgahWKxEgfnf5g32jD8CQ0DBxvJn/WP9S2lIqZDSxD5Lcmma/eGoPX7Pf4F/4/wv49/yb/1n/Wf9lxyw/0M+NCf/wNFuWP91JNGgKph/UAnVRk/5H1JBerIj/mSySd8iV38b0j99Sh9c5LJh/nfUKfxnO8lqT/zXRKmB49/ktuM/SuTE8ackMZPCzMoOlg7q6yCyw+y0QC5r4Bc/CFYmcpVR5ouJ1Ac3vG/BligoYK5JTNVhO5zvXJpG/4jDD4/vfve78ZOf/CQuvPAr8ctf/kI8ecv/g3cQg23f/e7FySryVHuc3Pxkkflv/AEZlj8wARJh/ZNqAqyw/rX9sf21/2H/C8rQ/mfahfoz3HQe7X/LRtKzrkvT4o+mx18ef7Pjb8//WPOfGjHfOZxeJA1IMRswHSXF1FP+B3112V9wfQL2h3NU809NpM+ZqOPPfZluzUX0xH9wrYv/6GUC/Dd987/iD0liIgdrZN2G4C0p78Q1Ei/DyEJRReidOtyiatbGljv88AFXtGXCim3zflPuDyiLxWptBUHcVuLZWfbYJPoDA4Px6KOPFWYOxL333gvORZzy4Q/Hi178ojjn7LPi1498e7znve+JI3/jSPOfGWGiCFBJtGDLHX6MP8uf9Y/1r+2P7a/MAb0N+x+ymPa/gAR5Dq0A1f6n/e+mxx8efwkeuCkRRZPiT8+/51+4H4F/vlY0I20kaEfkf+RVob6aUGq4w0cMx4q/Wbf6H+y3JIhGs7/sivLXVPoYvsbv/Fsbf84/psxQ7mY8/7rnnouHh6AZpASYjKtagMjVcRak8mAZEc2TIxZIPxUH7/+oQqstj7FQO+AOSDaudXAERdM0+i996Uvik5/8izj6qKNiy4VbxNXXXBvvec974tGHH4kFmy0Qu5YtWxbPPP10fO7zn48nn3yyctX8N/5ShISSjpXlz/rH+tf2p1oK21/oSToq9j9kJex/AQ/2P9N5aLb/3XKiwYYmxh8ev/EvPWD8W/478i9/dvq+cfCb8p3E6TMQIPShWhqjY0fF7ZXjz57iz99c+p1YvXIt+KZgzfjrwF/mG9uQcv5xdsjfYCsvzK+kAbepElIXEPU0pyrkDs+rQtZSYhnFSgzjThGeRdYRVqWeWqtd3knqbsfH35pI/7Zbb4trrrk6/vlrX42vfe0b8fhjj+luwT333hN3/uIX8Qt8nn76mXgM5U8gQWz+F1gZf5Y/6x9qV6pYrHNr/Utjavtj+2v/o3hu9r+kGu1/FkNRnuTqthtN9b+r3fT4mxl/ef5TDxj/xn93/iWfMZfNUIDRkf/RMdxsQafbjnTFH3xiGEvWm7z9rZ2ohwJXhjtNoZ/j7uA/C3oZf3koYqr8N/0EcQt/DeY/vzCQC9/riUVqAgxJkAmX+kpBOa2kbgYiBHAmlgf1vQPW5cvf2Y/URmmsQ5XmCmfRf77Kok1e7xVtEP3P/n+fjaN+9+h429veqqQwH/ThUvn/mc/+r/jimWcmy8Dm8fj/3qPfG0cffTTqmv/Gn+XP+sf6t2XcU6na/pAP1cbY/jbe/2i6/+Xx01Nqrv/t+ff8G/+Wf7pFWpz/ABuY04GTSOe5+IraMP+QXNKpWqEz/8N6yj8okTFK/JEV1G8v+Z++pQ8+9TL+2ZJ/e+Fee8Vei/caN//k/F9KR7/m3zA6agSoBgo3g0euKNDcEM08yFMqq9pC9zhabfLUMJ5GFrvYnkvmkPNkdsg1FtzLRdsh3XViSTPpr1j1XKxbt1bsngr/t9l225i/YAGUj/lv/Em8KGSWP+sf6ZZUulLo1r8SDNsf21/7H033vzz+9L2b6n97/j3/JXJ1/NuK5eknwkmSu0h8OP4nC8gJrTIfhCKUtHiWp+Z+/M3sDyd+nPnnOSwjx49QCy3HyT8wl1S+Oc7W3f4nTyWT+55+4V73+Gdv/uvQQw/Dg4xvIyoagH8OcQP472v5H338GDKFE0+gMmGL3aIDBAq+SFzNylcIKMd6owRLuV8ro7YOUb8FJpzm48g6xkl9xQd0VIL+VJ+ahXsNp3/KKR+Om26+SawgX7iQbz3zv/Kz8ltMRwf12Pw3/oqcWf4gHFVerH+oJBqvf5tufzx++z/2/2gX9A+dOEH/y/4vWQd30/6/XG/735Ihxx+OfyUKjj+hH9PPnovxF+MlLVTyipmYm8A+P1pKPgcFVf/pFOyBFmza40fJevEX2pGG6mUT9lPzH/1Fn+N0/ovI0E9EcNIbnv+b7eNXXlxfvZJ0S04pnvWBYUks73pIhqkZqiDrKWNJMoqysdZYcZtl7XLuKUvPDrAMcZO7UhDsn0sWNYv+gw8/iJeZr5rC+NU0ZwF8JCvN/0QcOVP3jL9EBnli+QMTrH8IhcbrX9s/OK1UDViaaH89/55/49/yb/1n/W/7RyloVvxt+z++/UeAkP5hj/mftCQZdbdjb6KqOJmo0Bl/Kmk6jv/ZX/RTw3SOf/bjD3YB86OnvXH5GoHzfwXmvP2R4NUaK277Kf+GJHEZVQ4ZwksI5BBzj/v4qKbYICawjAsB3mVSUMwzQ1jzj/1nTZRXTxyl+SoL7LC37JYHpj8p/lcOg4HY5ZH5b/xZ/igJ1j9VO1j/tg2N7U/lhe2v/Q+oybLY/6O2tP9L7ZCcsP/v+Mfxn+NfetLpM3BdvWrH//2U/+AruCZq/4CFAT1rmB5ECTaIj5Hx52DJ/4hCTTISVQkrtW8CfQ7U8UeddGzrLvgy8fnvJ/mbneMf5FfE+M72agAGhjhjOWu8cTSMZ8KZXOCj4Z1CX39Ibacdd4wTTzy+NiH81X6P3XeP17/x9bHNNttmEcvRIXtmjdb+FOmzL/XaAlrS11pKCXs86Hf6HKKWho6/6fPv8Rv/ln9wwPqPxlhcaJL9s/6z/rP+s/6z/gcGrP9t/xhi0yiCE2QGV46/nX9IJLSx0JV/YZ6HmElnqpf8j24hdmZ5E2wE3Hr4Gy74KydzLpBgnkr+aS7SlzhWWeziP6R0wvynZGO+csrAWvY+vfqfjxGPlf8jtY1Nf7z8o+lvfP4PtgVX0OVrpDDpeEcfJZkraQoe5G59z9SQnpeP2HnnneMDH/hgDAwmSufPnxfnnHNuXHzJJXHKH50SV111Zbz2ta9ja/WxZJ99pDySDkpbimNy9NkpX5NT6YsOr5kE9P6ceqcq6ZOKHu9nFe73AX2Oof2UIMbZsPE3ff49/mbLv+ff899k+2f8G//Gf/q3TfR/Lf+Wf8u/5R/hPCN6x7+Tjv+RR8BDwRPJ/5Dj+taybkhU/mPbc/5FM8YGbDyn6A8poTvV8SvF2h6/8lK959/IM9s/4sb6j1jYGPovXzehrpPJXCuJirtDEtuU3cw78o5RnQs9YcyL4sJEbFY84cQTYpdddo5D33hI/MaRb4/PfvZv4tRT/zYWzJ/PGxJx2OGHx9YLtyndiFrtoWwnTp+UK311wjsf7DpXGgfrlENIVRXM/qDfyf8mjr/p8+/xN1v+Pf+e/ybbP+Pf+Df+KQVlaZj/a/m3/Fv+Lf9V/THQz1hfSYC+j/83rv4ruMJGr0ggS7mU/A/PMpsyUflTH8oCZYf1m+zKyGj+av5pw/Sfe3Z1/P3/uD675LqH+R9J/547n4p/+uLNeUUboH/5t++O97/9/8bhLzwnTjrym/Gj/7h7wuOvo4bm1qWMPf5ypWPwn2fJoYnyv1LdMP3kv+47jJH/27j0Z3r8pl9uWQSeHa7vlaHAE3kQfcz+MO6WCCbczz2t89UTyUCBhE3weefvvDO+fP758eCDD6KLgTjvvPNi6622iTcecoiSz18699w44f0nqLb6S7ROiT6vQpfMHS68dia5eTdLC961g62+ftOqSNWmQanGVMbPDlrd8mAT0z/jjDPizLPOKrOz6elzyDM5ftM3/42/1L+UhU2tfyx/lj/Ln+WvelvWP83yP63/rf+t/63/rf+pCbFs4vifJKdN/pA36c7/8Dlh9K9USc4w1zX/Q7pcJkqfuZdR8y+ToH/7TU/EV75wy4TyHyPpf+erd8b1P3gAAxl//KtWrY0/e//34pg/WBrfu+vYeOcJL4+PHn9prF6dfBIz5vL8Y1Y65/8C5PLORm6JzNV8YYCd86/xYjXR+Wcvo87/CPq95B95Daaf86L5mGb84Z3E6jYTqIXVg1XcgBYmWvWQMPc1raUBJ4aZV25RhJsvqDsYe+yxe9x2289TqaDNyudWxn333ROL99wTNQfjySeeiIcffCiWvnJJgm0a6PMaSJ9sAsSFGCk1oh3/eqeJ6OTImEDW3Sa2MH0ybkrzz/bmv7hg/Fn+rH+odqFXpWetf21/YBzSztr+0t2w/2H/y/6nQkT7344/6Dg7/lAABb2IGHai8Tf55/hLXHD8tQnir1/c8kR86o9+GH9y3CXx5dN/GmvXrIubrn04vvL5mzEJdP4jLv7XO+NfzrtV+8y/fPPC2+PGqx5WzufHVz0Un/nIFWh/cfzDp66Lp55cJfm/8coH4+Jv/DL++Qs3x8d/73vxtbNujqF1yOik06TsTk1Oc7aZfxpaNxTn/8NP49mnVsbffOxq0Wf5N0D7YydcEp/5kyvj/ruebvmfd97yeHzqv/8gPnrCxXE+rn3d2nXxy9ufjsu/e3fcfOMj8U+gPZ783XfHM/HrR70k3vDmxRrbYW/fS/7cjT96ELR1oSpX/FN4MZfzTytXrowVK5/DmMbO/3EurH/EBcx44r+f4t/BOpicZD5NTKGElMl5gbjQbnHgEB2uh3SeZSjV+2sAHp5A/Z133jE233yLeOqpJ9VcAo3o8PHHn4hddtqJLSTwF154Ybzn6PfEvMF5OtZTv6IzOfq8lrxevR1H+7z8Sl/J7PJCcI5XmfGUYtMHP8z/gmFgPDE6MfwTfsYfmWD5S52TcLD+gXLhTUaIU1j/gglp/2x/aHT4KRs6oLb/wIftT8qI7W/6E7353wCO/Q+oE/sf9r/sf9Hnsv9JdWD/m0CYiP9Nro2f/3lu5Zo45tf+JRbtsXW86bdeFN/6ys/jsx+9KrbZfgtsfxjr1sCRQzf/+D+vj9M+jqRtof+3H7syFi6cH9cjEfyB3/xm7PWSHeLQt+2F5Ow98fETL5X/d/ONj8VH339xXHnpPXHIW/eMr+Lp4L9BkleO4lj5J9B60Ut3iAWbzYt99t8b4L00AABAAElEQVRRc/6pP/pBfPnv/jMOOnyPWIMnfN/9uq/FQ/c8Gyt17f8az99jm/i133yxEtef+dhVsfU28+P5u28V2z9vy3jhS7eHazq2//HCl+8Qf/TXB+OacFVw16774f3x7NOr40V7Pw8lI/QvfdwJ8d/+34bwN1r+UZNB6I7kvxThRPBv/o/G//kM1sjf+iqGYQhj/sIiChG5EeeUem24i4XvplE9KhQFNnyCN2JteZH3AKUHBUN4mTSDv3l4H/Fzq1apLcvXImvwta99LY466nfj3C+dt2H6eEJ55RFL0JRUeDXsHmt2Xq5/KKPMvE5ddF67ijsvPpugXRkBhJj7ta9hHOvdO21CIjiAPk3f/G/DwvirMkPxsvy1ZSOVpvUP1bD1L4SDAlIX258iHra/fGKF/ob9D/tf1Zba/7T/7fgjfSnZTe7Kj3D85fgzcUF3yvG/hAKMyNzMdMRfNw9sGweNk/8h35c/vSaWP7UqXrpkxzj48N1iyX67xjNPrIzFv7Jt7PT8beKGqx+KFyNp++SjK2Pe5vPilz9/MlavWhfzFsyLl6DNTdc9Ep8+503xul/bg5Ri7drhOOMvr8UwOLfDMW/e/PifZ70pBucNxm6Lt453v+Fr8cE/PwAJ5s3a6gBVOf/KOuFBw4MO3T0u+NxN8aZ3vDgefeS5uODvfxZfvfq3Re/tv/uSePrJlXEunho+7uRX4onj1fGrS58XBx+2e+yz387x9BOrYqddFsavvGIH6JmB2O/1uyOYTZzRJiuVJFrpxvMML5X078N7jD987KVxyl+/NnbcdQukKLMOf/OKNZgGk2+nLcsinj1sHzx5jZrOP2n++8H/Xfgf/4m5p3ZOWazzX/OfSpEmkAgL4YRrPizEd0kLLQkqnJ54/pXtNyb9+Rqa8JtZ9AHeRcnLJqZzwUDyK5IYo5KoLJakqDzZE/HEY4/HunXrYvsdtqO8iWms+bztto97772n1Ssfv3/lq14VP/j+ZagD1vZCn/SwtJ3oQl/lZXpYhX0VhrO+FlZFmYIyFEi56AJBHedEPmcS+3X8qMiTXDh+0y+sAKjFFzKV/+SR+S9RJyuMP8uf9Y90gxQGV9QT1r+2P2l5c237C6Gw/2H/y/6n/W8ayRJ/Of4ALxIRjr8YUGBx/FniTLLC8efGir8VurbyPwKe4Cf8FUP9vF0Xxsl/+Zr48LKL5b+8AU/8nnjKqySxR/z6XnEFngx+9IEVcSASt0Noc/X37ounH18Vhx+5p+owUfyl//PjOPd//yTuvPmJmL/5fL3yIfVfIOH7/BicT10Y8bJX7xRbLpwXd97yZLz81TtLLYw2/8xB1LD7l7c9CbUxFCe9/ZvK1TEUe275mtj3jYtip523jP/+lwfHR/CaCw7n0Lcsjvedsm9RN0mznf/iFXTIXxl/pf/Tax+KD/72RXHCh/aNd//+y1k5q5cL4aa05m/86YFJfW0f5c4/gTN95P8Pw2aPzP/k/HONhfcE8MAs55+YYP5ToAOm8piVJp9/Zb5zY9KfXy4bQgNCnLuEsC5aqVFMJs8N6iQGXQbGYXHhXGuL1dDQUNxxxx2xdMmSuOKKK9TfDttvHy/Ya8+45278AiTqsJtdd90tttl667jpZzcXakljPPoL/+MnIgby3UvOBvrRpXEAXQsPO9K+oi+VQmJadFWtaxN2VZ6coFLQ+FlD+6VZ3Zi+tKH5b/xJNi1/VTMULWL9Y/3bNks0O7Y/UBK2v0VP2P+gdIgL6WJpn2Ustf9l/9P+Nx9wSeFw/NPlXqVhJWtQbP8TTLD/3QUQssP+ZxsW4/mfe79jP7hlW3bYX8hUzX+QkUXI3nHc3nH0B/eJ6694CE/t/jROeNu/xSV3vDcO+/XF8ak/viIef+i5eA1e9TCEJ3K/939/GQ/cvzz++18dpH5P/fhVceOVD8cf/o8DY8n+u8QPv3N3/PUfXaEcCys8fN/yMn8D8eiDy2P5s+tiF7zagnmZSh/VtLCo4l1JMhRsve0CvXriq9f8Tmy7/QKcHogVK9bGFlvi1aao/lvLcO3/bUlch3cIX4hrP/Ft/xoX33FMi35+Yzw71nBHGf/Vl98fJ7/7O/Enn3lt/Be8n5gdZ122y0XXWMr5YHHtd5uLfxqrVgKR9n87ODXH/T+hTDCo0y+scYqJi875l/zpPb15a6OMXPjL+lnCpDH32vLHztAbjJywVSjhJQsU0sRfi3pey3TRB4kkwA5JiYY2LyIvhnet+GFgy3dLti+Qw8eidhwOjvF/9tlnx3uPPTZ22223GBwcjP/35JPjxhtujGuv4VcKUB2f9x1/XJxxxhnZHo1QlDLD85Ohr8tAY3bE/bLlfhqI7LjSbwsoa8x9+gsXLsQdt60aO37OYsWf9hs2/x6/59/4h9AXuW+a/rf8W/4t/5Z/6z9qwub5/xozJ9/2z/Nv/Dcu/p82+Uc2qJ3fGZn/wTkkU+795TPxay85DwnclbH/658f7zzxFXqdxDokhJcevGs8dO/yuOzbd8eBeJ3DQYfvHj+89F68luGZePVrdtW83HfXM7H/IYti/9c9PxbgieFvnHMr3mOMJzFJGPT/89pH4pYfP4YE87r4py/eHC9/5Y54AngLXdfI/JOuFastt16ARPAafYv9hS99Xuy021ZxPhLAA0iqrV47FO897F/iG1+6Ne4F7Tfx2h9aEQe0rh1f1MfDjQu3WhDPPrt6g+N/GE9J/8HvXIQE8evjDXin8jNPrI6n8QqLNXyFRNG/rS2G1Mo/oed+zT9NG/7AP+f/qgyOlL9x8q+YgI3p/+N1E1zoYGCvgFzJac4WJ03nMpFKkLMKP3wHBre5Yi/44J8/SrfPK14Rl3//8lixfEXcfOvP4kMfOoU1ReLAAw+I66+/LpYvxx0jJp/rLaLJ0lfPXCV9Xo++MaFyXLe0D8qUhS+VWSaJ7Q/6xy47Np5b8VycdeZZmo+mjT9ntbnz7/GTA55/sqCJ+s/4N/4t/9Z/1n/W/7Z/zYt/bP9t/23/p8H+w4AqpwM48dsbPBiZ/9ljr23i9/CKhfcc9nU8mDY/nsC7hz/5d4fggUC2HIjX4xUON13zsF7twKzRIiRs99l/15iHBwbZ5bKTl8af/t738ATxPbEST/i+49i94/Jv3xNPPbVSYvyivXeIP3znt5F0XRs74PUQp/3TW9Dt2PknUuU1bf+8zWO/7b4Ql9z53vibc47AKyUuja9+/paYvxmu6c2L478uwyshUPn3PrxvvPfwb+DJYlw73l/8if9zSAzgvcavRBL71E9eFb9z8Ffjq1f+1zHH/+UzfhrLn1wdHz7uP3S9dfW/zvm1eOs7X5yHzAxj4VUz/4Rha187OsG5wsXMgfzXscuOw/ugF8YZp5+uSya/+Wnl/zgeLRwTdnDS+afCkjL/PJrL+ceBxXu+gJnSHFXBbh4lwPkObx7n/FNlUNjbhXu/bO84/4Lz49WvenX2IYYMx5ZbbhWbb7FFPPn44+VuCk8PxEkn/T4A9/flFRzsB58p0NfFtSjnjgQTffKamfDOuzk8V0ZCepkJ7wv6J33gpEwSn3UWB5mKqUHj16A7Vk2b/46ha9fjh0oz/huj/4z/bg5Y/i3/1n/N8f+6pd/+n/Wf9Z/1n/VfU+L/6dL/f3b6vnHwmxaV7rrzP1nYnf95FK+V2GnXLUeS7yn/8Nijz8XzdtoCCdp2/ud8JGCvuOTeOO0rb0HeaKXO1/zTaPRrUrJewPJn1sRW2+AVE0zMIv57DEngHXbYPAbwxHLNaSmThXP8gbuddtmiK/8zhKeOV69ZhwTyAnS54fGPpF+vo9IfDX+/ufSiWP0cMlJzJP90zLHLkCTeMk4//QxwpHv+JzP+yv+5Mv6KP85lU8c/f3gIAqRELbgA4OougHKpZAsXCIvQkPsQv3JHAedx94jvWhm5DKFsxXMr9Kmt2A8Bcs455ySR0m7K9PHCj/xlzPZVkD4fHK7DyOtP+qrFQfYR/fbIc69p42/6/Hv8VVcZ/+SA5b9Z+t/yb/lPzWf9Z/1n/W/7Z/vXpPjP9t/2f3rsP3IkZCVTJdzBPzRJ5lHKic78z06LtlT+h2VaSoqlF/27I14hwWUY72dVfoZdMP9Emuhnhx1xvtC/H6+4uP3mx1SfZayqNqi4OX74jq+14LIV3kfMk5X+jrsggc3KpUU5QOOhTBDzTAf9wQWDsXb52vj+9+5S1RxOGT8vDMv+b9hNr7cQ/ZL/msz451T+ifk0jZ6jxh8OWuN3/q3v84/zlSBOBKRg8C4MIaEtwcBiCEgiQ1ve/WFymFn2toGiEGVtQSplStDK8tx9Fq+ZGIRw8/0ypEGFoGY8jTa6CzMB+morsr3RZ62+o0/ekXlaOHtgSD1UGRmUS1+Ov+nz7/ED70S2GGH8W/6t/6z/q8kresH2jxyw/e9D/8/23/bf/k/R845/HP9BIdr/SYdHaxqIXHq2/2BgZaFyPPr1LfTBhGFH/ke9VvvDHBFaEX/Mqdb27QRPlnXlX9hBubxXvHqX2B5P/ubSpv/IQ8/GT/GuYtUjDdHPb4gv3GqzOOgIJImp/6ZInxe8cuWa+Ol1oNW6+hxTzX8tOWDXWMinlUGL+S8tqtI7fb56YO7kvzCuOpka54j5Z1kdf+5gjYLKmxaDklUs7pr/2p6nSUp5RxRqW7rmCc4t62Lbhb/a3vYPzBGDpp3/89sTo+ffMQcgJGHjrCVRbuscVcCkKhiKW2+9NQ468MCsi7bEExfWH4YUUSB412GonNMRyklH7+lQHSqEydFPYiQKgg2lnzxv7vhbCcKGzr/H32z59/x7/pts/4x/49/4t//XVP/f+s/6z/rP+m+j6T8kc8bK/6yXf2EBxHEy+Z+lB+4SSw/aJRurY8wpOnvlQYtQvkjZKBW3zpUXidYEIeN/npskfTbcadFW8YE/PSA7UW/ULeqyTZ/94whpYp3r0r+l8vjjR/uS/9pr8Z7x2b/5TPz2b/+OqEw0/6YLKOM///zz45Of+ETcdtttk+I/R7U+fZQWfoq3TDaNN36c4zL++J3/q/PPOw2ZGJ+9+U+9rIWP52vmObvAPZO6eZwzzrMJEFaoS4oJAbRqzRoV8u4IX2iNcau5ksA8w0f6UZbJTO7gboKQlvtToa+rhcCJTGPpa/i6O2X+G3+WP+ocaIaiF6x/rH9tf2x/7X/IS7L/Zf/T/rfjD/hIjr8Yizr+ZPwMLHCZYPzv+JsJ1KbnH9rj5+9VMf6Uvz0y/hLAUudsrPzPXKK/3bbbxn777x97v+zlsWTJPrH33nu35I/vAX7ta18Tb3vb22LRrrt25d8233zzOOSQN8YRhx8Ru+yCHwVcsADtl8T++x8YL9n7pfGKfZbEZgs2c/w7En9ScRsXf/2Yf5tPuU0R5w7Tw+QkPxJjZbnTiA7hKX+cl2ORL49JniNZzB10MqgUMZ8QLiaHHaO+ctDY1TcWUDdfUZF3fUpTnMVi+lPjP961o9S9+S8EC9jGn+WPegiL9Q9UrPWv7U8x2DLPkIsiHra/9j+m5n/Y/7P/BW1i/9/xD+M6+9/ggeMPxx9zKf7QtUJ6B5DjUXKGSd98apavWOjM/1DEie92/ofZowH+VJWarif/qJ7xh1rmaZblIXY68k99Sp+MyRzbQLzqla+MP/iDD8aWW2wRn/70p+ORRx+NY445Jl70ohfGued+KVavXhNPPvl4vOLU01D+nrjqR1fiR+QWxo+uvCr+86c/iTWrVytJfNRRR8Wn/+enkRieFyf/4cmxauXKOP6EE+L+B+7X/Ewl/8bJ4Zzymp3/68a/bFwX/vsz/zawePFijZVymlAoIisF0VFWjstGjuAQ7zoWEA2AWcgSF+1QpT571e0Roo3/qEbQpWbprm/6qWTFvcLoFk/Kcdl08X/xnnuBncNx1z13mf9kUNcCrPH2uPGXLAB/LH/WP9a/RVF06IuWrqX+YDlhgh3JSzkumy79y/O2f+CM7b/tLwWka7H9tf9h/8v+p4yp3A77n/Y/7X8WQ9lhL1u+Ju0nyzex//mJM/bF+30XpfUeQZ9WnE9MyxvGOeZ9NmX+p1/ov2PJt5HEZeIsJ/7Vr3p1nH322bF06dJWrPGP//iP8dSTT8YpH/qQyj75538RL9hjj3jf8cfHbxx5ZHzgpJPirW99y3r8v+322+LI3zgybr755pxDrcm5ydvf3333uwXFC86/QHgssNjk81/lwfQ1DZuU/wzrkio2w7xTVI+BLe7LoEtboSD/udEdpUwQsxg1eeMpG7CHjkUhdParCjwFVYO6ePA1F3aIxfQnx/+77/qlEsTmP0EkKHWsjD/eBxZbLH8FF9Y/1r+2P7a/RR3Y/xAj7H9Nzv+y/wvvwv6/4x86mfa/i1GpG8cfjj/mSPxVxZf+ED58AlXoVXKYhXyaVKeg63BG56n6U/+vL/uUAfaQ30pPBZllo8YfNU4lKfat/oGeptAv+beDX3NwLF+xIt6FBO273vXu4OslXoB3F5MnP8f7hl/8ohfFH//xH8eiRbuK5dX/0ME069/zL7ggLrjgQtAG8fznpmv+K32lF6aZPtGThE1/pvifSeJWcpjqHFNSJpr7FPI8REa33JBgMEHB5zl+tUCTiEq5y3XrgCcl7KVn9ZZ4Q7/cKRVEA8csMf1kS3LH/Df+iAfLn/UPlSP0qfWv7Y/tL4TB/of9L9pGKkX7n/IX5VO3mEHm2P8GYxx/EB0M5zO5oz3HX5IPCojjT8LD8bekJANOWhUsDYq/q5as49e2/MYPgy8cQ1TWiz+UyCtt0grjQMwrHERCpyf9W2uVvjIP1CD6kL8F8+fHdttuh8TwFnp6eI8X7IHXUDyGp43PVArg5ltujqOOOjqW7LM0vv/9y+L33n8iBVdzI7ja/ktmu/FHDhGLtn+Tsf94J3FKZIozFQEYKX6iPHfEWgGRWERx/hofW7KA0ORK5DUVqquEsk4i6Ytz3EVEM8wXg2pBAbWATqgFSk3f/Df+LH9QBdINUkTWP9Kv4AXVLdUmeEN1av1LhtCYJDeqKypG2f6kDEmUbH/tfwAI9r/sf9r/psHAQkOKj+MPcYOeluMvx5+OP5scf1If4p/KoCP+Kr9O1Xa1x4o/eJMB7XvzvysNNdCDqtLF/U5/GNyUzcFAxSxELeB31b9r1wzHo0gKf/s734rvXXoZmdleUIlNr7n2mjjm2GPiNa99bXz5vPP0pO/TTz+V86baqOj4p/CXG8c/gtwk/X88DpzwlHbgfjlUpzoAg1WWJ3SjosCWXz3Ihefy2WL2o+LSD8uH8GE7CsegvuPKOvx+GlvXijzAfjk0/cob89/4q1iAeFRxQZHlj3zhQqZY/5SvhXSrVfDF+tf2x/bX/of9L/uf9r8ZPTv+cPzl+LPbUXT8rTjC+QcGVEpGZlyFJ3nBEz2QwhPjxZ/K53Tnf/gEZ1f8MQj9qySzOm13mAmfVv+d+Z++oj8i//Xggw/FtttuG8973g4xf/4Cjf9bF30r/tt/+yDKt+NMxPN22jGe//zdyP3Ybbfnx1ZbbaX9Z596GvkAPH28YDMcD8RDDzwYe+25WGI9fwGe/9Qygv8j6LcYrlaYkzK/nfx3/oWMTMY0Mf+ivEICgveLJOV5ZwO7uKeWONM+nauiPIga/Cd4cHK44xzqUDEQ3Pqg83ynTLK5KptW37VPvbcm6XEieJOlVUf7HTRMX8w0/wEe4sz4IyOKYSc0LH/ChbBh/WP9m5YkpYLrDtvSkhvbP9t/+x+SDftf9j/tfzv+cPxHdShXkqkW7dJEOP50/Akb2d/xN6PI9Ie4KanGjDF7wr+kRQ8G1viDySa+Ki/7K32rjHVH+t99Sl+xeTv+eOCBB+K6666Pyy67PK688srYaaed4m8++5lYsXxF3HD9dfHDK66I737nu7FkySvIpHj7238jbrzhxyj/YXzjX/8lTjvt1Hjs0Ud07pv//s049bTT4pprrokjjjgcZeCx82/OPyKhSmlj5DuZ/OvA4sWLU1pLYNA6YOJtQGJdCDCEzPQTSXGfTzLi6fn2gmNeDu8cpUIoV4YyXSKvkt3WO0ntlnma/amMisT0zX/jL2Ut5cryZ/1DFZqYsP61/QESbH8lEUUs7H/Y/7L/af/b8Qe9hBJ20V9w/MUAF2xw/On42/kHaISMJOQ3cYXDT5y+bxx0xCIdDCD/MlzyP1mnpUxwOJn8DxxVPvnXo/z1K/3f3OfbsWbV2vX4v/seu8djjzwaK1etyskA/7feZls8TbxNPPDgg0iHrVMbztqWW24RO++yazyO+s8+tzynh2uwd2c8dbxy9Zp49umnrf9bkC071v89y19n/pWSK5DxvR1DrYwzmMr3V0ComZbhOdbTE76qjSM2K0zX3QpUYS19tQBbtaBSwMI+dNeNddAmFRR22D5XomH6NeMPRk2A/yf9/klx3LHLzH+gyfijtFn+rH+gWa1/aWAgD7Y/tr+pFO1/2P+y/0kPwf63HKVcOf5w/Of41/F/5i24nkD83S/5j+GO+R8eMX5FldVk0HrQhPABBSR9Rx0/69b4g/1yn/8oH2l/2ZXeG9tQ+hh+3H/vvfHc6tVd+Htm+TPxwP0PxPC6deSQeE5ePffcc3H33XfF8hVIEI/g/8N4n/EzTBCzReU/2k7W/3/LW94Sb33zm7vo4yDnnxczgr7zL/2XfxnMp3opuIMxMJTiS4ARZTzmHxFRy5QvpmOFApURKAQhUIgeeEbHeT4fc2K9Af1gRvafLVHauqvEEtM3/40/yo/kCivLn/WP9S8Fwfan6gTb307/Il0N+x/2v+x/2v92/OH4y/Fnp310/E1u0Hdy/iEjy5QPcgSfEfkXHRd+8XSNP5k8Zi6QZV3+J7tRh6P4H2ig956zmfoamz77Vt0x8k/9Tp9snK35r0WLFsULX/wiTj0vsnv+WTbW/LOu7iKomeVvDuc/ByXAAgA1RpnzxAMOSnCe8p3nCygSHzoAGIAI3LXgiyYSEmra2me/eScp61dXRm3YlJ3p9RJlv7Y0fXI2mcIdMAosKQU8TH6Sj+a/8Wf5s/6x/pXGLHoy96kmbX/ACz1O0G03bP/JDyz2P8SI4lEUv8P+nzQImcIdbEfzv+z/gjn2/x3/OP4riqLqCWkP6Q37H+CF/Q/gg3AoVpY6k6qThbPC/6gP8fGCsHTmX3SsIp7gUWscXfaPuQiey0Fpn9Univ/aiXpLciK7QfvbJ/Rz3LPD/2pNJXY2yP/0HKc8/7Np/II7L6ih489bjZRIfL2Ai9QEGJJgEF90x6mcLncSkmNKSqHZYLljwGcZ6rOgOcnqkp2Kz7nCIY6pNFi/tZi+WDEZ/g+0jK/5b/xRjmW2i9Dp0PJH6UoVZ/1j/Wv7Y/tr/8P+F61CLvY/xYfJ+J/2/zOOcfzj+MPxh+OPuRt/MSmJ+WPypsRK2uDZm5qp4alaoTP/w3rSf8pFjBJ/ZgX120v+p2/pk3tzLP7i9Tr/R9zn3I2Gf57rV/sP2afYQzVQuAlerijQ3BAdPMhTKqvaQvc4Wm3y1DDuhkmZsD2XfDg5T2aHXGPBvTS0HdJdH5aYvvmfIDP+KHgSCcuf9Y90pfVv24TY/gASQgX0hO2vgJEeBHbtf9j/SuGQjNj/TFcinW76FSV4t//t+MPxl+NPx9+wE+k9OP5m/E37QDuRbBk1/8NzWEbmf/I7nOPkfxjL0f6Q3evZH54iff73OX0Of73xz+78F59817RxVe4WjJx/nrL/PQ7+hWuhe87NP6acwok7wDQY2C06QKDgu2AktjIm2OMhtQEW7dfKqM3dAdRvgYmV6jFO6isWoKMa6E/11Rf2TH9q/K/8rPzWJJj/xl+RR8uf9Q81rvWv7U9xVmx/4ZPY/6CTYP/L/ufU/E/7/5Qixz+OPxz/Qg6SCRKI3IVwOP5POzsX8x9M7mqhkhsv/5PeteafVRl/a8GmPf8sH5n/AVdIQ/WyCSnW/FN/0ec4R47f+bfx5l/nhAesxsOf7c9GsT+6L8BJoIxySbGur5wuZcgIS4aZGa6CnLeEKMkoysZaY8VtlrXLuZd59KSg9zjnrhSE6RdeazNR/mdbcRsrbs3/RBw5U/eMv0QGeWL5AxOsfwgF61/bP9t/qkYsqRIman+zsdZYcWv7Sy6II7a/hRP2P1IywA77H1Q09j8IBfsf9j/sf6SpnJX+h3I8MudQWPkPoS0XPEr+R0JdrL6aUcb1KW2w3xl/cvLHy//0F/1U+p3jn/35N0w7pk5Pe/cw/5xl+7+JeLBizvu/SBJjMBxPWYZ09yenmHDOFDCOVTMr5vAT7AR4V0hVQDSklqyTd03Y/UDVBNyvSsb0p4H/ORfkcVXi5j+Ra/xZ/qx/qnaw/m0bOtufygts6y7Mh+0/pcX+DyGRnCAv7P/Z/6WaSEXBdbWq9v8d/zj+07NWkAosUJrUm46/HH/NvfiTrwCdqP8DWzDQjX+KAe3DyPEPlvyPKHTkf1q7lJsG0Cd/HH/UoAPbujup+bf93dj2d2DPPRfL90sHEOLLCZMwY5/SnAX6amY+/p/mj+eqcLOa9lWfKz4Tjq1O5C7vBrEvdk+Vwvos0guxuV/o5EYXYfpkWeELvxpr/pMhxp+ML1hh+aN8FDVTVEYeWf+IDxSXyhfrXzGD7LD9Sd1h+2v/w/5X6kj7n8VQaFP27X+2DKj9b8cfjr8cf/Vz/PlnZ+wXBx++CKHDJPQ/NGUuNejAUd3VNg/Yc7f/jXIEslO2v4V6m+jspH/k0m/H2pXrnP8CEBx/zI34Y3AYM0XBTeHCGjKbv9KHIp7gTGYF7bICD4f0vDx2uI/PwGCpxLNsw454AseZzMrzKMVp3GdiFe6bfmEvuZFsM//5K8lYuDL+kg+FFZY/6x+KhfVv6kuwwvYHPLD9Tf9CytL+h/0v+5/2vx1/wDI4/nL8SS8p7aNibsffzj8ACMJCV/4Fjx8hgzvx/APaKbFccEao9Wx/O5GJZo2j7/xbWzMlbCaOP+LG/j+lb2PEPxDJZG7eycmjfEdK+UJZicUVd9Ha1rnArXXqAS5V2eQRC9CW9XKl86xTDuG8VsFgpezQ9CsfwBHxz/wXvArGjD/KDzCSMMGB5c/6B+oTi/UvxIIKoi7Sn2QMhSW/9Maztj9ih+2v/Y+W11UNiv0v+1/QDsKF/U/GL/a/ZVGLWbX/Tf/B/rfjD2pJLI2Jv4oCwGY0/PMsszkT9b/Fw7Q22h3b/+hP+h3exgbGXzg1Bv95lhyaKP9Nn5wjFyon6hYlzr91+T/lkU1+BYBfAuBCgccGGRg6BsNDbWep7AmUGXqrgVZqUg/Zlk5WzeKgBW/qk/maE8k9VQsJZCPTN/8TCcaf5Q9IsP6x/rX9sf21/yF/K10lOU46tv+VvEifocOtZIH9T/vfjj8cfzn+LOrR8bfzDz3mX6A3u+NPvt6RbWlj1/c/Svqmndbp0f6yr1HzPw2hz9TuqONHaTf/C9fH4H8R8Anz3/TN/17xN1jtqBK4BWqDRRkQrUz06iEt7gvWqSgIzmF9nSthqqe0VCMTwVIqRDv++VWEpJM9M4GMVLWomH7yz/wHJow/8IBftigyZvmz/rH+tf2hOrD9lXfRmRy1/5G+A9f2v8QFeBDpc9r/pMpIXtj/dvzh+Iv6wfFnuhKOv51/mOb8C8VLcWuH/S22eKT9URa0M/+jGAftphL/zyH6zn9Z/8wl/TNYnekMMvg0K9xs/kqD8lQwqpRdCW8+dDyk85LI4C8+M3GsRfXbPyrGQwV0VABMJuOJoOybL2vGWREuGwbA6sb0k0fmv/FHqbL8Wf8QB1SO1r/kgu0P7TMxAVTY/tr/sP+VwmD/E3yw/50xR4Yvjj8gFI6/HH86/nb+oaf8C43oJPM/CthH2B86qqPoH33DvDixSgMNod1U8z9ziL7zX8CFJr5snP+bOv4puhvJ/0Pmga4UnxamlPI5DESe/FE6GhYpDG7lbkkMeS16N00pY321RzlVhBa2R3dDpU92WR4lznIcDrM2q5t+8m8K/N9v3/1i3/32Nf+NP4mf5NfyZ/1j/StLY/sDNsjYJjto2m1/7X/Y/6Ig2P+1/+/4x/Gf4196BY7/m5z/IALGHr/SOHQlKSrKWmT9zP/Io0R7LCX/wzwga4zpf+t07/a37+g7/wV49D7/ZJc+/IbUevhz/nFj5V/xm4BguISZIojd+hRxTTDwPP81MZzTOlXt8lQPaIsiLdjJmFQdc/bQLr/ewPP59QOeI3U0Mn3wYvL8P/CgA2PpkqXmv/FH8ZIgWv7ECLHD+sf61/bH9rd4I/Y/5J/Z/7L/af/b8YfjL8efdJMnH386/s/0TH/lP4gJBtT48B/5Hx1lYNkuR+nY888+EI5OKv/Dlk2mX8ZOHvB/hvJvy5YdGx/4/ZNmjH4OfubGb/q4bVRfFyEQAowDefsHAppPCMdAfs25vleGTxETvnXBaSy8G9C9sA6VpkIRrNhvLYshNMIBw1bTJ1eKEJBfk+J/8lkdlVXltfkP3hp/lj/rH+tf6EY58rY/tr/2P+x/2f+0/y2rOFX/2/EP44zOxfFH+hqOvxx/zc34M5/wbOd/gGfF0e38D7FdH0aS/GuVWoDyT9XKIj5YPGr+B43Hzv80gP5c8T84T3qwgPPYnn9OsfN/4oJwzr269JP9m08xlmxrVHSWilKHhOdAWYB9agPdEWILLlzznA6wwXG5lZZKMcv51VZRwIuJh5GSrrXLTj2b/eB00+kfu2xZvPzlr5BQkrX/+9TT4p577hmf/5ib5H/hbnsqOGXmP7Fp/Fn+rH9SQVSlrSPrf1klKlvbn8bb36b7Hx4/XAX6T9CRUgliiP1f+/8AheOfIht0HGg1ISEUEu1RaPLA8V+LFY6/gA3H/5CNuRB/5rN7kmcK9obsn2qMlH81kkJQP638AyQhv4XO4lYj7HfEH6RfTvUrferGqifJia7xEyYY/6z0P6jvbf8aaf/wugmKIwAg8Aqz+cUTSWsqCt4u4unOauUMS8tCdOcuv16gfaBd7XDIl5UXHwIHpSJomH43/5cde2xceskl8e//9u/xzX//93jyqafIvA3wP7lo/ht/5IDlD0yQSFj/WP8WnWD70zK7rR3bX/sfUpXQElQU5aMvh9n/E2fkqW7Q/6KOQU1Vtv21/5FwYERp+0vZgEzY/rbMbmvH9tf2F7Ixa/IveSWps3q0/1W/ddo/3RmBLeTTw/IlKP/8Y5mUQTGU2HCvNX7VK3X6lD6HP9fkX7pb151zwzl0/q9gmHzRUsCM/X7zf+bzMXJJKgda7hRozHiOnOf4o5gERd4Rojjj9RMQYNj8bCepV4usiN0BvukYCoJAopLgL9LnUhrx675FezSV/hsOeUP81jveEXfffVfcf/8D8aMf/SgefeTRmLdgflz07Ytis802j9WrV5r/xp/lTzqE6sX6x/rX9sf21/6H/S8YBbqV9j/Ttea68ML+t+MPx1+OPx1/O/8w4fxLtSYj8j+ZwVk//kKaZ72l2h/mfUifOMylfD+nlf+hH4dz9fQ4+ad+oS8+tMYPk93j+Gcq/0a+c/5mir7zj+nWzST/B4cJWC5EA3aJWS28k6P9vBueuiCFPBUDTqr++lpiiBX4jw+7YKvSaW6YatedImwaSH+fJS+PT37iE3HmmWfGffc9EJ/61Kdixx13jL1ftndsvXDrOPvss+M73/lOfPxPPy7ukcP8JCchsjow/40/IGIUK235g4DwHx/rn9QaUh9VDzdc/+YvaaRNaqL98fib7X94/j3/Tfa/jX/j3/i3/0Of2P5fZ/6nBEwKFoAP/OsJ4JJ9yEhiRP6hdQ6N0JzLhOLP4U76aJywzJ0m0J8L+S/kGHJqnf9jwrxp+bdB3ckgAvihUNYsMbb8K7BoCy8Bg7qEjfLItS0ba2EbLDysRVlSzpIGauhcuZNU+0BZE+gfccSb4rvf+W785Cc/jq985cK485d3ijePPPJIfPzjH4tjjjkm3vSmw2P/A/aP/fbdF6wCY8Qv8nQU/rc4yx3z3/gTDNqYsfxJQlI6rH+arn89/mbbX8+/5z/9qWb6n8a/8W/8pzfo+JdBN3jBD3cd/xMYYETD8x8Ag/IOXOuhkmTLevkH8YqrmqPI/INgVHMW48WfbDca/kSdHfQ5fTJqtPHPIvzpydE6l6Pln3j9nEctzj+12FFZMh7+58D847u7xChHo6FBB1TEclvu8rBGnkY11NW/0sSow4PSHm3zL7vj12K5KNFc2qsVb2Qr04z+UaVp9DniRx9/DJsc/3333oP9gXjwwQfj4ksvFcfWrFkbP/jBFXHwwQcnB8fh/xmnnx5nnXW2+jD/yQGxDLA0/pIVNLTcI/IgbQ2XP4+/2frX8+/5b7L/Yfwb/8Y/HKLifzct/rD8W/4t/5b/9fUf40QGivVTn/KFhmQRlw3lf5QDonzhM13xNzprNH3G7L3yXxE+52l6+P/jH/8Yr0K9csboC3MzOH7TZxYYYNLXA5QoBkuQQEqniQm2mmRLtcG67YV3DFhAAOcJOh98Dw3fI6LkbykPfKVACXN1hxWqKztNJYL9ptG/6KJvxZuOODzwGHcs3Gph7Lf/gZToeMMb3hCf+4d/JEdj/vx5ccghb4zLLvseWaRPruoMmP/GXyLD8kc+QISsf6x/bX9sf+1/2P+ia2n/M51F+9+OPygP1IsKzJodfzGOanL86fF7/jcW/pkY1ntkR7O/skY8sfH433T6051/u+GGG+JGfBRhZ5idPgXsiPMvZEj/5z91q6g193CqdQeIjoTMKM7gf4iMIChYrLtDWZ53N0o5igbxtQQCZxD7WrTl3Sk2RD88xi77YklXNVZoCP1bbr0lrr76mvjnf/7n+PrXvx6PPfaoAppL8BTxPffeFxf+01fi0ku/F1deeVXc9LObzH/jTxJj+aP+KJoDysP6h0rT+ldyATzY/tj+2v+w/2X/k3YBixxs+9+OPxx/URwcf4IJjr8VSzU5/9BT/oXfsqABwT+9ylac0RF/VfvS9r+Tq7S/0jhsRm7X/E8e6twG+d/X9Jud/+oJf84/Qk4gQPif6fzrwOLFiyXPlN+SCuZuSrmukVOKnSLVVbj5kMYQnzrWKYRmVB7UK63e1AtWqIBhaotd6oscfKnYUb9p9LfYYotYs3pNfPGLZ8app/5t3HD9deLN5ptvLj6uWr2qPSfkk3idHDX/jT/LH2TB+kc6w/oXCtL2x/a3w5+AxUyjaf8j+WD/y/4n5MP+dxEEqocOfdG0+IPD9/jFBa08/yXWr7igmAAgjv8VZPR9/P2JM/aNg45YlAJBvdgx/9hFsregAec2df6hX+i/Y8m3Y9VKJs6K4bH9SbwJbtY/0rXkyAj5q8eleJPKn54kpjLQdeHRPGGWx/hwPy8aB9QK+a/qfKw/EzQsRk30pJtM6kDdlRV7KP2qAosBBtTj+9C1oF8uww2jv2rFyli3bh0YkZyu42dymJ8sJXPI+GR+OQKvzH/jj5JEdGBt+bP+SYVBVdqxWP/a/tj+UjRSQWhHu033Pzz+oibpVGGp/hfdLX5SnZYD+1/phiZrwCv7n/Y/7X9SR9j/Bhccf6R7IUcDoGgtc8j/xjXr8qv9kw2E9wxFx1Hw7CAqaK9D/+vVFcwkrTd2MoEtVQO7tcIY+Z+UpCRA2k2j37D8l/1PygcWChSW2ep/UrQljakcGE7jmoss57Uzu88FGd3yQDAHQ8FHw/JqCUlzjpWeE1uocekBm9IzzqRzSbVT36VKbdBk+h865cPx05t+BiaZ/0SM8QcmkA9aW/6sfwgE61/bn1QKtr/2P+x/2f+0/+34I1+tAk+xFXLRa2wd0HFQssXxlyILRp3leRvHn46/M8Jqev6hNf6apcmAq8Th5Tem6HyjXInbEfkfJZBLm4xaR+of1uhB/mqtptJ3/idRUuc/rRdhh8Xx70zFv/C0OQUS85wIHGpSaqZOgssSCDn+dTMI5/IPyV1V5ooldUFFJpRLib4KzYq8I4Uf0WCQq0U0sm2WFEXEkw2i/9BDD8bqVasw6GaOnzhp8vx7/J5/459K3/qPJlN2tEH2z/rP+s/6z/rP+t/2z/bP9t/+D2zBjPh/6XyO5D+fA84kL66LJ3Fto+Z/0oizQg/5H9TRGNkh+lfbJtFPPiZD7f8ldGz/KF+UiJmR/9H5jyRxTk+R/tZhJn95DupAVbJeCjNHgW+YaDTc47l8tkX1axG3KNfP6aAKv6LGHxfKOiU/bfriEnkiPiabS/KdBxvm/0knfSCWLTtOz3Ynb7Or7Nj8N/5g4i1/1j/Wv7Y/tr9pU/X9WFrIYnCnYH+zD/s/fLbX/gfDZywVVvZ/7f8DA/a/oBnsf9j/sP9RbOTcyX/wBx9rGrNt10bJ/8jwdds/Jpe74u9B5H+UZFanbUOZCaeW3cxDGlE8ydxP9OcY/pctOzZO+sBJrXly/g+sKEtT8p/y61Mgeb8os74EAm/ylJdAUE4l6uSN6jJrTMHFZ8cdnxcnnnC82NaW84HYfffd4g1veH1ss/XWcJCyJ1RHV1x39M0ykZ0cffYYw0w8137Yd1LKc7xL1d/06zx18l9jF2/6f/xNn3+Pv9ny7/n3/DfZ/hn/xr/x31z/1/Jv+bf8W/4d/1IKpiv/wSyKEjNKJZRU73r5H50cNf/CK0FGCZNS8y9MNulb5Monlb5Vxroj8z99Sn8u5r+UUeuwMR35v7Hnn/OLT8f8O/9Hjsy9/KeSxLo7gKzwYBlAfR1EDigHVaY8a+BuCBUyE8k777JLfOCDH6Rm0mfB/HlxzjnnxCUXXxKn/PGH4qqrr4rXvfY11AI6v88r9kFV9tZepkJft+j5Yq5Cn33zT4niAubqRKoOr7vP6OvdUg0ev16M7fFLBpqIf89/s/Wf59/z32T7b/wb/8Y/4gnBoHn+v+Xf8m/5t/xPXf9lTiZ/8yKzKFSqkC5lTGpJdOR/xs6/sFGRSyWREZmWjnrJv2QcywbNpM+Z6CX/Njb/wbsu/ouVmshe+N9FHzkzZuz44Yz0Nv/TSL/QNv2Z4T+SxJp2JHz5WH/CR2skXoeRBaaI6p3C3KJq1saWO/zwBgPvFhQgHX/iibHLLjvHGw85JI488u3xmc9+Nk499dSYN3++UHbY4YfHVltvk43VWfY4XfT11QZeEinworjFX1VQ3LaEz/TFHfFomubf/CfajD/Ln/WP9a/tj2yL7a/9j2IU7X/Z/7T/TWHAh5tcTVv8Zf/b/ndRtY5/Hf9TwUDD9Jb/4MNmituwHh6R/5FUVZXFPgkyPmI4Iv/T0j+sW/nPfkuCaDT7z66Y/2kqfQx/duv/ggrOOeeKi+afB2PNv+o4/hGvepS/6ci/tuRvGvk/SEHmVOo54qF03zS1WA3gWGcp5BwtVpBlLEAH98suj3n3iU8iv/N33hlf/vL58dCDD+H8YHz5vPNiq622jsMOORS1h+NLXzo3TjzxBO0TYNNNP0Fcr08PSus6B/hiG+zleV45PqZv/k8z/o0/iFZLP1j+yA1qG+sf61/bH9tf+x9VI9r/sv9p/9/xz/TGn/a/qV/BBahXxt9V29r/tP+5If9T9giAYbzCVc3/MHnLXKAwpZMFX9yXwLXzPzpkIRq08Ke+eGZ0/499q+4Y+ad+p082cvzkd3JJBS3+MyMrtmO1ofxbi/+sO03yn4n9vKaZoD/T4286/UFOuoDFrwRgJ0FGgGGp4GQhC3heFbJW3rNlOTvJzx4v2CNuu+22Um84Vq5cGffed2+8YPEL0MdAPPHEE/HwQw/H0qVL1WY66Gcim+tUN7iiFn3u87rzTtb6190P9Cvvmzr+ps+/x5+6x/hvpv4z/o1/2kDLv+W/eK6N8v+s/6z/rP+s/23/bP+mZv9qEldZEyVRoFmVP1EJ0iej5X+67A/zQGyiVEvuTyb/UjtpKv0cd0kOk5cs6IX/qjh1/nfSb03lDNHnuGdy/E2nn7caKZF8ry8WqQkgJIVcuNRdoXK63MlIxMooETi81YBll513jc022zyeeurJhGoWx5OPPxG77LpL6Szi/PMviKPfc3TMn7dA7bSaAv3BcseEzzLXezEJ8tI9x8Pdcj1MDOerNNrDn8r4Z5p+5X9Txz/T/Df9lCPjr5n6x/g3/tO8Gv9N9D8s/5Z/yz/DC+s/6z8GmUqbteJNBsP9HH9a//eL/mdSEkhl8qTkSrRB7j1HmKdqhZr/4fyznvSfckGj4D8rqN9e8i99S5/aYY7ln3i94+X/LP/9Iv+UbAgq7ZUEP9VAviiYAj4MBwdoUPKUFVhRx2CAntLJMmkLnkOF+kuVOGT1WLdurWR7oCIKyoXEBufNj+dWPJf9QIkM4bH6b3ztG/Guo94d5517Llry1Nj0B0H/mJ0Wq54IiD5okqgGo6vR9eqXNMv118FmvWykl7JTkXFM2rATdlPply5ZVsev0alanpxl9Pf4yc91ccfuuAf4DV40bPycFJolzpfH7/k3/qEOqNaop6AL+l3/Wf6t/6z/bf9s/+3/2P+z/2f/z/6f/d+J+/+L7poPttGGlLY1/9GZ/6nnWFOC1go1EIUPKV3ckr+S/1H8wQlRLMLvn+MPh0NY0WbzBB906yn/NMfpv++442PdGo4ZfNNYwAMd5cBYRt7Uha/aaB+D51mtNUfcKSxUoEfe1vc/sw/ZQ/WX88q6rMOlF/oHHHgQHvxcEGvXrGWLTU5/psffC/3Pfe7zRDfYA/xzPsoc8cUGlKWcHzFeMkP+d+Ofc17zjxuQP+aj1dX68rex6CNJzFFgYIMaZoGPriNHKGBQmHPw+GHL2oRsyYXCjj2+SmLdunWx/Xbbl3K0wd8OO2wf9917HzrlHSdyLuKVr1oa37/sctTrjT47JPNb9FlAolqSvgSCxzkUnGeFnBwJDzrgFXGG1FRjwd5kxk86s4T+bbfeyqtJhcCdho2fA+ZUNHX+PX7Pv/Fv+bf+k3W3/bP9pxdEhYBV//t/tv+2/7b/tv+2/7b/Mv2Ttf9QItQjXNRFy37iSMkXnBgt/1Pjb7Su9GV5W+3ZL85NMv+ijFqf0CeDcyiwWWIr+QK+6qAwHnxTGbmJnazf5i25KT6zDZeypfznobiPdrklTX3bvNDRhnOGHdYZj/7VV19FciNyK5uO/kyPvyf65CWngbzkBGilAuzigPzDX+I/85+sn7KEPUzwlPKvoLEx6SNJzGvEK64JGOyTGAfGdG5rrBhE4hBnsaM6iSwNkMdc1g0NxR233xFLliyNH13xQ7XffvvtY/Gee8bd99ytfsmsRYsWxVbbbBM/u/lnarch+mTu2Y+gfQF9vUZdLa8NmeO8KnTHcaAC8vKtsva4cnwkyjo5JjVB/dzWvjWprFgW1jX95E7lkfkPThh/lj/rn5autf6VSrD9sf1tyYT9j/S7Kh/oUtn/sv9p/zuDC8qF4w/oBPChxhaOv9rxN1Hi+JM2w/EnpaTKiKRlGuPPxYt3ihcCayPzP4pxIZyiDCCKfmf+p8Q/lN+WEGsnD1Ve+mVbLkPYqfvKKan/tvx35p/6if4Xv/iFWL1ynf0fzn8BBjdz2/5lrlHDIY4xtsw/CupFEigLlJ1EfSf+N5T/ZII/eZVMYw986n6k/G8s+pgbjioHw/WQFHEaKF5MGmtmunOQrMPqqSqwxdXXfZ47+5yz45hjjolFu+0e8wbnxckn/2HceOMNce211yKZlISOf9/74u9PP53VsUwHfUKsLOQjdod05WJnmRaUV1TifH7NgW1Mnyyoy+Tm3/yv/CPYjD/Ln/UPLYf1b9tS2v7Y/rYNrf2Pygv7X/a/Wt7TJOMP+58tDtr/tP8NMNj/tP85cf8b3/OecP6HOaBu/UtdlOmwbv+frw3lwtJO/0f5Lp2ZTP5p7tEXD1qDtv9j/6eAH5uJy1/e0mn1sBHsP16hgbfxomOS4jKA9wXziAsz4sO4S8TgDpuuoL++dlgCz/rZJC688Ctx+eWXxQ8uvzxu+PEN8bK9XxYf+tCH+NS2OjzggAPjuuuuj+XPrlCT6aafKijT1kxg65gXSdWEAZWS9v40j9/0yWzzX1ww/ix/1DsEg/VPW+eSHVUXW/9Oq/21/bH9sf21/2H/gybG/r/sgf0P+1/2P9s+p/3PNi+6/G/meZSoIYfoouOzofwP2rQSnmwlZcOd9fQvvxHO3rW0/H/87BnplDNNoC8OtcY/vfk3+//krv0/cWGa/J/BtuAKukgIE2Z8WFq8pqST51q4ywo8HOLz0mXRuzbKO43XrFkdH/nwn8SSpUvj0DceGu981zvjjjt+gZrZyf4H7BcXfedbhQ5Ki7BU5TIZ+npNTqEvOrxQdsQToJs6LOnzquk8Jh3TN/+r4Uo8G38Tl3/LH3hm/UNliwV61vrX9sf21/6H/S/pQ/ufxS5gY//b8YfjL8efjr+LLpxV+Q88e4yHgiea/9FT60pIFT3PVEvP/p8ihmIZ0Kxx9J1/aGfmEjYTxx9xk704/pz++Bsimcytd3J4JCMOz1Zps8ydZdxPbzerY1Z4h4lKgQsTsa0DnBuO55aviMefeAzn8ksPPEs9cs455/CZ6hbV2uFU6LPvkfSls3KlcVT6OjB98x+YSewloI2/ygdwBXLDu8OSaK1YRvlFnayGg7b8s4rlrzCKsBL/cosD6x+yos0O63/bH9sfyEMq06p365a61vrX9sf2Vxa1mFX7H3Qr7H/Z/5ThABjsf9f8A1VEE+OP7bbbNjbbbDP51hsa/w74bahXLX1l7LTzThP0v4sCxmY0/cOzzOZsiL7q0cXhTusBQxZUv6duR/o/bIAFm36i3zFaDc/5hw6O2P8V1oX8Av+Z9H/KI8N80TLyxRWunC9oYF7YML5+UC+27Ok4Ux/ZgufVJA+zLZNMVYujBR8qYfCz/NnlEniu1F9iY0r0SbZX+u2K/UP/6KOPjqPwKXgal//9OP6mz7/H32z59/x7/pts/4x/49/4L241hYG++xj+t/0/8kdMAiuw4/iDzHD8NYX4l/yz/rH+2dTx99lnnxN/+Zd/SfiNib/BwcE47bT/HZd+73vxt6edGldfdXW8//ffjxZj5D9gN3gvqp3/4XPC6F+qMkfIdc3/FPU5Jn1UVe2a/6kVqXtH1b8NoT8m/8GVbv6LS6ye/BI32/wXe7HaWPpnz8V7xgv32mvG6PeSfyQPNtb4TX8Yr4OhxJPJSOBWVvOXJbUArUz0UkEQuSnW5RyLIPm33nprHHjQQch8swVrYIf/qKZf4MO+3mmsZtmzynm3gC1Kd5OlT6pcmkx/W95RXLCAXDD/jT/Ln/WP9a/tj+0vvW37H/a/6Gva/4R/aP+bMHD8QaXo+ItYcPwJJmBx/A2ZoLOAGHoi+Q/yjstM5B8+9tGPIQF82rj0h9YN4Xeizo/9D9g/Dj30sPiTj3wkPvKhD8dWWy+c3vxLXgXW4CH/6X+X/ZH5H+aSuvSPckzkPT+T5P8coj+X7M9hhx0Wb3nb2zA1o+f/xHbOGqfO+acW5vsp/zlYB5OTzKeJIdr4Kos0CNWlJp+rfOh4SOcJCNRU9aFYvXp1qc+7TtAO+V/2kbjkbaTyQnTSU2Y6tUgrmTFZ+kyLakG/INJI+lVAmzr+ps+/xw8ONFj+Pf+ef+OfUtBM+2/5t/xb/i3/1n/W/46/M/nAcCB5MfvzD7vvvntssdnmseeeL4y3vvUtsffLX1rimcy/8EbGq161b7z5LW+OF//qryhnQm331LNPx5rVq7g7bvzzwx9cEWtXr0Gl4fiPSy6OefPnx7bbbMfDEfkXcm1i+Z9W/kUGaIT8McfDBPCI/I++Yc5zpIbN8BDaKY0z8fzTXKQ/1/JfyePR838t/ms6R8w/MTHK/M+18VMmxsp/NmH88ymlnF/dSaTSYGJYmXMJ+AAAQABJREFUCV0UQnJTlrMOSrTw3TCqR4Xy/7f37tGWVdWZ+Lq3ildBUaUgL7FKFB8IqLxiUAQBoxijTVCJitEyQtJij+7OGAFxjNbBH/1Tox0VNZARXgWIgmLStiRRg7QCgpQaQATbJ6/ioVhVFK+iKOre3/d9c6599jn33Mt9VFl17/n2vWfvtddea82955qPb869zz55303J4zDLwCoasYzgZdJSfum+pEj8ps0goKGw8F02pj8z/tNDcCZSRc1/yx/0C/Jg/bP9Cf9GAyOrC7GAneBi+2v/Y/9r/GH8Zfw5M/xJ/hn/E4FnnGT8CYkw/jT+dvw/mfzHaaedXrbfYdtywP4vLT//xS/K4fhm9sUXX1I+9vGPCrZf+oVLy67P3LXcffdd5cX77Vfe+Y63l3tW3ldOP+20cucdd5VPf+pTk7a/+zz3eeWhtWvLffffOzb/Iq0dP/8jP4k2vKawdRPnf+IhQjQeL//DvMUU8j9zjv4syX8xhCTv6+L8X5X7up3b+Ge+oI0kIO7iDPEpYokERSMXKHI8Ik8wCSCkQ1jxv/nqAAZhPcdCA25ijQKGHEXCio8tq4kGYHtSR3M2DkuCsulPlf+aQ/LR/A/WWf6sf9AH2x8ZVttf+x/7X+MP4y/jT+Nv4uQKlB1/OP6SPGDl+BM8AGJ2/E2JEC+wimVz5z/A9xe9aL9y1FFHlo0jT5UjXvVqJIkvLudfcC7mY6i86pWvKi/Dj86tfXit8i/DzLlwwYaxf/N42CTi/z878cRyxRVf1rhj8y+0jTX/kgS06c3/kJCIi7rkhjwbQ5+dMSaG5A2TqeV/2JMDcjN36PNyZpf/gU3gVCvPx6lw/k/wocq/+MJMQz/5nxvx93CkbVMIIAxDUMhYcEeJFz4Uj5nX98rEXYRsQoFnbjladipRkr3geCxzGCo6W3I1gk7YBmtZgTKZjX/Tnw7/g89iZK7IVfLa/IdYWf6sf7Y/tr9pE+1/7H+NP4y/jD+J8IkUjb8df0AOGC8QLGtx/Of4l4GT439ayM2Z/6DKXXnllWXjUxulf9ddd1159NHHyvOft29ZtXpN+e2DD5ZPfOJvy/77vwTH48E6qig1NR6wk6Syqll0ztRn1NT49wUvfGE57vWvL+f94wXS9Yn9H8dsz3/QmpA+ieVC+rIn2PCLFX3zP0w4jut/BoC+OCxObd35L84TkkmUtfb8c4qd/xMXqCldSz/9q3WzLf5EtChTgMnHNeJKM1eLnTBGFIoQDKgzn8hqWJFsyQoanMqpBmegbdyXioFZr2MiVgcyfXJyRvyH9pr/lj/rX9gU259qW21/7X/SwzO4sP81/mjARrURxl8NS6gfwLMBaY1/yQfjf8c/jv9oCxz/Ov6vvoG+k14Dy6bIf3AMvuIz/U9kfkfxCorty8YNG8oJxx9f1jy0tnzly1eUz33+82U+3inMxiI9Sfrz580rf4tE86fO+ky5/4H7eOa5tPx/PDuQ9b3+D5fak/8Zj35lDQdq8DfOdgz+1AADTF+cbl3/Voo/CIps/wbX/uNLALRzkE7avPzAVqAyjoQehyC3m4UJYcO6oKUaYxhaBnXPftjl1yaa3HAtSPhMf+b8F7PNf8uflNH6Z/tj+0sZsP+hS+di/2v8UWFXA8SMv8JMtoEtFMb4FwbD+J9MkHwwaSM7ihW3/Dj+SbANXsSCfeNvscL4G2ygLBh/hd0AKybEX3pEk43ic+D++5dFO+9c7rrrTrFx5b33lg+d8cFy1GuOKq88/JXl6KOPbuwPu8Qysf598IMfLA+vfbgsv/BC0ElF7fX/GLXat8na/370lRkGCT49LF+KE6QFJVm1b+inmLA2B+JGxUn6n+yGXhg8L2trpq+5aq4/vMjM8z8ctXP9m9r+SHZJAsyu82P/V4WNjOGy+fi/pfHHfL0fpV4v7xRVrcNz5DyWN7jyjhDFGV8/gQLTrkkpa3vyKctDSD3zheQUJBoJ/qhFLNmJr5tI62H6HeEik6fD/3POPqfDXpTMf8uf9c/2x/bX/sf+1/jD+Mv4swMQwQvjb8cfjr+kEo4/Zx5/hm1h4JlWxvH/FPMfo2VnJIUZ/+++5x7l/aeeWlb88IfljjvuKAt23LEsXrSo3HvffXgFxSN4mnekbLftdsHq1tSFMPfn/wlvOaG8+sgjy1/+5V+VhQsXKsmwbv26suHJJ5XjadIzzD/EEEwidOV/on5s/qfJV9R+2Nb8A3EHzQzjkFgiJuv4H+aRWhcxQf5jrtAXH2aR/73s8ssla5gabMfOf9V5XZf1P9gwx+zf8CgFlgu1EMV6k0N3kqSZcRc95j+UPAwDDqp9SoYGidUIG/AfHw7BXrHklrc6dKcIG9PvsMb8t/w1qoKCytY/Whh+wpIAcmgHzLH90d16saa1sv2FgPAfH6qQ/Y8MCTiRW/tfsCJ4YfwBI8qF7DD+MP5oTAUKKht/EG7wE57E+MP4i7IA5TD+NP4MZaBANMtU8Tct7LtOeldZ8YMV5XvXXlf22GOP8t//63+TiB2w/wHl21d9u6y48cZyyy0/Lrfdflv5xre+CVopf2mZGuIotOm//KCDyic/+Ymy7777lmuvvabceuut5daf3FLe/KY3qUs3/knAHEdEgucWHoCVffI/bfphJLvo04VMiL9Hu/FH+BzSQk/8z3n6W3n+a926J8oT69blLPeZ/00g/5xtzbvx59aJP5csWcLbAzFJ2IQYtCrqQQqDqrFCppzJ5Li7wHoqND61rbbY7bOwFX4tT++3CY6wPyp5AIvp875biyG1bP6nnIA3lj/rH+yF7Q9VgvYTzLD9lfcIR0L72X+x/7H/Nf4w/uL7FY0/aQ3pP7BhEYvxt/G344+WQlTlcPyVdgK8cfy1SeOvs846q9xzzz3lsssuK48/9mhZveYhWOI0yJC/+fPnld1326M8sf6Jsup3qzcb/z9yziHl8GN3G5t/ULKn+onJzX9bg+RYcjUt/D2H6P+nl36zPLV+o/Nfxl+wp7MDf+mnSwkMwwPANOk9ElRxfvIuD6Ejd7koIUETxvQE++FTExToG39sx2oeZ7HefWcZexAQ0eFPI6JJjBMETJ98qB/zXwJECQnxAGsob/y3/IXekBn4UGasf5IKiQpWtj+UC0qG7W+1H/Y/kAb7X+MP4jzjL2GJ8KPyGiEX9KX6GH/JgdCDBHvAFoEv4y/wJOTG+Mv40/hb9tLxh6yCTCVWk40/6IQYwq1cubKsfogJ4m7/89RTG8vK++4tq1atGtf+7rTTwsLPQn12Kjst3KksWLBA5pt2qtrvifEv21Xa3Kb/Q+fa/2ntv2QAVzSF6w87SnrsZ/q988/9SfNfEghGbkr+m/5A838+hYlfTwhFhXAhgOR7YvhXl1DfELxOdU3ThQALOyr4JGjieBwne+IrBRxfbbhCNbPTNbdl+ua/5S/1zfpn+2P7S+9Q3Y98iXboTppq+5/wGva/BNDGH1AN4y9ATxgI40/jb8cfjr8cfwaGcvy9VecfVq1eU9auZXIYyzTjvxUrViCfAkTI2AEukN+Wuve++8trX3ss/OHvL/9CIMbzUHq5V/9wecL1mzH/s7XTJwec/3L+b1blP/W6CVknrKDU+lE6ReJ6yDiNDqPzESh+HNcTKATjXHJDwR+CdYrQPavZrWaCs2lg+GilwxyjLqZv/kNeImFs+aNqhdO3/tn+2P7a/9j/6ukcPgFr/BGoyfgr+GD8afzt+MPxF6KHJq5UQShaNkIlrHgjia2admFBHP86/h7o+Psj/3BIecUxu0MvoCT5LaOadB1C/oca08ZfjXpRf7Cj3E4UIy3UNGAhckKR/1Fzdol2OopVW/7mKP0/PfCbZf36p8TLCa9fj1GSJZF0d/zr+HdLxb/1+3RS0yE8ihLqjHUm65j4pdEYwt0hOtn4OgDrUMZdLy7a01Ms0ZvttKhAElEDG0A7gL4M8jhWtsuN6U+P/zss2LEs2H5Bzk3ldmW7+V85Yvmz/tn+2P7a/9j/Gn8Yfxl/Gn+3OeD4Y3rxh+M/BLKOfx1/MrjAMnvzH5HXUXJmhFeB/Zr/AWBi7meUjyhHxqeMjMn/8Oonc/0YA/8T+t85Td/4+2nnv8pds3X+URopGxN6+vvKvzKDKIXlhl8TkIGjHaASs44FfiK7Uvfijlu2US+MhPmMTth0Fo6Q46oBj/DuCIZMI6NBWWv60+L/e9/z7nLi2080/y1/1j/KQNdi+2P7a/8jtbD/Tctg/GH8Zfxp/J3mgCEOFscfjv/kJzPkjXAidxz/RhoAekKO6BvHKJBHjv/BhbmQ/+C84qMJ5txqfhE9MDkcs87fLBwz//rOLzNJ6swB2gt7xreCI0HBY+PgL7QcaPpbYf7rPcveW0499VRMOoQh/sfMv/UfUjsX9H8c+aNqyxqEcjKdAFlIZWdZCq0tMrpM6qKSYCreOjOqd99EpdZYsRcGUOccAZscmeYh5Q0ltWXzahxMnxybKv9lwBuWc4RmB2Wx1/yXQFLOLH9h761/tj9hn21/7X/k8mEYpuN/5Owbl2P/Y//bCIPxh/GXkg3G/7Ksxp/G345/oQqKxBz/yz9uNfi7ZgkEBmseYhS/WcXTRPIHW6RqxuR/av4hLqYf/mOLSdi/2mpQ6W+t+LvOv/N/EeoMWP6T+W/ottS8Ywio7TVTKcVlG1n2uBnE96ToD6ZeAhRjqMi+bEuB0tgcCkf06Arb464SLQ0X0Yi+UZOGqDmmAkZjG9MnC8TvXv4nH81/ygsXMMryBz6ERFj/wAfbH6iF7a/9j/2v8UegLeMv+sf4BEeMP8kOcsT4X1wgI/DHMiQE/33xd8pQ7aGGxp/gWXDE+BN8MP6EWhh/bt34k3KaWqucAlQYRo/PAUeSN1W6N/9Q7V/CisnZP9pT2of4xP2CQaJP1rauH7tNIp7FFv/tf8gn+98thT+QJK6a3ZkIyqjAkI7xiUPWRLtQZu7jCWt20cJj8WwxlV7VdVjU65Xn2OdXVIb1HTe2yfx0jhvGAo2yn+mTsWTGJPivCTL/87F4y18VHW6tf7Y/kAHabdtf+x/7X2ZvjD+Mv4w/u4GS8b/wtuMPoUbHX4GdJxV/KU5z/OX4izIz9/IfI4wdJOO4vLSPvNIx+R8lfrqvn8nlrvzPMPCXkswatDNgGJxm/Lb9mVP0nf/CnBt/zyb8LbseCsn7RZH1ZUKBNzLiDobmVKqOUiSPmZSkjuPDCa+/YNfRcx7gWDwG84IBuRe16tQZm614UPerVFBCw/Qnz/86T+Y/5Yh8s/xZ/2hL8LH9sf21/7H/lV+gRTD+CB8ZWItl4y9ywfjX+N/xBzXB8R94AFGocRWdJ1NdXGQrHf+SIY7/BSUgHPkLUnMr/mYUHfawyr9qWDUp+Ze2QF86+R8mm/QtLulTjl11aoz/naP0qThYGt6Oe/2tNuLXFrQ/OFvbvy3I/y08/0oSExTQKw6nANevY0ZAFUJNleZHe7gbQoNIRypEwV+81BjcEGqyJyrSmFQjqjbsp5HQNxfTByNmwH+9W9X8lwxa/qx/tj+2v/Y/9r/GH5AB4oL6M8gqG38ZfxK4dxbjb/BiBvhbP8xC3ZK6GX8Zfxl/GX/BGMy6/Ef4BOZ/Io4Oo8Y1PUboNe3cZPI/7CCDiC0TbBgxB5qM/x10+mCYsmhyKipzP/cmxX8wu4v/2Xk6+Tf0ifnfQvS39PUPOH0kiam5WCPrOwK0GIKINRK/owBONBd6pxS3qfNqz278UP95tygFSV8tYBUPs5Jb/FUDwS1HVWduVMba9M1/y5/1TxbB9sf21/7H/tf4w/jL+NP4W9GE4w/ESwqZiJEyhHL8BWY4/nT8DRNBK+H8AxHD9PIvfNgsLC3SwT35H43aa3/4iOF4+R+2rfkfjpsJon75H5ky6PCg0gcXt+78V0oFfQ7niov9D5mAz3jyLx5Rm9hsduc/h6nIvBQ9R4yfseR169KwGsK+jqbx4AHosi5b5SySDbz7xCeRQ4iwZlvUcGGXIb5YBqU4zhp8wGDTnzn///Vf/7VcffV3zH/Ln/UPloX2iObF9sf2l9Jg/2P/a/xh/EVLYPxZLaLxt+MPx1+OP2cefxJvO/6f/fkP2cPEywTNNf/D5C1zYazryv8IWPNAn/lHhyb+0ljj4w/l2ZgrGif/NNfpk41ba/7tiSeeKGseWsOpHzv/rBOg6jP/6NDMP5s5/ycGzkb8OUyl14nzKwEoxEVIHrCDya+CwAKPq0G0qinhSCRzHequLmqi3uoXd5K6+/H2p+mLPWD49Pl/5113lrvuvtP8t/zJEFn/qp2y/aEs0G7b/kIW9HUWsiP8kP2P/a/xx8zxh/EfbIsetjD+hZENl2P8Dz4Yf4QwGH8Yfxl/bf34s95EldbCp7XyP6yCTX/a/A+fGGbTGdr/OohGS7g+SPTjulv8Z8Vk+L+J/e8XL/tS+dJll4Ur2wL0m/nfQtdv+vy1jrrwvcJYZCbAmVByyaWe+M3DeScpZkxJYXQbzmF4Ly3MjMKG7KxBIywPEhqDTrP+HqwIm77YYP5DSCx/1r+0Fdog9rb9kXmw/ZXXtv+hc7X/jRurxh8B44y/jD+Nv4kYHH/ITSaGEp4mfMh93hhz/OX40/F3J/1RA4zBjr+JKWEkAl4r4JDJYPylvThUG7TxJ9sJf+hBjD72NxrIBk3G/lRbNefog0+TuX7n30LgmvlXIXjXT/7Y2vh38+Bf6D4tAkxDvCwGJexzQrihNHMH/yxpldZC9ziaPnFoFE/D6nBOaP36QtNZT1twIDzLhb4juuvEkU3f/A8hs/xR8ULXrH+2P7a/UIYwDfY/VAf7XzCBIgFmGH9IJygW+hh/GX+GcnAdr3PjlsLBlfF3sMLxh+Mvx5+Ov51/SOdQ8y+Mvuknqrug4+jB3zymWhxr4a/4Ds0E+R/mkuh/OOQY+8tDAfLnPH1e/pjrr/ynlyaf0ETsIrN6+G/8TwaCK+BNIzNiF2RrAvkLhnKt3s4/Tj7/CpGjciIDTYMZ8ig2kpl8FwzZr2Pax4rWAAvnh+1jgZBzF+01CTETrIh9HNRXfEFHNaCl9hoLJdM3/y1/0ifqBRfrH20MuWH7Y/sbDkU+x/4n7IMcqIrSEe1Wf2v/G4yp/ABzjD/ABOMv408iC+Nvxx+wkEOOv8gF2UXHv7QL+pfvJIQw/gZDHH9AKBJQkh0T4e/wrmSZ7Gv767Ad/IUxxvgfZIUmiP/nFn0yx/kvipL9D5gwC/yP7ktQQamjecrY1FdOZx2ic+kwo/T4R5PswGO0CuoVK+5FXaeeJd0l4QBY9B7rKMpAmL7Yktwx//OGmZjCuz6WP+iU9c/2x/Y3bKT9TzgM+9/EGopNtDL+MP4y/gzETSNRS8bfYRnIE8cfYILjL4qC408EV46/JQqOv0Mj6hfWgikZf0NRJhV/ZSdswuN0+5842ra/FL6J5I90dXxO0A+j275+598mnn/nf7Zs/gu5OKgwtTiXET29FxCb4hwpYOyrZTQMpQ9hp4B3pTTDjuCGE3uyDQQgx+YvydYlvkrPPdR1qgHe2Hpw6S/ZZ5/yyU/8r/J3n/pUOfwPDwcnyAvz3/JHNQlF4bpqlfXP9sf2t3VLyf4H3oIPfNj/Gn9QEqqnAKoy/gI/YjH+rKAb21oEawYdf/v6Bzv+8vx7/gc3/8CvoE91/uE+hrrxNz0sUUcv/hpO/CEK9SEPtGyK0/I/s48++WP8UUGH8cfWjr+G+YoI/ihUTUANjXDyYgJ542YUz4QzuOCj4W2lrz8k1ZiUOudoxf5ayyigxB2uMCCbabeWTb/h/3bbbVe+cPEl5etX/p9y/vnnl49+/KPlmbs+42n5f+qp/7ksW7aMTMZC7pr/4oLlL+RBCodV1TmKSS1b/xr9I1ts/2z/aT+5QEXwsf+z/zf+Mf4jshKq0Nr4VyZSvBCqN/4PhrRkhDfwhceNv4IPFXOSU7Vs/Gn8SZyVmMv4e0vib+KcqdJHn3aWV/aPCk4V77Z/o6nzeVAzPoQE88zyT7OPvtzBLLF/rzvudeU4fIz/Bhf/zafi0kQLzHAtCR7Gk0hUPqqzKlhQ0EygTJswiufl65MpfE3N8DDvCOVY3FLzaXAwCOsjPRyj0XgE4MY4tU/SGRT6R776yHL8CX9a7r7rnnL//feXG264vhx88MHlmmu+U6695jrxf9l7lpUn12+I6ZmA/+JvTBZb4d/8t/xZ/2x/bH/tf+x/jT+Mv4w/4QuwABUoeB90/O3rpyRAFgY0/vL8e/4t/736D63gQ8H42u7U8j980BA9qi2hq5l0/oezwCXkcfDoyyN3rl9smCr/N1/+bc899iw77LCDZojTS7vp/B9UZIDyn3qJBCWg3smjfiuJC0mQvGrFOgiIpEPygh0+YRVlbsJA1GOZYFbiMtwx2+SuXggWkFXU1GmQ6B/wkgPLmWeeWZZfeGG57/57y8c+9tGyyy67lKVLn1vmb7NN+drXv1a+/e//Xo495pjyyKOPBH8m4L9mTwba/BcHeBOComX5IxOkx9a/RhwG3v7whYyDbH99/Z5/yz895WDiL+u/9d/6b/23/bP9DxlQBE2FCI+o+NH5D8aM7SRPv/yP4kpmj6aYf+DQk9M/nQXD2L75p9lKf/b4n+C/83/95Y9STA5NVf5nz/zjBkRmC1Co75WhwvPKASRx9aN4GlhiwnKUtI7UE1kUi7rUHfZlkrlmkdGDTxvr6wdNQwJVDapeg0T/mNceU77171eVW358a/nyZV8ud9xxBzgxVBYvXqT3EC9b9t7ylre+tbzjpHeWpUuWkkuSRPErimovxuV+w1ZWmv+WP+uf7Y/tb5pI+x/7X+MP4y+gpAYoDS7+rIByUPG3r19BwsDGX55/zz8Datu/PvkXxI3d+R/+ugWxE12nMhFa1/wP3SmXxq1yZxL5B47Vl/8DQn/2yB/nH/M+zvxzurlMdf5nz/Wn1A/w9eOdxDnJeuoypnqYEsElE026ScSy1DqP8TAjz1zUXS0wBv/JVFob/OudhuoWI6ued+vQdxDpU+lWrXqwuf6VK1dKCR988MFy9dVXlzWrVpe1a9eW737nO+UYPE38dPzncbEXaz2Rbf5b/iAQ1j/bH9tf+x/7X2ANOUjjD7Jh0PGXr5+gfHDxt+ff82/5t/7TFw5i/mGz2D/lgYQulPNR/keJoLH4m3mlLv3DJOgGNtsjhzGt/NMsor9Z+E/WOf/j/Ffq3KbMvw7XwSLJqxfSQGGR/a1BlYSPq3jomO+qYR8ueHWNxFI7quvcdeBu3IGAAWAyOV+Izr7KTIswxsA+lWaQ6H/zG98oxx77WvBhuOyw44Jy6KGHkgnl+utvQPmQMm8bmEm80+eQQw8rv/jZz8lpfMbnf/COHDf/610vy5/1z/YHWkAAZvtr/2P/Kz9q/GH8Nej409fPoIOf3AxY/OH59/xb/q3/Y+0feKL8zjTyP0oY9eQfaGP7xB/6hjmPkRqnYQT9lGeaQf5pFtGfbfaXjx5OlH/SRGo6e+afc9Jn/mfb9VMnBvn651NLOb/1q4ijvI+jgBKV0NzQ5WgjYVA1n1fl/Z66ZXqS5WyHd16SsSP4MTspv3RfUiR+M2fBHhQWvstj0Oj/9Gc/KzeuWFG++tWvlgU77oinileD16XcfNNN5er/+91y5f/5F/BnqNzw/evLddd/T4qW3BPn+G6gNv/ZljWpomCtOGr+W/6sf2HfaeCkO1AT6AmXwbU/vn7Pv+Xf+j+o+Mv2z/bP9s/2z/ZvMONv2/9x7D+qJ8r/RFYB2QbEUJHrqXkIWtOx+R8+RKinhsfL/zBvMYX8z5yjP0vyXwyhM3qm4GD+67zXbf/5d/5vbuQ/50u1JQFxF2eITxFLJCgauUCR4xF55lqQ1NUhWYqsz/RwlSY0CIVO0cKQo0jY8bFlNdEAOCZhA7UBpP/pT3+q/MPZf1/Wb3iqLL/gAjA6ePWpT32y/P3nP1fmzRsujz/+eEzA0/A/zDOVN4cx/y1/EIXQQhSsf7Y/tr/2P/a/xh+ECBUoDDD+Et7y9ac+QCjw0IcQg/E/NUS8wCqWp8HfBN561MX4O1jn+MPxBzTH8UfE9LMn/iI2qPkfmj4aNG568z+sx0f/Ue5v/9QbDx0iBJ1y/CHCMcAcos8Lml34C1rMeQZWolFz/m/w8p/zM20rIaAwUNmp9gSNLFEoKCDDOkgpYUqys+CNCZQcyk9XPdvEeDAQODhERc+6Ub2nIlKbWTuQ9Nc9sV5cA2t0/WQQObl+PetZAncmwf9zzjkHLbuXymvWm/+WP+uf7U+1Cba/cFpwThHaiysD6X98/fKw8rX1lVe1xvjH+I8eYzL4y/iXWmP8T09Sl+prjb8dfzj+cvw1G+Iv5R8yTxP5B6Z24AWV/4Flk5Hv5H+4G3Vp/1URFlC2EKsJ7R/G5lOpbDUWf9Ux5x59ZMxxybMj/lh+0cU5/5xMzKbzf1STZhmE/CelVYrMhC4L1NlgQhgDKnE8Xg5l5ROJHfZEKSsYcGog1DLpWZe4L5XCxQ2PiVhtYfofPO30cvttt5v/ISaWP6mG9Y+mxfbH9tf+JwCl/a/xh/FXBzemm8wNwAOxJRbjz+AD18bfFIsAlpQLxx8QCsdfHQUJ6QiWhJg4/hB3HH8MXPyBbFAHX/TOP4715H/UNju08z/VD1OMGv+DkcfYX/Vt5X8Gjb70rHX9tj/OP0InQqV69W/L5V/xJQCeFKQT//UDXUVlHNEJ844P61rN4hJYWRe0VGM0o2VQ9+yHXb6svMEmtZB3JQad/gO/+W1Z/ySeHs45MP8pPxKgECnLn/WPZsb2p5oI6EUaW/JFC/azyvYXDJH5sP+R3wY77H+NPyrsaoCY8VeYibZjgcIYf9F+yoCGSzH+Mv4ixjD+Mv4KMYBdSLBJudCC/awy/gRDZD5nGf7ESRMvCjNO0v6rbc/8KzOM6+fT0/KlGjPwl9pXIJIi0+R/kvZcpi9WNdcfWtRcPy8cH+MP8GGS8id+apXCRBY6/7hJ7Q/e3S9rFrzOO0WsKXiOmoGlytgl30mZZo/zF4qsys5KlewaDfhjeKyiKsQ42UCP26NM8Gn64pCYaP5LTiQrlj/rn+1P2k3bX/sfegj7X+MP4y/jT+NvRRIRVAg6a5XhheMPx18MPB1/Ov6mSXD+Yeb5lzC1Y/FnrwmmHa72dySToW3+q32T/2EKiDU5ygT5j2gx++mTP/G6CUim81+Tnn/HfxScsfLP2mbZTPhneJQKy4VaiGLqNfZRIc1kWIZ6tsFaCq8dHET7XZ+5azn5lJN1tK5GcAfp2Xs/uxx55KvLTgsXqlcc04AYhtYgyjOlz7tVvQvp84Shg7qETqrb9MUr89/yZ/2TKtj+zMz+2/7a/9j/dnPA+MP4y/jT+Nvxh+MvRpyOPzPujoQCGOL4f+vMf2TCJCIjKS+zP5EBYuXY/E/nmA6r55TwD3+figtFhMUqKizgf87Tn2H+zfGX4y+qT3uZkv5NQv7iSWLymR8qZc0SY8u/NAsd5UUCluCHyss806677Vo+8IEPRGes58+fV75w8cXl6quuLqf9zWnlxhtvLK961RE4Esv+BxyA/hgAfbkSvRnQV46Y/WPAGLPuigZ31IAFtTJ989/yF9pg/aPRAy/4YXGK9s/2J3ln+0uFwkKfqU3HJdn/kCNa6JLtf+1/7X+pDsa/xh/GH8ZfdIoyB8afxt90DJCHyeVfNlv8Ad/EP/qoUSX1dVbY7c7/sEUDeLUT+FfTqP2mgQZgVRf+Iw3Kfq/8izpbz3H6ZFS/69/S82/6ksCny39uNv3bivg/HDoq1Q0lZgK3kdq8y4N9MYMtKNT6V5pYfVilPuh7yimnlN12260c+Zojy5ve9Kbyv/7u78pZn/lMmbfNfLU99phjyo4LdsJ4oMOfBkRfToT6Y636KdHnyWR/jBl/MRx/MZOLJpqXpTL2eCNzDtE/5KCDyyEHH4oLHczrH/T59/UPtv57/j3/8p+2/wPp/63/1n/rP+MJ499BjH9s/2z/bP82hf1jQpaJkvqpT/lOlP+B7LXzL7LBzK+wmnLJ0TiuisJnU86/oHPtPzb/NAD0ycHk39Nevzgspm86/pv+QPMfLx7GK1IkgaHQfPkwlRoqnp+OyWDbzsI7RqzoCDCV/21vO7F84dIvlt888BvdMfripZeWnXZcWF5z5Gsk35dcckk5+S9PwTcLUrk3Cf04MdIfwbgjeeq6Y8UTxlcamMiOZDYL/GbD3KH/B3/4inLgSw9U8nsQrz8cG6Z5QOff1z/Y+u/59/zLzdn+DaT/t/5b/63/xn/Gv4MZ/9n+2/5vLfafiWHmX5RvUcK5lX/hSTLvgunaXPmXQae/qfM/y5YtK6e+//3K9MVKk6h57OT/rH+S7Dkaf+lWUUwxLhNKzXwx7vtgh2qMHfyPYMU6JVmbu0Zop45Zj/I8/GDd3nvvXX75y1+QZ+r7xBPryj333lOWLH1OGUGbNavXlN/85jdIar60kTkNo/Yzoz+Mr0VQcIfrgNryLhavB9fBfRR5LazpasYGM7x+0zf/LX/WP9sfGlMstr9ggv2P/a/xB82B8ZfMgfGn8bfjD6iC4y9axQ4fHH86/p9J/mWT5h/4LW9qKP4Z1RPH9uZ/QoE7+Z9hNYj4T4hHCt7CvxR25V+0ie5BhUdAqzX/c5r+7Mo/YYblsXvnvzf/t0nlbxr5R9PfPPm3/D5B6ihuRUuvuUYymKIx1Gy5h2rdHeIxlJE556I6lHfFaya222678tBDD+UBboaxv6bs9qzdaAP0ufyyy8tJ7zqpDOP9xe1laLr0eTag39xRrYPKUvESVWjow4zJ+IWQ18aomq30ydhBvv5Bn39fv+Xf+j+49t/6b/23/lv/hc0r2q2wdwDwr+2f7Z/tn+2f7Z+SGZHtmI79j7yOkiP5dewm/wMby/zKqJ6AiXYj0Dku2pP+1f3YRtqln/9hIoj5mmyXm678y5ymP7vyT5phTNa4+T/73zntf+NFwVRWSMAoBYH6m8qbqVUcZCU3MAeoZJGP9fN1DnywmIaEedeNG8NqNK95QDsOPG/e/LJu3RPshP2hMjKysfzzP/3v8s4/e0e55NIv5IDj0+c7Md79rKUkxOGCvkQ2BFdmCCcV5yISJNwsfLqTj+GzNcs8C37w4HMYKl1QVDbXz2Oo0mVnn62V/sEr15Qnn1xfRndZqlPUSePc6zLXr3/Q59/XH3o8qPrv+ff8029Z/gMi2P9Vzx9b+/+5jf9s/23/bf/t/+z/7f/1tCeTFq1lsv5/97u3iZxH9qdNYYKk5nmwo5wJh27yPyjzO+d4oycP91mYcxmO/AsFVOAM7VHszb9EhgYt5jD9v3jv+8qGDcEoZaJwreIKVqrNi2dOjUl55dZqnk35r2BOfDuPncm1YKvYi7364+vM5wUNrDV4tM0eeWxi+n9w2GF68HPDhqdiXAkF+lRB28z0t/T1T4b+eeedp/wneVzZ0lEEcpv4k8c4CZytceQfvCV7G/nXIGzPSm4wFmlwBPKdcqGjWEP/Nhd9qjZnvBHQPBdVs6wL0haXqSvlyfCywyoM8+R42jjPNatXK1G8ePGiuBJdTimLn7G4rFy5EqOQDi+ulJe//KXlRzfdpJFnRF+kgz7WIMF1cjLpi6bKHfoqNbMx8fVH6nuc698q6LcveRCvX5MQsz2Q8+/r76i85X/w7J/l3/JfIYf13/o/aPjP9s/2z/aPln8w4z/rv/V/E+g/ImjqkBJdzTZ/44nJH7hVJrG68j8SvZA/ql+cRY//ZXIrRsYQkf/pm3+prdBdI2k7x+iDVUxRMJGrJ7OZS1P+LQ+QP8j2VY4Fv8lW1CX/xRvyU4lCTgu4SZZzCB5kO26xxDbWSiommcnS5wh6qHsL0d/S1z8Z+uI6WCze98s/aV54VFKf8xTzH5M0cf4xZm/8/OPmpo8niVOAdLY0BDhhXQ/qo6BL04mgPoSRQsyeIZxhVUbLRnz/4Fe/+pXeN3z9925Al9GyePHi8twlS8rdd9+FfbTHi+n22GOPstNOC8vtP71No5A0SeYz22Pok9ry392tFqQbbUm/U+ZeKBaP8tw7BzkFNGx8WTFfkaF5pNFjgRfUHpHtOATOPU4E5dbS07rpSYJbiv72e/9xWff44+XC392F8+HJ89yxYVGbuX39cZVbjv+mTw6Y/1tK/y1/lj/rn+2P7Q/Rj/GP8Z/xr/E/MIHjH0HDuR7/Gv9uGvy7dMku5bk0ndSbJv/BxwEjmcB1FIm1WETDphJ1yKewmxQP6ZXcwQbHWK/8SyqlmqFSB9CU1Szzfw7TP//8C8qG9RtxsbMj/7Rhw4ayYIcdynnn4mlZThE+dQbbZR4x/gz0OTn5B/ekY+Ri5SlkAsLfK/+032oBxlNFlOBHzRj9w8zE3GD9tPo3efp4DrhnynM3dJc7VH5sKvnaHDX8uoCWuCo9W3zRRcvLu9/97rLXs/cqw3jM+K//+q/Lf9x8S/mPH/0IF4ivK+DH5f7ife8tZ5/zDxwaSx2QOyjn7pToq1M826zzbQ+LY3qdM8at9KONHoGeG/Rb/B/I6x/0+ff1S4+h0VjorLBUszII+u/514R7/in4ln/rv+2f7T9tAZcBwL/2f5pn+z/Ku/2f/Z/UgcKAxfZvpvkP/uCsElLBTnGVqyb/U+2vBK9b/5i26qI/zOQo22hQjJKBWiR8enZ5DE+yziX6yH+FjZpD+ac6/7gy299u+Z8L9ke4IvRTb5bRNPOuDpPckcHWvKNM4YYI0BAwKUnFxYdCUdvx2OWXX16uuebacu2115abb76p7Pei/crpp5+OR9bDzBx62CvKj5AwfvyxR9lZy0zp11/Qi3F4ajwxnSg2oIsL4l7U6qSbc+YJzHb655z992X58uV5HYN3/YM+/77+lm2Sng+W/nv+Pf8dP2b7P2j+3/pv/bf+Vxxv+2f7Z/wHbWBkK6WY6/Gv/d/m8H+0IpShEKNM9fbN//Tnf3RsvzuVySZ9oxvDNmOrjm17809zlL6yUJO5/lYb8as1xz35t/7859zhM8P81y233FJuuOH7OOstQ5+Swcsw/S3HfyWJ9ag/ssL8gTjNSWR/MTfcz7qYq9jD3RAmVplI5vcE+DWD2vSpDU+WM844o7z0wAPLa446upz49hPLr3/1Sw6rNocdemj51je+Efu5nil9fo2h0qfxiftUqEtlqkqkNhI4nnhnMX3wYgbzb/5b/qx/1CH+2/7Y/tJz2v/Y/6Zf4DuuuGAX5kE2Qvu5Mv4gb6aPP40/Us60sf+x/7H/sf+FMXD8mz7X/ldQ42nxRwCSeOdwWFEyMLtlXoW+ujv/09//ol2X/DFPxDqO+PT5l4ij2GEw6ePCwaW4/iiLdaqZHP/Rt4v/YuWk+V/p33TTzeUm/HYYZ4wfntHvk35SNP0tyH8kiTXtwOh8rD/UV2u+PwbAnSpaf5WPwUy0xpYFfmh/ebcCEkQh0lcLsH0M78hds2YVSmzGsVBAg+UXX4RNduZGZaw3MX0JNE9KFDr0eR6mb/5L7ix/1j/bn7CRtr+b1P/Z/8DC2v+GbrXwj/GH8Zfxp/Gn8SdkwPjb+Nv4e9r4e+dFO5dt528Lhzo2/9KLPxc9Y3F52UtfVnZ51q7j5j/0Q2qSSCSIe/I/StVWlWUb6i4fMRwn/6P8ZMV/zCtlgqgf/uFQem8x27GM9SDRxyU7/+X4c6uNP4c7L0HGc8T4GUMqrFKrWHGff3pamJKMIuYSC1qxnEXu8+4Tn0Rm/85xPaisdkN8sQxKjz/2mLbqDQPz+6Yf58czx8f0zX84r5CG34/8W/6geslx65/tn+2/7Y/tLy2i/c/vA3/a/9r/Gn84/nH85/h3tscfyy+6qPx/H/2fMOjj51/4u1Bnffaz5Zr/+91y1lmfKT9YsaL81V/9ZcRgPfkP8SOjM4ZoNf/D5DFzwazryv/QjMih9qGPDsQ06qax2DDySxqIgyV9jq224+Sf5jp9stH4z/h3a8W/w1R66Tm/EomCyhJarPLOjiopyTyuBtGKKeGf/exn5Q9ecRgOMNgNdUfLbMdO3IES6E5Sp1/Uo88M6XMchdmmb/5b/qQN1InQU+sfeWH7Y/tr/wNbwMc4pA6xlc+2/6V5AG+mh3/UFZ7X+Mf4z/jX+J/RCBfjr7CMwQzjD+MP449Njb8+/D8+jMTvZyfMf4yMjJTLLr+sHHzoIXr95xkf+lA544NnlB133DEwSxf+q0lcaa2MmKxZwkUCpd78T2g5B0n/zzwPlpnavzrIoNKP6+Yz1WQmPixMhv/2P+TYjOXP/A8mkg9xq4dc5Xt9schM4Egoecgnc295OO8khcQSFNM0PPXkU+rLZ4nrs8jBZFVLwDV6kNAYdJps3yzTpE/FGc5xTN/8t/xRyXTbJJVXu/IzscJRKKf1z/bH9tf+x/43OWD8IUbIf04B/xl/GX8af4cfcfzh+MPxh+OPqcZfe++9d9luh+3L0qVLy3FveEPZ78X7deVfhnBz/+CDXl5e//rXl333fUEEdHC8ax9+qDyJ34B6Ovt7/feuLxufQo4GU/Ptq64qw8PzysJFC7Hbi3+ZlESjSO8ID3A2lf/RXhyqDXRTFA1In+1k//QgQp/4MxroHCYTf2pAjTnH6ONyJnP9k82/kU9PN/+cT7K/8tT0MQfOP0IcevWfmg1J6cH/aEWLgENUbhSl3pQoNqQ0sVMcUl0dV/c4mj5xaBRP44gs+3OJh3PiYAzINRY8g4y+I7rrxBrTN/9DyCx/VDyphPXP9ke20va340LsfyASkgrYCftfCUYgCBSNP4y/QjmkI8afASUCdBNXZPBu/O34w/GX40/H3/ATgR62ZPx92t/8TfnsZz5bvnjppeVtJ55Y/umf/6l86IwPNfHfpaj/2Mc/Xt5ywlvKBcsvKEwqM/9y2t+cXt510rvyCiaHf/bZZ5+ydu3D5YH7Hugj//QP9BPBlr75n8zt9OZ/4jskE+R/GMvR/5DdY/wPD00y/p/t9Hn5Y67f+a9Jz3/mNXvlT1ps/L9Z8P98CiyDzdFhaa/sA8U4dJkaCcWGcnMSqcf4Ycvahc1ywXGUhnD7Q/1iKFawt9rz1RTxq5mROWZ7gnjdMjP9GfH//af+57Lu8XXlouXLzX/KleWPXLD+2f7Y/tr/2P8Stxh/GH8BZ+rtipIH+EfjT+NvPrLl+GNG8QcBN+M5x3+Ofx3/QxGmGH9Se1744heWI486qmzcuLEcccQR5aKLLy7nn3++dOqVRxyOH517eXno4bVN/iUUDrS0TF7/TvyzE8tXrviyuo/xf9UvYkxdAm2j8DP2lPzB7kT5H4xa5189m/5t/IUWzCfxvCfpf9l+kOlvyfzbsmXvKTss2KGcc/Y5zv9RPyaSf+UbQmUo3nMl/6m8fAihLiuUF6qeCfu4VoJr6Ta5pH8orcyBlDdNQ2MgeCTqog3X8YkjHFS/YydLwSFgNKKp6ZM5U+a/Opn/wTrxwfJXta7qHrfWv7Retj+0vba/Mpz2P/a/xh+BIcIkGP8Z/4Y8cM0HRIz/gw+OfxI2OP4LBaFuROQVa0DsQNnG38EJxx9VEsaLv2hT/vXKf1GCmP73uuuuLY8/+mh53vOfV1atWlUe/M2D5RMf/9uy/377S/nko6ehfy944QvKca8/rpx33nl9458n12XyFhLc9n/MDgofYTsZ+5eKgU1ccff1x9F2/oeDT4S/5hL9DeuZZZxt+S/6Pn4mN/+cb+dfqtTPfvsHW4CL4fXkMqK7PzHFNEbhArGvltEwLl+mSgneLpMScoSbROzJNtXwYKxqCThuNXKmvwn4H3OhKTT/JXWWP+uf7Y/tr/2P/W/1jsYfHaBn/FV5gW0tAkAZ/1JbjP8pEsEJ8sLxj+M/mokwFFxXr8obzI5/WylFKA31xvHXVOIvyFDmQ+h/hob4bu9SFmy/A94lvLEcj9dMPIT3D3/liq+Uz3/+82Xe/Pkt+aMsPj3/56PPJz/xt+Uzn/50uf/++/vmX+78xSPT8H+gj/NtFk4+FupHb/w1nPkf2dVW/qcpot/U/e/soX/3zx9unq00/gpbSknhf12mPv+2v5PRf/J3uvHPML8ixN9sqQ5waIQzFrPGGwejeL6ag/Mx67bS1x+yk8J3TTRrwoXSgcplsIquAwNmTads+puG/2SxFvPf8mf9kxbY/sAigBNkhu1vx+eQHdUX2f9sGv8TkCHkzP5fKmf8Y/xn+2v/Y/9Lhws5qD6Xu7Vs/2v/S9FQZgBSMoD5h3hNSwAoXv/++7+kLFq0qNx5911Qk5Fy7733lDNOP6O85sjXlMMPP7wc/ZqjJTOhVYz10Pdp8Nfpp39Q7yK+AK+kVDjQR/9WfOe30+A/6LezvDE6Tw3n3u3/+brR5jQb+vjZtRnN/+yhf/23fqvrH4//ms+tUP4xwc7/DXD+c7ijuBJdJITpzuNOliQaylw1m0U2oKKP6PsCFGveNUR1vtNYjdmQA+nJet4lY6swDxyCxiPooJzGglS5mD45MTX+613PMsjkIPhs/lv+rH+2P7a/sof2P+kXsLH/Nf4w/jL+NP5OW+j4oxWZBWyeavzh+A98c/xLkIHF8eeU42+wbOedF4l7e+65R/nAqf+lrFjxg/LrX/267Lhgp7LXnnvp2COPP1pGAGa32367zL9EzuTp9O8tJ7y1HHnkq8uHP/zhsvPChWXhooVl2223CSzYsn+//unD5Ttfv2/K+Qc9Nd6Vf8DpTjr+lMSwg66RDyVP3f7w6evIL4X8bX30H3n4yfK1S+4Mnjv/5fwfxF2xWEv/qABbY/4TKhnKVe/kcU9BBIyR1DZ0N+weo+2qi3rCmJfVudjYYwX6sl2sNA6HyV0kb+odJVFTN9MPxooj4t/k+c9JYaK4WdS/w3DxvrNr/lv+Gq2vCm39m77+Ub+sf7Y/tr/JAfsf4x+a0wR8xh9gRYcdxl/GX8ZfchWKdrJk/EVGiCNTjP+MP2c3/mY25KR3nVRuvHFFufZ715Xd99it/Pf/9l/lMw444IBy1VVXle+vuLH8+Oaby+233Va++c1vwqHkN7whMxPN/0EHHVw++clPlBfsu2+59ppry6233lpuveUn5c1v/k9V2ih2OIPQv3P+523lzl8+Atdd8w8cHQs2emI4miX9oM3zn2r8E4NK2lWs9MfK/9ygf/ZHflIeWf1kMGxW+b/gP9NL/eY/RWPK8x9iNJn5T0kx/S3G/6Elz1kia8BXSYSich0vlqBhGMXj73gnhZLEemJVR8OZMevNvDEXbvhmGu2ink8R865QHI+xuQ4twSbpZRwhiqZP/kyd/6e+//3lsXXrysX4Kon5nyJm+bP+2f7Y/qZBDKtq/2P/S3DCJTFJioTxT/BjOviD3CQbjf+CD8TNxr/QMPtf+1/7XxgDx7/GX8yq9MefZ332rLLynpXlS5d9qTz22KNl9ZqH5EK4Yv5l2222KbvtsXtZt259Wb3qdzqmkXhc+rVp/e8ue+5Q/vpjLy0Hv2pX539mmP96aNX6cvaZPy3XfINPaPeff07o1oo/3/Pu9+Bp9h3L2f9wNmQtzpLwZnPKn/OPW1f+db4SvZx0ZmtlcfiwfwYM2Nf7ciQVnLoQ5hARrPU9B1SyPqVmFOiYv4KoB1s5HgWrfhUHv37AkfmVCX2tAIdNP7g5E/7/8te/yikRd81/y5/1L22W7Y/tr/0PnTMW+1/jD+Mv40/jb8cfSOAzZnP8NfP4i67V8S+Z4PhzuvmPEeRNVq68h0wck3/ZsPGpcu/KlToW6aPAc+38y8Idd1KuhuOwjVqgwWOPPj7l/Mvq+9eX/7FsRTn6zXuWo/7k2eVFL1tcFj0jXk8xHn2GWzx33R2t8TfPok/+Rz/S17Y/khu25VmPvX4MoWPczAb6658YLXf9/JFy49UPlK9ffDfmYIPsrPG383+zMf85tGTpktHmaeGq5NJ4rKjgUNxRJnkRYPJuIBcCi9T/gpcao6gOWGc5j8cGayk/+rIj/zkcC6zn0wb1bo3G4SOgooIDpm/+W/6sfzQYtj+2v5ADLPY/YAJVAn7S/tf4w/hLgBGw0fhTskB2wD7EBmvj72QIeMF/2k4WHH84/nL86fh7C+cfPvLhj5T777uvnHve+bBT08t/3H77T2HR4qm9SKoWjXnsa//I9t/+z/5PgMj+fzr4Z2jJkqVA1kBNSgQTZkdiFlIVKDO3ejqYjFY1wXjeCmIiF3UjzTHspJVicov91CC6snu25AhBz/TNf8sfZAC6Yv2z/dG7n2goaVi50IRKNmx/gx32P/a/xh+R7TL+Mv40/nb8UbEBPKTjLzJBDzc5/nT87fyD1IHQWUtYCudfnH9y/q1zs9j5l/HyT0jjgjlKRiDowjKEF6JrX9+foTkh8/CvuzHY6jEudujU6ysW7MvmXFBQsxg4v4Gg6YjDOh5jmD6YZv5DLix/Uh3rn+0P7YHtL5hAh9LxM9QP+x8JRxdf7H/5FctUGQqJ8YfxlzCVVsafgPT6MWrqBhb+EjxfI0fbavxt/O34g1rh+INccPzv/EcHTBl/O/5w/KUQdIDzn3iS+DlCSTQHzEsQO7KMEv4AIVHBBDG/7M2DySu1yGbqIMipQTqHWGJ9fAki6klD6WIWtEQnrbEyffM/JMPyZ/2z/bH9tf+x/zX+MP4KcGj8mbC5biLXK5wt3nC/tRh/O/5w/BVxKNXC8afjb+cf4BWcf0kvqcyTcl5kifNPzj85/yRP2eR/5y1atPhM4crQFUlIfUNENMWa6DO1p3OsB40SpmZVp00InL4QiTFGh7NBV9f4umRoKWnhvzNUDGn65r/lr0c3upQIitNRmrb+hFrjmPXP9sf2ly6t8VN1R5pk/xd8sf81/ui4EuMvGgnjT+NP40/jzy7fKNQQEELrjtE0/u5ALMcf5AVkw/GX4y/HX2Evu0yn839ix1Ycf/JNxPlkLwo8W3z0xRsCYxzhmgliXQhW2aQe4dFc0FKN0Ya3rtU9+2GXX29rbl7VAg2nmrYGRtH0yZTgjFhq/lv+IBJkgvUveJCWiVzJBZoiZcFx2x/bX5lP+x/aCy72v8YfFXY1QMz4y/gTtiGerKORiI/xN5kiBxKQwvjb+BsiYfzdmAjoRYJt8kUL9rPK+BsMkfkw/jT+DO0w/jb+nq34e97ixTufGWIcho13QbUM4bXeKNPWsSq2hJP44iN2eKw5qA7ZkBulnvE1YbQh4GTfWNgJyyhq864K34/WLCiafnJjivzffvvty0c/9rGy3377lRU/+D4GMf8tf9Y/2x/b346Hsf+Rd7H/Nf4w/pIqGH92rCOBuvH39PB3CFP0dfxDmXL84fjD8YfjD8cfHQ87e+KP93/gA2XpkqXl9p/+1Pk/eLP0aAOZ/5y3887POLNJ+MKiKWdLWQZXYsO0cF1CyOn8AAEUaDW/HlubqCvuGrBNNI+2Gi0btRLDowhYTV9Mk0edLv+feuqpsmHDhvK6172uHHXU0eX//ez/lbVr14rhmivzP4UPG8tfwwvrn+2P7S/UgSjA/s/+P9Cg8Y/xnxBTPBZR3aXxLzlh/O/4x/Gf418+6OX4X8mQ6iC0pc9w/sP5n9mY/1qy93PKaaedVvbZZ5/y/RtuKHfdfY/zf412Dyb+ww/XLdG3zRQkgxl0/l0VCZUTGQZCxJPCzLPFDyLQSGJHX88iE1FWn4azXQUe5UMso+qcbWs39TT9mfB/1113Ke98xzvLkUceVVavWV0efPDB8otf/KIsX75c89CP/6eccgqmL+aCT9aQ/pAeFy/ltttuL9df/72Yd80TVjn/7zv5ZM0Y518ikLLCZpSBc887V6X2ilSevdee5Y//+I3ZGi1hTdv0v/KVK8pDD63JbikcEZmUk34gRYQAACL6SURBVE8+Be3jXGufSn8DEuXLl1+IfnEGbbrHHHNMef7zny86lV6OLPrnnhvn2k/+TzkF10mSWMSbFv1bbvlx+cEPV+BAnFM0DPongz9BCx1RJXpoV+mfJ/7UAxoebUbLs2Go33DcceowiuvW9bboX3b5l8pjjzzaV/9EU0PllYi3Qf+JdevKJV/4Ql/9+6PX/lFZuvS5otWe/0r/3H88Ly8A59uj/yef8r6+809Juummm8qPfvSjuDiseRlV/8lXca1n/iv9kB9xDR0rn4bKc5+3tPB8e+ef/Ujh0ksvLetwrf2WzpzU1rispP/oo4+Vyy/7IkZImhogym847g1l77331rF+8nee5Kf247azUGY5pI625p/7K37wg3LLj28JxmC/LX+hl2Pnv9L/R9DEUXQCF1vy9/zn71uOOfoYnCuupDX/lf4ll1xc1j/xZPRTfxBO+Yo56eh/nX8e502nL3/5ijHzT/pv+pM/KbvvvqcGIp3mSpJ+yHqQqfOv8wb9iezPDTd8v/zkJ7eiI6+Tw2M1Q/vz4he9sLz61UfGcDzTnH8SIG/PP/+CMjKykReBRUQb+hPZn9+tXl3++Z++mn3UuVkdf/zx5VnPetYmtz/XXXedbgi25z/OucBWTs/+vHi/l5QjXvUqDdOef14MdeO88yF3kId+/n8i+/Pgb39b/vfXvtbof51/sviEPz2hPPOZu4j/pFH9T6U/nv2ZP29+ee9fLNNQVW85Yzx5yv93v/td+T9VYUUxr/I3Xftz4MsOKH/4ij8c1/6cdx5s5ThLZ07q2eJMU/4eeOCB8i9Xfl08jjPlICF/J77txLJo0SIdq/rftn/j2Z9tt922vPvd79EwGqnH/nz76qvLr+/4dUNuU9ifl7/8oHLYoYfhXHGNfezP+eefNy7+m8j+rFy5svzbv32z0f+2/L3zHe8oCxbsBH4FX+v8V/rj2Z8FC3YsJ510UjOX5C1HqPL3rW/9e7nrrjsxLLgnBmI1Q/tz6CGHlIMOOihnFsP22J9zz6X8UFK5iGhDfyL7c8edd5WrrvpW9lHnZvXnf/7nhd82o8xUejmy9sfDPwsX7lze/vY/a05HvKHy47w41r/92zfKvfetxPGoi4Ycefr25zDo1ssOPFCXXvW/soP0p2t/fv2rXxXKe9X/tv1Z9p5lZf78bcCL7vmv9MezP898xjPLW956wrj258orryzU67qQS5X+dO3PK484vOz/kv0bmSVxTgl5w/V07c/Pf/7zcu01323GiXOOMU9+X/oS0JiK/dl1113L8cf/qeZSI/XIH/3Bg797MMQGBCdrfyhu58LO4mzQiRdPzsa5MvZ50QtfhOsARzah/eFTdd+77vpG/9v25xTwp/KfZ9FcSdIfz/7svvse5c1vfnMzl73yd8UVXy1rEMdN1f48tXFjufDCC3Um7RW5dOwxR5fnPe/5yS2c6SayP7f8+NayYkV8i7VNk+WTEWP2m3/NGuiPZ3/22uvZ5Y1v/ONGPsjjtvxdfvmXyyOPPtw1/yEHE9uf9U+sLxdfchHODGelE4szpvwdg9jiec99ruqr/qNaC+lP1/7cjFjoBz/8YaP/ktukT/0iwd75r/THsz982vN1r/+jLv3n5XAsyv8Xv/jF8vjjj6uGK17GZOzPuscfUxzVMKfl/457w+vKc56zpJFZEt8U9odx4s03/QfOsTUhWT6FMZTOv3v+dX4gPh7+2Weffcqxx742mrF/j/25+JJLyvon1zfyNVn78/DDj5TLLr8cZ4dz7bE/b3zjn5S99txL/N+U9ufGFSvKj29BLNQTf5P+dO3Pvvu+oLz1bW8tO2y/Q9lpp4WY12eXa669riy/8ILy6KOPgmM5F63570e/bX+jD2dr7NKWP/FN/EO71K82/6O36Ys5W5D/8zk5YZjiixGjMNhySJqhnCBMZD3HtAZS5CGFiZxgzjDaoi/1hQvbj45A3VmH1iN5THuoJx0eK2pDc2b64Jj4IuaJi1Pn/6rfrSqf+9znytf/5UoE+kcoMSHF4/RwrjkbPfwnXc4d51HTh1VsSZ9L//nPQznnnE/VoDPbY6w0yKTfPf8ckrXYSHZQatMHPdKMj1qJJVHDcfMQNmwWMscCr46tdApd8hdXFvIY/Xvoqx9a6TxijEq/tidXeL699JsK0ue5JX1tsSKlrMYpYk/nz/OFzPeRfzpJtacSYWnaJ30eZJu++scuyf9o10OfY/fMv0AXrxsdgi5LMY42pMfT5Q4vUP8d+pX/GkIdQCPbqQs6dM9/8Fk2QBeHAdkZZZRyfBbCJugKxtDncSysVyecj05QVVr1tT9oVPnJbl3yB+r95p+DsV484Dmqo6iLTqUv+dO5BL/a9LO6a/5VhxVGxt9Y+0eAyKWeLxnTlj/2azXAQCF/7FX5zxYxfjSV/CG6Ee/JsF75YzN00sg99LWb89pP/jicFjQcQx/H2JVS0yt/osbO5C0H6KGvK2B/HmvR5y4rK/976Y9nf0YU3QX3uua/0hclUuOHZ8TriT32Gm/+owfX6IVN1/yrGlzDSdb51MjaCRqk1U/+anseb8+/CIlY9sfYwYugr0NY6ZyzcZv+3LA/5AkvrqP/ZH6Vvzjy+7c/vfPf2L/x5j+Ft9/8h/zxmlCCMIQ81AllXVxl1X/uVfpxJPUKO+35VzesQj4G1P40TKDCJp9QF9VSWnIteC9mxkHaPy2aEx0g+2NJ+RvP/lR9Jo3x7U+MGWfSoa+5Usek1UOf9pVLnX/Ot/qoejr2R2yh4HDUsfJHTlWBJC2eG1vGaYiPoh/VXfI3nv3RkK1BKr8q/TjO66Ihx9Kmr9Mkv3he+o/rj4Yo41g//IN6ttbpZ796ERye16NLasat9AfH/pABW4v94TxRrmJaY48yyunRTDbzFO2yZcjfNPGPaDXj1vlHbcqfVISNUv+75E+847n0yJ9OjCeNBhin7saWV8KF8sw1izii/zzGejXGyFlVG49rfyaFf4KuiLXok+dV3diCJ9Wmz+vjwvNt458YB21xktGfI7Ev1yppO9b/4agOc9xNZ39EZ5z4i6dDkroIbnrox/Gx888J0Bz0m3+Ox/MnL/vZH3YEoaDLlmyevMROv/kP+7d57I8mdpz4i/zQ+fEccYrt+c+qMfO/KfAPqdr+BPNDkrr9n2SPE9BP/nKexsgfhqMm8gGpn+Im2GfO+l65527c9NUMTxR/jyP/KRiU17b+N/M/jvz3i39DBjkgzpDnz2tr2b++/t/0yaXx9W8a/NeTxDENGluyIXslIdG0aHLEe+7mJLB17HICw1ApqcG31mNGG4FluxRazW8M2Rkzh8xq0wd/zX+KQUcqG7FrCpQ+y1+ww/pn+2P7K98iJGH/Y/9r/GH8FRhBOMH4s4PRE2i3oVQHaYFbxp/G3xAO4++OVjS60hTCtsSu8bfxt/G38TdspuMPJGUcf821+GsevsJ4Jp2dFkQWdI1CiriLpLsVOMgt13h7JzUBgoA7DKzip25QZg9W8usMWrRl+9iVDmFXd/lR2dWMTUxfHCSvg5sR7Jr/lBTLn/UPcmD7Aztp+yvnkQ5EG6zsf+x/jT+Mv4w/CaaxyDAaf9dAw/EHRMLxl+NPCgGUIuFTs3X87fwHJcP5B3LB+S/n/5x/48Mm8U5iGQa6Dd4/TtcRfqRTl/u50d12fm2Xg0iYmLypT6fneLHheGjIcfmPZqIhR4VqDpiL6Zv/lj/qC5ZUtEYncj831j+wyfbH9tf+x/7X+ANg1vjL+NP4uyueCCBFPOX4w/EXg0/Hn46/Ay8pEVHjrDAUnVxHrZfIZEzu+Ev64/hTbHD8Dd1w/A1ZAB/mevxBWBlSjw0fl6cRoDPlh+VI2mFHKeXmENriSLZRL4zEOCUGwLZZxMKoVgMegOFFWz6ZroX0sJi++W/5gyJQH1K3rH/JDNsfyURyw/bX/sf+N22k8Qe8pvGX8afxt+MPAWhGU3Vx/MVnZsUWx58pFI6/nX9w/sX5pzQHDCqxOP/m/Jv8ZCYZAk7im4khHZU58RWU+pBvyA7vpHFBRjdvyFOYoiteAaBGWKFRFLludtRTX/PSUdKJ5LJKTPxwaZLTpk+OmP+SipAnSQz3LX/WPypHODPbH5pu21/7H9pGKoX9r9CEMEXDDDKH8AIc4lHjD+Mv48+43wpJMP6WfXD84fgPHgPuwfGnvKSYkXjC8RehFRbHn44/aSMcfzr/N1j5T7yTeOczaQLpHBRpRkSFCprGCKziGNb4V21UoJyF7Bv3rJuDdVC0Qi92RERPAYsDqFBTHqhN2Q6VasL6aKtmLONftVFh+uKP2IeVwj/UNMypTEUN+Yom5r/lz/qXdgUKIVWhYlRVoZ6gkvW2f8mValGCL+RWk1uotgZ1tj+2v/b/1BUZlfC3WbT/pV2FiTD+MP4w/oAi0DBAIWQfqBhZFE5HJeuNP5Ir1aIGX8gt4w8wAYvjbylQMAPcMP4w/qjWgqa0QjHjLzCD/DD+Mv6aBv7C42jV0KZW5W58M4c7fOKAdjgOVAfNmmF20cJjzWPJksdmWBRG8GE/vqJiWM/406Dz+5HsHOPGDsq5a/qVN+a/5a/KAtSjqguqrH/kCxcyxfYnvxbSbVbBF9tf+x/7X+MP4y/jT+Nvfh3S8YfjL8ef3UDR8b/iCOcfGFAhV8M1meH8g/MPVRYgEc4/kBlaBiX/orxCGAT+mmNkfSkIvJGtOzBkh8oEV2k8qDX4D+XBwdHWMbSJuzkci8dwfw8Dco/yVe9+NmOzjgeRNDZ9MUKKaP5b/hodgVgw1cdFumL9kzGx/ZFEQChasoEq29/wNPQ29j/2v8Yfxl9EVsaftIjkAnkRWJNl429ywfGH46/QCce/sA9gRWMjVG5hTMcfciaOP+Q94EBasoEqxx+OP4g09HH+b9bnP5Uk1t0BeIXhBJDxSghOMYU9QGVOeezhaWACSzoSZTTxGHttSsfCPxmKdCbViKgN++F4ezF98tH8t/ylrgX6kBaFYjUmVyrEX3y0/kllsALPbH9CTGSGbX/tf+x/jT9gDIy/wi5mEGv8CZxp/O34w/FXO/wUhHT85fjT8afjTxoG579SDgSYajlyENpz/mGg8i9IEocQDCHrNIKEi/K+XPP9JUhcMtjiMbZjPiZaY8sCP7yJhONMGLOVvtrMKnyGlEVmM44VldxyVHXmRmWsTd/8t/yF3nBt/bP9sf2V77D/kTe1/wVeEGQgakgIYfwBZhh/GX/CRNBKGH8z2nD8IY/h+AuSQJ/h+NPxdxgF5x+cf3H+KcGzwLRWzr85/zh+/nHp0iWjI0AUglZglBCWXCuNKvdDiAQ6WN8UaqPcwvqyKZ/i0iBNX+5joXXW+4g5Xm2DKqSpTZ8cI/PAF7KnLg0PG461CrVRbs1/yx9FqNEtylLVNciI9Q/84B2tyhMxy/bH9tf+R26H+mD/Y//bwhXGH+lDW7ALKtIlI5Vdxl/GX4IUKSCN7nAfi/GX8ZfxJxTB+LvxJoRbxt/G35QD6oXxd5gHOUz6TDKG9qLRmFZB1Z2V8ddmw1/DjVzyK3mYj5iSmAtSFcRhJQs8rgbRSoKtQ5xMpqf0WLEmLtqpt/rxqWQBJQ0T/dWHXdnD9MWI5Ezy3fyXBJEpLGBr+aOyhJRY/4IPSozb/tj+2v+koax2UtZT5sL+F7xgokbWM7bGH7CcYIu4YfwlRqRkGH9JUYw/ZUEpFCxga/wpweAK7AhtMf6iEXX86/jf+Y8wlNVOynrSUAB6oWz81WU3jT+NP2cD/sZ9rFz4Xk8sehSfPi92AwbA9uVhBRVhCAggI7E8jLcZcxnSjz+wo2CDjIMOcLxoELuyF6TUIV8JmD44Zf5b/qx/shVig+1PNY+2v7CN9j9kgv2v8YfxF4Gl8afxN72C4w/++B4Rk+MvwYTE0IqnQkC4FoaKVyk6/hRDuHL8L1Y4/wClcf7B+Ye0ndo4/q7mcSDj73mLFu18Jq2jErYwDvpWVBUQpbnhSHNfVjT9qqryzlAErDiK9sPMLtf21djQY/NOEupphOMvadEi8TATxiiaPniR/NO7OPl9lMpPMsr8JxeCJZY/8YLckBZZ/2x/bH879pIuh7aTymH/I77Y/xp/GH+RA8afwtrG38JQjj8cfzn+dPzt/ENiZkFmAmjnH5x/kYuMlfNPiRewGZD809CSJUtw2xmQeRgGgcF0LoqraxkB9hDayIDiroKUpgbftUNWt4boqonmXMcA2q9ETN/8t/xZ/1rGo5oGmhc99WH7Y/sLp9G81i8cCsWjWcZWdWqixLX9Dx24+FGVzP7X/tf+1/7X/rfxJdU0ssL4w/Gf41/H/85/GH87/oBDZPAQARXdY7OMrerURIlrx1+zLf7SfYEAQTHXnEai5bxhoD06SD2IJSsZ8pHPXRNBQV4CXWqNVQAsrlWjdezFEQ46QkJBLEEYa2uV6Zv/IQ+SCcuf9Q+mg3aINkNmg99y4GL7Y/vb8jMshpfhOmSkluJLuOF07H/AnmCF/a9ugtOYVJYYfxh/hDxIJow/jD/gRIw/AnwZf8EqGH+GgTT+Nv5u4Wzjb8cfjLciJ+j4i0ZytsefiAVwCTGXMvoj+n5uTDHBQKSAsa+W7UmPCJMJ5q6QKnAE7hewJ9vwC66xDDHTXMvVyZq++d8RC9w8oLRY/siS4AR5Yf2z/aGZsP2l+yAXqlex/7H/Nf5opXThNOg3jL+MP42/qQnVU0AvHH+AH7HoVXYqwpsGrNCe8XegbrIkSsbfjj8cfzn+opkMQ8l19SqOPxx/zPX4Y2jpUr5uoioA3KK8o1bhJaNCX/MdVQIvwg960JrnpTNVmYUMUbTVgaziU4AYiyMzpGF7Vul9+SwnndiYfsO/5Au/5mD+U4Ysfwr+wArrH8QBiyxLmgzbn9CRxn5Uvtj+QlLsfygO9r9hO40/jL+MP2UW0zISVNChptOgKzH+JEMc/zj+cPzl+B+2wPGn4084RrpKukksdJPOfyUjxI14pUQwpjJIXBKacPwR8jJb4o/hUZxpyDonEQKPTfxKMHZ4gFeSysAiG3B3RN/XRYFlfIb4Tjst2LIhB+IBtA5liuMcQq+3YBOWTT/ZS24E28x//kozFq4sf8GHZIX1z/aHamH7G/YSrLD/AQ/sfwNfyFgafxh/GX8afzv+gGdw/OX4kygp/KNibtwEijgftY6/W5xx/B1y4fhb2sKV8w/VdIgVzj8MXv4hfrguoASSthl4czNCRwKGyKtgv2fhM1nDPF5js67jfBifhibvKOCYRkZbfm2hU83OQZPjmX7wQiwx/y1/1j/bH9vfBqS0XYz9j/2v8Yfxl/Fn2yrWsvG34w/HX44/HX/X/ILzD/ANzr84/+T8m/OPjVuYXP41bxnxK6iUHi555zkTVKNMVrIaqyxpv0no8hiWDjnsKHmM1tjGMqS8MJ8g7jRkRl6Dqonpm/8hK5Y/Bb7Wv7iJa/tj+0vDYP9j/xuaoLXxR8VW1WvWcJi6wuSx8ZfxZ5UR42/GRY4/HH85/gwsRW/h+Nv5B+kDRML5F+dfIAZYnH9x/gVi0Mo/zVu8eNGZFI2IvyLVO5zBGAVGQJtYk0GHmlXgybraD91R1pPH7IM/PYHMBigMUf/ULUZWAIM6jVeH09b0yRXzvwqF5c/6B1mgONj+hL3UGvzgYvubfgUb+x/7XwIb4w9YCOMv4890EMbfjj8cfyVOcPwZUBpxlePvwNM11NTW+QcqivMPVSicf3D+AbJAcRjg/MO8RUgSM2kbhoFogtG2Im6UUSu7yVU8dMySmIYNXx0RtcFIhmg6mHzV0z4I3FQNGmGVNWq0i2HBf9M3/6mJlj/rH+0EPyEPtj80lWEouebH9pdMsP+x/zX+MP6iRQzAafzZ5gW5Qr7gI8eBFV0qPoE1sx6Qy/jb8YfjDyqH4w8ZC+PvsJu0lDKpXDn/ITcCTsiPYGP8WaUCtkP/EpYsc8NKfMQ4rFDkx/43GUG+GH9s9fhr3qJFi8/klJX84TnBJQl1CHQINsVdrWJXUg9Rj446Fl2yVTzGASPCp4o5NlfRnyW25ZrvFGR9tGlqwzBzNw5ja/rmf8hPiASFw/Jn/YMYyOVGeoDWRlJi+0PG2P7a/6RvpTSE/ZRccGX/a/xh/AU9MP6UZTD+r1bR8QfhteMvx58RbDn+dv6hekmhyIi2HH87/qbLZMrb8Xe4zLmZfwA0xOUFShRIGhrC27vkHCpSwJb/fBIYy2gGFlEZ9fyBgKYLG+H2WyiQBtaLovk+sNzDMR7nHqljXB1QJhn1pt9hJnlO5gefyVrzn8ISslP5Yvmz/kkqqC5cbH9sf+VTtLL/gUu1/zX+SG0w/jL+NP52/AGg5PjL8SdAsxyD42+FDs4/hDzAR9I+6ION8z/kBfjg/Be4QINBoQi5cP5lbudfhpYseQ6mOr+oxxLmHxsJAmupFPF1tDiYuWK1yGbqILFhRzmc7sP80YhaTdujcE1GiO2ik9ZYmb75T1mgxFj+rH+2P7a/9j/8fk84R/tfOYfOSsAj8IV4U4FGtuCu8YfxVxUL40/jb8cf0AbHX+khFHlGFOr40/E3VMPxJ1XD8bfzD84/OP8wVDqvmwhfKQvJb2s3oJr2gtFXZm87x2oLNuDS6dRpEwZXD2FjjNHh7NPVtT6iHUPQQrf7q6npm/+Wvx7d7FIi65/tT2O02/YzzDpkxfbX/sf+l0Cl0ZO6Exgj640/jL8gENW7hmwY/xr/QxK6bEOVkLAikpissv/t6I/xB3lB2XH86/g/DUSX6XD+Q+wIQ9FjY9OOOP8DRtCG4B+bEJ9YV++j2qzqtFEX2x/bXwjC9P2P3kQWd9YzSIKg6YsnVExIJdcUUMkfVtzyk0d4NBdKcBT5jQ2VIa3qh12+XqK5eV0LPHE1bQ2MoumTKcEZsdT8t/xBJMgE6hM/1r80NuSLFuxnle0PGEJe2P6G3QAr7H/sfyvsaICI8Yfxl0xly7GiaPxJpsiBhEs1/gw/0hIT468EWxCVWLCfVcZf4IjUx/EvYxUuxl/GX8ZfoQvGn+kojL9nBf7Gb8fJm4X08t2FKGkKh/hicj5w3xzSEbo94kcZ/3ow29SIfIipZzSo70EkoIqm6TJGAMMxNj+mT84kI81/cULcsPxZ/2x/qmXQV+ZpJ2x/7X/sf40/jL86sKnCT+PP4ITxNxCk4w/HX4htaScdfzr+jghbXhPvn3L+wfkXyILzT86/Of/ZAdLj5B+HR2kwudCK0naGNcU+CiozLZFBGUpyuLK1OKj2aXg5Ri4j+bw788AcopNq1oCo4NlE2fTNf4kNxcHyZ/1LE2H7A0aIF7a/9j/2v4EyjD+Mv8ABCQOMo/En8EJoRkJvbYy/wRP+40MX6vhDQAKcyK3jL8efjr9lK51/cP4hBAFr5x+cf2hcJQoqO/6OJ4mJM/kBU+LJXu4rHBHAYqniC32FmQCMR1hd+3YaaCjtiskYK2pYUDWfUI7muNPLrHQdg8WapTZ9sIh3wmMegl9kIDhv/oMvlj/rn+2P7S9sIv1Hx0B2du1/yBgsYpBKZIn9L/gh2TD+MP4i6EwVYdH4U3bC+N/xj+MPx1+OPx1/kwMdeO38g/MvhEzOvwxK/iV+NF0WIAJJ/ppfBzXnXSYKRBzGoTAYdJ90ILIeuiuJBugbfzEEf5WeixxN9lcvPkgsTcP4aBLjRAPTJx/qx/yXAFFCUn4sf9Y/2gzbH9tf+x/6VyoDtzCQ9r/gAv+CHcYflIvAV9V/Gn/Bahh/Gn87/oBhcPzl+DP8A9dcHH+TD/Xj+FtCAX5U/OD4m3ib/46/HH8RX1MYuIXNmKPx17xFixedGQIf5oDXTPyki88q7bLcFOJAhGNhQHhoFJaE7yHmlvt6Yonb0TC2ekhDB/Rkfx0kFS52Td/8t/xRF2h4YmnUrinU+lAmOnCWrH+2P7a/9j/2v8Yf8gzhSI2/jD8FGIy/wYaATPxmcSzYd/wT9lIMcfzn+Jc64vgj7APWYgf3mkIccv6DDHH+x/F3qIbzD3Mz/zBv0aJFZza2D0FFpKa45kPGMIM4yC3X+Ck7bIgiALFYxU/doKzHklE5nPVxnO2jnZQJu0xksLKrmQYyfXKGvDb/LX/WP9sf219aQ3oK+x/7X8iB8Qegk/GXTEICSG2wMv4MXG38TQyNRYIBnqScOP4AK8AOx1+hJykWVTzAHMef5AyxluNPx5+OPx1/Ov6kNaSnGNz4c2jJkiXhF8AGushgSPoJ8KapC7+K46yTPy0j+NpeFaIhBm+8Pd+MhrIWtkZD9uI/jouGEsWobrVvaLEf69Ulzyn3cyO6pg8WgUcy5ua/5c/612VPaEZkRGx/gg+2v/Y/cKD2v6kINA8EFLkYfxj/Gf9CN7gk0G50IvdzY/wNNjn+cPzh+CvwhON/WEbHX114KhwJ/YnzP5nMcvwBNXH8MbviD5q1yKNgo8fF6z6ug4AwQDMvip9oig3a4ggKARrDQDJPqQqO0SwcgVATixqoEA8E0XZw4YBYTD/5RH4kb83/ZIblz/oHUUhpsP2x/bX/SR8hrwFPbv9LEEEk0V6MP4y/jD+Nv2ETHH+kYeQrmYClHH8FPwgqsTj+dPwpO5lBBsuOv5MZjr8df0MUUhpgK6EZ2KGOOP4AF+Zw/BVJYnwPK4wjwwlMunZCICgGsQtEkTeE6EzxUgmZ0PhqW0gL+0py2CN2WKOXnufIGi3sDcZlIRuYPhgBfpAj5r+kIkTI8mf9kzjY/tj+0jjCn9j/gA32v8Qmxh80jlQKrbEigmh2eND4Cywx/qRcEOdHcKeS8bf0gwri+IPi4fhDWiJhoLZwcfwb7DD+Nv6mjYBGGH+DDcbftI3G3/QRVIr0F3MQf+OdxDufmZeJDa4UBkDeUZlKuskADqoMXkQcotY8XhfBz6Y1h9I42nBcFCBRNDBxABXqzgO1KduhUk1YH23VjGX8qzYqUM6CRjB98qPOlvnfCBV4QrnCvuXP+mf7k4oBhZD5pGJkUXqCStbb/idXqkUNvpBbTW4lGIgaLvY/9j/2v1Vb5G9lX2hOoDVUHPtf+1/7XygCFQMKIf2gYmRRehJ+xv6XfCGDqkUJvqhWfCMHs0AGYs/+x/6nSgtVqYqH/Q+YQX7Y/9r/2v+mYYBCyH1QMaqpoJ6En7H/JV/IIN0OqY42K3M3vpnFHThf1cWBGiDjQBkO/mqgHCza82COw8IIPuzHR9SH9R0nOnTciVH/2tD0xbRkh/lfhcjyZ/2rsgANqeYCVbY/5AsXMiXubcte1ypubX/tf+x/jT9gIoy/jD+Nv/l1SMcfjr8cfzr+DnzMdSQj4CQzvnD8TZ6QGY6/HX9XWYBEpH6wxvE3ucCFTJm78TefmUfwwDV/zTOyvhQEPkimO3BqwDLBVbbNbHsoDxqOto6hTdzN41g8hvu7GJB7YXJCypqx65imb/5b/qAN0BPrn+0PDGZjI1Vu2VjbXzkT+x9aC/rYlmzQfqSntf8lb4w/jL+MP6EJxt+ylo4/wIYOtiBPKByOvxx/Of6iIjj+cvzp+BM+wfGnHKPCqEHOfypJrLsDyAoPC0YSNASQiq/z1LJ4FS3wNDCBRXwjGcfxNQYd0Iap5vjiT/PodgaxatMWPpnkMMoczPST1+a/JMPyR3lImUCJJkt71j/bH9tf+x8ZBFgE+1/jj3QVBPbGX8afulGUNxPrTSTj7wBRTfCLXS6Of8gEx1+OPzPWcPwpu+D4M0EFuEGo6fjT8bcshPMPA5V/QJI4HMMQsr4jzRO/MAd8fw2AA8Emj7GdnnCU+cRetR98iAnHmTBmK71aglX4DLGSW/zJ77AN+jXGNyQu2pi++W/5S0cMRbH+2f7Y/sp32P/Im9r/Ai8IMhBTsMCP8QcAlfGX8WdgbuNvRhvBC8cfjr8gCsIQjj9DKRx/O//g/EuCR24SUTr/5fyf859x+1zrVv7p/wf7kmYDWul0XQAAAABJRU5ErkJggg==)\n", - "\n", - "
Quantum auto encoder layout: uncoded data of size 4 transforms into two outputs, a coded register of size 2 and trash outputs of size 2 at state $|00\\rangle$\n", - "
\n", - "
" - ] - }, - { - "cell_type": "markdown", - "id": "6a685c3b", - "metadata": { - "id": "6a685c3b" - }, - "source": [ - "# Pre-user-defined functions which will be used to construct the quantum layer\n", - "\n", - "As a first step we build some user-defined functions which allow us flexible modeling. We have three functions:\n", - "1. `angle_encoding`: This function loads data of size `num_qubits` on `num_qubits` qubits via RY gates. It has an output port named `qbv`.\n", - "2. `encoder_ansatz` : A simple variational ansatz for encoding `num_qubits` qubits on `num_encoding_qubits` qubits (see description within the code-block). The input port is `x`, and the output ports are `coded` and `trash`." - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "f2b814d9", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:51:55.917096Z", - "iopub.status.busy": "2024-05-07T14:51:55.916566Z", - "iopub.status.idle": "2024-05-07T14:51:59.024617Z", - "shell.execute_reply": "2024-05-07T14:51:59.023600Z" - }, - "pycharm": { - "is_executing": true - }, - "id": "f2b814d9" - }, - "outputs": [], - "source": [ - "from classiq import (\n", - " CX,\n", - " RY,\n", - " CArray,\n", - " CInt,\n", - " CReal,\n", - " Input,\n", - " Output,\n", - " QArray,\n", - " QBit,\n", - " allocate,\n", - " bind,\n", - " create_model,\n", - " qfunc,\n", - " repeat,\n", - ")\n", - "from classiq.qmod.symbolic import pi" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "75634100", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:51:59.030300Z", - "iopub.status.busy": "2024-05-07T14:51:59.028905Z", - "iopub.status.idle": "2024-05-07T14:51:59.037330Z", - "shell.execute_reply": "2024-05-07T14:51:59.036640Z" - }, - "id": "75634100" - }, - "outputs": [], - "source": [ - "@qfunc\n", - "def angle_encoding(exe_params: CArray[CReal], qbv: Output[QArray[QBit]]) -> None:\n", - " allocate(exe_params.len, qbv)\n", - " repeat(\n", - " count=exe_params.len,\n", - " iteration=lambda index: RY(pi * exe_params[index], qbv[index]),\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "id": "7132bf7f", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:51:59.041648Z", - "iopub.status.busy": "2024-05-07T14:51:59.040513Z", - "iopub.status.idle": "2024-05-07T14:51:59.048695Z", - "shell.execute_reply": "2024-05-07T14:51:59.048146Z" - }, - "id": "7132bf7f" - }, - "outputs": [], - "source": [ - "@qfunc\n", - "def encoder_ansatz(\n", - " num_qubits: CInt,\n", - " num_encoding_qubits: CInt,\n", - " exe_params: CArray[CReal],\n", - " x: Input[QArray[QBit, \"num_qubits\"]],\n", - " trash: Output[QArray[QBit, \"num_qubits-num_encoding_qubits\"]],\n", - " coded: Output[QArray[QBit, \"num_encoding_qubits\"]],\n", - ") -> None:\n", - " \"\"\"\n", - " This is a parametric model which has num_trash_qubits = num_qubits-num_encoding_qubits as an output.\n", - " It contains num_trash_qubits layers, each composed of RY gates and CX gates with a linear connectivity,\n", - " and a final layer with RY gate on each of the trash qubits is applied.\n", - " \"\"\"\n", - "\n", - " def single_layer(rep: CInt) -> None:\n", - " repeat(\n", - " count=num_qubits,\n", - " iteration=lambda index: RY(exe_params[rep * num_qubits + index], x[index]), # What is the logic behind 1st arg of RY?\n", - " )\n", - " repeat(\n", - " count=num_qubits - 1,\n", - " iteration=lambda index: CX(x[index], x[index + 1]),\n", - " )\n", - "\n", - " repeat(count=num_qubits - num_encoding_qubits, iteration=single_layer) # Could be lammbda func\n", - " bind(x, [coded, trash])\n", - " repeat(\n", - " count=num_qubits - num_encoding_qubits,\n", - " iteration=lambda index: RY(\n", - " exe_params[(num_qubits - num_encoding_qubits) * num_qubits + index], # What is the logic behind 1st arg of RY?\n", - " trash[index],\n", - " ),\n", - " )" - ] - }, - { - "cell_type": "markdown", - "id": "493d4499", - "metadata": { - "id": "493d4499" - }, - "source": [ - "# An example: auto encoder for domain wall data" - ] - }, - { - "cell_type": "markdown", - "id": "428691bc", - "metadata": { - "id": "428691bc" - }, - "source": [ - "In the following example we will try to encode data which has a domain wall structure. Let us define the relevant data for strings of size 4." - ] - }, - { - "cell_type": "markdown", - "id": "535d9181", - "metadata": { - "id": "535d9181" - }, - "source": [ - "## The data" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "id": "1cdcd74c", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:51:59.051331Z", - "iopub.status.busy": "2024-05-07T14:51:59.050956Z", - "iopub.status.idle": "2024-05-07T14:51:59.055305Z", - "shell.execute_reply": "2024-05-07T14:51:59.054655Z" - }, - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "1cdcd74c", - "outputId": "73ddf030-feac-429b-efd8-9e00e08db78a" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "domain wall data:\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "array([[0, 0, 1, 1],\n", - " [0, 0, 0, 1],\n", - " [0, 1, 1, 1]])" - ] - }, - "metadata": {}, - "execution_count": 74 - } - ], - "source": [ - "import numpy as np\n", - "\n", - "domain_wall_data = np.array([[0, 0, 1, 1], [0, 0, 0, 1], [0, 1, 1, 1]])\n", - "print(\"domain wall data:\")\n", - "domain_wall_data" - ] - }, - { - "cell_type": "markdown", - "id": "0a09e977", - "metadata": { - "id": "0a09e977" - }, - "source": [ - "## The quantum program" - ] - }, - { - "cell_type": "markdown", - "id": "decfc82e-fae0-4d3d-91c8-3b2a660af884", - "metadata": { - "id": "decfc82e-fae0-4d3d-91c8-3b2a660af884" - }, - "source": [ - "We will try to encode this data on size 4 on 2 qubits. Let us built the corresponding quantum layer based on the pre-defined functions above." - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "id": "6fb450af-1613-4284-8625-ff7f2ae12557", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:51:59.057848Z", - "iopub.status.busy": "2024-05-07T14:51:59.057452Z", - "iopub.status.idle": "2024-05-07T14:51:59.061978Z", - "shell.execute_reply": "2024-05-07T14:51:59.061324Z" - }, - "id": "6fb450af-1613-4284-8625-ff7f2ae12557" - }, - "outputs": [], - "source": [ - "from classiq import show, swap_test, synthesize\n", - "\n", - "NUM_QUBITS = 4\n", - "NUM_ENCODING_QUBITS = 2\n", - "num_trash_qubits = NUM_QUBITS - NUM_ENCODING_QUBITS\n", - "num_weights_in_encoder = NUM_QUBITS * num_trash_qubits + num_trash_qubits" - ] - }, - { - "cell_type": "markdown", - "id": "2454d248-5614-4300-a5e3-d4826469e1c8", - "metadata": { - "id": "2454d248-5614-4300-a5e3-d4826469e1c8" - }, - "source": [ - "Let us construct the model" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "id": "5f1bc0cd", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:51:59.065357Z", - "iopub.status.busy": "2024-05-07T14:51:59.064898Z", - "iopub.status.idle": "2024-05-07T14:51:59.109586Z", - "shell.execute_reply": "2024-05-07T14:51:59.108752Z" - }, - "id": "5f1bc0cd" - }, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(\n", - " w: CArray[CReal, num_weights_in_encoder],\n", - " input: CArray[CReal, NUM_QUBITS],\n", - " trash: Output[QArray[QBit, num_trash_qubits]],\n", - " coded: Output[QArray[QBit, NUM_ENCODING_QUBITS]],\n", - " test: Output[QBit],\n", - ") -> None:\n", - " x = QArray(\"x\")\n", - " psi2 = QArray(\"psi2\")\n", - " allocate(num_trash_qubits, psi2)\n", - " angle_encoding(exe_params=input, qbv=x)\n", - " encoder_ansatz(\n", - " num_qubits=NUM_QUBITS,\n", - " num_encoding_qubits=NUM_ENCODING_QUBITS,\n", - " exe_params=w,\n", - " x=x,\n", - " trash=trash,\n", - " coded=coded,\n", - " )\n", - "\n", - " swap_test(state1=trash, state2=psi2, test=test)\n", - "\n", - "\n", - "ae_qmod = create_model(main)" - ] - }, - { - "cell_type": "markdown", - "id": "4597538f", - "metadata": { - "id": "4597538f" - }, - "source": [ - "We synthesize and visualize the quantum layer:" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "1ef859c2-02ef-46e7-a4fc-ff02ae77b28a", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:51:59.114780Z", - "iopub.status.busy": "2024-05-07T14:51:59.113594Z", - "iopub.status.idle": "2024-05-07T14:52:01.559527Z", - "shell.execute_reply": "2024-05-07T14:52:01.558874Z" - }, - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "1ef859c2-02ef-46e7-a4fc-ff02ae77b28a", - "outputId": "578495ad-65eb-4b8c-878d-9c7d8007faae" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/43212190-cc36-47d8-a3ea-a2929ae4e696?version=0.41.2\n" - ] - } - ], - "source": [ - "qprog = synthesize(ae_qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "5a41ccaa", - "metadata": { - "id": "5a41ccaa" - }, - "source": [ - "## The network\n", - "\n", - "The network for training contains only a quantum layer. The corresponding quantum program was already defined above, what is left is to define some execution preferences and the classical post-process. The classical output is defined as $1-\\alpha^2$, with $\\alpha$ being the probability of the test qubit to be at state 0." - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "20c207bc", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:01.562592Z", - "iopub.status.busy": "2024-05-07T14:52:01.562150Z", - "iopub.status.idle": "2024-05-07T14:52:02.797968Z", - "shell.execute_reply": "2024-05-07T14:52:02.797311Z" - }, - "id": "20c207bc" - }, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from torch.utils.data import DataLoader\n", - "\n", - "from classiq.applications.qnn import QLayer\n", - "from classiq.applications.qnn.types import (\n", - " MultipleArguments,\n", - " ResultsCollection,\n", - " SavedResult,\n", - ")\n", - "from classiq.execution import (\n", - " ExecutionPreferences,\n", - " execute_qnn,\n", - " set_quantum_program_execution_preferences,\n", - ")\n", - "from classiq.synthesis import SerializedQuantumProgram" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "id": "9f55ec56", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:02.801081Z", - "iopub.status.busy": "2024-05-07T14:52:02.800375Z", - "iopub.status.idle": "2024-05-07T14:52:02.804668Z", - "shell.execute_reply": "2024-05-07T14:52:02.804076Z" - }, - "id": "9f55ec56" - }, - "outputs": [], - "source": [ - "num_shots = 4096\n", - "\n", - "\n", - "def execute(\n", - " quantum_program: SerializedQuantumProgram, arguments: MultipleArguments\n", - ") -> ResultsCollection:\n", - " quantum_program = set_quantum_program_execution_preferences(\n", - " quantum_program, preferences=ExecutionPreferences(num_shots=num_shots)\n", - " )\n", - " return execute_qnn(quantum_program, arguments)\n", - "\n", - "\n", - "def post_process(result: SavedResult) -> torch.Tensor:\n", - " alpha_sqaured = result.value.counts_of_output(\"test\")[\"0\"] / num_shots\n", - " out = 1 - alpha_sqaured\n", - " return torch.tensor(out)" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "id": "d7913804", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:02.807180Z", - "iopub.status.busy": "2024-05-07T14:52:02.806812Z", - "iopub.status.idle": "2024-05-07T14:52:02.815094Z", - "shell.execute_reply": "2024-05-07T14:52:02.814520Z" - }, - "id": "d7913804" - }, - "outputs": [], - "source": [ - "def create_net(*args, **kwargs) -> nn.Module:\n", - " class Net(nn.Module):\n", - " def __init__(self, *args, **kwargs):\n", - " super().__init__()\n", - "\n", - " self.qlayer = QLayer(\n", - " qprog,\n", - " execute,\n", - " post_process,\n", - " *args,\n", - " **kwargs,\n", - " )\n", - "\n", - " def forward(self, x):\n", - " x = self.qlayer(x)\n", - " return x\n", - "\n", - " return Net(*args, **kwargs)\n", - "\n", - "\n", - "encoder_train_network = create_net()" - ] - }, - { - "cell_type": "markdown", - "id": "7590c55d", - "metadata": { - "id": "7590c55d" - }, - "source": [ - "## Creating dataset\n", - "\n", - "The cost function we would like to minimize is $|1-\\alpha^2|$ for all our training data. Looking at the qlayer output this means that we should define the corresponding labels as $0$." - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "931ecd5a", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:02.817442Z", - "iopub.status.busy": "2024-05-07T14:52:02.817102Z", - "iopub.status.idle": "2024-05-07T14:52:02.820913Z", - "shell.execute_reply": "2024-05-07T14:52:02.820320Z" - }, - "id": "931ecd5a" - }, - "outputs": [], - "source": [ - "class MyDWDataset:\n", - " def __init__(self, data, labels) -> None:\n", - " self.data = torch.from_numpy(data).float()\n", - " self.labels = torch.unsqueeze(torch.from_numpy(labels), dim=-1).float()\n", - "\n", - " def __len__(self):\n", - " return self.data.shape[0]\n", - "\n", - " def __getitem__(self, idx):\n", - " return self.data[idx], self.labels[idx]" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "id": "775728a9", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:02.823056Z", - "iopub.status.busy": "2024-05-07T14:52:02.822880Z", - "iopub.status.idle": "2024-05-07T14:52:02.827516Z", - "shell.execute_reply": "2024-05-07T14:52:02.826900Z" - }, - "id": "775728a9" - }, - "outputs": [], - "source": [ - "labels = np.array([0, 0, 0])\n", - "train_dataset = MyDWDataset(domain_wall_data, labels)\n", - "train_data_loader = DataLoader(\n", - " train_dataset, batch_size=2, shuffle=True, drop_last=False\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "608173a0", - "metadata": { - "id": "608173a0" - }, - "source": [ - "## Define the training" - ] - }, - { - "cell_type": "code", - "execution_count": 160, - "id": "938eab77", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:02.829661Z", - "iopub.status.busy": "2024-05-07T14:52:02.829493Z", - "iopub.status.idle": "2024-05-07T14:52:02.833752Z", - "shell.execute_reply": "2024-05-07T14:52:02.833184Z" - }, - "id": "938eab77" - }, - "outputs": [], - "source": [ - "import time as time\n", - "\n", - "\n", - "def train(\n", - " model: nn.Module,\n", - " data_loader: DataLoader,\n", - " loss_func: nn.modules.loss._Loss,\n", - " optimizer: optim.Optimizer,\n", - " epoch: int = 40,\n", - ") -> None:\n", - " for index in range(epoch):\n", - " start = time.time()\n", - " for data, label in data_loader:\n", - " optimizer.zero_grad()\n", - " output = model(data)\n", - " loss = loss_func(torch.squeeze(output), torch.squeeze(label))\n", - " loss.backward()\n", - " optimizer.step()\n", - "\n", - " print(time.time() - start) # Prints time per step\n", - " print(index, f\"\\tloss = {loss.item()}\")" - ] - }, - { - "cell_type": "markdown", - "id": "ee98061f", - "metadata": { - "id": "ee98061f" - }, - "source": [ - "## Setting some hyper-parameters\n", - "\n", - "The L1 loss function fits the intended cost function we aim to minimize." - ] - }, - { - "cell_type": "code", - "execution_count": 171, - "id": "ee0a0551", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:02.836010Z", - "iopub.status.busy": "2024-05-07T14:52:02.835828Z", - "iopub.status.idle": "2024-05-07T14:52:02.838960Z", - "shell.execute_reply": "2024-05-07T14:52:02.838372Z" - }, - "id": "ee0a0551" - }, - "outputs": [], - "source": [ - "_LEARNING_RATE = 0.03\n", - "loss_func = nn.L1Loss()\n", - "optimizer = optim.SGD(encoder_train_network.parameters(), lr=_LEARNING_RATE)\n", - "# optimizer = optim.SGD(encoder_train_network.parameters(), lr=_LEARNING_RATE, momentum=0.9)\n", - "# optimizer = optim.Adam(encoder_train_network.parameters(), lr=_LEARNING_RATE)" - ] - }, - { - "cell_type": "markdown", - "id": "e38d76f1", - "metadata": { - "id": "e38d76f1" - }, - "source": [ - "## Training\n", - "\n", - "In this demo we will initialize the network with trained parameters, and run only 1 epoch for demonstration. A reasonable training with the above hyper-parameters can be achieved with $\\sim 40$ epochs. To train the network from the beginning uncomment the following code line:" - ] - }, - { - "cell_type": "code", - "execution_count": 172, - "id": "868a106c", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:02.841035Z", - "iopub.status.busy": "2024-05-07T14:52:02.840865Z", - "iopub.status.idle": "2024-05-07T14:52:02.844053Z", - "shell.execute_reply": "2024-05-07T14:52:02.843452Z" - }, - "id": "868a106c" - }, - "outputs": [], - "source": [ - "trained_weights = torch.nn.Parameter(\n", - " torch.Tensor(\n", - " [1.5227, 0.3588, 0.6905, 1.4777, 1.5718, 1.5615, 1.5414, 0.6021, 0.1254, 0.9903]\n", - " )\n", - ")\n", - "\n", - "# trained_weights = torch.nn.Parameter(torch.rand(10)) # if uncomment parameters will be prepared for training from scratch\n", - "\n", - "\n", - "encoder_train_network.qlayer.weight = trained_weights" - ] - }, - { - "cell_type": "code", - "execution_count": 173, - "id": "4a0f11fa", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:02.846070Z", - "iopub.status.busy": "2024-05-07T14:52:02.845891Z", - "iopub.status.idle": "2024-05-07T14:52:09.887741Z", - "shell.execute_reply": "2024-05-07T14:52:09.887070Z" - }, - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "4a0f11fa", - "outputId": "1449653a-c212-4c93-e524-956018c8a36f" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "9.504712343215942\n", - "0 \tloss = 0.9384765625\n", - "9.940344333648682\n", - "1 \tloss = 0.8662109375\n", - "8.715864419937134\n", - "2 \tloss = 0.9384765625\n", - "8.663626194000244\n", - "3 \tloss = 0.8662109375\n", - "8.422551393508911\n", - "4 \tloss = 0.8662109375\n", - "10.218191146850586\n", - "5 \tloss = 1.5341796875\n", - "8.701385498046875\n", - "6 \tloss = 0.9384765625\n", - "8.76116394996643\n", - "7 \tloss = 0.8662109375\n", - "8.970725297927856\n", - "8 \tloss = 1.5341796875\n", - "8.719649314880371\n", - "9 \tloss = 0.8662109375\n", - "10.413763761520386\n", - "10 \tloss = 0.9384765625\n", - "9.923221111297607\n", - "11 \tloss = 0.9384765625\n", - "9.860797882080078\n", - "12 \tloss = 0.8662109375\n", - "8.769683361053467\n", - "13 \tloss = 0.9384765625\n", - "8.7511465549469\n", - "14 \tloss = 1.5341796875\n", - "8.806759119033813\n", - "15 \tloss = 0.8662109375\n", - "8.751865863800049\n", - "16 \tloss = 0.9384765625\n", - "8.84875226020813\n", - "17 \tloss = 0.8662109375\n", - "8.649004459381104\n", - "18 \tloss = 0.9384765625\n", - "8.527371168136597\n", - "19 \tloss = 1.5341796875\n", - "8.607317924499512\n", - "20 \tloss = 0.9384765625\n", - "8.692336320877075\n", - "21 \tloss = 1.5341796875\n", - "8.559823036193848\n", - "22 \tloss = 0.8662109375\n", - "8.736822366714478\n", - "23 \tloss = 0.9384765625\n", - "8.550743341445923\n", - "24 \tloss = 0.9384765625\n", - "8.747317552566528\n", - "25 \tloss = 1.5341796875\n", - "8.791818857192993\n", - "26 \tloss = 0.9384765625\n", - "8.596765518188477\n", - "27 \tloss = 1.5341796875\n", - "8.465184688568115\n", - "28 \tloss = 0.9384765625\n", - "8.531871557235718\n", - "29 \tloss = 1.5341796875\n", - "8.585519313812256\n", - "30 \tloss = 0.8662109375\n", - "8.611732244491577\n", - "31 \tloss = 0.9384765625\n", - "8.495190143585205\n", - "32 \tloss = 0.9384765625\n", - "9.039399147033691\n", - "33 \tloss = 0.9384765625\n", - "8.793837070465088\n", - "34 \tloss = 1.5341796875\n", - "8.449427843093872\n", - "35 \tloss = 1.5341796875\n", - "8.70375394821167\n", - "36 \tloss = 0.8662109375\n", - "8.75142765045166\n", - "37 \tloss = 1.5341796875\n", - "8.50106692314148\n", - "38 \tloss = 0.9384765625\n", - "8.682931661605835\n", - "39 \tloss = 0.9384765625\n", - "8.873902082443237\n", - "40 \tloss = 0.9384765625\n", - "8.528905153274536\n", - "41 \tloss = 0.9384765625\n", - "8.679835319519043\n", - "42 \tloss = 1.5341796875\n", - "9.041699409484863\n", - "43 \tloss = 0.8662109375\n", - "8.815622806549072\n", - "44 \tloss = 1.5341796875\n", - "8.466412782669067\n", - "45 \tloss = 0.9384765625\n", - "8.495747566223145\n", - "46 \tloss = 0.8662109375\n", - "9.709753274917603\n", - "47 \tloss = 1.5341796875\n", - "8.380079746246338\n", - "48 \tloss = 0.9384765625\n", - "8.505638122558594\n", - "49 \tloss = 1.5341796875\n" - ] - } - ], - "source": [ - "data_loader = train_data_loader\n", - "\n", - "train(encoder_train_network, data_loader, loss_func, optimizer, epoch=5)" - ] - }, - { - "cell_type": "markdown", - "id": "7fb11e18", - "metadata": { - "id": "7fb11e18" - }, - "source": [ - "## Verification\n", - "\n", - "Once we trained our network, we can build a new network with the trained variables. We can thus verify our encoder by taking only the encoding block, changing post_process, etc.\n", - "\n", - "Below we verify our quantum auto encoder by comparing between input and output of an encoder-decoder network:\n", - "\n", - "We will create the following network, which contains two quantum blocks:\n", - "* The first two blocks of the previous network: a block for loading the inputs followed by our quantum encoder.\n", - "* The inverse of the quantum encoder, where the inputs for the trash qubits are new zero inputs.\n", - "\n", - "**The network's weights will be allocated with the trained ones**\n", - "\n", - "
\n", - "\n", - "![encoder-decoder.jpg](data:image/jpeg;base64,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)\n", - "\n", - "\n", - "
QLayer for verifying quantum auto encoder, containing three quantum blocks: (1) data encoding, (2) trained encoder, and (3) inverse of trained encoder (i.e., decoder).
\n", - "
" - ] - }, - { - "cell_type": "markdown", - "id": "812d2bc5", - "metadata": { - "id": "812d2bc5" - }, - "source": [ - "### We start with building the quantum layer for the validator" - ] - }, - { - "cell_type": "markdown", - "id": "952545a9-6e50-4a62-8538-f896220d15de", - "metadata": { - "id": "952545a9-6e50-4a62-8538-f896220d15de" - }, - "source": [ - "The validator contains the inverse of our encoder, for this, we will have to wrap our encoder function. This is because the `invert` quantum function except a single inout port." - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "id": "e2eb15db-866e-4ac1-8b7d-a3efa239f994", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:09.890580Z", - "iopub.status.busy": "2024-05-07T14:52:09.890066Z", - "iopub.status.idle": "2024-05-07T14:52:09.894377Z", - "shell.execute_reply": "2024-05-07T14:52:09.893824Z" - }, - "id": "e2eb15db-866e-4ac1-8b7d-a3efa239f994" - }, - "outputs": [], - "source": [ - "@qfunc\n", - "def encoder_ansatz_wrapper(\n", - " num_qubits: CInt,\n", - " num_encoding_qubits: CInt,\n", - " exe_params: CArray[CReal],\n", - " qbv: QArray[QBit, \"num_qubits\"],\n", - ") -> None:\n", - " coded = QArray(\"coded\")\n", - " trash = QArray(\"trash\")\n", - " encoder_ansatz(\n", - " num_qubits=num_qubits,\n", - " num_encoding_qubits=num_encoding_qubits,\n", - " exe_params=exe_params,\n", - " x=qbv,\n", - " trash=trash,\n", - " coded=coded,\n", - " )\n", - " bind([coded, trash], qbv)" - ] - }, - { - "cell_type": "markdown", - "id": "e01fcd94-072b-4483-8373-404826057669", - "metadata": { - "id": "e01fcd94-072b-4483-8373-404826057669" - }, - "source": [ - "We are now ready for modeling our verification quantum layer" - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "id": "e87cfbcc-cc20-4728-a2b9-e8abf18ec52d", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:09.896624Z", - "iopub.status.busy": "2024-05-07T14:52:09.896454Z", - "iopub.status.idle": "2024-05-07T14:52:09.926569Z", - "shell.execute_reply": "2024-05-07T14:52:09.926000Z" - }, - "id": "e87cfbcc-cc20-4728-a2b9-e8abf18ec52d" - }, - "outputs": [], - "source": [ - "from classiq import invert\n", - "\n", - "\n", - "@qfunc\n", - "def main(\n", - " w: CArray[CReal, num_weights_in_encoder],\n", - " input: CArray[CReal, NUM_QUBITS],\n", - " decoded: Output[QArray[QBit, NUM_QUBITS]],\n", - " trash: Output[QArray[QBit, num_trash_qubits]],\n", - ") -> None:\n", - " psi2 = QArray(\"psi2\")\n", - " coded = QArray(\"coded\")\n", - " allocate(num_trash_qubits, psi2)\n", - " angle_encoding(exe_params=input, qbv=decoded)\n", - " encoder_ansatz(\n", - " num_qubits=NUM_QUBITS,\n", - " num_encoding_qubits=NUM_ENCODING_QUBITS,\n", - " exe_params=w,\n", - " x=decoded,\n", - " trash=trash,\n", - " coded=coded,\n", - " )\n", - "\n", - " bind([coded, psi2], decoded)\n", - " invert(\n", - " operand=lambda: encoder_ansatz_wrapper(\n", - " num_qubits=NUM_QUBITS,\n", - " num_encoding_qubits=NUM_ENCODING_QUBITS,\n", - " exe_params=w,\n", - " qbv=decoded,\n", - " ),\n", - " )\n", - "\n", - "\n", - "validator_qmod = create_model(main)" - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "id": "02ed5fc2-85a9-4473-bbbb-a443a765919d", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:09.928600Z", - "iopub.status.busy": "2024-05-07T14:52:09.928429Z", - "iopub.status.idle": "2024-05-07T14:52:12.227982Z", - "shell.execute_reply": "2024-05-07T14:52:12.227270Z" - }, - "id": "02ed5fc2-85a9-4473-bbbb-a443a765919d", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "90fa2a76-71b6-4515-ad48-bdae962bb5d5" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/ce332293-cc22-4da0-a755-e9b304aaa55f?version=0.41.2\n" - ] - } - ], - "source": [ - "validator_qprog = synthesize(validator_qmod)\n", - "show(validator_qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "7f3f9983", - "metadata": { - "id": "7f3f9983" - }, - "source": [ - "### Next, we define the classical output of the network. For the validator post-process we take the output with the maximal counts." - ] - }, - { - "cell_type": "code", - "execution_count": 148, - "id": "41266c52", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:12.232075Z", - "iopub.status.busy": "2024-05-07T14:52:12.231653Z", - "iopub.status.idle": "2024-05-07T14:52:12.236387Z", - "shell.execute_reply": "2024-05-07T14:52:12.235709Z" - }, - "id": "41266c52" - }, - "outputs": [], - "source": [ - "def execute_validator(\n", - " quantum_program: SerializedQuantumProgram, arguments: MultipleArguments\n", - ") -> ResultsCollection:\n", - " return execute_qnn(quantum_program, arguments)" - ] - }, - { - "cell_type": "code", - "execution_count": 149, - "id": "e5e8f6f2", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:12.239751Z", - "iopub.status.busy": "2024-05-07T14:52:12.239371Z", - "iopub.status.idle": "2024-05-07T14:52:12.243655Z", - "shell.execute_reply": "2024-05-07T14:52:12.242996Z" - }, - "id": "e5e8f6f2" - }, - "outputs": [], - "source": [ - "def post_process_validator(result: SavedResult) -> torch.Tensor:\n", - " counts = result.value.counts_of_output(\"decoded\")\n", - "\n", - " max_key = max(counts, key=counts.get)\n", - " # print(counts)\n", - " return torch.tensor([int(k) for k in max_key])" - ] - }, - { - "cell_type": "markdown", - "id": "39a94e36", - "metadata": { - "id": "39a94e36" - }, - "source": [ - "### We create the network and assign the trained parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 150, - "id": "43b1a4f8", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:12.247036Z", - "iopub.status.busy": "2024-05-07T14:52:12.246591Z", - "iopub.status.idle": "2024-05-07T14:52:12.262065Z", - "shell.execute_reply": "2024-05-07T14:52:12.261452Z" - }, - "id": "43b1a4f8" - }, - "outputs": [], - "source": [ - "def create_encoder_decoder_net(*args, **kwargs) -> nn.Module:\n", - " class Net(nn.Module):\n", - " def __init__(self, *args, **kwargs):\n", - " super().__init__()\n", - "\n", - " self.qlayer = QLayer(\n", - " validator_qprog,\n", - " execute_validator,\n", - " post_process_validator,\n", - " *args,\n", - " **kwargs,\n", - " )\n", - "\n", - " def forward(self, x):\n", - " x = self.qlayer(x)\n", - " return x\n", - "\n", - " return Net(*args, **kwargs)\n", - "\n", - "\n", - "validator_network = create_encoder_decoder_net()\n", - "validator_network.qlayer.weight = encoder_train_network.qlayer.weight" - ] - }, - { - "cell_type": "markdown", - "id": "0db9d1a8", - "metadata": { - "id": "0db9d1a8" - }, - "source": [ - "Now we can compare between the input and output of the validator, for each different data:" - ] - }, - { - "cell_type": "code", - "execution_count": 151, - "id": "28c93e9e", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:12.266494Z", - "iopub.status.busy": "2024-05-07T14:52:12.265482Z", - "iopub.status.idle": "2024-05-07T14:52:16.622434Z", - "shell.execute_reply": "2024-05-07T14:52:16.621830Z" - }, - "id": "28c93e9e", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "36118536-d37d-4568-8181-62d6d87cabcb" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "input= [0.0, 0.0, 0.0, 1.0] , output= [0.0, 0.0, 0.0, 0.0]\n", - "input= [0.0, 1.0, 1.0, 1.0] , output= [0.0, 1.0, 0.0, 1.0]\n", - "input= [0.0, 0.0, 1.0, 1.0] , output= [0.0, 0.0, 0.0, 0.0]\n" - ] - } - ], - "source": [ - "validator_data_loader = DataLoader(\n", - " train_dataset, batch_size=1, shuffle=True, drop_last=False\n", - ")\n", - "\n", - "for data, label in validator_data_loader:\n", - " output = validator_network(data)\n", - " print(\"input=\", data.tolist()[0], \", output=\", output.tolist()[0])" - ] - }, - { - "cell_type": "markdown", - "id": "6dca60d3", - "metadata": { - "id": "6dca60d3" - }, - "source": [ - "# Usage for anomaly detection" - ] - }, - { - "cell_type": "markdown", - "id": "2479f917", - "metadata": { - "id": "2479f917" - }, - "source": [ - "We can use our trained network for anomaly detection. Let see what happens to the trash qubits when we insert anomaly, namely, a non domain-wall data:" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "id": "31253024", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:16.624992Z", - "iopub.status.busy": "2024-05-07T14:52:16.624545Z", - "iopub.status.idle": "2024-05-07T14:52:16.628713Z", - "shell.execute_reply": "2024-05-07T14:52:16.628149Z" - }, - "id": "31253024" - }, - "outputs": [], - "source": [ - "input_anomaly_data = np.array(\n", - " [[0, 0, 1, 1], [0, 0, 0, 1], [0, 0, 1, 1], [1, 0, 1, 0], [1, 1, 1, 1]]\n", - ")\n", - "anomaly_labels = np.array([0, 0, 0, 0, 0])\n", - "anomaly_dataset = MyDWDataset(input_anomaly_data, anomaly_labels)\n", - "anomaly_data_loader = DataLoader(\n", - " anomaly_dataset, batch_size=1, shuffle=True, drop_last=False\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "f45de115", - "metadata": { - "id": "f45de115" - }, - "source": [ - "We print all the anomaly data based on some pre-defined accuracy for the cost function:" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "id": "e9ac2d78", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:16.631149Z", - "iopub.status.busy": "2024-05-07T14:52:16.630672Z", - "iopub.status.idle": "2024-05-07T14:52:23.745511Z", - "shell.execute_reply": "2024-05-07T14:52:23.743996Z" - }, - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "e9ac2d78", - "outputId": "7b329d75-6c0a-4a17-cc12-3c0285febddc" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "anomaly: [0.0, 0.0, 0.0, 1.0]\n", - "anomaly: [1.0, 0.0, 1.0, 0.0]\n", - "anomaly: [1.0, 1.0, 1.0, 1.0]\n", - "anomaly: [0.0, 0.0, 1.0, 1.0]\n", - "anomaly: [0.0, 0.0, 1.0, 1.0]\n" - ] - } - ], - "source": [ - "tolerance = 1e-2\n", - "for data, label in anomaly_data_loader:\n", - " output = encoder_train_network(data)\n", - " if abs(output.tolist()[0]) > tolerance:\n", - " print(\"anomaly:\", data.tolist()[0])" - ] - }, - { - "cell_type": "markdown", - "id": "1949ec76", - "metadata": { - "id": "1949ec76" - }, - "source": [ - "# Alternative network for training a quantum auto encoder\n", - "\n", - "Another way to introduce a cost function is via estimation of Hamiltonians. Measuring the Pauli $Z$ matrix on a qubit at the general state $|q\\rangle=a|0\\rangle+b|1\\rangle$ is $\\langle q |Z|q \\rangle=a^2-b^2$. Therefore, a cost function can be defined by taking expectation values on the trash output (without a swap-test) as follows:\n", - "$$\n", - "\\text{Cost} = \\frac{1}{2}\\sum^{\\text{num of trash qubits}}_{k=1} 1 - \\langle Z_k \\rangle.\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "188687e5-95c1-4841-ac59-3d47de5e1748", - "metadata": { - "id": "188687e5-95c1-4841-ac59-3d47de5e1748" - }, - "source": [ - "Below we show how the define the corresponding Qlayer: the quantum program and post-processing:" - ] - }, - { - "cell_type": "markdown", - "id": "3cf8c081-3853-4d43-b003-5a3aa50ebf12", - "metadata": { - "id": "3cf8c081-3853-4d43-b003-5a3aa50ebf12" - }, - "source": [ - "## The quantum program" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "id": "cdcab73f-a9cd-4779-9043-ee1813d82b38", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:23.750598Z", - "iopub.status.busy": "2024-05-07T14:52:23.749376Z", - "iopub.status.idle": "2024-05-07T14:52:26.038135Z", - "shell.execute_reply": "2024-05-07T14:52:26.037439Z" - }, - "id": "cdcab73f-a9cd-4779-9043-ee1813d82b38", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "73cabece-c106-4a7c-c13b-3c7e2ce17240" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/e4318b40-1f0e-4a80-9003-41ea4a335cd9?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(\n", - " w: CArray[CReal, num_weights_in_encoder],\n", - " input: CArray[CReal, NUM_QUBITS],\n", - " trash: Output[QArray[QBit, num_trash_qubits]],\n", - ") -> None:\n", - " x = QArray(\"x\")\n", - " coded = QArray(\"coded\")\n", - " angle_encoding(exe_params=input, qbv=x)\n", - " encoder_ansatz(\n", - " num_qubits=NUM_QUBITS,\n", - " num_encoding_qubits=NUM_ENCODING_QUBITS,\n", - " exe_params=w,\n", - " x=x,\n", - " trash=trash,\n", - " coded=coded,\n", - " )\n", - "\n", - "\n", - "ae_qmod = create_model(main)\n", - "\n", - "\n", - "qprog = synthesize(ae_qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "1160bc2e-84ea-42de-b48c-9a2113bee98c", - "metadata": { - "id": "1160bc2e-84ea-42de-b48c-9a2113bee98c" - }, - "source": [ - "## Execution and post-process\n", - "\n", - "The trash register is of size 2, we measure the Pauli $Z$ matrix on each of its qubits" - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "id": "a56ea5a2-b040-4923-a8fa-1b46faeb5d1a", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:26.040751Z", - "iopub.status.busy": "2024-05-07T14:52:26.040244Z", - "iopub.status.idle": "2024-05-07T14:52:26.044916Z", - "shell.execute_reply": "2024-05-07T14:52:26.044072Z" - }, - "id": "a56ea5a2-b040-4923-a8fa-1b46faeb5d1a" - }, - "outputs": [], - "source": [ - "from classiq.applications.chemistry import PauliOperator, PauliOperators\n", - "\n", - "\n", - "def execute(\n", - " quantum_program: SerializedQuantumProgram, arguments: MultipleArguments\n", - ") -> ResultsCollection:\n", - " return execute_qnn(\n", - " quantum_program,\n", - " arguments,\n", - " observable=PauliOperator(pauli_list=[(\"IZ\", 1), (\"ZI\", 1)]),\n", - " )\n", - "\n", - "\n", - "def post_process(result: SavedResult) -> torch.Tensor:\n", - " out = 1 / 2 * (2 - np.real(result.value.value))\n", - " return torch.tensor(out)" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "id": "f87fef6b-36b3-4707-b1cd-7042b0ff053c", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:52:26.048898Z", - "iopub.status.busy": "2024-05-07T14:52:26.048111Z", - "iopub.status.idle": "2024-05-07T14:52:26.059915Z", - "shell.execute_reply": "2024-05-07T14:52:26.058954Z" - }, - "id": "f87fef6b-36b3-4707-b1cd-7042b0ff053c" - }, - "outputs": [], - "source": [ - "def create_net(*args, **kwargs) -> nn.Module:\n", - " class Net(nn.Module):\n", - " def __init__(self, *args, **kwargs):\n", - " super().__init__()\n", - "\n", - " self.qlayer = QLayer(\n", - " qprog,\n", - " execute,\n", - " post_process,\n", - " *args,\n", - " **kwargs,\n", - " )\n", - "\n", - " def forward(self, x):\n", - " x = self.qlayer(x)\n", - " return x\n", - "\n", - " return Net(*args, **kwargs)\n", - "\n", - "\n", - "encoder_train_network = create_net()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - }, - "colab": { - "provenance": [], - "collapsed_sections": [ - "6dca60d3", - "1949ec76" - ] - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/community/QClass_2024/Sessions/week1_ QClass_workshop_with_sol.ipynb b/community/QClass_2024/Sessions/week1_ QClass_workshop_with_sol.ipynb deleted file mode 100644 index 8adcc3a6..00000000 --- a/community/QClass_2024/Sessions/week1_ QClass_workshop_with_sol.ipynb +++ /dev/null @@ -1,1487 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Quantum Software Development Journey: \n", - "# From Theory to Application with Classiq - Part 1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Welcome to the Classiq Workshop Series for QClass 2024!**\n", - "\n", - "In this series, we will develop the skills needed to participate in quantum software development!\n", - "\n", - "- Week 1: Classiq's Basics & High-Level Functional Design\n", - "- Week 2: Using Git as a Tool for In-Team Collaboration and Open Source Contributions\n", - "- Weeks 3-4: Advanced Algorithms, Introduction to Quantum Machine Learning (QML), and Their Applications\n", - "\n", - "**Here, you have early access to our [New Classiq's documentation](https://nightly.docs.classiq.io/latest/)!**\n", - "\n", - "\n", - "\n", - "\n", - "Additional resources you should use are\n", - "- The IDE of the classiq platform at [platform.classiq.io](platform.classiq.io)\n", - "- The [community Slack of Classiq](https://short.classiq.io/join-slack) - Classiq's team will answer any question you have over there, including implementation questions\n", - "- [Classiq's documentation](https://docs.classiq.io/latest/user-guide/platform/) with the dedicated [Python SDK explanations](https://docs.classiq.io/latest/user-guide/platform/qmod/python/functions/)\n", - "\n", - "Good luck!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setting The Scene" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Install the Classiq SDK package:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "# !pip install -U classiq" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You need to authenticate your device in order to use Classiq's backend synthesis engine and IDE. \n", - "**Make sure to register to the platform** at [platform.classiq.io](https://platform.classiq.io/) before you run the next cell:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "import classiq\n", - "# classiq.authenticate()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## A Warm Up" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### First Example" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Write a function that prepares the minus state $\\ket{-}=\\frac{1}{\\sqrt2}(\\ket{0}-\\ket{1})$, assuming it recives the qubit $\\ket{x}=\\ket{0}$ (hint): \n", - "\n", - "
\n", - "\n", - "HINT\n", - "\n", - "\n", - "Use `H(x)`,`X(x)`\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def prepare_minus_state(x:QBit):\n", - " pass #TODO delete pass\n", - " #TODO prepare |-> function" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we will test our code:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x: Output[QBit]):\n", - " allocate(1,x) # Initialize the qubit x\n", - " pass #TODO delete pass\n", - " #TODO apply the function prepare_minus" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/185d88cf-237a-4991-acb9-802f796c99ee?version=0.40.0\n" - ] - } - ], - "source": [ - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Uniform Superposition" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's continue warming up with creating a function that receives a quantum register and creates a uniform superposition for all qubits within this array. You should use the function `apply_to_all(gate_operand=, target=)`:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def create_initial_state(reg: QArray[QBit]):\n", - " pass #TODO delete pass\n", - " #TODO use the function apply_to_all in order create a uniform superposition" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Test your function by creating a new main function, synthesizing and viewing the circuit:" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(): #TODO fill in the correct declaration here, what variables this model should output?\n", - " pass #TODO delete pass\n", - " #TODO allocate reg with a few qubits\n", - " create_initial_state(reg)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO uncomment the following line:\n", - "# qprog = synthesize(create_model(main))\n", - "\n", - "#TODO show the quantum program" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Another implementation could utilize the `repeat(count=, iteration=)` function. The `repeat` function can be thought of as a \"classical for loop\". It could be handy in many situations, especially when combined with `if_` function, the \"classical if\" statement in Classiq. Together, they form 'Classical Control Flow'. \n", - "\n", - "Read more: [Classical Control Flow (repeat, if_)](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/?h=repea#__tabbed_1_2)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/9ef28f93-59fe-467a-8b6d-efd7a0648fce?version=0.40.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def create_initial_state(q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]): \n", - " allocate(4,reg)\n", - " create_initial_state(reg)\n", - "\n", - "qprog = synthesize(create_model(main))\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Guidelines for High-Level Functional Design with Classiq" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Some basic explanations about the high-level functional design with Classiq:**\n", - "\n", - "* There should always be a main (`def main(...)`) function - the model that captures your algorithm is described there\n", - "\n", - "* The model is always generated out of the main function \n", - "\n", - "* The model is sent to the synthesis engine (compiler) that return a quantum program which contains the quantum circuit" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Some basic guidelines about the modeling language (QMOD):**\n", - "\n", - "1. Every function you use with the QMOD language should have the decorator `@qfunc` before it\n", - "2. Every quantum variable should be declared, either as an argument of a function e.g. `def prepare_minus(x: QBit)` or as a local variable within the function itself with `x = QBit('x')`\n", - "\n", - "\n", - "3. Some quantum variables need to be initialized with the `allocate` function. This is required in 2 cases:\n", - "* A variable is an argument of a function with the declaration `Output` like `def main(x: Output[QNum])`\n", - "* A variable that was declared within a function like `a = QNum('a')`\n", - "\n", - "4. For the `main` function, you will always use `Output` for all variables. The `output` indicates that these quantum variables are not initialized outside the scope of the function.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - " Types of Initializations \n", - "There are a few ways to initialize a quantum variable:\n", - "\n", - "1. With `allocate` or `allocate_num` \n", - "2. With `prepare_int`, `prepare_state` or `prepare_amplitudes`\n", - "3. As the result of a numeric operation `|=`\n", - "4. With the `bind` operation (`->` in native)\n", - "5. With any function that declares its quantum variable argument as `output`\n", - "\n", - "
\n", - "\n", - "
\n", - " Types of Quantum Variables \n", - "In Qmod there are 3 types of quantum variables:\n", - "\n", - "1. `QBit` (`qbit`)\n", - "2. `QArray[QBit]` (`qbit[]`)\n", - "3. `QNum` (`qnum`)\n", - "\n", - "(See also [Quantum Variables](https://nightly.docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_variables_and_functions/))\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tutorial - State Preparation " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prepare State" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now, we will see how we can easily make arbitrary state using Classiq's `prepare_state`.\n", - "\n", - "For example, let’s say we want to prepare the state $ \\ket{\\Phi^+}=\\frac{1}{\\sqrt{2}}(\\ket{00}+\\ket{11}) $" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/9e0cede6-2313-4bf2-a1c8-884b0ce731d7?version=0.40.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " prepare_state(probabilities=[0.5,0,0,0.5], bound=0.01, out=x)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Or using `prepare_bell_state` in order to prepare states with relative phase:" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x:Output[QArray]):\n", - " prepare_bell_state(state_num=0, q=x) # phi-" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b172cbea-d4a9-468e-9323-6159e9f0fb88?version=0.40.0\n" - ] - } - ], - "source": [ - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - "\n", - "NOTE\n", - "\n", - "\n", - "\n", - "| State Number | Bell State | \n", - "|--------------|------------|\n", - "| 0 | $ \\ket{\\phi^+}= \\frac{1}{\\sqrt{2}}[\\ket{00}+\\ket{11}] $ | \n", - "| 1 | $ \\ket{\\phi^-}= \\frac{1}{\\sqrt{2}}[\\ket{00}-\\ket{11}]$ |\n", - "| 2 | $ \\ket{\\psi^+}= \\frac{1}{\\sqrt{2}}[\\ket{01}+\\ket{10}]$ |\n", - "| 3 | $ \\ket{\\psi^-}= \\frac{1}{\\sqrt{2}}[\\ket{01}-\\ket{10}]$ |\n", - "| 4=0 | $ \\ket{\\phi^+}= ...$ |\n", - "| ... | ... | ... | \n", - "\n", - "\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now it's your turn to prepare the state $ \\ket{\\Psi^+}=\\frac{1}{\\sqrt{2}}(\\ket{01}+\\ket{10}) $" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " pass #TODO delete pass\n", - " #TODO use the function prepare_state/ prepare_bell_state in order create a the desired state\n", - "\n", - "#TODO create model, synthesize it, and show it" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that we can use `prepare_state` to create much more complex states, for instance, we can create list of probabilities:" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "jupyter": { - "source_hidden": true - } - }, - "outputs": [], - "source": [ - "probabilities = [\n", - " 0,\n", - " 0.002,\n", - " 0.004,\n", - " 0.006,\n", - " 0.0081,\n", - " 0.0101,\n", - " 0.0121,\n", - " 0.0141,\n", - " 0.0161,\n", - " 0.0181,\n", - " 0.0202,\n", - " 0.0222,\n", - " 0.0242,\n", - " 0.0262,\n", - " 0.0282,\n", - " 0.0302,\n", - " 0.0323,\n", - " 0.0343,\n", - " 0.0363,\n", - " 0.0383,\n", - " 0.0403,\n", - " 0.0423,\n", - " 0.0444,\n", - " 0.0464,\n", - " 0.0484,\n", - " 0.0504,\n", - " 0.0524,\n", - " 0.0544,\n", - " 0.0565,\n", - " 0.0585,\n", - " 0.0605,\n", - " 0.0625,\n", - "]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And then generate the state:" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/42118092-b20e-4172-98c6-00943a067da4?version=0.40.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " prepare_state(probabilities=probabilities, bound=0.01, out=x)\n", - " \n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prepare Int" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also have a `prepare_int` function, which allows us to register integers effortlessly. For example, $binary(9) = 1001$, or any other integer can be prepared in a single line of code:" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/57617572-0d31-42e6-88c4-a54efb0d7b47?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum]) -> None:\n", - " prepare_int(9, x)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise: Parallel Addition " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this exercise, we will conclude state preparation and also get a teaser of the next part of the tutorial - Arithmetic Operations. \n", - "\n", - "Let's say that for some reason we used `prepare_int` to create the integer 7, and we want to perform addition operations with the integers 0, 4, and 7. We will do that using `prepare_state`." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " pass #TODO delete pass\n", - " x = QNum() #TODO complete the declarations of x,y\n", - " y = QNum()\n", - " \n", - " # TODO prepare the above-mentioned integer using prepare_int\n", - " prepare_state(probabilities=[], bound=0.01, out=y) # TODO complete the 'probabilities' list\n", - " \n", - " res|=x+y\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO uncomment the folllowing lines:\n", - "\n", - "# model = create_model(main)\n", - "# qprog = synthesize(model)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tutorial - Arithmetic Operations with Classiq" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "One of the key advantages of Classiq is it's simplistic and powerful compiler for quantum arithmetic. Let's see an example:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "num_qubits = 4\n", - "fraction_digits = 0 \n", - "is_signed = True\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum]):\n", - " allocate_num(num_qubits=num_qubits, is_signed=is_signed, fraction_digits=fraction_digits, out=x)\n", - " hadamard_transform(x)\n", - " y|= x**2 + 1\n", - "\n", - "qmod = create_model(main)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `allocate_num` function initializes a quantum variable that represent numbers. By default, it is initialized to the $\\ket{0}$ state. Then the `hadmard_transform` creates a superposition of all possible states in the domain $[-2^3,2^3-1]$. Finally, the arithmetic operation creates the entangled superposition of states:\n", - "$\\begin{equation}\n", - "\\sum_{x =-2^3}^{2^3-1}\\ket{x}\\ket{x^2+1}.\n", - "\\end{equation}$\n", - "\n", - "The `qmod` variable is a string that captures the algorithm we have just created in a JSON format. Now, what we want is to synthesize (compile) in order to receive a concrete quantum program that contains the quantum circuit implementation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Advanced Arithmetics" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now let's create a general linear function with Classiq: $y= ax+b$ where $a,b$ are classical integer parameters and $x,y$ is a quantum states representing integers:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def linear_func(a:CInt,b: CInt, x:QNum, y: Output[QNum]):\n", - " y |= a*x+b" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x:Output[QNum], y: Output[QNum]):\n", - "\n", - " a = 2\n", - " b = 1\n", - " allocate_num(num_qubits=4,is_signed=False,fraction_digits=0,out=x)\n", - " hadamard_transform(x)\n", - " linear_func(a,b,x,y)\n", - "\n", - "qmod = create_model(main)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "qprog = synthesize(qmod)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's execute the circuit from directly from the SDK:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "job = execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And we can view the results in the IDE:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "job.open_in_ide()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Or to directly analyze it within the SDK:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'x': 8.0, 'y': 17.0}\n", - "{'x': 5.0, 'y': 11.0}\n", - "{'x': 13.0, 'y': 27.0}\n", - "{'x': 7.0, 'y': 15.0}\n", - "{'x': 14.0, 'y': 29.0}\n", - "{'x': 6.0, 'y': 13.0}\n", - "{'x': 2.0, 'y': 5.0}\n", - "{'x': 15.0, 'y': 31.0}\n", - "{'x': 1.0, 'y': 3.0}\n", - "{'x': 12.0, 'y': 25.0}\n", - "{'x': 10.0, 'y': 21.0}\n", - "{'x': 9.0, 'y': 19.0}\n", - "{'x': 11.0, 'y': 23.0}\n", - "{'x': 0.0, 'y': 1.0}\n", - "{'x': 4.0, 'y': 9.0}\n", - "{'x': 3.0, 'y': 7.0}\n" - ] - } - ], - "source": [ - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "for sampled_state in parsed_counts: print(sampled_state.state)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Now it's your turn!** \n", - "\n", - "Implement the same linear function, but now $x$ is in the domain $[0,1)$ and is represented by 4 qubits. The parameters $a,b$ should be now `float` with the values of: $a=0.5, b=1.5$." - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [], - "source": [ - "#TODO complete here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Tutorial - Two controlled Linear operations" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's say we want now to have two linear operations applied on the same quantum variable (register). But the arithmetic operation initialize a new quantum variable, so how can we do that? The answer is that we need to apply the operation to another variable and then XOR it to the variable we want. \n", - "\n", - "This can be useful if the linear operation we want to apply is controlled upon a control variable. Let's first define the functional building block:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def inplace_linear_attempt(a:CInt,b: CInt, x:QNum, y: QNum):\n", - " tmp = QNum('tmp')\n", - " linear_func(a,b,x,tmp)\n", - " inplace_xor(tmp,y)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And checking our basic function implementation:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/6e172347-e427-4622-84d0-01d46371a787?version=0.40.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(x: Output[QNum],y: Output[QNum]):\n", - " a = 1\n", - " b = 2\n", - "\n", - " allocate_num(4,False,0,y)\n", - " allocate_num(4,False,0,x)\n", - " hadamard_transform(x)\n", - " inplace_linear_attempt(a,b,x,y)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "OK, cool. So now we want to add a control qubit that controlled on the state $\\ket{0}$ implements the linear function $\\ket{x}\\rightarrow\\ket{x}\\ket{x+2}$ and controlled on the state $\\ket{1}$ implements the linear function $\\ket{x}\\rightarrow\\ket{x}\\ket{2x+1}$:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "@qfunc\n", - "def control_logic(a: CArray[CInt], b: CArray[CInt], controller:QNum, x: QNum, y: QNum):\n", - " \n", - " repeat( count=a.len, \n", - " iteration=lambda i: control(controller==i, lambda: inplace_linear_attempt(a[i],b[i],x,y)))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(controller: Output[QNum], x: Output[QNum],y: Output[QNum]):\n", - "\n", - " # Linear polynom parameters\n", - " a = [1,2]\n", - " b = [2,1]\n", - "\n", - " # Initializing x to a superposition in the domain [0,2^4-1]\n", - " allocate_num(4,False,0,x)\n", - " hadamard_transform(x)\n", - " \n", - " #Initialize y\n", - " allocate_num(4,False,0,y)\n", - "\n", - " # Setting the controller in a superposition\n", - " allocate_num(1,False,0,controller)\n", - " H(controller)\n", - "\n", - " # Implementing the control logic\n", - " control_logic(a,b,controller,x,y)\n", - "\n", - " \n", - "qmod = create_model(main)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8c213254-0a37-4a2c-94b9-c43e52da760e?version=0.40.0\n" - ] - } - ], - "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "By executing we can actually see we get what we want:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'controller': 0.0, 'x': 15.0, 'y': 1.0}\n", - "{'controller': 0.0, 'x': 6.0, 'y': 8.0}\n", - "{'controller': 1.0, 'x': 4.0, 'y': 9.0}\n", - "{'controller': 0.0, 'x': 8.0, 'y': 10.0}\n", - "{'controller': 0.0, 'x': 11.0, 'y': 13.0}\n", - "{'controller': 0.0, 'x': 7.0, 'y': 9.0}\n", - "{'controller': 0.0, 'x': 13.0, 'y': 15.0}\n", - "{'controller': 1.0, 'x': 0.0, 'y': 1.0}\n", - "{'controller': 1.0, 'x': 7.0, 'y': 15.0}\n", - "{'controller': 1.0, 'x': 12.0, 'y': 9.0}\n", - "{'controller': 0.0, 'x': 0.0, 'y': 2.0}\n", - "{'controller': 1.0, 'x': 10.0, 'y': 5.0}\n", - "{'controller': 1.0, 'x': 1.0, 'y': 3.0}\n", - "{'controller': 0.0, 'x': 9.0, 'y': 11.0}\n", - "{'controller': 1.0, 'x': 5.0, 'y': 11.0}\n", - "{'controller': 1.0, 'x': 6.0, 'y': 13.0}\n", - "{'controller': 1.0, 'x': 9.0, 'y': 3.0}\n", - "{'controller': 0.0, 'x': 5.0, 'y': 7.0}\n", - "{'controller': 0.0, 'x': 2.0, 'y': 4.0}\n", - "{'controller': 1.0, 'x': 11.0, 'y': 7.0}\n", - "{'controller': 0.0, 'x': 4.0, 'y': 6.0}\n", - "{'controller': 0.0, 'x': 3.0, 'y': 5.0}\n", - "{'controller': 1.0, 'x': 2.0, 'y': 5.0}\n", - "{'controller': 0.0, 'x': 1.0, 'y': 3.0}\n", - "{'controller': 0.0, 'x': 14.0, 'y': 0.0}\n", - "{'controller': 0.0, 'x': 12.0, 'y': 14.0}\n", - "{'controller': 1.0, 'x': 13.0, 'y': 11.0}\n", - "{'controller': 1.0, 'x': 3.0, 'y': 7.0}\n", - "{'controller': 0.0, 'x': 10.0, 'y': 12.0}\n", - "{'controller': 1.0, 'x': 8.0, 'y': 1.0}\n", - "{'controller': 1.0, 'x': 14.0, 'y': 13.0}\n", - "{'controller': 1.0, 'x': 15.0, 'y': 15.0}\n" - ] - } - ], - "source": [ - "def print_parsed_counts(job):\n", - " results = job.result()\n", - " parsed_counts = results[0].value.parsed_counts\n", - " for parsed_state in parsed_counts: print(parsed_state.state)\n", - "\n", - "job = execute(qprog)\n", - "print_parsed_counts(job)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Of course there is the issue of rounding and overflow - when one tries to represent $2*15+1=31$ with $4$ binary digits that's not possible (because the domain $[0,31]$ of integers is represented by at least 5 bits). See our [documentation](https://docs.classiq.io/latest/user-guide/platform/qmod/python/quantum-expressions/#inplace-arithmetic-operators) for further explanations.\n", - "\n", - "Let's try to use Classiq and optimize the circuit for minimal circuit width:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 20, depth: 688\n" - ] - } - ], - "source": [ - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - " \n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And when optimizing for depth:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 32, depth: 398\n" - ] - } - ], - "source": [ - "qmod = set_constraints(qmod,Constraints(optimization_parameter='depth'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Firstly, we can see here a clear demonstration of the power of high-level functional design!** The same algorithm with the same functionality was optimized once for depth and once for width and the result is 2 different circuits with different characteristics that implement the same functionality.\n", - "\n", - "Secondly, is this the best we can do? Obviously the Classiq synthesis engine is optimizing for us the algorithm quite good. But, can we change something with our functionality, with our algorithm to get more efficient circuits? \n", - "\n", - "If we go back to out `inplace_linear_attempt` function, we can see that we initialize a `tmp` variable that requires more qubits and is not used. For such scenarios we have the `within_apply`. This logic implements sort of $UVU^{\\dagger}$ and when temporary variables are outputs of $U$ and used only by $V$ they are uncomputed by $U^{\\dagger}$. Let's see for our example:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def inplace_linear_func(a:CInt,b: CInt, x:QNum, y: QNum):\n", - " tmp = QNum('tmp')\n", - " within_apply(compute= lambda: linear_func(a,b,x,tmp),\n", - " action= lambda: inplace_xor(tmp,y))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With the new `control_logic`:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def control_logic_2(a: CArray[CInt], b: CArray[CInt], controller:QNum, x: QNum, y: QNum):\n", - " \n", - " repeat( count=a.len, \n", - " iteration=lambda i: control(controller==i, lambda: inplace_linear_func(a[i],b[i],x,y)))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And when we put all together now:" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(controller: Output[QNum], x: Output[QNum],y: Output[QNum]):\n", - "\n", - " # Linear polynom parameters\n", - " a = [1,2]\n", - " b = [2,1]\n", - "\n", - " # Initializing x to a superposition in the domain [0,2^4-1]\n", - " allocate_num(4,False,0,x)\n", - " hadamard_transform(x)\n", - " \n", - " #Initialize y\n", - " allocate_num(4,False,0,y)\n", - "\n", - " # Setting the controller in a superposition\n", - " allocate_num(1,False,0,controller)\n", - " H(controller)\n", - "\n", - " # Implementing the control logic\n", - " control_logic_2(a,b,controller,x,y)\n", - "\n", - " \n", - "qmod = create_model(main)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "qprog = synthesize(qmod)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/46696929-79f8-43c0-87e9-fdbebd48156f?version=0.40.0\n" - ] - } - ], - "source": [ - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And now when we optimize for width:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And for depth:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "qmod = set_constraints(qmod,Constraints(optimization_parameter='depth'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "So using the `within_apply` logic enabled us to reduce the optimal circuit implementation in terms of width from $20$ to $16$ and the optimal circuit depth from $398$ to $203$! " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "## Cheat Sheet" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initalizations" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "allocate(\n", - " num_qubits: CInt,\n", - " out: Output[QArray[QBit, Literal[\"num_qubits\"]]])\n", - " '''\n", - " x = QArray('x')\n", - " allocate(4,x)\n", - " '''\n", - "\n", - "allocate_num(\n", - " num_qubits: CInt,\n", - " is_signed: QParam[bool],\n", - " fraction_digits: CInt,\n", - " out: Output[QNum])\n", - "'''\n", - "x = QNum('x')\n", - "allocate_num(4,False,4,x)\n", - "'''" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Operations" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "repeat(\n", - " count: CInt,\n", - " iteration: QCallable[CInt],\n", - ")\n", - "'''\n", - "x = QArray\n", - "allocate(4,x)\n", - "repeat(x.len,lambda index: H(x))\n", - "'''\n", - "\n", - "control(\n", - " operand: QCallable,\n", - " ctrl: QArray[QBit],\n", - ") \n", - "'''\n", - "x = QArray('x')\n", - "y = QArray('y')\n", - "x = allocate(4,x)\n", - "y = allocate(4,y)\n", - "repeat(x.len,lambda i: control(lambda: X(y[i]),x[i]))\n", - "'''" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Solutions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### First Example" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def prepare_minus_state(x:QBit):\n", - " X(x)\n", - " H(x)\n", - " \n", - "@qfunc\n", - "def main(x: Output[QBit]):\n", - " allocate(1,x) # Initalize the qubit x\n", - " prepare_minus_state(x)\n", - "\n", - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Uniform Superposition" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def create_initial_state(reg: QArray[QBit]):\n", - " apply_to_all(H,reg)\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]): #TODO fill int the correct declaration here, what variables this model shoul output?\n", - " allocate(4,reg)\n", - " create_initial_state(reg)\n", - "\n", - "qprog = synthesize(create_model(main))\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prepare Bell State" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x:Output[QArray]):\n", - " prepare_bell_state(state_num=2, q=x) # psi+\n", - "\n", - "# Or:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " prepare_state(probabilities=[0,0.5,0.5,0], bound=0.01, out=x)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Parallel Addition" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " prepare_int(7,x)\n", - " \n", - " y = QNum(\"y\")\n", - " prepare_state(probabilities=[1/3,0,0,0,1/3,0,0,1/3], bound=0.01, out=y)\n", - " res|=x+y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Advanced Arithmetics" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x:Output[QNum], y: Output[QNum]):\n", - "\n", - " a = 0.5\n", - " b = 1.5\n", - " allocate_num(num_qubits=4,is_signed=False,fraction_digits=4,out=x)\n", - " hadamard_transform(x)\n", - " linear_func(a,b,x,y)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.8" - }, - "vscode": { - "interpreter": { - "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Rajana_Rama_Satya_Sai_Durga_Prasad_HW1_QClass2024.ipynb b/community/QClass_2024/Sessions/week1_QClass_workshop_with_sol.ipynb similarity index 71% rename from community/QClass_2024/Submissions/HW1/Rajana_Rama_Satya_Sai_Durga_Prasad_HW1_QClass2024.ipynb rename to community/QClass_2024/Sessions/week1_QClass_workshop_with_sol.ipynb index ea05ee27..febebef3 100644 --- a/community/QClass_2024/Submissions/HW1/Rajana_Rama_Satya_Sai_Durga_Prasad_HW1_QClass2024.ipynb +++ b/community/QClass_2024/Sessions/week1_QClass_workshop_with_sol.ipynb @@ -10,7 +10,7 @@ "\n", "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", + "The [QMOD language reference](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", "\n", "This workshop consists of step-by-step exercises. It is structured as follows:\n", "\n", @@ -24,7 +24,7 @@ "\n", "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", + "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/classiq_101/registration_installations/).\n", "\n", "### Python Qmod Exercises - General Instructions\n", "\n", @@ -32,7 +32,7 @@ "1. Make sure you define a `main` function that calls functions you create.\n", "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" + "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/reference-manual/platform/executor/). You can also execute it with the IDE after visualizing the circuit.\n" ] }, { @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -78,28 +78,13 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ExecutionJob(id='4247b766-12c5-45b3-9252-f0bd43c07074')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", "\n", - "# Your code here:\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "#execute(qprog)\n", - "show(qprog)" + "# Your code here:" ] }, { @@ -108,7 +93,7 @@ "source": [ "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", + "See also [Quantum Variables](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_variables_and_functions/).\n", "\n", "We will discuss other quantum types during the workshop.\n" ] @@ -131,37 +116,18 @@ "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" + "See also [Functions](https://docs.classiq.io/latest/reference-manual/platform/qmod/library-reference/core-library-functions/)\n" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b3d8557f-3bec-47e5-8826-c0e83e5cf652?version=0.41.1\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", - "@qfunc\n", - "def prepare_bellstate(x:QBit,y:QBit):\n", - " H(x)\n", - " CX(x,y)\n", - "@qfunc\n", - "def main(x:Output[QBit],y:Output[QBit]):\n", - " allocate(1,x)\n", - " allocate(1,y)\n", - " prepare_bellstate(x,y)\n", - " \n", - " \n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -178,30 +144,13 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/322007b5-8557-461d-b6dc-fd571b6336fc?version=0.41.1\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", - "@qfunc\n", - "def prepare_randomstate(reg: QArray[QBit]):\n", - " H(reg[0])\n", - " CX(reg[0],reg[1])\n", - " \n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(2,reg)\n", - " prepare_randomstate(reg)\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -216,35 +165,20 @@ "\n", "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", + "See also [Classical repeat](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", "\n", "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f1969b5f-9fa5-4f39-b7ca-a137dd48f26f?version=0.41.1\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", - "@qfunc\n", - "def my_hadamard_transform(reg:QArray[QBit]) -> None:\n", - " repeat(reg.len, lambda i:H(reg[i]))\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10,reg)\n", - " my_hadamard_transform(reg)\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -259,7 +193,7 @@ "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." + "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/operators/#example-2)." ] }, { @@ -273,14 +207,14 @@ "Sometimes, however, power can be simplified, thus saving computational resources.\n", "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", + "See also [Power operator](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/power/).\n", "\n", "Use the following code to generate a 2-qubit (real) unitary matrix:" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -312,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -325,25 +259,13 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ac9ea0a9-339a-4a35-a6da-c85c670ec950?version=0.41.1\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", - "@qfunc\n", - "def main(reg: Output[QArray[QBit]]) -> None:\n", - " allocate(2,reg)\n", - " power(3,lambda: unitary(unitary_matrix,reg))\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -357,7 +279,7 @@ "## Exercise 4 - User-defined Operators\n", "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", + "See also [Operators](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/operators/).\n", "\n", "Follow these guidelines:\n", "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", @@ -369,38 +291,14 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/32237109-3955-40c2-bbf6-df4607bec44a?version=0.41.1\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", "\n", - "@qfunc\n", - "def my_apply_to_all(operand: QCallable[QBit], reg: QArray[QBit]):\n", - " repeat(reg.len, lambda i:operand(reg[i]))\n", - "\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(reg:QArray[QBit]) -> None:\n", - " my_apply_to_all(lambda h:H(h),reg)\n", - " \n", - "@qfunc\n", - "def main(reg:Output[QArray[QBit]]):\n", - " allocate(10,reg)\n", - " my_hadamard_transform(reg)\n", - " \n", - "\n", - "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", "show(qprog)" @@ -415,36 +313,18 @@ "### Exercise 5a - Control Operator\n", "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" + "See also [Quantum operators](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_operations/).\n" ] }, { "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/e35293dd-9aa9-4c15-9aab-31cae4621842?version=0.41.1\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", - "from classiq.qmod.symbolic import *\n", "\n", "# Your code here:\n", - "@qfunc\n", - "def control_ry(ctrl:QBit,tgt:QBit):\n", - " control(ctrl,lambda:RY(pi/2,tgt))\n", - "\n", - "@qfunc\n", - "def main(ctrl:Output[QBit], tgt: Output[QBit]):\n", - " allocate(1,ctrl)\n", - " allocate(1,tgt)\n", - " control_ry(ctrl,tgt)\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", @@ -458,11 +338,11 @@ "### Exercise 5b - Control (\"Quantum If\")\n", "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", + "See also [Numeric types](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/quantum-types/).\n", "\n", "In QMOD this generalization is available as a native statement - control.\n", "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", + "See also [control](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/operators/).\n", "\n", "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", @@ -472,43 +352,177 @@ }, { "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/dbc85c64-6617-4d21-bd6a-9ae66c495a2e?version=0.41.1\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", - "@qfunc\n", - "def main(x:Output[QNum], tgt:Output[QBit]):\n", - " prepare_int(9,x)\n", - " allocate(1,tgt)\n", - " control(x==9, lambda:X(tgt))\n", "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", "show(qprog)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solutions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### First Example" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def prepare_minus_state(x: QBit):\n", + " X(x)\n", + " H(x)\n", + "\n", + "\n", + "@qfunc\n", + "def main(x: Output[QBit]):\n", + " allocate(1, x) # Initalize the qubit x\n", + " prepare_minus_state(x)\n", + "\n", + "\n", + "quantum_model = create_model(main)\n", + "quantum_program = synthesize(quantum_model)\n", + "show(quantum_program)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Uniform Superposition" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def create_initial_state(reg: QArray[QBit]):\n", + " apply_to_all(H, reg)\n", + "\n", + "\n", + "@qfunc\n", + "def main(\n", + " reg: Output[QArray],\n", + "): # TODO fill int the correct declaration here, what variables this model shoul output?\n", + " allocate(4, reg)\n", + " create_initial_state(reg)\n", + "\n", + "\n", + "qprog = synthesize(create_model(main))\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prepare Bell State" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def main(x: Output[QArray]):\n", + " prepare_bell_state(state_num=2, q=x) # psi+\n", + "\n", + "\n", + "# Or:\n", + "\n", + "\n", + "@qfunc\n", + "def main(x: Output[QArray[QBit]]):\n", + " prepare_state(probabilities=[0, 0.5, 0.5, 0], bound=0.01, out=x)\n", + "\n", + "\n", + "model = create_model(main)\n", + "qprog = synthesize(model)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parallel Addition" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "@qfunc\n", + "def main(res: Output[QNum]) -> None:\n", + " x = QNum(\"x\")\n", + " prepare_int(7, x)\n", + "\n", + " y = QNum(\"y\")\n", + " prepare_state(probabilities=[1 / 3, 0, 0, 0, 1 / 3, 0, 0, 1 / 3], bound=0.01, out=y)\n", + " res |= x + y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Advanced Arithmetics" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def linear_func(a: CInt, b: CInt, x: QNum, y: Output[QNum]):\n", + " y |= a * x + b\n", + "\n", + "\n", + "@qfunc\n", + "def main(x: Output[QNum], y: Output[QNum]):\n", + "\n", + " a = 0.5\n", + " b = 1.5\n", + " allocate_num(num_qubits=4, is_signed=False, fraction_digits=4, out=x)\n", + " hadamard_transform(x)\n", + " linear_func(a, b, x, y)\n", + "\n", + "\n", + "qmod = create_model(main)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.11.7 ('classiq')", "language": "python", "name": "python3" }, @@ -523,6 +537,11 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.7" + }, + "vscode": { + "interpreter": { + "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" + } } }, "nbformat": 4, diff --git a/community/QClass_2024/Sessions/week3_QClass_workshop_with_solution.ipynb b/community/QClass_2024/Sessions/week3_QClass_workshop_with_solution.ipynb deleted file mode 100644 index 1559a2a2..00000000 --- a/community/QClass_2024/Sessions/week3_QClass_workshop_with_solution.ipynb +++ /dev/null @@ -1,919 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "e7682d31-1cf2-4c6d-98b7-75fadfefb6bc", - "metadata": {}, - "source": [ - "# Quantum Software Development Journey: \n", - "# From Theory to Application with Classiq - Part 3" - ] - }, - { - "cell_type": "markdown", - "id": "01dfc0bf-5fdb-4d52-8fb4-168fc930aaff", - "metadata": {}, - "source": [ - "**Welcome to the Classiq Workshop Series for QClass 2024!**\n", - "\n", - "In this series, we will develop the skills needed to participate in quantum software development!\n", - "\n", - "- Week 1: Classiq's Basics & High-Level Functional Design\n", - "- Week 2: Using Git as a Tool for In-Team Collaboration and Open Source Contributions\n", - "- **Week 3: Introduction to Quantum Machine Learning (QML) & VQE**\n", - "- Week 4: QNN and and Advanced Applications\n", - "\n", - "**[New Classiq's documentation](https://docs.classiq.io/latest/)!**\n", - "\n", - "\n", - "\n", - "\n", - "Additional resources you should use are\n", - "- The IDE of the classiq platform at [platform.classiq.io](platform.classiq.io)\n", - "- The [community Slack of Classiq](https://short.classiq.io/join-slack) - Classiq's team will answer any question you have over there, including implementation questions\n", - "- Course's [GitHub repository](https://github.com/Classiq/classiq-library/tree/main/community/QClass_2024)\n", - "\n", - " \n", - "**Good luck!**" - ] - }, - { - "cell_type": "markdown", - "id": "4962a36e-bf41-48a2-9ad0-cbae90f43d98", - "metadata": {}, - "source": [ - "## VQE" - ] - }, - { - "cell_type": "markdown", - "id": "30587afe-3f19-4c1d-9f88-4a9083e3a158", - "metadata": {}, - "source": [ - "\n", - "The Variational Quantum Eigensolver is an algorithm that finds the minimal eigenvalue of a matrix by executing a parametric circuit (also referred to as an ansatz), estimating the expected value of the matrix for the state the circuit creates (from the distribution received by the execution), and using a classical optimizer to select the next set of parameters for the circuit, until reaching convergence (or exceeding a set amount of maximum iterations).\n", - "\n", - "The estimation of the expectation value is done on Pauli based matrices, so any matrix we want to perform this operation on, need to be decomposed into a sum of Pauli terms.\n", - "\n", - "**In this example, we will create a simple VQE algorithm that estimates the minimal eigenvalue of the following 2x2 matrix:**\n", - "\n", - "`[[1, -1], [-1, 0]] = 1/2*I + 1/2*Z - X`" - ] - }, - { - "cell_type": "markdown", - "id": "34dfc66c-b7f1-4ac5-adcb-b0acdbb53fb3", - "metadata": {}, - "source": [ - "### U Gate" - ] - }, - { - "cell_type": "markdown", - "id": "7ab65ac7-73fd-4582-bcf0-0be311e698e5", - "metadata": {}, - "source": [ - "The single-qubit gate applies phase and rotation with three Euler angles.\n", - "\n", - "Matrix representation:\n", - "\n", - "$$\n", - "U(\\gamma,\\phi,\\theta,\\lambda) = e^{i\\gamma}\\begin{pmatrix}\n", - "\\cos(\\frac{\\theta}{2}) & -e^{i\\lambda}\\sin(\\frac{\\theta}{2}) \\\\\n", - "e^{i\\phi}\\sin(\\frac{\\theta}{2}) & e^{i(\\phi+\\lambda)}\\cos(\\frac{\\theta}{2}) \\\\\n", - "\\end{pmatrix}\n", - "$$\n", - "\n", - "Parameters:\n", - "\n", - "- `theta`: `CReal`\n", - "- `phi`: `CReal`\n", - "- `lam`: `CReal`\n", - "- `gam`: `CReal`\n", - "- `target`: `QBit`" - ] - }, - { - "cell_type": "markdown", - "id": "ee7fdf75-a40b-4eb6-95c7-453b66a4aba7", - "metadata": {}, - "source": [ - "### VQE Implementation" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "df12ed0b-0f92-43c0-8a0a-6d36b12474f2", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], \n", - " [ \n", - " PauliTerm([Pauli.I], 0.5),\n", - " PauliTerm([Pauli.Z], 0.5),\n", - " PauliTerm([Pauli.X], -1)])\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QBit], angles: CArray[CReal, 3]) -> None:\n", - " allocate(1, q)\n", - " U(angles[0], angles[1], angles[2], 0, q) \n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN,\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA, # Constrained Optimization by Linear Approximation\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)" - ] - }, - { - "cell_type": "markdown", - "id": "4a973762-c597-4519-89e9-a09b0d4b47b9", - "metadata": {}, - "source": [ - "
\n", - "\n", - "NOTE\n", - "\n", - "\n", - "\n", - "Read more about the supported optimizers:[here](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/ground-state-solving/advanced-usage/solver-customization/)\n", - "
\n" - ] - }, - { - "cell_type": "markdown", - "id": "cb2528fe-9d3e-478e-88f7-c3fbb1761973", - "metadata": {}, - "source": [ - "Executing from the Classiq Platform:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "5120177b-6737-4922-bae3-d8fef9f6fcf2", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c44965b8-fb5a-4797-9aeb-741ef2559093?version=0.41.1\n" - ] - } - ], - "source": [ - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "d6e678ca-0813-4a62-a96a-7b37e61065bd", - "metadata": {}, - "source": [ - "Or directly from the SDK:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "2ed72afa-d3ab-48f1-8b1c-b1de431cff99", - "metadata": {}, - "outputs": [], - "source": [ - "res = execute(qprog)\n", - "# res.open_in_ide()\n", - "vqe_result = res.result()[0].value" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "9d7fbad5-ee44-45ef-893e-5a7632994daf", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -0.60498046875\n", - "Optimal parameters: {'angles_0': -4.289061524925964, 'angles_1': -6.274092431830335, 'angles_2': -1.1512443092629974}\n", - "Eigenstate: {'0': (0.5426173548182918+0j), '1': (0.8399800034822258+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "0e5662bb-c2e5-44a6-904a-526f9fc266cd", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "### Analytical Solution" - ] - }, - { - "cell_type": "markdown", - "id": "a74428eb-ff56-4f7f-8c3f-7d11136394ce", - "metadata": {}, - "source": [ - "- VQE is a **numerical** optimization technique used to find the ground state energy of a quantum system.\n", - "- For simple systems, an **analytical** solution can be achieved by diagonalizing the Hamiltonian matrix.\n", - "\n", - "Diagonalization is possible when the Hamiltonian can be represented as a **finite-dimensional matrix** and the matrix is ״well-behaved״ (e.g., Hermitian and non-singular). \n", - "\n", - "In summary, for small systems or simple Hamiltonians, the eigenvalues and eigenvectors can be found exactly by diagonalizing the matrix. Let's show an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "aaa82b4f-3ae3-4d61-a337-e0485d3c346a", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "H = np.array([[1, -1], [-1, 0]])\n", - "\n", - "E , v = np.linalg.eig(H)\n", - "E_min = min(E)\n", - "\n", - "v_min = np.array(v[:,np.argmin(E)])" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "886fccb5-ce0d-4594-b41f-b5b7a05cef4c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimal energy energy is: -0.6180339887498948\n" - ] - } - ], - "source": [ - "print(\"The minimal energy energy is: \",E_min)" - ] - }, - { - "cell_type": "markdown", - "id": "e2a0f981-bfc5-4944-8c01-db1cc97a95f3", - "metadata": {}, - "source": [ - "**Looks like the VQE estimated the minimum energy well!**\n", - "\n", - "Let's have another small validation, this time for the analytical solution of the eigenvalue equation:" - ] - }, - { - "cell_type": "markdown", - "id": "acdcebda-6a15-4e83-93b1-013c8d4fcf31", - "metadata": {}, - "source": [ - "$$ \\hat{H} V_{min} = E_{min} \\cdot V_{min} \\rightarrow V_{min} = \\frac{\\hat{H} V_{min}}{E_{min}} $$" - ] - }, - { - "cell_type": "markdown", - "id": "39cae87a-5de6-4303-a90a-a3fa31e9f2e7", - "metadata": {}, - "source": [ - "**Let's validate this relation!**" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "6f3107c1-7580-4682-9cdb-ebcb4fc45972", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.52573111, 0.85065081])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "v_min" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "fd646a18-cf0c-46af-918a-5e607e4e494b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.52573111, 0.85065081])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(H @ v_min)/E_min " - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "db74fb2c-6f55-4c4b-ad84-d23e97a211c7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([False, False])" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "v_min == (H @ v_min)/E_min" - ] - }, - { - "cell_type": "markdown", - "id": "8351de9e-fcd2-48f8-a2b3-b7480e93009e", - "metadata": {}, - "source": [ - "**How could it be?**" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "f3dc8319-9360-447c-b115-0fdc98e47cc0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The eigenvalue equation is validated!\n" - ] - } - ], - "source": [ - "if np.allclose((H @ v_min)/E_min, v_min):\n", - " print(\"The eigenvalue equation is validated!\")\n", - "else:\n", - " print(\"The eigenvalue equation is not validated!\")" - ] - }, - { - "cell_type": "markdown", - "id": "054aa87b-8e2b-4abc-b68b-646321532e85", - "metadata": {}, - "source": [ - "(The \"`array([False, False])`\" was due to rounding errors)" - ] - }, - { - "cell_type": "markdown", - "id": "52d61c0b-a0f9-4f7c-88b6-f4333f1d0c2c", - "metadata": {}, - "source": [ - "## Exercise - Two Qubits VQE" - ] - }, - { - "cell_type": "markdown", - "id": "29e116c2-39f0-4cb4-81da-3828b353bfe6", - "metadata": {}, - "source": [ - "Now we will practice the implementation of a similar case to the last example, but this time for two qubits, following the Hamiltonian:\n", - "\n", - "\n", - "$H = \\frac{1}{2}I \\otimes I + \\frac{1}{2}Z \\otimes Z - X \\otimes X $\n", - "\n", - "Use the last example to implement and execute VQE for this Hamiltonian." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "4b3d4130-98f6-4c92-8266-5bebb4cfdcc8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/518bc08d-8db8-4f62-819c-7153a22b7faf?version=0.41.1\n" - ] - } - ], - "source": [ - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [...]) #TODO: Complete Hamiltonian\n", - "\n", - "\n", - "@qfunc\n", - "def main(...) -> None:\n", - " #TODO: Complete the function according to the instructions, choose simple ansatz.\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN,\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "b3ef1dab-4ee6-4f96-8e85-d5a8bbd091aa", - "metadata": {}, - "source": [ - "## H₂ Molecule Problem" - ] - }, - { - "cell_type": "markdown", - "id": "b8ad3059-7e43-4ae9-9b80-4c8c5da916ae", - "metadata": {}, - "source": [ - "Now we will dive into more applicative approche of using VQE with Classiq for modeling molcoules and finding thier ground state and energy.\n", - "\n", - "**Hamiltonian for $H_2$ Molecule**\n", - "\n", - "The physical Hamiltonian for the hydrogen molecule $H_2$ in the [Born-Oppenheimer approximation](https://en.wikipedia.org/wiki/Born%E2%80%93Oppenheimer_approximation) can be expressed as (atomic units):\n", - "\n", - "$$\n", - "\\hat{H} = - \\sum_{i=1}^{2} \\frac{\\nabla_i^2}{2} - \\frac{1}{|\\mathbf{r}_1 - \\mathbf{R}_A|} - \\frac{1}{|\\mathbf{r}_2 - \\mathbf{R}_A|} - \\frac{1}{|\\mathbf{r}_1 - \\mathbf{R}_B|} - \\frac{1}{|\\mathbf{r}_2 - \\mathbf{R}_B|} + \\frac{1}{|\\mathbf{r}_1 - \\mathbf{r}_2|} + \\frac{1}{|\\mathbf{R}_A - \\mathbf{R}_B|}\n", - "$$\n", - "\n", - "Where:\n", - "- $\\mathbf{r}_1$ and $\\mathbf{r}_2$ are the positions of the two electrons.\n", - "- $\\mathbf{R}_A$ and $\\mathbf{R}_B$ are the positions of the two protons (nuclei).\n", - "- The terms represent:\n", - " - The kinetic energy of the electrons: $- \\sum_{i=1}^{2} \\frac{\\nabla_i^2}{2}$\n", - " - The electron-nucleus attractions: $- \\frac{1}{|\\mathbf{r}_1 - \\mathbf{R}_A|} - \\frac{1}{|\\mathbf{r}_2 - \\mathbf{R}_A|} - \\frac{1}{|\\mathbf{r}_1 - \\mathbf{R}_B|} - \\frac{1}{|\\mathbf{r}_2 - \\mathbf{R}_B|}$\n", - " - The electron-electron repulsion: $\\frac{1}{|\\mathbf{r}_1 - \\mathbf{r}_2|}$\n", - " - The nucleus-nucleus repulsion: $\\frac{1}{|\\mathbf{R}_A - \\mathbf{R}_B|}$\n", - " \n", - "**How can we implement such a Hamiltonian on a quantum computer?**\n", - "\n", - "In the first step of this VQE process, we will need to use:\n", - "- **Jordan-Wigner Transformation**: To map the fermionic Hamiltonian to a qubit Hamiltonian.\n", - "- **Hartree-Fock Method**: To provide an initial guess for the wavefunction.\n", - "- **UCC Ansatz**: To construct the parameterized quantum circuit that will be optimized during the VQE process.\n" - ] - }, - { - "cell_type": "markdown", - "id": "9ec42e74-c057-4aff-a3f4-b8f41c97a0f1", - "metadata": { - "jp-MarkdownHeadingCollapsed": true - }, - "source": [ - "### Imports" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "e8002d74-1dbf-4e9a-9e3c-0fd0a8d3d710", - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "# from classiq import qfunc, create_model, molecule_ucc, synthesize, show, QBit, allocate, cfunc, execute, QConstant\n", - "from classiq.qmod.builtins import MoleculeProblem, Molecule, ChemistryAtom, Position\n", - "from classiq.qmod.builtins.classical_functions import molecule_problem_to_hamiltonian\n", - "from classiq.qmod.builtins.classical_execution_primitives import vqe, molecule_ground_state_solution_post_process, save\n", - "from classiq.interface.generator.expressions.enums.chemistry import Element, FermionMapping \n", - "from classiq.interface.generator.expressions.enums import Optimizer " - ] - }, - { - "cell_type": "markdown", - "id": "f966ab33-bfdd-4f2e-9e63-5cb5751e1797", - "metadata": {}, - "source": [ - "### implementation" - ] - }, - { - "cell_type": "markdown", - "id": "c6cbd8ef-19d3-40d6-97c0-8b2c22f226e3", - "metadata": {}, - "source": [ - "- We will define the `Molecule` structure, as well as the `MoleculeProblem` we are trying to solve.\n", - "\n", - "- **The built-in functions we will use here will generate the Hamiltonian and the parameterized circuit for us.**" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "87f817b3-f03c-47ee-94c5-4ea0feaf6bfb", - "metadata": {}, - "outputs": [], - "source": [ - "molecule_H2 = Molecule(\n", - " spin=1,\n", - " charge=0,\n", - " atoms=[\n", - " ChemistryAtom(element=Element.H, position=Position(x=0.0, y=0.0, z=0)),\n", - " ChemistryAtom(element=Element.H, position=Position(x=0.0, y=0.0, z=0.735)), # Angstrom\n", - " ]\n", - ")\n", - "\n", - "\n", - "chemistry_problem = MoleculeProblem(\n", - " molecule=molecule_H2,\n", - " mapping=FermionMapping.JORDAN_WIGNER, #'BRAVYI_KITAEV'\n", - " z2_symmetries=False, # If `z2_symmetries=False`, 4 qubits need to be allocated in main\n", - " freeze_core=True,\n", - " remove_orbitals=[]\n", - ")\n", - "\n", - "molecule_problem = QConstant(\"molecule_problem\", MoleculeProblem, chemistry_problem)\n", - "\n", - "@qfunc\n", - "def main():\n", - " q = QArray(\"q\")\n", - " allocate(4,q) # allocate 4 qubits if `z2_symmetries=False`, else: allocate 1 qubit\n", - " molecule_hartree_fock(molecule_problem,q)\n", - " molecule_ucc(molecule_problem = molecule_problem,excitations=[1,2],qbv=q)\n", - "\n", - "\n", - "@cfunc\n", - "def cmain():\n", - " ham = molecule_problem_to_hamiltonian(molecule_problem)\n", - " vqe_result = vqe(\n", - " hamiltonian=(ham),\n", - " maximize=False,\n", - " initial_point=[],\n", - " optimizer=Optimizer.COBYLA, \n", - " max_iteration=100,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0)\n", - " molecule_result = molecule_ground_state_solution_post_process(molecule_problem,vqe_result)\n", - " save({\"vqe_res\": vqe_result, \"ham\": ham, 'molecule_result': molecule_result}) \n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "25c49b37-cdab-4382-9bd8-1f2ceefe2b72", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/20721c4e-d449-4ee1-8aa4-7497ec8b20a5?version=0.41.1\n" - ] - } - ], - "source": [ - "qmod = create_model(main,classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "07067cd2-caec-4a83-9abb-06b12695d97f", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "execution.open_in_ide()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "3eac8218-ef81-4255-af2c-e2e9666c3197", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "list" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(res)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "297dc43d-d95e-439e-8ec1-0eadf0bfda8c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(res)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "37051ac4-817d-4f0e-a112-c31618b4878d", - "metadata": {}, - "outputs": [], - "source": [ - "vqe_result = res[0].value \n", - "hamiltonian = res[1].value\n", - "total_energy = res[2].value['total_energy'] # nuclear_repulsion_energy + vqe_energy\n", - "nuclear_energy = res[2].value['nuclear_repulsion_energy']" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "9efe5a16-4e9e-417e-80ab-7d88d8bf25c5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.857821819076969 Ha\n", - "Nuclear repulsion energy: 0.7199689944489797 Ha\n", - "Optimal parameters: {'param_0': -3.1874228460829723, 'param_1': 0.013694712771728136, 'param_2': 0.11708980402134109}\n", - "Eigenstate: {'0110': (0.038273277230987154+0j), '1010': (0.08838834764831845+0j), '0101': (0.9953505192895616+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy} Ha\") # vqe_energy WITHOUT nuclear_repulsion_energy\n", - "print(f\"Nuclear repulsion energy: {nuclear_energy} Ha\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "980c8ab0-88d4-43cf-84b9-7614b4087771", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'pauli': [0, 0, 0, 0], 'coefficient': -0.8105479805373275},\n", - " {'pauli': [0, 0, 0, 3], 'coefficient': 0.17218393261915557},\n", - " {'pauli': [0, 0, 3, 0], 'coefficient': -0.2257534922240239},\n", - " {'pauli': [0, 3, 0, 0], 'coefficient': 0.17218393261915554},\n", - " {'pauli': [3, 0, 0, 0], 'coefficient': -0.22575349222402397},\n", - " {'pauli': [0, 0, 3, 3], 'coefficient': 0.12091263261776627},\n", - " {'pauli': [0, 3, 0, 3], 'coefficient': 0.16892753870087907},\n", - " {'pauli': [2, 2, 2, 2], 'coefficient': 0.04523279994605784},\n", - " {'pauli': [1, 1, 2, 2], 'coefficient': 0.04523279994605784},\n", - " {'pauli': [2, 2, 1, 1], 'coefficient': 0.04523279994605784},\n", - " {'pauli': [1, 1, 1, 1], 'coefficient': 0.04523279994605784},\n", - " {'pauli': [3, 0, 0, 3], 'coefficient': 0.16614543256382414},\n", - " {'pauli': [0, 3, 3, 0], 'coefficient': 0.16614543256382414},\n", - " {'pauli': [3, 0, 3, 0], 'coefficient': 0.17464343068300445},\n", - " {'pauli': [3, 3, 0, 0], 'coefficient': 0.12091263261776627}]" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "hamiltonian # pauli:[0,1,2,3] == [I,X,Y,Z]" - ] - }, - { - "cell_type": "markdown", - "id": "4d868399-b5af-46ca-b2da-c0664ae1a827", - "metadata": {}, - "source": [ - "**Finally, the total energy of the hydrogen molecule is estimated as:**" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "a8b7eba2-3be6-453f-a8f4-bfd3feba4d62", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The total energy is: -1.1378528246279895 Ha\n" - ] - } - ], - "source": [ - "print(f\"The total energy is: {total_energy} Ha\")" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "e1a8f4ef-d837-4c57-9992-a907677b4ae4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "total_energy == vqe_result.energy + nuclear_energy" - ] - }, - { - "cell_type": "markdown", - "id": "0d3d663a-2484-49ba-9400-852d8de141b7", - "metadata": {}, - "source": [ - "what is the value by theory?" - ] - }, - { - "cell_type": "markdown", - "id": "a3f881af-3293-454c-aee0-04d1f300c844", - "metadata": {}, - "source": [ - "**In the third homework assignment, you will compare and validate these results by using 2 qubits Hamiltonian!**" - ] - }, - { - "cell_type": "markdown", - "id": "63ad2936-5d73-4bd4-8f91-c62e4cc20f40", - "metadata": {}, - "source": [ - "## Read More" - ] - }, - { - "cell_type": "markdown", - "id": "ce12c5cd-6382-451a-a547-2f564bac546d", - "metadata": {}, - "source": [ - "\n", - "- [**VQE Method for Molecule Energy Solver**](https://docs.classiq.io/latest/explore/built_in_apps/chemistry/chemistry/#2-constructing-and-synthesizing-a-ground-state-solver)\n", - " - This link provides a detailed demonstration of how to use the `construct_chemistry_model` function, which constructs a VQE model for Molecule eigensolver.\n", - "\n", - "- [**Combinatorial Optimization using QAOA**](https://docs.classiq.io/latest/explore/applications/optimization/electric_grid_optimization/electric_grid_optimization/)\n", - " - This link covers the use of the Quantum Approximate Optimization Algorithm (QAOA) for combinatorial optimization problems, with a specific example on Electric Grid Optimization.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "0213aef6-bd41-4c0a-97e6-c5df3dfb13ab", - "metadata": {}, - "source": [ - "## Solution - Two Qubits VQE" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1e12cba4-2e15-46a9-8d2f-852eaa5e135d", - "metadata": {}, - "outputs": [], - "source": [ - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], \n", - " [ \n", - " PauliTerm([Pauli.I, Pauli.I], 0.5),\n", - " PauliTerm([Pauli.Z, Pauli.Z], 0.5),\n", - " PauliTerm([Pauli.X, Pauli.X], -1)\n", - " ])\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN,\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.8" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Submissions/HW1/Adrabi_Abderrahim_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Adrabi_Abderrahim_HW1_QClass2024.ipynb deleted file mode 100644 index e70fb0df..00000000 --- a/community/QClass_2024/Submissions/HW1/Adrabi_Abderrahim_HW1_QClass2024.ipynb +++ /dev/null @@ -1,549 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "A5UaTY6uX17I" - }, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "code", - "source": [ - "!pip install classiq -q\n" - ], - "metadata": { - "id": "3lOvygcaaxcs" - }, - "execution_count": 1, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CbyA4CPTX17S" - }, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "3hwfKJcwX17T" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PQe097xGX17V" - }, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "5DB2R-zpX17W", - "outputId": "671c1993-ec71-4132-de4f-025245dcae7c" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.10/dist-packages/classiq/_internals/authentication/token_manager.py:96: UserWarning: Device is already registered.\n", - "Generating a new refresh token should only be done if the current refresh token is compromised.\n", - "To do so, set the overwrite parameter to true\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "authenticate()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "JUz7NVwHX17W" - }, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "H6PIPNDYX17Y" - }, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "fp87ynDWX17Y" - }, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "dH9Q2OBYX17Z" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def bell_pair(q1: QBit, q2: QBit) -> None:\n", - " H(target=q1)\n", - " CX(control=q1, target=q2)\n", - "\n", - "@qfunc\n", - "def main(q1: Output[QBit], q2: Output[QBit]) -> None:\n", - " allocate(1, q1)\n", - " allocate(1, q2)\n", - " bell_pair(q1, q2)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6tmahGgDX17a" - }, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "xnpluoDGX17b" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def bell_pair(q: QArray[QBit]) -> None:\n", - " H(target=q[0])\n", - " CX(control=q[0], target=q[1])\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(2, q)\n", - " bell_pair(q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "SgkMLf_QX17c" - }, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "5aoM-B_yX17e" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "def my_hadamard_transform(qubits: QArray[QBit]) -> None:\n", - " repeat(qubits.len, lambda i: H(target=qubits[i]))\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(10, q)\n", - " my_hadamard_transform(q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "N4gV1zb3X17f" - }, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wbjYA8l5X17g" - }, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "DIK2uNZ-X17h" - }, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ca-iHEpSX17i" - }, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "v1a_DiE3X17j" - }, - "outputs": [], - "source": [ - "#def unitary(\n", - "# elements: CArray[CArray[CReal]],\n", - "# target: QArray[QBit],\n", - "#) -> None:\n", - "# pass" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "y1IX9X87X17k" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def punitary(q: QArray[QBit]) -> None:\n", - " power(3, lambda :unitary(unitary_matrix, q))\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(2, q)\n", - " punitary(q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "e5JECuEYX17l" - }, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "Vm8Nyfe_X17l" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_apply_to_all(op: QCallable[QBit], q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: op(q[i]))\n", - "\n", - "def my_hadamard_transform(qubits: QArray[QBit]) -> None:\n", - " my_apply_to_all(H, qubits)\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(10, q)\n", - " my_hadamard_transform(q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "0JbdST5XX17n" - }, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "_pu3mGjSX17n" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "import numpy as np\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def ry_control(control_bit: QBit, target: QBit) -> None:\n", - " control(control_bit, lambda: RY(np.pi/2, target=target))\n", - "\n", - "@qfunc\n", - "def main(control_bit: Output[QBit], target: Output[QBit]) -> None:\n", - " allocate(1, control_bit)\n", - " allocate(1, target)\n", - " ry_control(control_bit, target)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "i_eTlLHcX17o" - }, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "8aTWDeQ2X17p" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], q: Output[QBit]) -> None:\n", - " prepare_int(9, x)\n", - " allocate(1, q)\n", - " control(x == 9, lambda: X(q))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "OzaHP7gMOQMZ" - }, - "execution_count": null, - "outputs": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.8" - }, - "colab": { - "provenance": [], - "include_colab_link": true - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/community/QClass_2024/Submissions/HW1/Amon_Koike_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Amon_Koike_HW1_QClass2024.ipynb deleted file mode 100644 index 9fb32ec7..00000000 --- a/community/QClass_2024/Submissions/HW1/Amon_Koike_HW1_QClass2024.ipynb +++ /dev/null @@ -1,561 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/37637729-76c0-4416-ba08-f31362be6ad1?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/872f0108-4b2c-4109-98de-1b20df112537?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def create_bell_pair(q0: QBit, q1: QBit):\n", - " H(q0) # Apply the Hadamard gate to q0\n", - " CX(q0, q1) # Apply the CNOT gate with q0 as control and q1 as target\n", - " \n", - "@qfunc\n", - "def main(q0: Output[QBit],q1: Output[QBit]):\n", - " allocate(1, q0) # 量子ビットq0を初期化\n", - " allocate(1, q1) # 量子ビットq1を初期化\n", - " create_bell_pair(q0, q1) # Create the Bell pair using the defined function\n", - " \n", - "\n", - "# メイン関数\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f027ebbc-ad17-4341-81f7-a3ba9b892af9?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "# Bell状態を生成する関数を定義\n", - "@qfunc\n", - "def create_bell_pair(q: QArray[QBit]):\n", - " H(q[0]) # q[0]にアダマールゲートを適用\n", - " CX(q[0], q[1]) # q[0]を制御ビット、q[1]をターゲットビットとしてCNOTゲートを適用\n", - "\n", - "# メイン関数を定義\n", - "@qfunc\n", - "def main(q: Output[QArray]):\n", - " allocate(2,q)\n", - " create_bell_pair(q) # Bell状態を生成\n", - " \n", - " \n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0177805c-2140-4d5e-b99a-a9596942d9c3?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(qubits: QArray[QBit]):\n", - " repeat(qubits.len, lambda i: H(qubits[i]))\n", - " \n", - "@qfunc\n", - "def main(qubits: Output[QNum]):\n", - " num_qubits = 10\n", - " allocate(num_qubits,qubits)\n", - " my_hadamard_transform(qubits)\n", - " \n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f2f26859-1f4f-47e4-a6fa-efd87a784966?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "# Your code here:\n", - "# ユニタリ行列の3乗を計算\n", - "unitary_matrix_cubed = np.linalg.matrix_power(qr_unitary, 3)\n", - "unitary_matrix_cubed_constant = QConstant(\"unitary_matrix_cubed\", List[List[float]], unitary_matrix_cubed.tolist())\n", - "\n", - "# モデルを作成する関数の定義\n", - "@qfunc\n", - "def main(qubits0: Output[QNum],qubits1: Output[QNum]):\n", - " num_qubits = 2\n", - " allocate(num_qubits,qubits0) # 2量子ビット変数を定義\n", - " allocate(num_qubits,qubits1) # 2量子ビット変数を定義\n", - " # ユニタリ行列を適用\n", - " unitary(unitary_matrix, qubits0)\n", - "\n", - " unitary(unitary_matrix_cubed_constant, qubits1)\n", - "\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/2a08e6f2-8f6d-4e83-9bf0-709d93c87d04?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "# Define the function to apply a single-qubit operation to all qubits\n", - "@qfunc\n", - "def my_apply_to_all(qubits: QArray[QBit]):\n", - " apply_to_all(H, qubits)\n", - "\n", - "# Re-implement my_hadamard_transform using my_apply_to_all\n", - "@qfunc\n", - "def my_hadamard_transform(qubits: QArray[QBit]):\n", - " my_apply_to_all(qubits)\n", - "\n", - "@qfunc\n", - "def main(qubits: Output[QNum]):\n", - " num_qubits = 10\n", - " allocate(num_qubits,qubits)\n", - " my_hadamard_transform(qubits)\n", - "\n", - "# Create and synthesize the model\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b481b27f-dff7-45f4-8a36-2c25ba474b8b?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "from classiq.qmod.symbolic import pi\n", - "\n", - "\n", - "# メイン関数を定義\n", - "@qfunc\n", - "def main(target: Output[QBit]):\n", - " # 2つのシングルキュービット変数を作成\n", - " num_qubits = 1\n", - " qba = QArray(\"qba\")\n", - " allocate(num_qubits, qba)\n", - " allocate(num_qubits,target) # 2量子ビット変数を定義\n", - "\n", - " # qubits0をコントロールキュービットとして、qubits1にRYゲートを適用\n", - " control(qba, lambda: RY(pi / 2, target))\n", - "\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ff850d78-941b-43f8-b431-d8ccc3a92b71?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum])-> None:\n", - " # 2つのシングルキュービット変数を作成\n", - " \n", - " prepare_int(9, x)\n", - " \n", - " \n", - " # QBit型の出力変数qを宣言\n", - " qbit = Output[QNum](\"qbit\")\n", - " allocate(1,qbit)\n", - " # xが9である条件の下でqbitを反転させる\n", - " control(ctrl= x == 9, operand=lambda: X(qbit))\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Aniekan_Afangideh_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Aniekan_Afangideh_HW1_QClass2024.ipynb deleted file mode 100644 index 48bac6a8..00000000 --- a/community/QClass_2024/Submissions/HW1/Aniekan_Afangideh_HW1_QClass2024.ipynb +++ /dev/null @@ -1,567 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0217ea7a-3f50-4498-b139-ab68ff8a1101?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f0770ecf-0463-46f4-b97b-3c7326ff1aad?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_function(x:QBit, y:QBit):\n", - " H(x)\n", - " CX(x, y)\n", - "\n", - "@qfunc\n", - "def main(x: Output[QBit], y: Output[QBit]):\n", - " allocate(1,x)\n", - " allocate(1,y)\n", - " my_function(x,y)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/eff4d409-98f8-4608-b2c5-1e84d91d2427?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_function(reg: QArray[QBit]):\n", - " H(reg[0])\n", - " CX(reg[0], reg[1])\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(2,reg)\n", - " my_function(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/00c3f76a-8570-44d9-ac1d-e8d745c0da98?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_hadamard_transform(reg: QArray[QBit]):\n", - " repeat(reg.len, lambda i: H(reg[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10, reg)\n", - " my_hadamard_transform(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/3b242d63-67db-4482-aec6-a3761f48a70f?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def unitary1(elements: QArray[QBit]):\n", - " apply_to_all(X, elements)\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(2,reg)\n", - " unitary1(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "## Has a gate count of 2" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/03db2ec5-3f57-48cc-9d61-06184d25a9c8?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(2,reg)\n", - " unitary1(reg)\n", - " unitary1(reg)\n", - " unitary1(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "## Has a gate count of 6 " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d7e0654e-273e-4193-ac8a-f274b276e360?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_apply_to_all(my_operand: QCallable[QBit], q: QArray[QBit]):\n", - " #apply_to_all(H, q)\n", - " repeat(q.len, lambda i: H(q[i]))\n", - "\n", - "def my_operand(q: QBit):\n", - " H(q)\n", - " \n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10, reg)\n", - " my_apply_to_all(my_operand, reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/78ab17bf-8e0f-4a02-b280-b6f237c1cbaf?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from math import pi\n", - "# Your code here:\n", - "@qfunc\n", - "def my(my_operand: QCallable[CReal, QBit], target: QBit):\n", - " H(target)\n", - " my_operand(pi / 2, target)\n", - " \n", - "def my_operand(angle: CReal, target: QBit) -> None:\n", - " RY(angle, target)\n", - "\n", - "@qfunc\n", - "def main(r:Output[QBit]) -> None:\n", - " #q = QBit(\"q\")\n", - " allocate(1,r)\n", - " my(my_operand, r)\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/36761b29-e064-4ed2-a2e4-8b178d5b9f2c?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def cont(target: QBit):\n", - " #n = QNum('n')\n", - " X(target)\n", - " \n", - "@qfunc\n", - "def main(target: Output[QArray[QBit]], x: Output[QBit]):\n", - " #n = QNum('n')\n", - " allocate(1,x)\n", - " prepare_int(9,target)\n", - " control(ctrl =target, operand=lambda: X(x))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "# The extra qubit X still remains a zero" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Christopher_vanBommel_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Christopher_vanBommel_HW1_QClass2024.ipynb deleted file mode 100644 index 2610ea98..00000000 --- a/community/QClass_2024/Submissions/HW1/Christopher_vanBommel_HW1_QClass2024.ipynb +++ /dev/null @@ -1,805 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "haTRJlbEXnja" - }, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "wT46ACRRX9dc", - "outputId": "7c30145b-bc08-4815-9b52-0594a1863d13" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting classiq\n", - " Downloading classiq-0.41.1-py3-none-any.whl (398 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m398.1/398.1 kB\u001b[0m \u001b[31m2.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting ConfigArgParse<2.0.0,>=1.5.3 (from classiq)\n", - " Downloading ConfigArgParse-1.7-py3-none-any.whl (25 kB)\n", - "Collecting Pyomo<6.6,>=6.5 (from classiq)\n", - " Downloading Pyomo-6.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.7 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting black<25.0,>=24.0 (from classiq)\n", - " Downloading black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.8 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m10.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting httpx<1,>=0.23.0 (from classiq)\n", - " Downloading httpx-0.27.0-py3-none-any.whl (75 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m4.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: keyring<24.0.0,>=23.5.0 in /usr/lib/python3/dist-packages (from classiq) (23.5.0)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (3.7.1)\n", - "Collecting networkx<3.0.0,>=2.5.1 (from classiq)\n", - " Downloading networkx-2.8.8-py3-none-any.whl (2.0 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m10.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: numexpr<3.0.0,>=2.7.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.10.0)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.25.2)\n", - "Collecting packaging<23.0,>=22.0 (from classiq)\n", - " Downloading packaging-22.0-py3-none-any.whl (42 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m1.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: pandas<3.0.0,>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.0.3)\n", - "Requirement already satisfied: plotly<6.0.0,>=5.7.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (5.15.0)\n", - "Collecting pydantic<2.0.0,>=1.9.1 (from classiq)\n", - " Downloading pydantic-1.10.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: scipy<2.0.0,>=1.10.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.11.4)\n", - "Collecting sympy<1.11.0,>=1.9.0 (from classiq)\n", - " Downloading sympy-1.10.1-py3-none-any.whl (6.4 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m13.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: tabulate<1,>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from classiq) (0.9.0)\n", - "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (8.1.7)\n", - "Collecting mypy-extensions>=0.4.3 (from black<25.0,>=24.0->classiq)\n", - " Downloading mypy_extensions-1.0.0-py3-none-any.whl (4.7 kB)\n", - "Collecting pathspec>=0.9.0 (from black<25.0,>=24.0->classiq)\n", - " Downloading pathspec-0.12.1-py3-none-any.whl (31 kB)\n", - "Requirement already satisfied: platformdirs>=2 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.2.2)\n", - "Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (2.0.1)\n", - "Requirement already satisfied: typing-extensions>=4.0.1 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.11.0)\n", - "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7.1)\n", - "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (2024.2.2)\n", - "Collecting httpcore==1.* (from httpx<1,>=0.23.0->classiq)\n", - " Downloading httpcore-1.0.5-py3-none-any.whl (77 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m4.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7)\n", - "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (1.3.1)\n", - "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx<1,>=0.23.0->classiq)\n", - " Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m5.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.2.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.51.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.5)\n", - "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (9.4.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.1.2)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2023.4)\n", - "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2024.1)\n", - "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from plotly<6.0.0,>=5.7.0->classiq) (8.3.0)\n", - "Collecting ply (from Pyomo<6.6,>=6.5->classiq)\n", - " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.3.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n", - "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx<1,>=0.23.0->classiq) (1.2.1)\n", - "Installing collected packages: ply, sympy, Pyomo, pydantic, pathspec, packaging, networkx, mypy-extensions, h11, ConfigArgParse, httpcore, black, httpx, classiq\n", - " Attempting uninstall: sympy\n", - " Found existing installation: sympy 1.12\n", - " Uninstalling sympy-1.12:\n", - " Successfully uninstalled sympy-1.12\n", - " Attempting uninstall: pydantic\n", - " Found existing installation: pydantic 2.7.1\n", - " Uninstalling pydantic-2.7.1:\n", - " Successfully uninstalled pydantic-2.7.1\n", - " Attempting uninstall: packaging\n", - " Found existing installation: packaging 24.0\n", - " Uninstalling packaging-24.0:\n", - " Successfully uninstalled packaging-24.0\n", - " Attempting uninstall: networkx\n", - " Found existing installation: networkx 3.3\n", - " Uninstalling networkx-3.3:\n", - " Successfully uninstalled networkx-3.3\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "torch 2.3.0+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-nccl-cu12==2.20.5; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n", - "\u001b[0mSuccessfully installed ConfigArgParse-1.7 Pyomo-6.5.0 black-24.4.2 classiq-0.41.1 h11-0.14.0 httpcore-1.0.5 httpx-0.27.0 mypy-extensions-1.0.0 networkx-2.8.8 packaging-22.0 pathspec-0.12.1 ply-3.11 pydantic-1.10.15 sympy-1.10.1\n", - "Your user code: LLLV-QHKZ\n", - "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=LLLV-QHKZ\n" - ] - } - ], - "source": [ - "!pip install -U classiq\n", - "import classiq\n", - "classiq.authenticate()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "xx6lnn2cXnjf" - }, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "4MgbcApjXnjg" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "alMuna_dXnji" - }, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "IQxa0bcYXnji", - "outputId": "a8ef8885-f5cf-49c8-f9a4-9fcdd5bdecf7" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8d62c44e-718d-4970-834d-e49f70e4d73c?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "iaSDsxK5Xnji" - }, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hL3SqukJXnji" - }, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Tf51uPvyXnjj" - }, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Ae8tXRP2Xnjj", - "outputId": "7c47f41d-da85-46da-f943-f62fd02e5883" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b9330836-bf8b-4d95-84ca-33e86871e3cb?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def Bell(x: QBit, y: QBit):\n", - " H(x)\n", - " CX(x, y)\n", - "\n", - "@qfunc\n", - "def main(x: Output[QBit], y: Output[QBit]):\n", - " allocate(1, x)\n", - " allocate(1, y)\n", - " Bell(x, y)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "H6tPltPXXnjj" - }, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "spi56_ozXnjk", - "outputId": "a34ef716-7696-48b2-f487-302ec2a47a9a" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/427bdb0f-9676-4b34-b49b-231a77bf65fd?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def Bell(z: QArray[QBit]):\n", - " H(z[0])\n", - " CX(z[0], z[1])\n", - "\n", - "@qfunc\n", - "def main(z: Output[QArray[QBit]]):\n", - " allocate(2, z)\n", - " Bell(z)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bqj7SyQQXnjk" - }, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "kFHSHCRAXnjk", - "outputId": "0eb23721-87d6-46b2-a496-ea244daa3da5" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/67ee8258-2081-498b-977c-01009209ec9d?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_hadamard_transform(x: QArray[QBit]):\n", - " repeat(x.len, lambda i: H(x[i]))\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(10, x)\n", - " my_hadamard_transform(x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "udXSlG-NXnjl" - }, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "cVHxdVp2Xnjl" - }, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "UUVK2pMQXnjl" - }, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "m1fL4VdZXnjl" - }, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "Q0JakyBAXnjl" - }, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/67a8427a-8109-4ea1-b79e-cf0fd11e0893?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(2, x)\n", - " unitary(unitary_matrix, x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "L-SoXalTXnjl", - "outputId": "1a399db3-589d-40f5-bb4f-023edad372d1" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/2fd1b0ca-b88b-41a5-9f25-cd98c3985d05?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(2, x)\n", - " power(3, lambda: unitary(elements=unitary_matrix, target=x))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bkDaXbGSXnjm" - }, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "6-XOgBK4Xnjm", - "outputId": "833d12db-d9c3-4fea-88dd-6c2fa169cb9b" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/64fbda62-141f-4f37-9f61-4e40e65953db?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_apply_to_all(q: QArray[QBit], gate: QCallable[QBit]):\n", - " repeat(q.len, lambda i: gate(q[i]))\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]):\n", - " allocate(10, q)\n", - " my_apply_to_all(q, H)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Pv0EFjDDXnjm" - }, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "2JBmYyw1Xnjm", - "outputId": "145a176f-baf1-42bf-e769-44c87cf2a1db" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/827bf4ef-67c7-47e0-af8e-210b26750b9f?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_CRY(x: QBit, y: QBit):\n", - " control(x, lambda: RY(np.pi/2, y))\n", - "\n", - "@qfunc\n", - "def main(x: Output[QBit], y: Output[QBit]):\n", - " allocate(1, x)\n", - " allocate(1, y)\n", - " my_CRY(x, y)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "NmrOf6m3Xnjm" - }, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/bf34b793-e556-4392-a264-501908e54a76?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum]):\n", - " prepare_int(9, x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/fc015ca6-0c52-4940-9b28-6a7c1ada3bc4?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QBit]):\n", - " prepare_int(9, x)\n", - " allocate(1, y)\n", - " control (x == 9, lambda: X(y))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "mFH2c5mSXnjn", - "outputId": "5705f261-c2c4-439c-e7de-c7b8e178c270" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/92e55dfb-f4ae-4399-81be-19183860918f?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QBit]):\n", - " prepare_int(9, x)\n", - " allocate(1, y)\n", - " control (x == 8, lambda: X(y))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.3" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/community/QClass_2024/Submissions/HW1/Christos_Koromilas_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Christos_Koromilas_HW1_QClass2024.ipynb deleted file mode 100644 index e2913c39..00000000 --- a/community/QClass_2024/Submissions/HW1/Christos_Koromilas_HW1_QClass2024.ipynb +++ /dev/null @@ -1,566 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "dwave-cloud-client 0.11.4 requires pydantic<3,>=2, but you have pydantic 1.10.16 which is incompatible.\n", - "poetry 1.8.3 requires keyring<25.0.0,>=24.0.0, but you have keyring 23.13.1 which is incompatible.\n", - "poetry 1.8.3 requires packaging>=23.1, but you have packaging 22.0 which is incompatible.\n" - ] - } - ], - "source": [ - "!pip install -U -q classiq" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Your user code: LMFG-TPCJ\n", - "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=LMFG-TPCJ\n" - ] - } - ], - "source": [ - "import classiq\n", - "classiq.authenticate()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/7e889e54-69b5-4ee1-9572-7b13e0343234?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/eb04c776-477b-45ba-8ba1-ee5c996e7965?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def create_bell_pair(q1: QBit, q2: QBit) -> None:\n", - " H(target=q1)\n", - " CX(control=q1, target=q2)\n", - "@qfunc\n", - "def main(res1: Output[QBit], res2: Output[QBit]) -> None:\n", - " allocate(1, res1) \n", - " allocate(1, res2) \n", - " create_bell_pair(q1=res1, q2=res2)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5f7efea8-6c98-47db-98b3-05e067722517?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def create_bell_pair(qubits: QArray) -> None:\n", - " H(target=qubits[0])\n", - " CX(control=qubits[0], target=qubits[1])\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray]) -> None:\n", - " allocate(2, res) # Properly allocating qubits\n", - " create_bell_pair(qubits=res)\n", - " return res\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/3be67af9-6bb3-4314-8686-e2e6dfe4df27?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: H(q[i]))\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(10, q)\n", - " my_hadamard_transform(q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0036f036-0ede-44f5-aa3f-6b876d08467a?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(2, q)\n", - " power(3, lambda: unitary(unitary_matrix, q))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ba045335-2706-4ee2-80df-8886f1cf67b4?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_apply_to_all(operand: QCallable[QBit], q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: operand(q[i]))\n", - "\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]) -> None:\n", - " my_apply_to_all(lambda t: H(t), q)\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(10, q)\n", - " my_hadamard_transform(q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/43018914-1bb0-4c33-b819-538d648255f6?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import pi\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_controlled_ry(control_bit: QBit, target: QBit) -> None:\n", - " control(control_bit, lambda: RY(pi / 2, target))\n", - "\n", - "\n", - "@qfunc\n", - "def main(control_bit: Output[QBit], target: Output[QBit]) -> None:\n", - " allocate(1, control_bit)\n", - " allocate(1, target)\n", - " my_controlled_ry(control_bit, target)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/2682e185-f4bf-4ff7-a21a-37ddca29e45e?version=0.42.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], target: Output[QBit]) -> None:\n", - " prepare_int(9, x)\n", - " allocate(1, target)\n", - " control(x == 9, lambda: X(target))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Claudia_Zendejas-Morales_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Claudia_Zendejas-Morales_HW1_QClass2024.ipynb deleted file mode 100644 index 823fe701..00000000 --- a/community/QClass_2024/Submissions/HW1/Claudia_Zendejas-Morales_HW1_QClass2024.ipynb +++ /dev/null @@ -1,823 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ce259560-876c-40a5-8974-f7add71592d7?version=0.41.2\n" - ] - } - ], - "source": [ - "show(quantum_program) # let's see the quantum program in the online IDE" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 0.0}: 1029, {'res': 1.0}: 1019]\n" - ] - } - ], - "source": [ - "job = execute(quantum_program) # let's execute the quantum program\n", - "\n", - "# job.open_in_ide() # to view in IDE\n", - "\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we see the result state ('res') and how many counts for each one (in front fo the state)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/87a1d782-0826-4337-b59a-4ef7616cf3fc?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def prepare_my_bell_state(x:QBit, y:QBit) -> None:\n", - " H(x)\n", - " CX(x, y)\n", - "\n", - "@qfunc\n", - "def main(x: Output[QBit], y: Output[QBit]) -> None:\n", - " allocate(1, x)\n", - " allocate(1, y)\n", - " prepare_my_bell_state(x, y)\n", - "\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'x': 0.0, 'y': 0.0}: 1042, {'x': 1.0, 'y': 1.0}: 1006]\n" - ] - } - ], - "source": [ - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we can see that we obtained the states '00' and '11' with half the probability for each one" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f0a77a16-a5ba-4e0e-941a-d0d2171efcfd?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def prepare_my_bell_state_2(reg: QArray[QBit]) -> None:\n", - " H(reg[0])\n", - " CX(reg[0], reg[1])\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None:\n", - " allocate(2, reg)\n", - " prepare_my_bell_state_2(reg)\n", - "\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'reg': 3.0}: 1047, {'reg': 0.0}: 1001]\n" - ] - } - ], - "source": [ - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we can see that we obtained the states '00' (=0) and '11' (=3) with half the probability for each one" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/120d57a5-c745-4e4b-828e-165606094fbd?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(reg: QArray[QBit]) -> None:\n", - " repeat(reg.len, lambda i: H(reg[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None: \n", - " allocate(10, reg)\n", - " my_hadamard_transform(reg)\n", - "\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[1, 2, 3, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 38, 40, 41, 42, 43, 44, 45, 46, 47, 49, 50, 51, 52, 53, 54, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 79, 80, 81, 82, 83, 84, 85, 86, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 102, 103, 104, 105, 106, 107, 109, 110, 111, 112, 114, 115, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 153, 154, 155, 157, 158, 159, 160, 161, 162, 163, 165, 166, 167, 169, 170, 171, 172, 173, 174, 175, 176, 177, 179, 180, 182, 183, 184, 185, 186, 188, 189, 190, 191, 192, 194, 195, 196, 197, 198, 200, 201, 203, 204, 205, 206, 207, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 221, 222, 223, 224, 225, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 249, 250, 251, 252, 253, 254, 256, 257, 258, 259, 260, 262, 263, 264, 265, 266, 267, 268, 269, 271, 272, 273, 274, 276, 277, 278, 279, 280, 281, 282, 283, 284, 286, 287, 289, 290, 291, 292, 293, 294, 295, 296, 297, 299, 300, 301, 302, 303, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 318, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 336, 337, 338, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 353, 354, 355, 356, 357, 358, 360, 361, 362, 363, 364, 365, 366, 367, 370, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 383, 384, 385, 386, 387, 388, 389, 390, 391, 393, 395, 399, 400, 402, 403, 404, 405, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 426, 428, 429, 430, 431, 432, 434, 435, 436, 437, 438, 439, 440, 443, 444, 445, 446, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 461, 462, 463, 464, 465, 466, 467, 468, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 487, 489, 490, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 503, 504, 506, 507, 510, 511, 512, 513, 514, 516, 517, 518, 519, 520, 522, 524, 525, 526, 527, 529, 530, 531, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 604, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 626, 627, 628, 629, 632, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 652, 653, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 671, 673, 674, 675, 677, 678, 679, 683, 684, 686, 687, 688, 689, 691, 692, 693, 694, 695, 696, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 718, 720, 721, 722, 723, 724, 725, 726, 727, 728, 730, 731, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 744, 745, 746, 747, 748, 749, 751, 753, 754, 755, 756, 757, 758, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 778, 779, 780, 781, 782, 783, 784, 786, 787, 788, 790, 791, 793, 795, 797, 799, 800, 802, 803, 804, 805, 806, 807, 808, 809, 811, 812, 813, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 850, 851, 852, 853, 854, 855, 856, 857, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 874, 875, 876, 877, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 893, 894, 895, 896, 897, 899, 900, 901, 902, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 954, 955, 956, 957, 958, 959, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 973, 974, 976, 977, 979, 980, 981, 982, 983, 984, 985, 987, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1016, 1017, 1018, 1020, 1021, 1022, 1023]\n" - ] - } - ], - "source": [ - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "\n", - "sorted_states = [int(sampled_state.state['reg']) for sampled_state in parsed_counts]\n", - "sorted_states.sort()\n", - "print(sorted_states) # we can see all the possible states for 10 qubits (from 0 to 2^{10} - 1 = 1023)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "```python\n", - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def apply_unitary_matrix(reg: QArray[QBit], exponent: CInt) -> None:\n", - " power(exponent, lambda: unitary(unitary_matrix, reg))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/878c7001-8a90-4de1-a940-59365437e376?version=0.41.2\n" - ] - } - ], - "source": [ - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None: # apply the unitary matrix once\n", - " allocate(2, reg)\n", - " apply_unitary_matrix(reg, 1)\n", - "\n", - "\n", - "\n", - "\n", - "qmod1 = create_model(main)\n", - "qprog1 = synthesize(qmod1)\n", - "show(qprog1)\n", - "\n", - "# from the IDE:\n", - "# Program info\n", - "# Depth: 7\n", - "# Width: 2\n", - "# Gate count\n", - "# U : 8\n", - "# CX : 3" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ca21082c-49a9-4536-831e-54281264dad3?version=0.41.2\n" - ] - } - ], - "source": [ - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None: # apply the unitary matrix thrice\n", - " allocate(2, reg)\n", - " apply_unitary_matrix(reg, 3)\n", - "\n", - "\n", - "\n", - "qmod3 = create_model(main)\n", - "qprog3 = synthesize(qmod3)\n", - "show(qprog3)\n", - "\n", - "# from the IDE:\n", - "# Program info\n", - "# Depth: 7\n", - "# Width: 2\n", - "# Gate count\n", - "# U : 8\n", - "# CX : 3" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/6bceb651-fc52-49e7-86d4-eee1f284bef4?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "\n", - "@qfunc\n", - "def my_apply_to_all(my_operand: QCallable[QBit], reg: QArray[QBit]) -> None:\n", - " # apply_to_all(gate_operand=my_operand, target=reg) # this is another option\n", - " repeat(reg.len, lambda i: my_operand(reg[i]))\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(reg: QArray[QBit]) -> None:\n", - " my_apply_to_all(H, reg)\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None: \n", - " allocate(10, reg)\n", - " my_hadamard_transform(reg)\n", - "\n", - " \n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 23, 26, 27, 28, 30, 31, 32, 33, 34, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 65, 67, 68, 69, 70, 71, 73, 74, 76, 77, 78, 79, 80, 81, 82, 83, 84, 87, 88, 89, 90, 91, 92, 93, 95, 96, 97, 98, 99, 101, 102, 103, 104, 105, 107, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 133, 134, 135, 136, 137, 138, 139, 141, 143, 144, 145, 146, 147, 149, 150, 151, 152, 154, 155, 156, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 170, 171, 172, 174, 175, 176, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 199, 200, 201, 202, 203, 204, 206, 207, 208, 210, 211, 212, 213, 214, 215, 217, 218, 219, 220, 222, 223, 224, 225, 226, 227, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 253, 254, 255, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 268, 269, 270, 271, 272, 273, 274, 275, 277, 278, 279, 280, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 304, 305, 306, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 319, 320, 322, 323, 324, 326, 328, 329, 330, 331, 332, 334, 335, 336, 337, 338, 339, 341, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 365, 367, 369, 370, 371, 372, 373, 374, 375, 376, 378, 379, 380, 381, 382, 383, 384, 385, 386, 388, 389, 391, 392, 393, 395, 397, 398, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 421, 422, 423, 424, 425, 426, 427, 429, 430, 431, 433, 434, 435, 436, 438, 441, 442, 443, 444, 445, 447, 448, 449, 450, 451, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 570, 572, 574, 575, 576, 577, 578, 579, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 604, 605, 606, 607, 608, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 621, 622, 623, 624, 625, 627, 628, 629, 631, 632, 633, 634, 635, 636, 637, 638, 639, 641, 642, 643, 645, 646, 648, 649, 650, 651, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 672, 673, 674, 676, 677, 678, 679, 680, 681, 682, 683, 685, 686, 687, 688, 689, 690, 691, 692, 693, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 709, 710, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 727, 728, 729, 730, 732, 733, 734, 736, 737, 738, 740, 742, 743, 745, 746, 747, 750, 753, 754, 755, 756, 757, 759, 761, 762, 763, 764, 765, 766, 768, 769, 770, 771, 772, 774, 775, 776, 777, 778, 779, 781, 782, 783, 784, 785, 786, 787, 788, 789, 791, 792, 793, 795, 796, 797, 799, 800, 801, 803, 805, 807, 808, 809, 810, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 860, 861, 862, 863, 864, 865, 867, 868, 869, 870, 871, 872, 873, 874, 875, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 908, 909, 910, 911, 912, 913, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 936, 937, 938, 939, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1012, 1013, 1014, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023]\n" - ] - } - ], - "source": [ - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "\n", - "sorted_states = [int(sampled_state.state['reg']) for sampled_state in parsed_counts]\n", - "sorted_states.sort()\n", - "print(sorted_states) # we can see all the possible states for 10 qubits (from 0 to 2^{10} - 1 = 1023)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/88b602ea-79f9-4e44-8323-b47712e662c4?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "from math import pi\n", - "\n", - "@qfunc\n", - "def my_cotrolled_ry(x:QBit, y:QBit) -> None:\n", - " control(x, lambda: RY(pi/2, y))\n", - "\n", - "@qfunc\n", - "def main(x: Output[QBit], y: Output[QBit]) -> None:\n", - " allocate(1, x)\n", - " allocate(1, y)\n", - " X(x) # so that the implemented Controlled-RY does apply RY to 'y'\n", - " my_cotrolled_ry(x, y)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'x': 1.0, 'y': 1.0}: 1047, {'x': 1.0, 'y': 0.0}: 1001]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we can see that we obtained the states '10' and '11' with half the probability for each one\n", - " # 'x' is always 1 because we apply the X gate and 'y' is in superposition (0 and 1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c89d8573-cf97-4546-8871-0c4a8d584699?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x:Output[QNum]):\n", - " prepare_int(9, x)\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'x': 9.0}: 2048]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we observe the prepared state: 9 (=1001) with all probability" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/cc68c0cf-a56f-4d03-91db-0955166d76ff?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_controlled_x(x: QNum, target: QBit) -> None:\n", - " control(x == 9, lambda: X(target))\n", - "\n", - "@qfunc\n", - "def main(x:Output[QNum], res: Output[QBit]):\n", - " allocate(1, res)\n", - " prepare_int(9, x)\n", - " my_controlled_x(x, res)\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'x': 9.0, 'res': 1.0}: 2048]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we observe the prepared state: 9 (=1001) and the state 1 for 'res' with all probability\n", - " # in this way we see the state: 25 (=11001), in the histogram when running in the IDE" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Csaba_Szilard_Racz-HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Csaba_Szilard_Racz-HW1_QClass2024.ipynb deleted file mode 100644 index 6a84a6dd..00000000 --- a/community/QClass_2024/Submissions/HW1/Csaba_Szilard_Racz-HW1_QClass2024.ipynb +++ /dev/null @@ -1,564 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/dfd770a9-b159-45e2-8d24-5673803e9467?version=0.41.1\n" - ] - } - ], - "source": [ - "# Your code here:\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/3a346585-0a1e-4239-b4f7-991a015970b5?version=0.41.1\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def bellPair(q1: QBit, q2: QBit) -> None:\n", - " H(q1)\n", - " CX(q1,q2)\n", - " \n", - "@qfunc\n", - "def main(res1: Output[QBit], res2: Output[QBit]) -> None:\n", - " allocate(1, res1)\n", - " allocate(1, res2)\n", - " bellPair(res1,res2)\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/70cee114-6a35-465a-bd6c-fa5c26b1d07a?version=0.41.1\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def bellPair(qbits: QArray[QBit]) -> None:\n", - " H(qbits[0])\n", - " CX(qbits[0],qbits[1])\n", - " \n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " allocate(2, res)\n", - " bellPair(res)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5da238f8-285a-4cd3-bcc9-5e414f203c71?version=0.41.1\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_hadamard_transform(qbits: QArray[QBit]) -> None:\n", - " repeat(qbits.len,iteration= lambda i: H(qbits[i])) # repeats qbits.len times the function of applying Hadamard on current element of QArray\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " allocate(10,res)\n", - " my_hadamard_transform(res)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "# from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/4857b4a4-d79f-43d1-b2c3-ea91bca45895?version=0.41.1\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def model(qbits: QArray[QBit]) -> None: # elements: CArray[CArray[CReal]], \n", - " unitary(unitary_matrix,qbits)\n", - " \n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " allocate(2,res)\n", - " model(res)\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a02d4d96-6e18-44fc-a700-ec280528d331?version=0.41.1\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def powerModel(qbits: QArray[QBit]) -> None:\n", - " power(3, lambda: unitary(unitary_matrix,qbits))\n", - " \n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " allocate(2,res)\n", - " powerModel(res)\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b2e79d9f-8325-45f3-a218-6091f647418f?version=0.41.1\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_apply_to_all(qbits: QArray[QBit], operand: QCallable[QBit]) -> None:\n", - " repeat(count=qbits.len, iteration= lambda i: operand(qbits[i]))\n", - "\n", - "@qfunc # function from exercise 2\n", - "def my_hadamard_transform(qbits: QArray[QBit]) -> None:\n", - " my_apply_to_all(qbits, H)\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " allocate(10,res)\n", - " my_hadamard_transform(res)\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0250d2c2-c44d-4892-8a35-73512bd8f25c?version=0.41.1\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def quatnumConditions(q1: QBit, q2: QBit) -> None:\n", - " control(q1, lambda: RY(np.pi/2, q2))\n", - " \n", - "@qfunc\n", - "def main(q1: Output[QBit], q2: Output[QBit]) -> None:\n", - " allocate(1,q1)\n", - " allocate(1,q2)\n", - " # more interesting if we were to put the control qubit in superposition first with:\n", - " # H(q1)\n", - " quatnumConditions(q1,q2)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/773aea25-dfd0-437e-bb9e-1df7aba1d6d7?version=0.41.1\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], q: Output[QBit]) -> None:\n", - " prepare_int(9, x)\n", - " allocate(1,q)\n", - " control(x == 9, lambda: X(q))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/HW1_QClass2024 - Bill Wisotsky.ipynb b/community/QClass_2024/Submissions/HW1/HW1_QClass2024 - Bill Wisotsky.ipynb deleted file mode 100644 index b06177c4..00000000 --- a/community/QClass_2024/Submissions/HW1/HW1_QClass2024 - Bill Wisotsky.ipynb +++ /dev/null @@ -1,575 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f24744e0-219d-4c19-b109-ba738fee34ee?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 188, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/78a771e0-8c31-4975-8f5b-ff83cfa632ed?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "@qfunc\n", - "def main():\n", - " q0 = QBit(\"q0\")\n", - " q1 = QBit(\"q1\")\n", - " allocate(1,q0)\n", - " allocate(1,q1)\n", - " H(q0)\n", - " CX(q0,q1)\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/87d38342-edba-491d-a03f-c809aa0a60c8?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def bell_state(q:QArray[QBit]):\n", - " H(q[0])\n", - " CX(q[0],q[1])\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray]):\n", - " allocate(2,q)\n", - " bell_state(q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/6b31c4ea-fea8-47e9-adbf-e1ee03ccf3ee?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]) -> None:\n", - " repeat(q.len,lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10,reg)\n", - " my_hadamard_transform(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " elements*target\n", - "\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 2, depth: 7\n" - ] - } - ], - "source": [ - "#### Application of the Unitary Matrix\n", - "\n", - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(2, x)\n", - " unitary(unitary_matrix, x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "#show(qprog)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/514069a2-ee68-494f-ab67-e32058eed3aa?version=0.40.0\n", - "Synthesized circuit width: 2, depth: 7\n" - ] - } - ], - "source": [ - "#### Application of the Unitary Matrix^3\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(2, x)\n", - " power(3,lambda: unitary(unitary_matrix, x))\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 195, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c5fd2696-40ce-4aef-9b90-77869802636a?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import CReal, H, QBit, QCallable, RX, allocate, qfunc\n", - "n=10\n", - "\n", - "@qfunc\n", - "#def my_operator(my_operand: QCallable[QBit], q: QBit) -> None:\n", - "def my_apply_to_all(q:QArray[QBit]) -> None:\n", - " my_operand(q)\n", - "\n", - "\n", - "def my_operand(target: QArray[QBit]) -> None:\n", - " apply_to_all(H,target)\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(n,reg)\n", - " my_apply_to_all(reg)\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 198, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/2b209de3-92c0-4230-ab98-a33e70201418?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def cry(x: QBit, target: QBit) -> None:\n", - " control(x, lambda: RY(pi/2, target))\n", - "@qfunc\n", - "def main():\n", - " q0=QBit(\"q0\")\n", - " q1=QBit(\"q1\")\n", - " allocate(1,q0)\n", - " allocate(1,q1)\n", - " cry(q0,q1)\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 217, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/88577703-7093-49c5-af32-93d47c2a651d?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum]):\n", - " prepare_int(9,x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 218, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/097577db-61d8-4988-b327-9a99b51ba7d6?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y:Output[QBit]):\n", - " prepare_int(9,x)\n", - " allocate(1,y)\n", - " control((x==9), lambda: X(y))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.18" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Jose_Alejandro_Garcia_Gonzalez_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Jose_Alejandro_Garcia_Gonzalez_HW1_QClass2024.ipynb deleted file mode 100644 index d2d46a84..00000000 --- a/community/QClass_2024/Submissions/HW1/Jose_Alejandro_Garcia_Gonzalez_HW1_QClass2024.ipynb +++ /dev/null @@ -1,590 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5a487576-7c0a-4f44-b873-3a7a156cdd44?version=0.41.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "# Your code here:\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "job = execute(qprog)\n", - "job.open_in_ide()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/aaced20c-b55d-4e92-bc28-b5e17a142160?version=0.41.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def prepare_bell_pair(x:QBit, y:QBit):\n", - " H(x)\n", - " CX(x,y)\n", - "\n", - "@qfunc\n", - "def main(x: Output[QBit], y: Output[QBit]):\n", - " allocate(1,x)\n", - " allocate(1,y)\n", - " prepare_bell_pair(x,y)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/404d5c2d-d765-424e-99c7-ea93efc0246d?version=0.41.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def prepare_bell_pair(x:QArray[QBit]):\n", - " H(x[0])\n", - " CX(x[0],x[1])\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]):\n", - " allocate(2,res)\n", - " prepare_bell_pair(res)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c4a255cb-bb61-4fe9-9743-13327299e82c?version=0.41.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(x:QArray[QBit]):\n", - " repeat(x.len, lambda i: H(x[i]))\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray]): \n", - " allocate(10,res)\n", - " my_hadamard_transform(res)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b23cd114-8fd1-4f28-aa19-747a92e315f3?version=0.41.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(2, x)\n", - " unitary(unitary_matrix, x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/821fb878-0eb2-4706-8fd6-28985930efcf?version=0.41.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def matrix(x:QArray[QBit]):\n", - " unitary(unitary_matrix, x)\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(2, x)\n", - " power(3, lambda: matrix(x))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8bb0d37f-e026-44b5-a11a-b6038e37071b?version=0.41.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_apply_to_all(my_operand: QCallable[QBit], q: QArray[QBit]):\n", - " repeat(q.len, lambda i: my_operand(q[i]))\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(x:QArray[QBit]):\n", - " my_apply_to_all(H,x)\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray]): \n", - " allocate(10,res)\n", - " my_hadamard_transform(res)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a256e659-d2c5-4581-bbbc-b0d3cc198067?version=0.41.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import pi\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def Manual_Control(target: QBit, cont: QBit):\n", - " control(cont, lambda: RY(pi/2, target))\n", - "\n", - "@qfunc\n", - "def main(x: Output[QBit], y: Output[QBit]):\n", - " allocate(1, x)\n", - " H(x)\n", - " allocate(1, y)\n", - " Manual_Control(y,x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b4f5a4f6-54cb-40a3-ae7f-21da56c16d6c?version=0.41.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum]):\n", - " prepare_int(9, x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f882b4a1-6862-4486-bf8d-4b53fa38a418?version=0.41.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(x: Output[QNum], target: Output[QBit]):\n", - " prepare_int(9, x)\n", - " allocate(1,target)\n", - " control(x == 6, lambda: X(target))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Mah_Noor_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Mah_Noor_HW1_QClass2024.ipynb deleted file mode 100644 index eba77cb1..00000000 --- a/community/QClass_2024/Submissions/HW1/Mah_Noor_HW1_QClass2024.ipynb +++ /dev/null @@ -1,571 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/32935030-c97f-4809-ab01-6b14820439da?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "def bell_state_using_two_variables(x:QBit, y:QBit):\n", - " H(x)\n", - " CX(x,y)\n", - "@qfunc\n", - "def main(a:Output[QBit], b:Output[QBit]):\n", - " allocate(1,a)\n", - " allocate(1,b)\n", - " bell_state_using_two_variables(a,b)\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/6b66b6b1-c5c9-41f0-812b-e1d24fc1f9b9?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "def bell_state_using_one_variable(x: QArray[QBit]):\n", - " H(x[0])\n", - " CX(x[0],x[1])\n", - "@qfunc\n", - "def main(reg:Output[QArray]):\n", - " allocate(2,reg)\n", - " bell_state_using_one_variable(reg)\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "def my_hadamard_transform(x: QArray[QBit]):\n", - " repeat( x.len, lambda i:H(x[i]))\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10,reg)\n", - " my_hadamard_transform(reg)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/7d7805d8-0d35-4e25-aa9b-acdcd080e8a5?version=0.41.2\n" - ] - } - ], - "source": [ - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/7229744e-e24c-499a-9743-b7ccacdd8cc6?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(2, x)\n", - " unitary(unitary_matrix, x)\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/4f0acd0a-938a-4083-804c-4c82b691e27e?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(2, x)\n", - " power(3, lambda:unitary(unitary_matrix, x))\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/33ee242d-e09e-4b2b-8047-7e601df209e5?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "def my_apply_to_all(reg:QArray[QBit], operand: QCallable[QBit] ):\n", - " apply_to_all(operand,reg)\n", - "\n", - "def my_hadamard_transform(y: QArray[QBit]):\n", - " my_apply_to_all(y,H)\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray]):\n", - " allocate(10,x)\n", - " my_hadamard_transform(x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from numpy import pi" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "def control_gate(x:QBit, y:QBit):\n", - " control(x, lambda: RY(pi / 2, y))" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(res: Output[QBit])-> None:\n", - " x = QBit(\"x\")\n", - " allocate(1, x)\n", - " allocate(1, res)\n", - " control_gate(x,res)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f146d8b4-d587-4ee1-b10c-b037007c33df?version=0.41.2\n" - ] - } - ], - "source": [ - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/07f84c53-db38-49c3-b14e-7804aebb6970?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x:Output[QNum], res:Output[QBit])-> None:\n", - "# allocate_num(4,False, 0, x)\n", - " allocate(1,res)\n", - " prepare_int(9, x)\n", - "\n", - " control(x==9, lambda : X(res))\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.18" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Noah_Nzeki_William_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Noah_Nzeki_William_HW1_QClass2024.ipynb deleted file mode 100755 index 77d83a26..00000000 --- a/community/QClass_2024/Submissions/HW1/Noah_Nzeki_William_HW1_QClass2024.ipynb +++ /dev/null @@ -1,544 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f3d7a8a9-b4e5-415b-907b-7545339467c6?version=0.41.1\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here: \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "#result = execute(qprog).result()\n", - "#print(result)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/4ebd2a6c-14e3-4b14-8628-13534e35c36b?version=0.41.1\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def prep_bell_state(q1: QBit, q2: QBit) -> None:\n", - " H(q1)\n", - " CX(q1, q2)\n", - " \n", - "@qfunc\n", - "def main(res1: Output[QBit], res2: Output[QBit]) -> None:\n", - " allocate(1, res1)\n", - " allocate(1, res2)\n", - " prep_bell_state(res1, res2)\n", - "#\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/7056fa8c-c9bd-450c-84ea-0e7b866bd8fe?version=0.41.1\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def prep_bell_state(qubits: QArray[QBit, 2]) -> None:\n", - " H(qubits[1])\n", - " CX(qubits[1], qubits[0])\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit, 2]]) -> None:\n", - " allocate(2, res) \n", - " prep_bell_state(res)\n", - "\n", - "\n", - "model = create_model(main)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/e0286555-126e-4c74-a26b-130744f21789?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]): \n", - " allocate(10,reg)\n", - " my_hadamard_transform(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/772b8449-7fe3-4534-be64-a90c15ab314b?version=0.41.1\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(qubit: Output[QArray[QBit]]) -> None:\n", - " allocate(2, qubit)\n", - " power(3, lambda: unitary(unitary_matrix, qubit))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f6020437-edac-4498-b445-426471d80b88?version=0.41.1\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_apply_to_all(my_operand: QCallable[QBit], qubit: QArray[QBit]) -> None:\n", - " repeat(qubit.len, lambda i: my_operand(qubit[i]))\n", - " \n", - "@qfunc\n", - "def my_hadamard_transform(qubit: QArray[QBit]) -> None:\n", - " my_apply_to_all(lambda t: H(t), qubit)\n", - "\n", - "@qfunc\n", - "def main(qubit: Output[QArray[QBit]]) -> None:\n", - " allocate(10, qubit)\n", - " my_hadamard_transform(qubit)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8b0e59eb-c207-4a24-bd01-0808bdcf0d29?version=0.41.1\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "from classiq.qmod.symbolic import pi\n", - "\n", - "@qfunc\n", - "def controlled_ry_gate(control_bit: QBit, target: QBit) -> None:\n", - " control(control_bit, lambda: RY(pi / 2, target))\n", - "\n", - "@qfunc\n", - "def main(control_bit: Output[QBit], target: Output[QBit]) -> None:\n", - " allocate(1, control_bit)\n", - " allocate(1, target)\n", - " controlled_ry_gate(control_bit, target)\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/756325a0-8671-49de-a68a-a63b97d159e2?version=0.41.1\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], target: Output[QBit]) -> None:\n", - " prepare_int(9, x)\n", - " allocate(1, target)\n", - " control(x == 9, lambda: X(target))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Otmane_ainelkitane_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Otmane_ainelkitane_HW1_QClass2024.ipynb deleted file mode 100644 index 1ba28caa..00000000 --- a/community/QClass_2024/Submissions/HW1/Otmane_ainelkitane_HW1_QClass2024.ipynb +++ /dev/null @@ -1,650 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "LX9Nj4MW7988" - }, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wiUgAF6b799A" - }, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "collapsed": true, - "id": "rVXqqX_29sJl", - "outputId": "bbb97ef1-d1c8-4fb8-e261-cdf2835b4933" - }, - "outputs": [], - "source": [ - "!pip install Classiq -U" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "id": "aW7zH-kF_E7I" - }, - "outputs": [], - "source": [ - "import classiq\n", - "classiq.authenticate()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "id": "PZqYYahm799B" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "JcaIP1z4799D" - }, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Ddd9pkX4799D", - "outputId": "1a7f0313-8e94-448d-bb70-e9d687bd9213" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a7f8d3ed-b5a9-4ea8-bb51-8e3ce0d91a45?version=0.41.1\n" - ] - } - ], - "source": [ - "#from classiq import *\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kXLBnCL7799D" - }, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "lfR9qo6w799E" - }, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rtn2t2Ss799E" - }, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "id": "PCKbZcmz799E" - }, - "outputs": [], - "source": [ - "#from classiq import *\n", - "\n", - "@qfunc\n", - "def Bell_state(reg: QArray[QBit]) -> None:\n", - " H(reg[0])\n", - " CX(reg[0], reg[1])\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "KftDIAch799F" - }, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "2sSaN_rb799G", - "outputId": "e487b48b-1962-4b30-dda9-b4628319a6b0" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b41d29b4-6c0f-4755-8fe4-eeef655d90c8?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None:\n", - " allocate(2, reg)\n", - " Bell_state(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "9MZU1trw799G" - }, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "7oWqiQZc799H", - "outputId": "7dd0102f-2dbd-42a0-d113-d4eb6a95b63d" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/98f614f3-51d8-448e-ac3c-8255a03e1101?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10,reg)\n", - " my_hadamard_transform(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "EIP8M24s799I" - }, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "EInvZN2C799I" - }, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "id": "KQ0U7_-X799I" - }, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kDFpeA9U799I" - }, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": { - "id": "ylzmS1JQ799J" - }, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "CVqGyIsG799J", - "outputId": "8b802983-240d-4b79-879a-0b6757b4ded0" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/e1876e2a-9375-4304-bec6-0a3e8d3fea6c?version=0.41.1\n" - ] - } - ], - "source": [ - "#1. Create a model that applies unitary_matrix on a 2 qubit variable.\n", - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None:\n", - " allocate(2, reg)\n", - " unitary(unitary_matrix,reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "# Depth: 7\n", - "# Width: 2\n" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "0vIfSXmZTGeZ", - "outputId": "044d433c-5fe9-47c5-ff5e-fec3af4c022f" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c8f3f1f4-e6b2-4db0-bc76-666c8734e47a?version=0.41.1\n" - ] - } - ], - "source": [ - "#2. Create another model that applies unitary_matrix raised to power 3 on a 2 qubit variable.\n", - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None:\n", - " allocate(2, reg)\n", - " power(3, lambda :unitary(unitary_matrix,reg))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "#Depth: 7\n", - "#Width: 2" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "dtwwMQIZUXXs" - }, - "outputs": [], - "source": [ - "# 3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "# in both cases we had the same Depth and width" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "XGGNdn2m799J" - }, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Fujf8Kj8799J", - "outputId": "2b25d971-01f2-4c38-889b-fde6dd75e69e" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/dce195a0-6bd2-44f9-a684-031290c29da5?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def my_apply_to_all(reg: QArray[QBit], my_operand: QCallable[QBit]) -> None:\n", - " repeat(reg.len, lambda i: my_operand(reg[i]))\n", - "\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray[QBit]]) -> None:\n", - " allocate(3, reg)\n", - " my_apply_to_all(reg, lambda q: X(q))\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wRgnSqNn799J" - }, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "yF2EPzzW799K", - "outputId": "6be03fe4-0450-45ad-df63-1ce0775b1bc9" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/3949fcd7-7692-4c9e-a652-4d35b95b66cc?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from sympy import pi\n", - "@qfunc\n", - "def my_control(ctr: QBit, target: QBit) -> None:\n", - " control(ctr, lambda: RY(pi/2, target))\n", - "\n", - "@qfunc\n", - "def main(qreg: Output[QArray[QBit]]) -> None:\n", - " allocate(2, qreg)\n", - " #X(qreg[0])\n", - " my_control(qreg[0], qreg[1])\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "LXja3yoA799K" - }, - "source": [ - "\n", - "\n", - "```\n", - "# This is formatted as code\n", - "```\n", - "\n", - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "AdiivlfV799K", - "outputId": "6324e711-60bb-457c-dee2-37f072b2625d" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5492ad49-897e-4dc8-aa7b-4d02792f66ca?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QBit]) -> None:\n", - " prepare_int(9, x)\n", - " allocate(1, y)\n", - " control(x == 9, lambda: X(y))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.9" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/community/QClass_2024/Submissions/HW1/Priyabrata_Bag_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Priyabrata_Bag_HW1_QClass2024.ipynb deleted file mode 100644 index 478e177c..00000000 --- a/community/QClass_2024/Submissions/HW1/Priyabrata_Bag_HW1_QClass2024.ipynb +++ /dev/null @@ -1,562 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8b83c81a-452e-440a-b786-a190f8046682?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "\n", - "show(qprog)\n", - "# execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/e2453fe4-e445-481e-9947-9c087505063d?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def Bell_state(p: QBit, q: QBit) -> None:\n", - " H(p)\n", - " CX(p, q)\n", - "\n", - "@qfunc\n", - "def main(p: Output[QBit], q: Output[QBit]) -> None:\n", - " allocate(1, p)\n", - " allocate(1, q)\n", - " Bell_state(p, q)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5e5ac9ab-db0d-4f9d-8fda-acc5c007131a?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def Bell_state(q: QArray[QBit]) -> None:\n", - " H(q[0])\n", - " CX(q[0], q[1])\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None:\n", - " allocate(2, reg)\n", - " Bell_state(q = reg)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/1e0fc549-4a19-4938-9e51-05e53a235e43?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]) -> None:\n", - " allocate(10, reg)\n", - " my_hadamard_transform(q = reg)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/1c68c502-70a1-4cba-abc1-335e98155a5f?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(reg: Output[QArray[QBit]]):\n", - " allocate(2, reg)\n", - " unitary(unitary_matrix, reg)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f5ced877-edcd-4f75-8b2a-cdc14441d419?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(reg: Output[QArray[QBit]]):\n", - " allocate(2, reg)\n", - " power(3, lambda: unitary(unitary_matrix, reg))\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/24bc22ab-e819-41bc-ba1b-57132867239e?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_apply_to_all(q: QArray[QBit], my_operand: QCallable[QBit]):\n", - " # apply_to_all(gate_operand = my_operand, target = q)\n", - " repeat(q.len, lambda i: my_operand(q[i]))\n", - "\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]):\n", - " my_apply_to_all(q = q, my_operand = H)\n", - "\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10, reg)\n", - " my_hadamard_transform(q = reg)\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0397b3bc-1ab9-400a-8bab-f514b51a935b?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_cry(cqb: QBit, tqb: QBit):\n", - " control(cqb, lambda: RY(symbolic.pi/2, tqb))\n", - "\n", - "@qfunc\n", - "def main(cqb: Output[QBit], tqb: Output[QBit]):\n", - " allocate(1, cqb)\n", - " allocate(1, tqb)\n", - " my_cry(cqb = cqb, tqb = tqb)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/9b1285c3-f2a1-4da1-9010-1a7b28223659?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], target: Output[QBit]):\n", - " prepare_int(9, x)\n", - " allocate(1, target)\n", - " control(x == 9, lambda: X(target))\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Razeen_Ud_Din_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Razeen_Ud_Din_HW1_QClass2024.ipynb deleted file mode 100644 index 6ecd0add..00000000 --- a/community/QClass_2024/Submissions/HW1/Razeen_Ud_Din_HW1_QClass2024.ipynb +++ /dev/null @@ -1,875 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "DKf6e1_ZUIAA" - }, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "source": [ - "#Doing Preparation" - ], - "metadata": { - "id": "7gEFb8v0XzOz" - } - }, - { - "cell_type": "code", - "source": [ - "# Installing Classiq\n", - "!pip install -U classiq" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "collapsed": true, - "id": "pSMVUYAhXoel", - "outputId": "53331c66-6cd2-4650-d6d9-fc22e1caf509" - }, - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting classiq\n", - " Downloading classiq-0.41.1-py3-none-any.whl (398 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m398.1/398.1 kB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting ConfigArgParse<2.0.0,>=1.5.3 (from classiq)\n", - " Downloading ConfigArgParse-1.7-py3-none-any.whl (25 kB)\n", - "Collecting Pyomo<6.6,>=6.5 (from classiq)\n", - " Downloading Pyomo-6.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.7 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m4.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting black<25.0,>=24.0 (from classiq)\n", - " Downloading black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.8 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m47.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting httpx<1,>=0.23.0 (from classiq)\n", - " Downloading httpx-0.27.0-py3-none-any.whl (75 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m7.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: keyring<24.0.0,>=23.5.0 in /usr/lib/python3/dist-packages (from classiq) (23.5.0)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (3.7.1)\n", - "Collecting networkx<3.0.0,>=2.5.1 (from classiq)\n", - " Downloading networkx-2.8.8-py3-none-any.whl (2.0 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m54.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: numexpr<3.0.0,>=2.7.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.10.0)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.25.2)\n", - "Collecting packaging<23.0,>=22.0 (from classiq)\n", - " Downloading packaging-22.0-py3-none-any.whl (42 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: pandas<3.0.0,>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.0.3)\n", - "Requirement already satisfied: plotly<6.0.0,>=5.7.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (5.15.0)\n", - "Collecting pydantic<2.0.0,>=1.9.1 (from classiq)\n", - " Downloading pydantic-1.10.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m49.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: scipy<2.0.0,>=1.10.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.11.4)\n", - "Collecting sympy<1.11.0,>=1.9.0 (from classiq)\n", - " Downloading sympy-1.10.1-py3-none-any.whl (6.4 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m64.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: tabulate<1,>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from classiq) (0.9.0)\n", - "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (8.1.7)\n", - "Collecting mypy-extensions>=0.4.3 (from black<25.0,>=24.0->classiq)\n", - " Downloading mypy_extensions-1.0.0-py3-none-any.whl (4.7 kB)\n", - "Collecting pathspec>=0.9.0 (from black<25.0,>=24.0->classiq)\n", - " Downloading pathspec-0.12.1-py3-none-any.whl (31 kB)\n", - "Requirement already satisfied: platformdirs>=2 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.2.1)\n", - "Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (2.0.1)\n", - "Requirement already satisfied: typing-extensions>=4.0.1 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.11.0)\n", - "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7.1)\n", - "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (2024.2.2)\n", - "Collecting httpcore==1.* (from httpx<1,>=0.23.0->classiq)\n", - " Downloading httpcore-1.0.5-py3-none-any.whl (77 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m8.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7)\n", - "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (1.3.1)\n", - "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx<1,>=0.23.0->classiq)\n", - " Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.2.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.51.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.5)\n", - "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (9.4.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.1.2)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2023.4)\n", - "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2024.1)\n", - "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from plotly<6.0.0,>=5.7.0->classiq) (8.3.0)\n", - "Collecting ply (from Pyomo<6.6,>=6.5->classiq)\n", - " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.3.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n", - "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx<1,>=0.23.0->classiq) (1.2.1)\n", - "Installing collected packages: ply, sympy, Pyomo, pydantic, pathspec, packaging, networkx, mypy-extensions, h11, ConfigArgParse, httpcore, black, httpx, classiq\n", - " Attempting uninstall: sympy\n", - " Found existing installation: sympy 1.12\n", - " Uninstalling sympy-1.12:\n", - " Successfully uninstalled sympy-1.12\n", - " Attempting uninstall: pydantic\n", - " Found existing installation: pydantic 2.7.1\n", - " Uninstalling pydantic-2.7.1:\n", - " Successfully uninstalled pydantic-2.7.1\n", - " Attempting uninstall: packaging\n", - " Found existing installation: packaging 24.0\n", - " Uninstalling packaging-24.0:\n", - " Successfully uninstalled packaging-24.0\n", - " Attempting uninstall: networkx\n", - " Found existing installation: networkx 3.3\n", - " Uninstalling networkx-3.3:\n", - " Successfully uninstalled networkx-3.3\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "torch 2.2.1+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-nccl-cu12==2.19.3; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.2.1+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n", - "\u001b[0mSuccessfully installed ConfigArgParse-1.7 Pyomo-6.5.0 black-24.4.2 classiq-0.41.1 h11-0.14.0 httpcore-1.0.5 httpx-0.27.0 mypy-extensions-1.0.0 networkx-2.8.8 packaging-22.0 pathspec-0.12.1 ply-3.11 pydantic-1.10.15 sympy-1.10.1\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Authentication\n", - "import classiq\n", - "classiq.authenticate()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "collapsed": true, - "id": "K_fsJpP6YJEQ", - "outputId": "31f3c6bf-2894-47e0-dae9-450e3fdc3b98" - }, - "execution_count": 2, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Your user code: VWSR-RZCM\n", - "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=VWSR-RZCM\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "iS9-C0N0UIAN" - }, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "uCj4T3_5UIAO" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "l425FkQFUIAP" - }, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "r63ehZ7jUIAP" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main) #create model\n", - "qprog = synthesize(qmod) # synthesize\n", - "\n", - "# Your code here:" - ] - }, - { - "cell_type": "code", - "source": [ - "#Showing qprog\n", - "show(qprog)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "IjP1y42PZIwG", - "outputId": "5177236d-aab2-4375-ac76-b1fd5df8b9bd" - }, - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/27ea28a3-48ca-47d7-9f71-6437eddde65a?version=0.41.1\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "#Executing qprog\n", - "execute(qprog)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "1APokD46ZH07", - "outputId": "bb1f540c-3c7f-46c0-91e5-3658c8d6c925" - }, - "execution_count": 6, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "ExecutionJob(id='1d2e83bd-ca33-46fd-881f-616c53b727c2')" - ] - }, - "metadata": {}, - "execution_count": 6 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Ji-gPBDWUIAQ" - }, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "UxsyXx51UIAQ" - }, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ZdXAtO--UIAQ" - }, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NE2JvAUGUIAQ", - "outputId": "416cb601-1e28-46d4-fd77-aea6309dcccb" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/467482a8-a688-4181-b128-a43468199000?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def Bell_state(q1:QBit,q2:QBit) -> None:\n", - " H(target=q1)\n", - " CX(control=q1,target=q2)\n", - "\n", - "@qfunc\n", - "def main(res1: Output[QBit], res2: Output[QBit]) -> None:\n", - " allocate(1,res1)\n", - " allocate(1,res2)\n", - " Bell_state(q1=res1,q2=res2)\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "95gq6bMpUIAQ" - }, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "qBlWalvsUIAR" - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def Bell_state(q1:QBit,q2:QBit) -> None:\n", - " H(target=q1)\n", - " CX(control=q1,target=q2)\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray]) -> None:\n", - " allocate(2,res)\n", - " Bell_state(q1=res[0],q2=res[1])\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "H_ny1mJjUIAR" - }, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "tUWSk1BrUIAR", - "outputId": "523856c3-80cb-4c9c-ba8d-310465cb035a" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/e91bf80b-36d7-4a42-9e07-97eb7d9623d2?version=0.41.1\n" - ] - } - ], - "source": [ - "from contextlib import redirect_stdout\n", - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(q:QArray[QBit]) -> None:\n", - " repeat(count=q.len, iteration=lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray]) -> None:\n", - " allocate(10,res)\n", - " my_hadamard_transform(res)\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "b3UwtxUDUIAS" - }, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2HnRD0j8UIAS" - }, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "id": "lzr_tHedUIAS" - }, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "qPY8ukKnUIAS" - }, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "ty9AiSUrUIAT" - }, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "df3xBcwFUIAT", - "outputId": "a2f0e894-c76e-47f7-df66-9b8b8b37f0cb" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/9c4221de-c4cf-49d1-8572-1153af9a1761?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray])-> None:\n", - " allocate(2,res)\n", - " unitary(unitary_matrix,res)\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray])-> None:\n", - " allocate(2,res)\n", - " power(3, lambda: unitary(unitary_matrix,res))\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "DsCfdAC6wxAM", - "outputId": "2f73a5c9-aaa1-4064-8dd9-6e62a6e3c599" - }, - "execution_count": 25, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/a735ee5a-a67d-4bb4-8c15-89d78ec6dad4?version=0.41.1\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "e47tQi4dUIAT" - }, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "7XYXkHZdUIAT", - "outputId": "57aaf2a4-bc8a-4359-bb1f-0f32e40bcc7a" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/dc6b610a-8e92-419f-84f8-712f92632741?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_apply_to_all(my_operand: QCallable[QArray], q: QArray[QBit]) -> None:\n", - " repeat(count=q.len, iteration=lambda i: my_operand(q[i]))\n", - "\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(q:QArray[QBit]) -> None:\n", - " my_apply_to_all(lambda target:H(target), q)\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " allocate(10,res)\n", - " my_hadamard_transform(res)\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PE0uAVlLUIAU" - }, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "5l4wbdnnUIAU", - "outputId": "ab24e9cb-a67e-4479-bfac-39d6c40de874" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/de67872d-0653-45b3-86b8-6c3d1a28b39d?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import pi\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_control(q1:QBit,q2:QBit)->None:\n", - " control(ctrl=q1, operand = lambda : RY(pi/2,q2))\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CEW8jLigUIAU" - }, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "PyVSkOLAUIAU", - "outputId": "c34263f4-aadb-4ef9-a645-95eeff3c3c67" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/779990c7-be0d-4ece-aba3-4ca0dbff8fe3?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x:Output[QNum])-> None:\n", - " prepare_int(9,x)\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x:Output[QNum],q:Output[QBit])-> None:\n", - " allocate(1,q)\n", - " prepare_int(9,x)\n", - " control(x==9, operand = lambda : X(q))\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "J7-kLb3xHDAl", - "outputId": "43927942-86ac-42e8-9796-cf83a7167af9" - }, - "execution_count": 43, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/faaef311-6cfd-4e78-af48-e0428a984d5b?version=0.41.1\n" - ] - } - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.8" - }, - "colab": { - "provenance": [] - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/community/QClass_2024/Submissions/HW1/Samyak_Jain_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Samyak_Jain_HW1_QClass2024.ipynb deleted file mode 100644 index 687cb0d9..00000000 --- a/community/QClass_2024/Submissions/HW1/Samyak_Jain_HW1_QClass2024.ipynb +++ /dev/null @@ -1,527 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/bf64f009-67b7-4a7f-93bb-7dcdf17c2908?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "model=create_model(main)\n", - "qprog=synthesize(model)\n", - "\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ad94e3ed-f9b9-40da-81c8-f62248a5ff51?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "\n", - "def main():\n", - " q1=QBit(\"q0\")\n", - " q2=QBit(\"q1\")\n", - " allocate(1,q1)\n", - " allocate(1,q2)\n", - " H(q1)\n", - " CX(q1,q2)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c0257d64-72af-4bce-af93-2dc95dae475a?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def my_bell_state(q:QArray[QBit]):\n", - " H(q[0])\n", - " CX(q[0],q[1])\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray]):\n", - " allocate(2,q)\n", - " my_bell_state(q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/1edf9c76-900d-4f89-9d86-90269333024f?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]) -> None:\n", - " repeat(q.len,lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10,reg)\n", - " my_hadamard_transform(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " element*target\n", - "def depth(quantum_program):\n", - " circuit_generated = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"circuit width of the synthesized: {circuit_generated.data.width}, depth: {circuit_generated.transpiled_circuit.depth}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ed856a60-4b2b-4ba6-b1bc-ff24f98f3a77?version=0.42.0\n", - "circuit width of the synthesized: 2, depth: 7\n", - "Opening: https://platform.classiq.io/circuit/58a66e46-30e0-4977-825f-286f1b514646?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]):\n", - " allocate(2,q)\n", - " unitary(unitary_matrix, q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "depth(qprog)\n", - "\n", - "# %%\n", - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]):\n", - " allocate(2,q)\n", - " power(3, lambda: unitary(unitary_matrix, q))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/383e3f18-d717-4783-93fe-7b80dc69975b?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "n = 10\n", - "\n", - "@qfunc\n", - "def my_apply_to_all(q:QArray[QBit]) -> None:\n", - " operand(q)\n", - "\n", - "@qfunc\n", - "def operand(target_q: QArray[QBit]) -> None:\n", - " apply_to_all(H, target_q)\n", - "\n", - "@qfunc\n", - "def main(output_q: Output[QArray]):\n", - " allocate(n, output_q)\n", - " my_apply_to_all(output_q)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/1377617e-f288-4a91-beb3-2bd94f2e4f8e?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def cry(x: QBit, target: QBit) -> None:\n", - " control(x, lambda: RY(np.pi/2, target))\n", - "@qfunc\n", - "def main():\n", - " q0=QBit(\"q0\")\n", - " q1=QBit(\"q1\")\n", - " allocate(1,q0)\n", - " allocate(1,q1)\n", - " cry(q0,q1)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/e755f46b-8887-43f7-8190-c78ccc23c11d?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y:Output[QBit]):\n", - " prepare_int(9,x)\n", - " allocate(1,y)\n", - " control((x==9), lambda: X(y))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Yasir_Mansour_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Yasir_Mansour_HW1_QClass2024.ipynb deleted file mode 100644 index d464ea5d..00000000 --- a/community/QClass_2024/Submissions/HW1/Yasir_Mansour_HW1_QClass2024.ipynb +++ /dev/null @@ -1,616 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "XtC66r2Y5_eT", - "tags": [] - }, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The QMOD language reference(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: Getting Started - Classiq(docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: Execution - Classiq(docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "RatBmdhm5_e2" - }, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 0 - }, - "id": "156317w1BFqw", - "outputId": "2bf3654e-05de-4dd1-f7cb-08c9b1d49011", - "tags": [] - }, - "outputs": [], - "source": [ - "!pip install -U -q classiq" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 0 - }, - "id": "EaDN5EkVC58C", - "outputId": "c2446774-718c-4d7c-eb0b-e8e1f676d27d", - "tags": [] - }, - "outputs": [], - "source": [ - "import classiq\n", - "classiq.authenticate()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "DpF2vKUh5_e7", - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def qfn(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " qfn(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "NXh4E69A5_fC" - }, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 0 - }, - "id": "UB612BIP5_fE", - "outputId": "6658d861-fccb-4acb-8bf2-1b52dee5b6c4", - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "s3CXWd3V5_fF" - }, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also Quantum Variables(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wtQE208K5_fH" - }, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8jM3lrC15_fI" - }, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them (Bell state(en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also Functions(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 0 - }, - "id": "fNOTP83I5_fJ", - "outputId": "4c0a03a2-6f67-4c15-957e-261b56f1ad91", - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def bell(q1: QBit, q2: QBit) -> None:\n", - " H(target=q1)\n", - " CX(control=q1,target=q2)\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res1: Output[QBit], res2: Output[QBit]) -> None:\n", - " allocate(1, res1)\n", - " allocate(1, res2)\n", - " bell(q1=res1,q2=res2)\n", - "\n", - "# Your code here:\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "AY_kkbyi5_fM" - }, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 0 - }, - "id": "Y-c9r6OT5_fO", - "outputId": "8a2a41c7-bcee-4765-8906-4b7026bf3b71", - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def bell(q: QArray) -> None:\n", - " H(target=q[0])\n", - " CX(control=q[0],target=q[1])\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QArray]) -> None:\n", - " allocate(2, res)\n", - " bell(res)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "SoXeCLcX5_fQ" - }, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also Classical repeat(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 0 - }, - "id": "vFrcPTqi5_fS", - "outputId": "48c6573f-ba4d-4c47-b65f-dd2204818e8e", - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_hadamard(q: QArray) -> None:\n", - " repeat(count=q.len, iteration=lambda i: H(target=q[i]))\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QArray]) -> None:\n", - " allocate(10, res)\n", - " my_hadamard(res)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "98liCUg15_fT" - }, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to capture(en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also Capturing context variables and parameters(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "fonXAiHP5_fU" - }, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also Power operator(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "tD_aBHoU5_fW", - "tags": [] - }, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "yRWVHm1O5_fY" - }, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "bTtPgsj75_fZ", - "tags": [] - }, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 0 - }, - "id": "6Js8fNbl5_fa", - "outputId": "4d13cc20-3b3f-45b8-93fb-b353ab8cbea0", - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(2, q)\n", - " power(3, lambda: unitary(unitary_matrix, q))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "P-jP3v9O5_fb" - }, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also Operators(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 0 - }, - "id": "vvMbP91D5_fc", - "outputId": "18fca5c9-3b26-4683-98c7-c17f27de698a", - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_apply_to_all(operand: QCallable[QBit], q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: operand(q[i]))\n", - "\n", - "@qfunc\n", - "def my_hadamard(q: QArray[QBit]) -> None:\n", - " my_apply_to_all(lambda t: H(t), q)\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(10, q)\n", - " my_hadamard(q)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "gh690ZGT5_fe" - }, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also Quantum operators(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 0 - }, - "id": "00trO6SJ5_ff", - "outputId": "b022f930-40a5-436c-b3af-0a4e4e5d21d7", - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "from classiq.qmod.symbolic import pi\n", - "\n", - "\n", - "@qfunc\n", - "def my_controlled_ry(control_bit: QBit, target: QBit) -> None:\n", - " control(control_bit, lambda: RY(pi / 2, target))\n", - "\n", - "\n", - "@qfunc\n", - "def main(control_bit: Output[QBit], target: Output[QBit]) -> None:\n", - " allocate(1, control_bit)\n", - " allocate(1, target)\n", - " my_controlled_ry(control_bit, target)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "execute(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "GJ9y7jlY5_fh" - }, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also Numeric types(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also control(docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "IohNdRCA5_fi", - "outputId": "c3d53156-d530-48b8-e31b-80990b06e66d", - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], target: Output[QBit]) -> None:\n", - " prepare_int(9, x)\n", - " allocate(1, target)\n", - " control(x == 9, lambda: X(target))\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 [Default]", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/Yue(Leslie)_Xu_HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/Yue(Leslie)_Xu_HW1_QClass2024.ipynb deleted file mode 100644 index a058a318..00000000 --- a/community/QClass_2024/Submissions/HW1/Yue(Leslie)_Xu_HW1_QClass2024.ipynb +++ /dev/null @@ -1,596 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "import classiq" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/1cee8a34-ac97-482b-8eb4-515ef4eaf1cc?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)\n", - "\n", - "show(quantum_program)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/49c63ffe-0823-4fc5-be6e-8824c1612be4?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def create_bell_state(q0:QBit,q1:QBit)-> None:\n", - " H(q0)\n", - " CX(control=q0,target=q1)\n", - "\n", - "@qfunc\n", - "def main(qubit0:Output[QBit],qubit1:Output[QBit]) -> None:\n", - " allocate(1, qubit0)\n", - " allocate(1, qubit1)\n", - " create_bell_state(qubit1,qubit0)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "\n", - "show(qprog)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c7d4fb03-3c5e-4a0f-bae3-80a2d4abc76f?version=0.41.1\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def create_bell_state(reg:QArray[QBit,2])-> None:\n", - " H(reg[0])\n", - " CX(control=reg[0],target=reg[1])\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit,2]]) -> None:\n", - " allocate(2, res)\n", - " create_bell_state(reg=res)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8ad28de1-8d6f-4b5e-a407-ebe0a06e2c46?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " prepare_state(probabilities=[0.5,0,0,0.5], bound=0.01, out=x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8b0d6333-e3fc-4935-923c-e760a5a8b3dd?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def Hadamard_transform_function(q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10,reg)\n", - " Hadamard_transform_function(reg)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/027e01e3-5744-426d-bc8a-bc94cd128368?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(q: Output[QArray]):\n", - " allocate(2, q)\n", - " unitary(unitary_matrix, q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/551669bd-c8de-4679-b48e-50a217ff8214?version=0.41.1\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray]):\n", - " allocate(2, q)\n", - " # unitary(unitary_matrix**3, q)\n", - " power(3, lambda: unitary(unitary_matrix, q))\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "The gate count for both cases are identical..." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d241576d-2987-4b64-bcda-aa8980e8a48a?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_apply_to_all(operand: QCallable[QBit], q: QArray[QBit]) -> None:\n", - " repeat(q.len, lambda i: operand(q[i]))\n", - "\n", - "\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]) -> None:\n", - " my_apply_to_all(lambda t: H(t), q)\n", - "\n", - "\n", - "@qfunc\n", - "def main(reg: Output[QArray]):\n", - " allocate(10,reg)\n", - " my_hadamard_transform(reg)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ce06fe93-bdf5-42ae-8cc6-ccbd7fb6fa5f?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "import numpy\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def C_Ry(control_QBit: QBit, target: QBit) -> None:\n", - " control(control_QBit, lambda: RY(np.pi/2, target))\n", - "\n", - "@qfunc\n", - "def main(control_QBit: Output[QBit], target: Output[QBit]) -> None:\n", - " allocate(1,control_QBit)\n", - " allocate(1,target)\n", - " C_Ry(control_QBit,target)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5945fbc7-0643-4fe7-b104-2a75c59d7168?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum],q:Output[QBit]):\n", - " prepare_int(9, x)\n", - " allocate(1,q)\n", - " control(x==9,lambda: X(q))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/bogachan_arslan-HW1_QClass2024.ipynb b/community/QClass_2024/Submissions/HW1/bogachan_arslan-HW1_QClass2024.ipynb deleted file mode 100644 index 12246d76..00000000 --- a/community/QClass_2024/Submissions/HW1/bogachan_arslan-HW1_QClass2024.ipynb +++ /dev/null @@ -1,648 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/getting-started/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/platform/executor/#full-example)). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-25T11:39:01.817661Z", - "start_time": "2024-05-25T11:38:50.988114Z" - } - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/39024066-9bdb-489e-a665-680c62496521?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-05-23T22:55:17.157290Z", - "start_time": "2024-05-23T22:55:11.291099Z" - } - }, - "execution_count": 3 - }, - { - "cell_type": "code", - "outputs": [], - "source": [ - "job = execute(qprog)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-05-23T22:55:26.725205Z", - "start_time": "2024-05-23T22:55:24.939847Z" - } - }, - "execution_count": 5 - }, - { - "cell_type": "code", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'res': 0.0}\n", - "{'res': 1.0}\n" - ] - } - ], - "source": [ - "def print_parsed_counts(job):\n", - " results = job.result()\n", - " parsed_counts = results[0].value.parsed_counts\n", - " for parsed_state in parsed_counts: print(parsed_state.state)\n", - " \n", - "print_parsed_counts(job)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-05-23T22:55:29.311139Z", - "start_time": "2024-05-23T22:55:27.819933Z" - } - }, - "execution_count": 6 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-variables/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/functions#syntax)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-23T23:02:41.433382Z", - "start_time": "2024-05-23T23:02:36.907429Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0d413ae1-0115-45da-84f8-2db0808e758b?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def prepare_bell_pair(q1: QBit, q2: QBit):\n", - " H(q1)\n", - " CX(q1,q2)\n", - " \n", - "@qfunc\n", - "def main(q1: Output[QBit], q2: Output[QBit]):\n", - " allocate(1, q1)\n", - " allocate(1, q2)\n", - " prepare_bell_pair(q1, q2)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-23T23:04:23.367303Z", - "start_time": "2024-05-23T23:04:19.700134Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ec6113d1-459e-4ee5-afa8-f242f4afcf10?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def prepare_bell_pair_from_array(q: QArray[QBit]):\n", - " H(q[0])\n", - " CX(q[0],q[1])\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-23T23:07:15.376743Z", - "start_time": "2024-05-23T23:07:11.675863Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/448239b0-18e3-4102-a80d-38a8d319071c?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]):\n", - " repeat(q.len, lambda i: H(q[i]))\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(10, x)\n", - " my_hadamard_transform(x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/#capturing-context-variables-and-parameters)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-25T12:21:19.223456Z", - "start_time": "2024-05-25T12:21:19.202293Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "unitary_matrix\n" - ] - } - ], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())\n", - "print(unitary_matrix)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-25T12:27:11.227515Z", - "start_time": "2024-05-25T12:27:01.271328Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a506852e-1a62-4726-bd93-e394ea1e404f?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def apply_unitary(q: QArray[QBit]):\n", - " unitary(unitary_matrix, q)\n", - " \n", - "@qfunc\n", - "def apply_unitary_power3(q: QArray[QBit]):\n", - " power(3, lambda: apply_unitary(q))\n", - " \n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]):\n", - " allocate(2, q)\n", - " apply_unitary(q)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ecbe5b9b-41fb-4c78-8e71-96a32104c3da?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]]):\n", - " allocate(2, q)\n", - " apply_unitary_power3(q)\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-05-25T12:27:24.668041Z", - "start_time": "2024-05-25T12:27:20.889459Z" - } - }, - "execution_count": 7 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-25T12:47:55.601431Z", - "start_time": "2024-05-25T12:47:51.614390Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/34de8e2c-e56d-4bd2-8d8c-a7497349f00a?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def my_apply_to_all(q: QArray[QBit], op: QCallable[QBit]):\n", - " repeat(q.len, lambda i: op(q[i]))\n", - " \n", - "@qfunc\n", - "def my_hadamard_transform(q: QArray[QBit]):\n", - " my_apply_to_all(q, lambda i: H(i))\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " allocate(10, x)\n", - " my_hadamard_transform(x)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/#syntax).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-25T12:54:10.188974Z", - "start_time": "2024-05-25T12:54:06.492070Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/35569097-265b-4d9c-ac94-00fd16c8d2e9?version=0.41.2\n" - ] - } - ], - "source": [ - "import math\n", - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(q1: Output[QBit], q2: Output[QBit]):\n", - " allocate(1, q1)\n", - " allocate(1, q2)\n", - " control(q1, lambda: RY(math.pi/2, q2))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use the `prepare_int` function to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-25T12:59:47.390348Z", - "start_time": "2024-05-25T12:59:43.704796Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c8958143-bd4a-4ea2-8056-4f6b4d319de5?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc \n", - "def main(x: Output[QNum], q: Output[QBit]):\n", - " prepare_int(9, x)\n", - " allocate(1, q)\n", - " control(x == 9, lambda: X(q))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW1/index.md b/community/QClass_2024/Submissions/HW1/index.md index 3680c4e2..c86bcb5b 100644 --- a/community/QClass_2024/Submissions/HW1/index.md +++ b/community/QClass_2024/Submissions/HW1/index.md @@ -1,7 +1,9 @@ # Submitting HW1 ## Submission: Rules & Instructions + To keep track of submissions, we kindly ask you to: + 1. Complete `HW1_QClass2024.ipynb`. 2. Rename the files to include your full name, for example: `Nadav_Ben-Ami_HW1_QClass2024.ipynb`. 3. Navigate to your local clone of the `classiq-library`. @@ -14,7 +16,7 @@ To keep track of submissions, we kindly ask you to: **Please ensure you follow these steps carefully to properly submit your assignment!** ## Support + If you need help or have questions, feel free to reach out in our Slack channel! ## Enjoy your learning journey at QClass 2024! - diff --git a/community/QClass_2024/Submissions/HW2/ANIEKAN_AFANGIDEH_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/ANIEKAN_AFANGIDEH_HW2_QClass2024.ipynb deleted file mode 100644 index f529908f..00000000 --- a/community/QClass_2024/Submissions/HW2/ANIEKAN_AFANGIDEH_HW2_QClass2024.ipynb +++ /dev/null @@ -1,825 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 138, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 141, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/de4a5f91-3abf-4e71-8a52-81128cd3db9c?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [ PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3)\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/9c51893c-6451-41e4-a1b9-224f63b798e1?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - "\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - "\n", - " res |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 144, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/32a9636b-cfa4-4eb0-80da-8658ab9cd574?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - "\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - "\n", - " res |= x * y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/14b1cbc2-c90a-4d89-a151-3be386fcdfb5?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - "\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - " prepare_int(1,z)\n", - "\n", - " res |= x + y - z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'meas': 0.0}: 1027, {'meas': 1.0}: 1021]" - ] - }, - "execution_count": 146, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main():\n", - " x = QBit('x')\n", - " prepare_state(probabilities=[1/2,1/2],bound= 0, out=x)\n", - " #y = QBit('y')\n", - " #prepare_state(probabilities=[1/2,1/2],bound= 0, out=y)\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "parsed_counts" - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "metadata": {}, - "outputs": [], - "source": [ - "## The x_variable measures state 0 more (corresponding to number 0)" - ] - }, - { - "cell_type": "code", - "execution_count": 148, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'meas': 0.0}: 558,\n", - " {'meas': 1.0}: 527,\n", - " {'meas': 3.0}: 499,\n", - " {'meas': 2.0}: 464]" - ] - }, - "execution_count": 148, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "@qfunc\n", - "def main():\n", - " y = QArray('y')\n", - " prepare_state(probabilities=[1/4,1/4,1/4,1/4],bound= 0, out=y)\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "parsed_counts" - ] - }, - { - "cell_type": "code", - "execution_count": 149, - "metadata": {}, - "outputs": [], - "source": [ - "## The y_variable measures state 0 more (corresponding to number 6)" - ] - }, - { - "cell_type": "code", - "execution_count": 150, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/4163a826-2945-4422-b84f-92bc85a2b5d2?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - "\n", - " prepare_int(1,x) #(subtract the 1 later)\n", - " prepare_int(6,y)\n", - "\n", - " res |= x -1 + y \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 348, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/1400508e-7789-4852-817b-faa408bc022f?version=0.41.2\n", - "Synthesized circuit width: 16 depth: 100\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def linear_func(x:QNum, y:QNum, res: Output[QNum]):\n", - " res |= x + y\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - "\n", - " tmp = QNum('tmp')\n", - " within_apply(compute= lambda: linear_func(x, y, tmp),\n", - " action= lambda: linear_func(tmp, z, res))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(\"Synthesized circuit width:\", generated_circuit.data.width, \"depth:\", generated_circuit.transpiled_circuit.depth)\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 286, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0f9a35d1-2b36-41ba-8d90-56feb9809735?version=0.41.2\n", - "Opening: https://platform.classiq.io/circuit/d62abc28-a6a1-4a6f-a9a4-ae9317340228?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " w = QNum('w')\n", - "\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - " prepare_int(4,w)\n", - "\n", - " a = x + y \n", - " b = a + z\n", - " res |= b + w\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 296, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/4e054d02-afe2-4e4a-b59b-ddcc18e1ec7c?version=0.41.2\n", - "Opening: https://platform.classiq.io/circuit/2b2d18b9-134f-45c7-829d-8a11399d3248?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " w = QNum('w')\n", - "\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - " prepare_int(4,w)\n", - "\n", - " res |= x + y + z + w\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 297, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d1c97569-898d-4e52-8269-6a586d1fce40?version=0.41.2\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 298, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d0c9e9b9-f518-44ec-bed9-7f46b091ae2e?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 346, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/fe65e99e-1ed0-4216-8141-9b6c88fd51e1?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]):\n", - " x = QArray(\"x\")\n", - " allocate(3, x)\n", - " #pre_prepared_state(x)\n", - " hadamard_transform(x)\n", - " \n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - " \n", - " control(msb == 0, lambda: RY(pi / 3, lsb)) \n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) \n", - " bind([lsb, msb], res)\n", - " \n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Adrabi_Abderrahim_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Adrabi_Abderrahim_HW2_QClass2024.ipynb deleted file mode 100644 index eb9e71a9..00000000 --- a/community/QClass_2024/Submissions/HW2/Adrabi_Abderrahim_HW2_QClass2024.ipynb +++ /dev/null @@ -1,814 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-HZI6UGEYetH" - }, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": { - "id": "zGT4LpS6YhfY" - }, - "outputs": [], - "source": [ - "!pip install classiq -q" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "f5-jS5YpYetK", - "outputId": "6e393d77-2936-4068-a790-18138bf35c8d" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.10/dist-packages/classiq/_internals/authentication/token_manager.py:96: UserWarning: Device is already registered.\n", - "Generating a new refresh token should only be done if the current refresh token is compromised.\n", - "To do so, set the overwrite parameter to true\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "authenticate()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7leKb-8cYetL" - }, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": { - "id": "GH9Yl2WdYetM" - }, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "sFdc72CIYetN" - }, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": { - "id": "SbGquPtWYetN" - }, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "V3_R791YYetO" - }, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": { - "id": "uliJIXP9YetO", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "8e642ff3-95ad-4fb2-9619-fd60535d7dfc" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/f397363a-c1fd-4e08-a07b-d716545a3241?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "H = [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I , Pauli.Z, Pauli.Y], coefficient=0.3),\n", - "]\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " H,\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "O3eJO0QTYetP" - }, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": { - "id": "K9ryGECTYetP", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "33b77ee6-ad32-4507-c821-36358638b65a" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/e3ddd293-1e5b-4ec7-8760-bfd8a134b056?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(a: Output[QNum], b: Output[QNum], c: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - "\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - "\n", - " a |= x + y\n", - " b |= x * y\n", - " c |= b - z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2aCl16IMYetQ" - }, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": { - "id": "ghOkzh01YetR", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "d620e606-a011-4257-80e7-b4d363f4edb4" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/61d2ccfe-e7e9-47f9-86bc-f8caff48ed7f?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - "\n", - " prepare_state([1/2, 0, 1/2, 0], 0, x)\n", - " prepare_state([0, 1/4, 1/4, 1/4, 0, 1/4, 0, 0], 0, y)\n", - "\n", - " res |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "40wgXn0DYetR" - }, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": { - "id": "w4BGmyPkYetS", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "94c9298c-5752-4818-d409-9eafef8214b0" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/2b4d8f13-4cef-4f90-8bd9-048e1ab51b3e?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def add(x: QNum, y: QNum, o: Output[QNum]) -> None:\n", - " o |= x + y\n", - "\n", - "\n", - "@qfunc\n", - "def subroutine(x: QNum, y: QNum, z: QNum, res: Output[QNum]) -> None:\n", - " aux = QNum(\"aux\", 4, False, 0)\n", - "\n", - " within_apply(compute=lambda: add(x, y, aux), action= lambda: add(z, aux, res))\n", - "\n", - " # free(aux)\n", - " # Handle 'aux' was errored with \"Trying to access handle 'aux' as input but it is in incorrect state\"\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - "\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - "\n", - " subroutine(x, y, z, res)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Fv18Hp2KYetS" - }, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": { - "id": "7jPQYLVSYetT", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "1492d4ce-80df-4aee-f6ac-6615fb7f2bf4" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/8949ee26-4773-4c28-bcfd-5cba8c6bd1ed?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def add(x: QNum, y: QNum, o: Output[QNum]) -> None:\n", - " o |= x + y\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " w = QNum('w')\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - "\n", - "\n", - " tmp1 = QNum('tmp1')\n", - " tmp2 = QNum('tmp2')\n", - " within_apply(compute= lambda: add(x, y, tmp1), action= lambda: add(tmp1, z, tmp2))\n", - " res |= w + tmp2\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "T7KckzcPYetT" - }, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": { - "id": "qFvqTTHOYetU", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "7dc4c20e-91d1-424e-f983-439bb2bdbfff" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/104c5460-bf6f-4d46-a704-9f628d8fa389?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " w = QNum('w')\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - "\n", - " res |= x + y + z + w\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "q8gu9QKNYetU" - }, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": { - "id": "j4QuAKfiYetU", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "d629304e-85f3-4cc4-c8fe-0ddd480d6bad" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/f8f3efc4-fa1d-47df-becc-55c3232d14e0?version=0.41.2\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CoX8uSksYetV" - }, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": { - "id": "Z_o1EZUUYetV", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "15359aae-4c57-4bb1-be0d-409f31493b52" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/0dbea396-66ef-437f-b8aa-febb381af49b?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hpjIVPUIYetW" - }, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": { - "id": "bzhCjAG7YetW", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "1b5979d7-aa97-4867-a06a-cb298e79a607" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/b8493ae0-c887-41d5-a6b6-a5832023d539?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " #1\n", - " x : QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " #2\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "source": [ - "?prepare_state" - ], - "metadata": { - "id": "iznlXjz3N_QK" - }, - "execution_count": 70, - "outputs": [] - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "2sIZhb1QO8dK" - }, - "execution_count": 70, - "outputs": [] - } - ], - "metadata": { - "colab": { - "provenance": [], - "include_colab_link": true - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.8" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/community/QClass_2024/Submissions/HW2/Amon_Koike_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Amon_Koike_HW2_QClass2024.ipynb deleted file mode 100644 index 2812ec20..00000000 --- a/community/QClass_2024/Submissions/HW2/Amon_Koike_HW2_QClass2024.ipynb +++ /dev/null @@ -1,828 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b621fbea-15e6-4329-b2fe-9f3e8f6076e5?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# パウリ演算子のリストを定義\n", - "pauli_operators = [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3)\n", - "]\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " pauli_operator=pauli_operators,\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a347dd79-0b6d-4138-852d-3463a9e85caf?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - "\n", - " x = QNum(\"x\") #TODO complete the declarations of x,y\n", - " prepare_int(2, x)\n", - " y = QNum(\"y\")\n", - " prepare_int(7, y)\n", - " \n", - " \n", - " \n", - " res|=x+y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/dda069ad-b296-4baa-90ef-2856ad1b2924?version=0.42.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - "\n", - " x = QNum(\"x\") #TODO complete the declarations of x,y\n", - " prepare_int(2, x)\n", - " y = QNum(\"y\")\n", - " prepare_int(7, y)\n", - " \n", - " \n", - " \n", - " res|=x*y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b73b42d2-03a3-42fe-9497-4b677ea831bd?version=0.42.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - "\n", - " x = QNum(\"x\") #TODO complete the declarations of x,y\n", - " prepare_int(2, x)\n", - " y = QNum(\"y\")\n", - " prepare_int(7, y)\n", - " z = QNum(\"z\")\n", - " prepare_int(1, z)\n", - " \n", - " \n", - " res|=x*y-z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/343ba65a-262d-4392-bc95-93e17cfe8684?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc(external=True)\n", - "def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - ") -> None:\n", - " pass\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " # 2量子ビット変数 x の宣言と初期化\n", - " x = QNum(\"x\")\n", - " prepare_state(probabilities=[0.5, 0, 0.5, 0], bound=0, out=x)\n", - " \n", - " # 3量子ビット変数 y の宣言と初期化\n", - " y = QNum(\"y\")\n", - " prepare_state(probabilities=[0, 1/4, 1/4, 1/4, 0, 0, 1/4, 0], bound=0, out=y)\n", - " \n", - " # 足し算の実行\n", - " res |= x + y\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 16, depth: 100\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def add_xy(x: QNum, y: QNum, res: Output[QNum]) -> None:\n", - " res |= x + y\n", - "\n", - "@qfunc\n", - "def add_temp_z(temp: QNum, z: QNum, res: Output[QNum]) -> None:\n", - " res |= temp + z\n", - "\n", - "@qfunc\n", - "def uncompute_xy(x: QNum, y: QNum, temp: Output[QNum]) -> None:\n", - " temp |= x + y\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " \n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " \n", - " temp = QNum(\"temp\")\n", - "\n", - " # within_applyを使用して加算操作を定義\n", - " within_apply(\n", - " compute = lambda: add_xy(x, y, temp), # U\n", - " action = lambda:add_temp_z(temp, z, res) # V\n", - " )\n", - "\n", - " # Uncompute the first operation\n", - " within_apply(\n", - " compute = lambda :uncompute_xy(x, y, temp), # U\n", - " action = lambda: None # V\n", - " )\n", - " \n", - " \n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "#show(qprog)\n", - "\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5e4a8495-6140-42d5-8f7e-19e6c0b7c774?version=0.42.0\n", - "{'res': 14.0}\n", - "Synthesized circuit width: 16, depth: 165\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def add_xy(x: QNum, y: QNum, temp: Output[QNum]) -> None:\n", - " temp |= x + y\n", - "\n", - "@qfunc\n", - "def add_temp_z(temp: QNum, z: QNum, res: Output[QNum]) -> None:\n", - " res |= temp + z\n", - "\n", - "@qfunc\n", - "def uncompute_xy(x: QNum, y: QNum, temp: Output[QNum]) -> None:\n", - " temp |= x + y\n", - " \n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " w = QNum(\"w\")\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " \n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " \n", - " temp = QNum(\"temp\")\n", - " temp_result = QNum(\"temp_result\")\n", - "\n", - " within_apply(\n", - " compute = lambda: add_xy(x, y, temp),\n", - " action = lambda: add_temp_z(temp, z, temp_result)\n", - " )\n", - "\n", - " # Uncompute the first operation\n", - " within_apply(\n", - " compute = lambda: uncompute_xy(x, y, temp),\n", - " action = lambda: None\n", - " )\n", - " \n", - " # 最終結果に w を加算\n", - " res |= w + temp_result\n", - " \n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "def print_parsed_counts(job):\n", - " results = job.result()\n", - " parsed_counts = results[0].value.parsed_counts\n", - " for parsed_state in parsed_counts: print(parsed_state.state)\n", - "\n", - "job = execute(qprog)\n", - "print_parsed_counts(job)\n", - "\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/3690200f-3162-43ec-b105-b23b9ba09060?version=0.42.0\n", - "{'res': 14.0}\n", - "Synthesized circuit width: 12, depth: 155\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " w = QNum(\"w\")\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " \n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " \n", - " # 単一の算術式を使用して結果を計算\n", - " res |= x + y + z + w\n", - " \n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "def print_parsed_counts(job):\n", - " results = job.result()\n", - " parsed_counts = results[0].value.parsed_counts\n", - " for parsed_state in parsed_counts: print(parsed_state.state)\n", - "\n", - "job = execute(qprog)\n", - "print_parsed_counts(job)\n", - "\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 116, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 28, depth: 108\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def linear_func(a: CReal, b: CReal, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(3, x)\n", - " allocate(5, res)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - "\n", - " # 一時変数としてtemp_resを使用して計算\n", - " temp_res = QNum(\"temp_res\")\n", - " allocate(5, temp_res)\n", - " \n", - " control(label, lambda: linear_func(1.0, 0.5, x, temp_res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, temp_res)) # 0.0 <= x < 0.5\n", - "\n", - " # 最終結果をresにコピー\n", - " res ^= temp_res\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - "print_depth_width(qprog)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/68b2615d-9d5a-4236-851e-0a711051deaf?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/13e2adfc-2b98-437f-9934-c1177d3e249a?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "from math import pi\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8-sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8\n", - " ]\n", - "# 事前に準備された状態を設定する関数\n", - "@qfunc\n", - "def pre_prepared_state( q: Output[QArray[QBit]]) -> None:\n", - " prepare_state(\n", - " probabilities=prob_list,\n", - " bound=0.0,\n", - " out=q\n", - " )\n", - "\n", - "\n", - "\n", - "# Your code here:\n", - "# メイン関数\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x = QArray(\"x\")\n", - " \n", - " pre_prepared_state(x) # 事前に準備された状態を使用\n", - " \n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb]) # xをlsbとmsbに分割\n", - "\n", - " # msbが|01>のとき、lsbにRY(pi/3)を適用\n", - " control(msb == 1, lambda: RY(pi / 3, lsb))\n", - "\n", - " # 最後に結果をresにバインド\n", - " bind([lsb, msb], res)\n", - "\n", - "# モデルの作成とプログラムの合成\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Christopher_vanBommel_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Christopher_vanBommel_HW2_QClass2024.ipynb deleted file mode 100644 index e4f8c642..00000000 --- a/community/QClass_2024/Submissions/HW2/Christopher_vanBommel_HW2_QClass2024.ipynb +++ /dev/null @@ -1,858 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting classiq\n", - " Downloading classiq-0.41.1-py3-none-any.whl (398 kB)\n", - " 0.0/398.1 kB ? eta -:--:--\n", - " ----------- 122.9/398.1 kB 3.6 MB/s eta 0:00:01\n", - " -------------------------------------- 398.1/398.1 kB 5.0 MB/s eta 0:00:00\n", - "Collecting ConfigArgParse<2.0.0,>=1.5.3 (from classiq)\n", - " Downloading ConfigArgParse-1.7-py3-none-any.whl (25 kB)\n", - "Collecting Pyomo<6.6,>=6.5 (from classiq)\n", - " Downloading Pyomo-6.5.0-cp311-cp311-win_amd64.whl (4.0 MB)\n", - " 0.0/4.0 MB ? eta -:--:--\n", - " --- 0.4/4.0 MB 10.9 MB/s eta 0:00:01\n", - " ------- 0.7/4.0 MB 11.2 MB/s eta 0:00:01\n", - " ---------- 1.1/4.0 MB 9.6 MB/s eta 0:00:01\n", - " ------------- 1.4/4.0 MB 9.9 MB/s eta 0:00:01\n", - " ----------------- 1.8/4.0 MB 10.2 MB/s eta 0:00:01\n", - " --------------------- 2.1/4.0 MB 9.7 MB/s eta 0:00:01\n", - " ------------------------ 2.5/4.0 MB 9.9 MB/s eta 0:00:01\n", - " ---------------------------- 2.9/4.0 MB 9.6 MB/s eta 0:00:01\n", - " -------------------------------- 3.2/4.0 MB 9.8 MB/s eta 0:00:01\n", - " ----------------------------------- 3.6/4.0 MB 9.6 MB/s eta 0:00:01\n", - " ------------------------------------- 3.8/4.0 MB 9.6 MB/s eta 0:00:01\n", - " --------------------------------------- 4.0/4.0 MB 9.2 MB/s eta 0:00:01\n", - " ---------------------------------------- 4.0/4.0 MB 8.6 MB/s eta 0:00:00\n", - "Collecting black<25.0,>=24.0 (from classiq)\n", - " Downloading black-24.4.2-cp311-cp311-win_amd64.whl (1.4 MB)\n", - " 0.0/1.4 MB ? eta -:--:--\n", - " --------- 0.3/1.4 MB 10.6 MB/s eta 0:00:01\n", - " ------------------- 0.7/1.4 MB 10.9 MB/s eta 0:00:01\n", - " ---------------------------- 1.0/1.4 MB 9.2 MB/s eta 0:00:01\n", - " -------------------------------------- 1.4/1.4 MB 9.6 MB/s eta 0:00:01\n", - " ---------------------------------------- 1.4/1.4 MB 9.0 MB/s eta 0:00:00\n", - "Collecting httpx<1,>=0.23.0 (from classiq)\n", - " Downloading httpx-0.27.0-py3-none-any.whl (75 kB)\n", - " 0.0/75.6 kB ? eta -:--:--\n", - " ---------------------------------------- 75.6/75.6 kB 4.1 MB/s eta 0:00:00\n", - "Requirement already satisfied: keyring<24.0.0,>=23.5.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from classiq) (23.13.1)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from classiq) (3.7.1)\n", - "Requirement already satisfied: networkx<3.0.0,>=2.5.1 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from classiq) (2.8.4)\n", - "Requirement already satisfied: numexpr<3.0.0,>=2.7.3 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from classiq) (2.8.4)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from classiq) (1.24.3)\n", - "Collecting packaging<23.0,>=22.0 (from classiq)\n", - " Downloading packaging-22.0-py3-none-any.whl (42 kB)\n", - " 0.0/42.6 kB ? eta -:--:--\n", - " ---------------------------------------- 42.6/42.6 kB 2.0 MB/s eta 0:00:00\n", - "Requirement already satisfied: pandas<3.0.0,>=1.4.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from classiq) (1.5.3)\n", - "Requirement already satisfied: plotly<6.0.0,>=5.7.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from classiq) (5.9.0)\n", - "Collecting pydantic<2.0.0,>=1.9.1 (from classiq)\n", - " Downloading pydantic-1.10.15-cp311-cp311-win_amd64.whl (2.1 MB)\n", - " 0.0/2.1 MB ? eta -:--:--\n", - " ------ 0.4/2.1 MB 11.2 MB/s eta 0:00:01\n", - " ------------ 0.7/2.1 MB 8.7 MB/s eta 0:00:01\n", - " -------------------- 1.1/2.1 MB 9.9 MB/s eta 0:00:01\n", - " -------------------------- 1.4/2.1 MB 8.9 MB/s eta 0:00:01\n", - " --------------------------------- 1.8/2.1 MB 9.4 MB/s eta 0:00:01\n", - " --------------------------------------- 2.1/2.1 MB 9.6 MB/s eta 0:00:01\n", - " ---------------------------------------- 2.1/2.1 MB 9.0 MB/s eta 0:00:00\n", - "Requirement already satisfied: scipy<2.0.0,>=1.10.1 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from classiq) (1.10.1)\n", - "Collecting sympy<1.11.0,>=1.9.0 (from classiq)\n", - " Downloading sympy-1.10.1-py3-none-any.whl (6.4 MB)\n", - " 0.0/6.4 MB ? eta -:--:--\n", - " -- 0.3/6.4 MB 10.2 MB/s eta 0:00:01\n", - " ---- 0.7/6.4 MB 10.4 MB/s eta 0:00:01\n", - " ------ 1.0/6.4 MB 9.3 MB/s eta 0:00:01\n", - " -------- 1.4/6.4 MB 9.6 MB/s eta 0:00:01\n", - " ---------- 1.7/6.4 MB 9.9 MB/s eta 0:00:01\n", - " ------------ 2.0/6.4 MB 9.3 MB/s eta 0:00:01\n", - " --------------- 2.4/6.4 MB 9.6 MB/s eta 0:00:01\n", - " ----------------- 2.8/6.4 MB 9.3 MB/s eta 0:00:01\n", - " ------------------- 3.1/6.4 MB 9.5 MB/s eta 0:00:01\n", - " --------------------- 3.5/6.4 MB 9.3 MB/s eta 0:00:01\n", - " ------------------------ 3.9/6.4 MB 9.3 MB/s eta 0:00:01\n", - " -------------------------- 4.3/6.4 MB 9.5 MB/s eta 0:00:01\n", - " ----------------------------- 4.7/6.4 MB 9.4 MB/s eta 0:00:01\n", - " ------------------------------- 5.1/6.4 MB 9.5 MB/s eta 0:00:01\n", - " ---------------------------------- 5.5/6.4 MB 9.5 MB/s eta 0:00:01\n", - " ------------------------------------ 5.9/6.4 MB 9.4 MB/s eta 0:00:01\n", - " --------------------------------------- 6.3/6.4 MB 9.5 MB/s eta 0:00:01\n", - " --------------------------------------- 6.4/6.4 MB 9.5 MB/s eta 0:00:01\n", - " ---------------------------------------- 6.4/6.4 MB 8.9 MB/s eta 0:00:00\n", - "Requirement already satisfied: tabulate<1,>=0.8.9 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from classiq) (0.8.10)\n", - "Requirement already satisfied: click>=8.0.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from black<25.0,>=24.0->classiq) (8.0.4)\n", - "Requirement already satisfied: mypy-extensions>=0.4.3 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from black<25.0,>=24.0->classiq) (0.4.3)\n", - "Requirement already satisfied: pathspec>=0.9.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from black<25.0,>=24.0->classiq) (0.10.3)\n", - "Requirement already satisfied: platformdirs>=2 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from black<25.0,>=24.0->classiq) (2.5.2)\n", - "Requirement already satisfied: anyio in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from httpx<1,>=0.23.0->classiq) (3.5.0)\n", - "Requirement already satisfied: certifi in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from httpx<1,>=0.23.0->classiq) (2023.5.7)\n", - "Collecting httpcore==1.* (from httpx<1,>=0.23.0->classiq)\n", - " Downloading httpcore-1.0.5-py3-none-any.whl (77 kB)\n", - " 0.0/77.9 kB ? eta -:--:--\n", - " ---------------------------------------- 77.9/77.9 kB ? eta 0:00:00\n", - "Requirement already satisfied: idna in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from httpx<1,>=0.23.0->classiq) (3.4)\n", - "Requirement already satisfied: sniffio in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from httpx<1,>=0.23.0->classiq) (1.2.0)\n", - "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx<1,>=0.23.0->classiq)\n", - " Using cached h11-0.14.0-py3-none-any.whl (58 kB)\n", - "Requirement already satisfied: jaraco.classes in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from keyring<24.0.0,>=23.5.0->classiq) (3.2.1)\n", - "Requirement already satisfied: importlib-metadata>=4.11.4 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from keyring<24.0.0,>=23.5.0->classiq) (6.0.0)\n", - "Requirement already satisfied: pywin32-ctypes>=0.2.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from keyring<24.0.0,>=23.5.0->classiq) (0.2.0)\n", - "Requirement already satisfied: contourpy>=1.0.1 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.0.5)\n", - "Requirement already satisfied: cycler>=0.10 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.11.0)\n", - "Requirement already satisfied: fonttools>=4.22.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.25.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.4)\n", - "Requirement already satisfied: pillow>=6.2.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (9.4.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.0.9)\n", - "Requirement already satisfied: python-dateutil>=2.7 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from pandas<3.0.0,>=1.4.0->classiq) (2022.7)\n", - "Requirement already satisfied: tenacity>=6.2.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from plotly<6.0.0,>=5.7.0->classiq) (8.2.2)\n", - "Requirement already satisfied: typing-extensions>=4.2.0 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from pydantic<2.0.0,>=1.9.1->classiq) (4.6.3)\n", - "Requirement already satisfied: ply in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from Pyomo<6.6,>=6.5->classiq) (3.11)\n", - "Requirement already satisfied: mpmath>=0.19 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.2.1)\n", - "Requirement already satisfied: colorama in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from click>=8.0.0->black<25.0,>=24.0->classiq) (0.4.6)\n", - "Requirement already satisfied: zipp>=0.5 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from importlib-metadata>=4.11.4->keyring<24.0.0,>=23.5.0->classiq) (3.11.0)\n", - "Requirement already satisfied: six>=1.5 in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n", - "Requirement already satisfied: more-itertools in c:\\users\\c_van\\anaconda3\\lib\\site-packages (from jaraco.classes->keyring<24.0.0,>=23.5.0->classiq) (8.12.0)\n", - "Installing collected packages: sympy, Pyomo, pydantic, packaging, h11, ConfigArgParse, httpcore, black, httpx, classiq\n", - " Attempting uninstall: sympy\n", - " Found existing installation: sympy 1.11.1\n", - " Uninstalling sympy-1.11.1:\n", - " Successfully uninstalled sympy-1.11.1\n", - " Attempting uninstall: packaging\n", - " Found existing installation: packaging 23.0\n", - " Uninstalling packaging-23.0:\n", - " Successfully uninstalled packaging-23.0\n", - " Attempting uninstall: black\n", - " Found existing installation: black 0.0\n", - " Uninstalling black-0.0:\n", - " Successfully uninstalled black-0.0\n", - "Successfully installed ConfigArgParse-1.7 Pyomo-6.5.0 black-24.4.2 classiq-0.41.1 h11-0.14.0 httpcore-1.0.5 httpx-0.27.0 packaging-22.0 pydantic-1.10.15 sympy-1.10.1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "tables 3.8.0 requires blosc2~=2.0.0, which is not installed.\n", - "tables 3.8.0 requires cython>=0.29.21, which is not installed.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Your user code: KFZF-VMRD\n", - "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=KFZF-VMRD\n" - ] - } - ], - "source": [ - "!pip install -U classiq\n", - "import classiq\n", - "classiq.authenticate()" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d753d2b0-5d8c-4723-9c09-0d21ebe103d9?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3),\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/8eb3a413-6924-4a89-978b-bffe9e55d2d9?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], res: Output[QNum]):\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f20136b0-79cb-45be-b767-06ea75364387?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], res: Output[QNum]):\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x * y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/76d9212c-dd0f-4d1c-bec9-3f31f17eb626?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], res: Output[QNum]):\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - " res |= x * y - z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/4b8fd3e0-79ee-456e-b4bc-4b547961abea?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], res: Output[QNum]):\n", - " prepare_state([0.5, 0, 0.5, 0], 0, x)\n", - " prepare_state([0, 0.25, 0.25, 0.25, 0, 0, 0.25, 0], 0, y)\n", - " res |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c0fe48c5-3f3a-4dc2-9786-b1b6d023b3b9?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def add(x: QNum, y: QNum, res: Output[QNum]):\n", - " res |= x + y\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], res: Output[QNum]):\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " tmp = QNum(\"tmp\")\n", - " within_apply(compute=lambda: add(x, y, tmp), action=lambda: add(tmp, z, res))\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f6a20b2e-aba3-45fc-a6e2-8a3a730bf956?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def add(x: QNum, y: QNum, res: Output[QNum]):\n", - " res |= x + y\n", - "\n", - "@qfunc\n", - "def main(w: Output[QNum], x: Output[QNum], y: Output[QNum], z: Output[QNum], res: Output[QNum], final: Output[QNum]):\n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " tmp = QNum(\"tmp\")\n", - " within_apply(compute=lambda: add(x, y, tmp), action=lambda: add(tmp, z, res))\n", - " add(w, res, final)\n", - "\n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/aa480ddc-d0ac-4fee-b220-e969232b9184?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(w: Output[QNum], x: Output[QNum], y: Output[QNum], z: Output[QNum], res: Output[QNum]):\n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " res |= x + y + z + w\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/db0c0d14-3b8a-4f28-8b23-878853b41a40?version=0.41.1\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d7d88f80-0117-44db-b269-10717ad1db5f?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/cdcdc779-038d-4d8e-a9e0-b172b27fb443?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Christos_Koromilas_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Christos_Koromilas_HW2_QClass2024.ipynb deleted file mode 100644 index 5b5872bd..00000000 --- a/community/QClass_2024/Submissions/HW2/Christos_Koromilas_HW2_QClass2024.ipynb +++ /dev/null @@ -1 +0,0 @@ -{"cells":[{"cell_type":"markdown","metadata":{"id":"pRhwRioySQnF"},"source":["# The Qmod Workshop - Part 2: Higher-Level Concepts\n","\n","This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook."]},{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"GLj0bU36SQnM","executionInfo":{"status":"ok","timestamp":1716292802746,"user_tz":-120,"elapsed":360371,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"549b1b77-e63a-4440-845f-48b97b4192e1"},"outputs":[{"output_type":"stream","name":"stdout","text":["\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m398.1/398.1 kB\u001b[0m \u001b[31m4.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m53.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m61.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m32.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m2.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m25.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m26.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m2.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m4.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m4.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n","torch 2.2.1+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-nccl-cu12==2.19.3; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.2.1+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n","\u001b[0mYour user code: TWSL-HMWS\n","If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=TWSL-HMWS\n"]}],"source":["# !pip install -U -q classiq\n","import classiq\n","classiq.authenticate()\n","from classiq import *"]},{"cell_type":"markdown","metadata":{"id":"NmYpu0bISQnO"},"source":["### Exercise 6 - Exponentiation and Pauli Operators\n","\n","The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n","\n","See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n","\n","The builtin struct type `PauliTerm` is defined as follows:"]},{"cell_type":"code","execution_count":2,"metadata":{"id":"kMCQ7-JJSQnP","executionInfo":{"status":"ok","timestamp":1716292802748,"user_tz":-120,"elapsed":16,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}}},"outputs":[],"source":["@struct\n","class PauliTerm:\n"," pauli: CArray[Pauli]\n"," coefficient: CReal"]},{"cell_type":"markdown","metadata":{"id":"nhXyS0BqSQnQ"},"source":["Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n","\n","Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n","\n","In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n","\n","The declaration of the `suzuki_trotter` function is:"]},{"cell_type":"code","execution_count":3,"metadata":{"id":"c_KMRXzeSQnR","executionInfo":{"status":"ok","timestamp":1716292803671,"user_tz":-120,"elapsed":8,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}}},"outputs":[],"source":["@qfunc(external=True)\n","def suzuki_trotter(\n"," pauli_operator: CArray[PauliTerm],\n"," evolution_coefficient: CReal,\n"," order: CInt,\n"," repetitions: CInt,\n"," qbv: QArray[QBit],\n",") -> None:\n"," pass"]},{"cell_type":"markdown","metadata":{"id":"cv-CU-B9SQnS"},"source":["Fill in the missing parts of the following code in order to complete this exercise:"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"WckQ7Oq0SQnS","executionInfo":{"status":"ok","timestamp":1716292805670,"user_tz":-120,"elapsed":2006,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"2b7d404e-1e29-48aa-db32-6e4379eb831b"},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/d61d5f62-6c25-4219-96ee-ef327a2f3c0c?version=0.41.1\n"]}],"source":["from classiq import *\n","\n","hamiltonian = [ # H=0.5XZXX + 0.25YIZI + 0.3 XIZY\n"," PauliTerm(pauli=[Pauli.X,Pauli.Z,Pauli.X,Pauli.X], coefficient=0.5),\n"," PauliTerm(pauli=[Pauli.Y,Pauli.I,Pauli.Z,Pauli.I], coefficient=0.25),\n"," PauliTerm(pauli=[Pauli.X,Pauli.I,Pauli.Z,Pauli.Y], coefficient=0.3)\n","]\n","\n","@qfunc\n","def main(q: Output[QArray[QBit]]) -> None:\n"," allocate(4, q)\n"," suzuki_trotter(\n"," pauli_operator=hamiltonian,\n"," evolution_coefficient=3,\n"," repetitions=4,\n"," order=2,\n"," qbv=q,\n"," )\n","\n","\n","qmod = create_model(main)\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"markdown","metadata":{"id":"TQzTBkgASQnU"},"source":["### Exercise 7 - Basic Arithmetics\n","\n","#### Exercise 7a\n","In this exercise we will use quantum numeric variables and calculate expressions over them.\n","\n","See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n","See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n","\n","Create the following quantum programs:\n","1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n","2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n","3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n","\n","Guidance:\n","* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n","* To initialize the variables, use the function `prepare_int`.\n"]},{"cell_type":"code","execution_count":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"7-FzMGPpSQnU","executionInfo":{"status":"ok","timestamp":1716292807389,"user_tz":-120,"elapsed":1725,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"17c85ffd-1113-4cfc-96ff-19791f3d34e4"},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/b3fbca92-cdfc-4c4e-a1db-7534401ed93e?version=0.41.1\n"]}],"source":["from classiq import *\n","\n","@qfunc\n","def main(res: Output[QNum]) -> None:\n"," x = QNum(\"x\")\n"," y = QNum(\"y\")\n","\n"," prepare_int(2, x)\n"," prepare_int(7, y)\n","\n"," res |= (x + y)\n","\n","qmod = create_model(main)\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"code","source":["from classiq import *\n","\n","@qfunc\n","def main(res: Output[QNum]) -> None:\n"," x = QNum(\"x\")\n"," y = QNum(\"y\")\n","\n"," prepare_int(2, x)\n"," prepare_int(7, y)\n","\n"," res |= (x * y)\n","\n","qmod = create_model(main)\n","qprog = synthesize(qmod)\n","show(qprog)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"kgPeDpdghiou","executionInfo":{"status":"ok","timestamp":1716292809195,"user_tz":-120,"elapsed":1811,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"3208ad2f-9f0a-4094-9934-e3eda9ef0f8b"},"execution_count":6,"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/78f7ed02-4bb2-4e9f-b825-754067ee215d?version=0.41.1\n"]}]},{"cell_type":"code","source":["from classiq import *\n","\n","@qfunc\n","def main(res: Output[QNum]) -> None:\n"," x = QNum(\"x\")\n"," y = QNum(\"y\")\n"," z = QNum(\"z\")\n","\n"," prepare_int(2, x)\n"," prepare_int(7, y)\n"," prepare_int(1, z)\n","\n"," res |= (x*y)-z\n","\n","qmod = create_model(main)\n","qprog = synthesize(qmod)\n","show(qprog)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"U1kY0avdhifF","executionInfo":{"status":"ok","timestamp":1716292812370,"user_tz":-120,"elapsed":3178,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"3e48e23b-7c3f-43b0-921a-e2e58e18c415"},"execution_count":7,"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/d588e184-2de0-493b-a96b-692a64691e7a?version=0.41.1\n"]}]},{"cell_type":"markdown","metadata":{"id":"eybV-CldSQnV"},"source":["#### Exercise 7b\n","Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n","\n","We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n","\n","1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n"," The declaration of the `prepare_state` function is:\n"," ```\n"," @qfunc(external=True)\n"," def prepare_state(\n"," probabilities: CArray[CReal],\n"," bound: CReal,\n"," out: Output[QArray[QBit]],\n"," ) -> None:\n"," pass\n"," ```\n"," (Set the bound to 0 in your code)\n","2. Compute `res = x + y`. Execute the resulting circuit. What did you get?"]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"bBLPkBZFSQnW","executionInfo":{"status":"ok","timestamp":1716292813910,"user_tz":-120,"elapsed":1546,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"4b40b6e2-66a8-4e82-fba8-beb84044fe8c"},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/27925701-9c9d-40a5-8152-6e442d6d4c80?version=0.41.1\n"]}],"source":["from classiq import *\n","\n","@qfunc\n","def main(res: Output[QNum]) -> None:\n"," x = QNum(\"x\")\n"," y = QNum(\"y\")\n"," prepare_state([0.5, 0, 0.5, 0], 0, x)\n"," prepare_state([0, 0.25, 0.25, 0.25, 0, 0, 0.25, 0], 0, y)\n"," res |= x + y\n","\n","\n","qmod = create_model(main)\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"markdown","metadata":{"id":"1q0kOUEjSQnW"},"source":["### Exercise 8 - Within-Apply\n","\n","The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n","It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n","\n","See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n","\n","#### Exercise 8a\n","\n","In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n","\n","Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n","1. Add `x` and `y`\n","2. Add the result to `z`\n","3. Uncompute the result of the first operation\n","\n","For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n","\n","Hints:\n","\n","* Use a temporary variable.\n","* Wrap the arithmetic operation in a function.\n","\n","Execute the circuit and make sure you obtain the expected result."]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"jkR1Z8O2SQnW","executionInfo":{"status":"ok","timestamp":1716293132600,"user_tz":-120,"elapsed":3394,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"538d1055-678e-4d78-af10-f85bf09c14ac"},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/fa9393e9-95c7-4c8b-923c-7e62289e6aea?version=0.41.1\n"]}],"source":["from classiq import *\n","\n","@qfunc\n","def adding_numbers(a: QNum, b:QNum, result: Output[QNum]):\n"," result |= a + b\n","\n","@qfunc\n","def main(res: Output[QNum]):\n"," x = QNum(\"x\")\n"," y = QNum(\"y\")\n"," z = QNum(\"z\")\n","\n"," prepare_int(3, x)\n"," prepare_int(5, y)\n"," prepare_int(2, z)\n","\n"," aux = QNum(\"aux\")\n","\n"," within_apply(\n"," compute=lambda: adding_numbers(x, y, aux),\n"," action=lambda: adding_numbers(aux, z, res)\n"," )\n"," # free(aux) I tried but didnt work\n","\n","qmod = create_model(main)\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"markdown","metadata":{"id":"n_sfzBAiSQnX"},"source":["#### Exercise 8b\n","\n","Why should we use `within-apply` and not just write three concatenated functions?\n","To understand the motivation, we will create another arithmetic circuit.\n","This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n","\n","Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n","\n","Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n","\n","1. Add `x` and `y` (as part of the `within_apply` operation)\n","2. Add the result to `z` (as part of the within_apply operation)\n","3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n","4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n","\n","Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?"]},{"cell_type":"code","execution_count":14,"metadata":{"id":"AbOi47s_SQnX","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1716293179881,"user_tz":-120,"elapsed":2685,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"10d7886d-d2a2-4fc2-8a70-e8aa08292d19"},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/a858e3eb-a93b-4b25-97ae-a9263935fe1e?version=0.41.1\n"]}],"source":["from classiq import *\n","\n","constraints = Constraints(optimization_parameter='width')\n","\n","@qfunc\n","def main(res: Output[QNum]):\n"," x = QNum(\"x\")\n"," y = QNum(\"y\")\n"," z = QNum(\"z\")\n"," w = QNum(\"w\")\n","\n"," aux = QNum(\"aux\")\n"," aux2 = QNum(\"aux2\")\n","\n"," prepare_int(3, x)\n"," prepare_int(5, y)\n"," prepare_int(2, z)\n"," prepare_int(4, w)\n","\n"," within_apply(\n"," compute=lambda: adding_numbers(x, y, aux),\n"," action=lambda: adding_numbers(aux, z, aux2)\n"," )\n","\n"," adding_numbers(aux2, w, res)\n","\n","qmod = create_model(main)\n","qmod = set_constraints(qmod, constraints)\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"markdown","metadata":{"id":"Qi8ScaQtSQnY"},"source":["#### Bonus: Use a Single Arithmetic Expression\n","\n","What happens when we don't manually decompose this expression?\n","\n","Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n","Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?"]},{"cell_type":"code","execution_count":15,"metadata":{"id":"kDGhJjv9SQnY","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1716293445039,"user_tz":-120,"elapsed":2991,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"94a734b7-9a84-4ebb-de94-5e62bfbaca21"},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/dc4194ae-e6b1-4d3d-a5a1-e9e27c44790c?version=0.41.1\n"]}],"source":["from classiq import *\n","\n","@qfunc\n","def main(res: Output[QNum]):\n"," x = QNum(\"x\")\n"," y = QNum(\"y\")\n"," z = QNum(\"z\")\n"," w = QNum(\"w\")\n","\n"," prepare_int(3, x)\n"," prepare_int(5, y)\n"," prepare_int(2, z)\n"," prepare_int(4, w)\n","\n"," res |= x + y + z + w\n","\n","qmod = create_model(main)\n","qmod = set_constraints(qmod, constraints)\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"markdown","metadata":{"id":"Da1T1oP-SQnZ"},"source":["### Exercise 9 - In-place Arithmetics\n","\n","For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n","\n","Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n","\n","See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n","\n","In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n","\n","For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n","\n","$$\n","f(x) = \\begin{cases}\n"," 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n"," x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n"," \\end{cases}\n","$$\n","\n","Notes:\n","- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n","- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n"]},{"cell_type":"code","execution_count":16,"metadata":{"id":"8rXUBuPmSQnZ","outputId":"fbe9860f-c219-40e0-c1bb-878ebb13e3e1","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1716293474838,"user_tz":-120,"elapsed":9232,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/9c6df385-d9cf-4399-9dfb-4f0d65d19fcb?version=0.41.1\n"]}],"source":["\n","from classiq import *\n","\n","\n","def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n"," res ^= a * x + b\n","\n","\n","@qfunc\n","def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n"," CX(qba[qba.len - 1], msb)\n","\n","\n","@qfunc\n","def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n"," allocate(5, res)\n"," allocate(3, x)\n"," hadamard_transform(x)\n","\n"," label = QArray(\"label\")\n"," allocate(1, label)\n","\n"," dup_msb(x, label)\n"," control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n"," X(label)\n"," control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n","\n","\n","qmod = create_model(main)\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"markdown","metadata":{"id":"OHHQaXBISQna"},"source":["### Exercise 10 - State-preparation Algorithm using Quantum-if\n","\n","#### Binding\n","The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:"]},{"cell_type":"code","execution_count":17,"metadata":{"id":"_bWJeuemSQna","outputId":"3a58c384-9b51-477b-bfc0-cf1d010a316e","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1716293738291,"user_tz":-120,"elapsed":10089,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/8d37bca3-915a-47bb-bf84-de3dd17d77fe?version=0.41.1\n"]}],"source":["from classiq import *\n","\n","\n","\n","from classiq import *\n","from math import pi\n","\n","\n","@qfunc\n","def main(res: Output[QArray[QBit]]) -> None:\n"," x: QArray[QBit] = QArray(\"x\")\n"," allocate(3, x)\n"," hadamard_transform(x)\n","\n"," lsb = QBit(\"lsb\")\n"," msb = QNum(\"msb\", 2, False, 0)\n"," bind(x, [lsb, msb])\n","\n"," control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n","\n"," bind([lsb, msb], res)\n","\n","model = create_model(main)\n","qprog = synthesize(model)\n","show(qprog)"]},{"cell_type":"markdown","metadata":{"id":"7mGBC5S_SQnb"},"source":["The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n","\n","After the `bind` operation:\n","1. The registers `lsb` and `msb` can be operated on as separated registers.\n","2. The register`x` is consumed and can no longer be used.\n","\n","The second `bind` operation concatenates the registers to the output register `res`.\n","\n","For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n","\n","The following series of gates generate it:\n","\n","Perform the Hadamard transform on all three qubits.\n","\n","Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n","\n","The following series of gates generate it:\n","1. Perform the Hadamard transform on all three qubits.\n","2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n","\n","If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"DKOuI5WRSQnb"},"outputs":[],"source":["from classiq import *\n","from classiq.qmod.symbolic import sqrt\n","\n","prob_list= [\n"," 1 / 8,\n"," 1 / 8,\n"," 1 / 8,\n"," -sqrt(3) / 16,\n"," 1 / 8 + sqrt(3) / 16,\n"," 1 / 8,\n"," 1 / 8,\n"," 1 / 8,\n"," 1 / 8,\n"," ]\n","@qfunc\n","def pre_prepared_state(q: QArray[QBit]) -> None:\n"," prepare_state(\n"," [\n"," 1 / 8,\n"," 1 / 8,\n"," 1 / 8,\n"," -sqrt(3) / 16,\n"," 1 / 8 + sqrt(3) / 16,\n"," 1 / 8,\n"," 1 / 8,\n"," 1 / 8,\n"," 1 / 8,\n"," ],\n"," 0.0,\n"," q,\n"," )\n","\n","\n","@qfunc\n","def main(x: Output[QArray[QBit]]):\n"," prepare_state(\n"," prob_list,\n"," 0.0,\n"," x,\n"," )\n","\n","qmod = create_model(main)\n","# write_qmod(qmod, \"prepare_state\")\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"code","source":["@qfunc\n","def main(res: Output[QArray[QBit]]) -> None:\n"," x: QArray[QBit] = QArray(\"x\")\n"," allocate(3, x)\n"," hadamard_transform(x)\n","\n"," lsb = QBit(\"lsb\")\n"," msb = QNum(\"msb\", 2, False, 0)\n"," bind(x, [lsb, msb])\n","\n"," control(msb == 2, lambda: RY(pi / 3, lsb))\n","\n"," bind([lsb, msb], res)\n","\n","model = create_model(main)\n","qprog = synthesize(model)\n","show(qprog)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Lw0TewdMIOCO","executionInfo":{"status":"ok","timestamp":1716294598186,"user_tz":-120,"elapsed":10249,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"29040fa1-f84f-4919-9fe9-bd670ac40a92"},"execution_count":22,"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/418454d8-5633-4b29-aa4a-d5865555d2e3?version=0.41.1\n"]}]}],"metadata":{"kernelspec":{"display_name":"Python 3 (ipykernel)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.11.8"},"colab":{"provenance":[]}},"nbformat":4,"nbformat_minor":0} \ No newline at end of file diff --git a/community/QClass_2024/Submissions/HW2/Claudia_Zendejas-Morales_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Claudia_Zendejas-Morales_HW2_QClass2024.ipynb deleted file mode 100644 index 1bc3ab8c..00000000 --- a/community/QClass_2024/Submissions/HW2/Claudia_Zendejas-Morales_HW2_QClass2024.ipynb +++ /dev/null @@ -1,983 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "```python\n", - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/45c2b80d-6dce-4cf4-b56e-316c98d6fff5?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3),\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/aa29bf7c-d3f4-47d6-97cb-b18edb9ae7a6?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None: # x + y\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 9.0}: 2048]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we see the result state ('res') = 9 = 2 + 7 with all probability" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/94e88df8-f6bd-4936-a8ff-f7235f286840?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None: # x * y\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x * y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 14.0}: 2048]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we see the result state ('res') = 14 = 2 * 7 with all probability" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/caf6fde5-8587-4467-975f-854ef08e7111?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None: # x * y - z\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - " res |= x * y - z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 13.0}: 2048]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we see the result state ('res') = 13 = 2 * 7 - 1 with all probability" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```python\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/cb930019-dd37-483c-902d-6054fdaf6636?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None: # x + y\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_state(probabilities=[1/2, 0, 1/2, 0], bound=0.0, out=x)\n", - " prepare_state(probabilities=[0, 1/4, 1/4, 1/4, 0, 0, 1/4, 0], bound=0.0, out=y)\n", - " res |= x + y\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 3.0}: 491, {'res': 5.0}: 266, {'res': 8.0}: 265, {'res': 1.0}: 259, {'res': 4.0}: 257, {'res': 2.0}: 256, {'res': 6.0}: 254]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we see all the possible results\n", - " # x + y = res\n", - " # ------------\n", - " # 0 + 1 = 1\n", - " # 0 + 2 = 2\n", - " # 0 + 3 = 3 <- probability of 3 is double (it is obtained with two different combinations: 'x' & 'y')\n", - " # 0 + 6 = 6\n", - " # 2 + 1 = 3 <- probability of 3 is double (it is obtained with two different combinations: 'x' & 'y')\n", - " # 2 + 2 = 4\n", - " # 2 + 3 = 5\n", - " # 2 + 6 = 8" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5eccff06-e236-42e4-9dc4-a8ea6829f81d?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def my_sum(a:QNum, b:QNum, r:Output[QNum]) -> None:\n", - " r |= a + b\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None: # x + y + z\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - "\n", - " temp = QNum(\"temp\")\n", - " \n", - " within_apply(lambda: my_sum(x, y, temp), lambda: my_sum(temp, z, res))\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 10.0}: 2048]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we the expected result: 10 = 3 + 5 + 2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5f1bcddf-c669-4eb2-a7af-25a861640eef?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None: # x + y + z + w\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " w = QNum(\"w\")\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - "\n", - " temp1 = QNum(\"temp1\")\n", - " temp2 = QNum(\"temp2\")\n", - " \n", - " within_apply(lambda: my_sum(x, y, temp1), lambda: my_sum(temp1, z, temp2))\n", - "\n", - " my_sum(temp2, w, res)\n", - "\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "# With no constrains:\n", - "# Program info\n", - "# Depth: 75\n", - "# Width: 25\n", - "# Gate count\n", - "# X : 6" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ccedc9e2-774f-4db6-b7dc-b02271a78bde?version=0.41.2\n" - ] - } - ], - "source": [ - "qmod = create_model(main)\n", - "qmod_constraints = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", - "qprog = synthesize(qmod_constraints)\n", - "show(qprog)\n", - "\n", - "# With constrains:\n", - "# Program info\n", - "# Depth: 97\n", - "# Width: 21 <- better value\n", - "# Gate count\n", - "# X : 6" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 14.0}: 2048]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we the expected result: 14 = 3 + 5 + 2 + 4" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f8c76932-f0b8-4a2f-bce6-03ce92a211dd?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None: # x + y + z + w\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " w = QNum(\"w\")\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - "\n", - " res |= x + y + z + w\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "# With no constrains:\n", - "# Program info\n", - "# Depth: 67 <- this is better than when 'within_apply' was used\n", - "# Width: 12\n", - "# Gate count\n", - "# X : 6" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/cb6097a9-0b34-4016-a964-ea34489c9b5a?version=0.41.2\n" - ] - } - ], - "source": [ - "qmod = create_model(main)\n", - "qmod_constraints = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", - "qprog = synthesize(qmod_constraints)\n", - "show(qprog)\n", - "\n", - "# With constrains:\n", - "# Program info\n", - "# Depth: 67 <- this is better than when 'within_apply' was used\n", - "# Width: 12 <- value didn't change\n", - "# Gate count\n", - "# X : 6" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 14.0}: 2048]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we the expected result: 14 = 3 + 5 + 2 + 4" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `control` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/62d857a5-c0c1-440a-8ac4-872376712ba1?version=0.41.2\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'x': 0.375, 'res': 1.75}: 278, {'x': 0.25, 'res': 1.5}: 265, {'x': 0.0, 'res': 1.0}: 261, {'x': 0.125, 'res': 1.25}: 253, {'x': 0.875, 'res': 1.375}: 253, {'x': 0.75, 'res': 1.25}: 250, {'x': 0.5, 'res': 1.0}: 244, {'x': 0.625, 'res': 1.125}: 244]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we see all the possible results\n", - " # 2x + 1 0 <= x < 0.5\n", - " # x + 0.5 0.5 <= x < 1\n", - " # examples: x op res\n", - " # 0.375 : 2x + 1 = 1.75\n", - " # 0.75 : x + 0.5 = 1.25" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/184f1913-9ff2-44b8-9321-2cb267b86171?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c087d349-bde7-4f9c-95c1-12d7bc62a21d?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8 - sqrt(3) / 16, # <- updated\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8 - sqrt(3) / 16, # <- updated\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 3.0}: 515, {'res': 1.0}: 278, {'res': 6.0}: 253, {'res': 7.0}: 248, {'res': 4.0}: 247, {'res': 0.0}: 239, {'res': 5.0}: 236, {'res': 2.0}: 32]\n" - ] - } - ], - "source": [ - "job = execute(qprog) # let's execute the quantum program\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "print(parsed_counts) # we see all the possible results" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Csaba_Szilard_Racz-HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Csaba_Szilard_Racz-HW2_QClass2024.ipynb deleted file mode 100644 index a6b1b72a..00000000 --- a/community/QClass_2024/Submissions/HW2/Csaba_Szilard_Racz-HW2_QClass2024.ipynb +++ /dev/null @@ -1,678 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/96b440ec-602c-4cc1-8760-7330cef566bc?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " \n", - " Pt1 = PauliTerm(pauli=[Pauli.X,Pauli.Z,Pauli.X,Pauli.X], coefficient=0.5)\n", - " Pt2 = PauliTerm(pauli=[Pauli.Y,Pauli.I,Pauli.Z,Pauli.I], coefficient=0.25)\n", - " Pt3 = PauliTerm(pauli=[Pauli.X,Pauli.I,Pauli.Z,Pauli.Y], coefficient=0.3)\n", - " suzuki_trotter(\n", - " pauli_operator = [Pt1,Pt2,Pt3],\n", - " evolution_coefficient=3,\n", - " order=2,\n", - " repetitions=4,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/2227b52d-fa68-4880-b6e0-6303cee46776?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " \n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - " \n", - " res |= x * y - z\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/689d50a4-01af-444a-827f-6556e16ff621?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " \n", - " prepare_state(\n", - " probabilities = [0.5, 0, 0.5, 0], # 0,1,2,3\n", - " bound = 0,\n", - " out = x\n", - " )\n", - " \n", - " prepare_state(\n", - " probabilities = [0, 0.25, 0.25, 0.25, 0, 0, 0.25, 0], # 0,1,2,3,4,5,6,7\n", - " bound = 0,\n", - " out = y\n", - " )\n", - " \n", - " res |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/eeebf166-c8a7-4ac5-b968-c89f7c7a4cd0?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def prep_plus(out: Output[QNum], x: QNum, y: QNum) -> None:\n", - " out |= x + y\n", - " \n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " \n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " \n", - " out = QNum(\"out\")\n", - " within_apply(lambda: prep_plus(out, x, y), lambda: prep_plus(res, out, z))\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/998eb506-6007-4d44-80a6-2283efc0dfc1?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def prep_plus(out: Output[QNum], x: QNum, y: QNum) -> None:\n", - " out |= x + y\n", - " \n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " w = QNum(\"w\")\n", - " \n", - " \n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - " \n", - " out = QNum(\"out\")\n", - " sub = QNum(\"sub\")\n", - " within_apply(lambda: prep_plus(out, x, y), lambda: prep_plus(sub, out, z))\n", - " # within_apply(lambda: prepare_int(4, w), lambda: prep_plus(res,res,w))\n", - " res |= sub + w\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "# adding constraint\n", - "qmod = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/f9e86827-8bde-4112-a24a-dda68a2e4c3c?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " w = QNum(\"w\")\n", - " \n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - " \n", - " res |= x+y+z+w\n", - "\n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/087a3c3d-6a79-4c3f-b675-1a9bbcb54624?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/3ece7430-c3a6-4dc5-b468-6b7507c80da3?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/819fb49c-c4ae-43d1-a521-9d32fb0a5b69?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " # applying rotation on the Least Significant Bit\n", - " control(msb == 1, lambda: RY(pi / 3, lsb))\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/HW2_QClass2024 - Bill Wisotsky.ipynb b/community/QClass_2024/Submissions/HW2/HW2_QClass2024 - Bill Wisotsky.ipynb deleted file mode 100644 index 596324c5..00000000 --- a/community/QClass_2024/Submissions/HW2/HW2_QClass2024 - Bill Wisotsky.ipynb +++ /dev/null @@ -1,734 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "ename": "PasswordSetError", - "evalue": "Can't store password on keychain: (-25244, 'Unknown Error')", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mClassiqExpiredTokenError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/client.py:114\u001b[0m, in \u001b[0;36mtry_again_on_failure..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 114\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mawait\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 115\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m ClassiqExpiredTokenError:\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/jobs.py:103\u001b[0m, in \u001b[0;36mJobPoller._request\u001b[0;34m(self, http_method, url, body)\u001b[0m\n\u001b[1;32m 100\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_async_client\u001b[38;5;241m.\u001b[39mrequest(\n\u001b[1;32m 101\u001b[0m method\u001b[38;5;241m=\u001b[39mhttp_method, url\u001b[38;5;241m=\u001b[39murl, json\u001b[38;5;241m=\u001b[39mbody, headers\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_additional_headers\n\u001b[1;32m 102\u001b[0m )\n\u001b[0;32m--> 103\u001b[0m \u001b[43mclient\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhandle_response\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresponse\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 104\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/client.py:190\u001b[0m, in \u001b[0;36mClient.handle_response\u001b[0;34m(self, response)\u001b[0m\n\u001b[1;32m 189\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m response\u001b[38;5;241m.\u001b[39mis_error:\n\u001b[0;32m--> 190\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle_error\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresponse\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 191\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_handle_success(response)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/client.py:201\u001b[0m, in \u001b[0;36mClient._handle_error\u001b[0;34m(response)\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m expired:\n\u001b[0;32m--> 201\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqExpiredTokenError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExpired token\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 203\u001b[0m message \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCall to API failed with code \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresponse\u001b[38;5;241m.\u001b[39mstatus_code\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n", - "\u001b[0;31mClassiqExpiredTokenError\u001b[0m: Expired token\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/keyring/backends/macOS/__init__.py:40\u001b[0m, in \u001b[0;36mKeyring.set_password\u001b[0;34m(self, service, username, password)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 40\u001b[0m \u001b[43mapi\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_generic_password\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mkeychain\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mservice\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43musername\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpassword\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m api\u001b[38;5;241m.\u001b[39mKeychainDenied \u001b[38;5;28;01mas\u001b[39;00m e:\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/keyring/backends/macOS/api.py:152\u001b[0m, in \u001b[0;36mset_generic_password\u001b[0;34m(name, service, username, password)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m contextlib\u001b[38;5;241m.\u001b[39msuppress(NotFound):\n\u001b[0;32m--> 152\u001b[0m \u001b[43mdelete_generic_password\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mservice\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43musername\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 154\u001b[0m q \u001b[38;5;241m=\u001b[39m create_query(\n\u001b[1;32m 155\u001b[0m kSecClass\u001b[38;5;241m=\u001b[39mk_(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mkSecClassGenericPassword\u001b[39m\u001b[38;5;124m'\u001b[39m),\n\u001b[1;32m 156\u001b[0m kSecAttrService\u001b[38;5;241m=\u001b[39mservice,\n\u001b[1;32m 157\u001b[0m kSecAttrAccount\u001b[38;5;241m=\u001b[39musername,\n\u001b[1;32m 158\u001b[0m kSecValueData\u001b[38;5;241m=\u001b[39mpassword,\n\u001b[1;32m 159\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/keyring/backends/macOS/api.py:173\u001b[0m, in \u001b[0;36mdelete_generic_password\u001b[0;34m(name, service, username)\u001b[0m\n\u001b[1;32m 172\u001b[0m status \u001b[38;5;241m=\u001b[39m SecItemDelete(q)\n\u001b[0;32m--> 173\u001b[0m \u001b[43mError\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstatus\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/keyring/backends/macOS/api.py:115\u001b[0m, in \u001b[0;36mError.raise_for_status\u001b[0;34m(cls, status)\u001b[0m\n\u001b[1;32m 110\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m SecAuthFailure(\n\u001b[1;32m 111\u001b[0m status,\n\u001b[1;32m 112\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSecurity Auth Failure: make sure \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpython is signed with codesign util\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 114\u001b[0m )\n\u001b[0;32m--> 115\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mcls\u001b[39m(status, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUnknown Error\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[0;31mError\u001b[0m: (-25244, 'Unknown Error')", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mPasswordSetError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[4], line 21\u001b[0m\n\u001b[1;32m 7\u001b[0m suzuki_trotter(\n\u001b[1;32m 8\u001b[0m [\n\u001b[1;32m 9\u001b[0m PauliTerm(pauli\u001b[38;5;241m=\u001b[39m[Pauli\u001b[38;5;241m.\u001b[39mX, Pauli\u001b[38;5;241m.\u001b[39mZ, Pauli\u001b[38;5;241m.\u001b[39mX, Pauli\u001b[38;5;241m.\u001b[39mX], coefficient\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m.5\u001b[39m),\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 16\u001b[0m qbv\u001b[38;5;241m=\u001b[39mq,\n\u001b[1;32m 17\u001b[0m )\n\u001b[1;32m 20\u001b[0m qmod \u001b[38;5;241m=\u001b[39m create_model(main)\n\u001b[0;32m---> 21\u001b[0m qprog \u001b[38;5;241m=\u001b[39m \u001b[43msynthesize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqmod\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 22\u001b[0m show(qprog)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/async_utils.py:45\u001b[0m, in \u001b[0;36msyncify_function..async_wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(async_func)\n\u001b[1;32m 44\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21masync_wrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T:\n\u001b[0;32m---> 45\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43masync_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/async_utils.py:39\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(coro)\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun\u001b[39m(coro: Awaitable[T]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T:\n\u001b[1;32m 35\u001b[0m \u001b[38;5;66;03m# Use this function instead of asyncio.run, since it ALWAYS\u001b[39;00m\n\u001b[1;32m 36\u001b[0m \u001b[38;5;66;03m# creates a new event loop and clears the thread event loop.\u001b[39;00m\n\u001b[1;32m 37\u001b[0m \u001b[38;5;66;03m# Never use asyncio.run in library code.\u001b[39;00m\n\u001b[1;32m 38\u001b[0m loop \u001b[38;5;241m=\u001b[39m get_event_loop()\n\u001b[0;32m---> 39\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mloop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_until_complete\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcoro\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/nest_asyncio.py:90\u001b[0m, in \u001b[0;36m_patch_loop..run_until_complete\u001b[0;34m(self, future)\u001b[0m\n\u001b[1;32m 87\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m f\u001b[38;5;241m.\u001b[39mdone():\n\u001b[1;32m 88\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[1;32m 89\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mEvent loop stopped before Future completed.\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 90\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresult\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/asyncio/futures.py:201\u001b[0m, in \u001b[0;36mFuture.result\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 199\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__log_traceback \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m 200\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 201\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_result\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/asyncio/tasks.py:256\u001b[0m, in \u001b[0;36mTask.__step\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 252\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 253\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m exc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 254\u001b[0m \u001b[38;5;66;03m# We use the `send` method directly, because coroutines\u001b[39;00m\n\u001b[1;32m 255\u001b[0m \u001b[38;5;66;03m# don't have `__iter__` and `__next__` methods.\u001b[39;00m\n\u001b[0;32m--> 256\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mcoro\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 257\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 258\u001b[0m result \u001b[38;5;241m=\u001b[39m coro\u001b[38;5;241m.\u001b[39mthrow(exc)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/synthesis.py:20\u001b[0m, in \u001b[0;36msynthesize_async\u001b[0;34m(serialized_model)\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msynthesize_async\u001b[39m(\n\u001b[1;32m 17\u001b[0m serialized_model: SerializedModel,\n\u001b[1;32m 18\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m SerializedQuantumProgram:\n\u001b[1;32m 19\u001b[0m model \u001b[38;5;241m=\u001b[39m pydantic\u001b[38;5;241m.\u001b[39mparse_raw_as(Model, serialized_model)\n\u001b[0;32m---> 20\u001b[0m quantum_program \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m ApiWrapper\u001b[38;5;241m.\u001b[39mcall_generation_task(model)\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m SerializedQuantumProgram(quantum_program\u001b[38;5;241m.\u001b[39mjson(indent\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m))\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/api_wrapper.py:107\u001b[0m, in \u001b[0;36mApiWrapper.call_generation_task\u001b[0;34m(cls, model)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;129m@classmethod\u001b[39m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_generation_task\u001b[39m(\n\u001b[1;32m 104\u001b[0m \u001b[38;5;28mcls\u001b[39m, model: Model\n\u001b[1;32m 105\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m generator_result\u001b[38;5;241m.\u001b[39mQuantumProgram:\n\u001b[1;32m 106\u001b[0m poller \u001b[38;5;241m=\u001b[39m JobPoller(base_url\u001b[38;5;241m=\u001b[39mroutes\u001b[38;5;241m.\u001b[39mTASKS_GENERATE_FULL_PATH)\n\u001b[0;32m--> 107\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m poller\u001b[38;5;241m.\u001b[39mrun_pydantic(model, timeout_sec\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _parse_job_response(result, generator_result\u001b[38;5;241m.\u001b[39mQuantumProgram)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/jobs.py:180\u001b[0m, in \u001b[0;36mJobPoller.run_pydantic\u001b[0;34m(self, model, timeout_sec)\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_pydantic\u001b[39m(\n\u001b[1;32m 174\u001b[0m \u001b[38;5;28mself\u001b[39m, model: pydantic\u001b[38;5;241m.\u001b[39mBaseModel, timeout_sec: Optional[\u001b[38;5;28mfloat\u001b[39m]\n\u001b[1;32m 175\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m GeneralJobDescription:\n\u001b[1;32m 176\u001b[0m \u001b[38;5;66;03m# TODO: we can't use model.dict() - it doesn't serialize complex class.\u001b[39;00m\n\u001b[1;32m 177\u001b[0m \u001b[38;5;66;03m# This was added because JSON serializer doesn't serialize complex type, and pydantic does.\u001b[39;00m\n\u001b[1;32m 178\u001b[0m \u001b[38;5;66;03m# We should add support for smarter json serialization.\u001b[39;00m\n\u001b[1;32m 179\u001b[0m body \u001b[38;5;241m=\u001b[39m json\u001b[38;5;241m.\u001b[39mloads(model\u001b[38;5;241m.\u001b[39mjson())\n\u001b[0;32m--> 180\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun(body, timeout_sec)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/jobs.py:163\u001b[0m, in \u001b[0;36mJobPoller.run\u001b[0;34m(self, body, timeout_sec)\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun\u001b[39m(\n\u001b[1;32m 160\u001b[0m \u001b[38;5;28mself\u001b[39m, body: Dict, timeout_sec: Optional[\u001b[38;5;28mfloat\u001b[39m]\n\u001b[1;32m 161\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m GeneralJobDescription:\n\u001b[1;32m 162\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_async_client:\n\u001b[0;32m--> 163\u001b[0m submit_response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_submit(body\u001b[38;5;241m=\u001b[39mbody)\n\u001b[1;32m 164\u001b[0m job_id \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_parse_job_id_response(response\u001b[38;5;241m=\u001b[39msubmit_response)\n\u001b[1;32m 165\u001b[0m poll_url \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_poll_url(job_id\u001b[38;5;241m=\u001b[39mjob_id)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/jobs.py:107\u001b[0m, in \u001b[0;36mJobPoller._submit\u001b[0;34m(self, body)\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_submit\u001b[39m(\u001b[38;5;28mself\u001b[39m, body: Dict) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m httpx\u001b[38;5;241m.\u001b[39mResponse:\n\u001b[0;32m--> 107\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_request(http_method\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPOST\u001b[39m\u001b[38;5;124m\"\u001b[39m, url\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_base_url, body\u001b[38;5;241m=\u001b[39mbody)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/client.py:125\u001b[0m, in \u001b[0;36mtry_again_on_failure..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m i \u001b[38;5;241m==\u001b[39m _RETRY_COUNT \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 124\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m\n\u001b[0;32m--> 125\u001b[0m \u001b[38;5;28;01mawait\u001b[39;00m client()\u001b[38;5;241m.\u001b[39mupdate_expired_access_token()\n\u001b[1;32m 126\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m httpx\u001b[38;5;241m.\u001b[39mRemoteProtocolError:\n\u001b[1;32m 127\u001b[0m _logger\u001b[38;5;241m.\u001b[39minfo(\n\u001b[1;32m 128\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExperienced a httpx connection error, retrying to connect...\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 129\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/client.py:272\u001b[0m, in \u001b[0;36mClient.update_expired_access_token\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 271\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mupdate_expired_access_token\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 272\u001b[0m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_token_manager\u001b[38;5;241m.\u001b[39mupdate_expired_access_token()\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/authentication/token_manager.py:75\u001b[0m, in \u001b[0;36mTokenManager.update_expired_access_token\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mupdate_expired_access_token\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 74\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_refresh_token \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 75\u001b[0m \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_refresh()\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[1;32m 77\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_clear_tokens()\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/authentication/token_manager.py:71\u001b[0m, in \u001b[0;36mTokenManager._refresh\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_refresh_token \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 70\u001b[0m tokens \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m Auth0()\u001b[38;5;241m.\u001b[39mrefresh_access_token(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_refresh_token)\n\u001b[0;32m---> 71\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_save_tokens\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtokens\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/authentication/token_manager.py:110\u001b[0m, in \u001b[0;36mTokenManager._save_tokens\u001b[0;34m(self, tokens, force_override_refresh_token)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_access_token \u001b[38;5;241m=\u001b[39m tokens\u001b[38;5;241m.\u001b[39maccess_token\n\u001b[0;32m--> 110\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_password_manager\u001b[38;5;241m.\u001b[39maccess_token \u001b[38;5;241m=\u001b[39m tokens\u001b[38;5;241m.\u001b[39maccess_token\n\u001b[1;32m 111\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m tokens\u001b[38;5;241m.\u001b[39mrefresh_token \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m force_override_refresh_token:\n\u001b[1;32m 112\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_refresh_token \u001b[38;5;241m=\u001b[39m tokens\u001b[38;5;241m.\u001b[39mrefresh_token\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/authentication/password_manager.py:38\u001b[0m, in \u001b[0;36mPasswordManager.access_token\u001b[0;34m(self, access_token)\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[38;5;129m@access_token\u001b[39m\u001b[38;5;241m.\u001b[39msetter\n\u001b[1;32m 37\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21maccess_token\u001b[39m(\u001b[38;5;28mself\u001b[39m, access_token: Optional[\u001b[38;5;28mstr\u001b[39m]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 38\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_set\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_settings\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mACCESS_TOKEN_KEY\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maccess_token\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/_internals/authentication/password_manager.py:74\u001b[0m, in \u001b[0;36mKeyringPasswordManager._set\u001b[0;34m(self, key, value)\u001b[0m\n\u001b[1;32m 72\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_clear(key)\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m---> 74\u001b[0m \u001b[43mkeyring\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_password\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 75\u001b[0m \u001b[43m \u001b[49m\u001b[43mservice_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_SERVICE_NAME\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 76\u001b[0m \u001b[43m \u001b[49m\u001b[43musername\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 77\u001b[0m \u001b[43m \u001b[49m\u001b[43mpassword\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 78\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/keyring/core.py:60\u001b[0m, in \u001b[0;36mset_password\u001b[0;34m(service_name, username, password)\u001b[0m\n\u001b[1;32m 58\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mset_password\u001b[39m(service_name: \u001b[38;5;28mstr\u001b[39m, username: \u001b[38;5;28mstr\u001b[39m, password: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 59\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Set password for the user in the specified service.\"\"\"\u001b[39;00m\n\u001b[0;32m---> 60\u001b[0m \u001b[43mget_keyring\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_password\u001b[49m\u001b[43m(\u001b[49m\u001b[43mservice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43musername\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpassword\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/keyring/backends/macOS/__init__.py:44\u001b[0m, in \u001b[0;36mKeyring.set_password\u001b[0;34m(self, service, username, password)\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m KeyringLocked(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCan\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt store password on keychain: \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(e))\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m api\u001b[38;5;241m.\u001b[39mError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m---> 44\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m PasswordSetError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCan\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt store password on keychain: \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(e))\n", - "\u001b[0;31mPasswordSetError\u001b[0m: Can't store password on keychain: (-25244, 'Unknown Error')" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=.3)\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - " res |= x + y\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - " res |= x * y \n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - " prepare_int(1,z)\n", - " res |= x * y -z\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " #allocate(2,x)\n", - " #allocate(3,y)\n", - " \n", - " prepare_state(probabilities=[0,1/4,1/4,1/4,0,0,1/4,0], bound=0, out=y)\n", - " prepare_state(probabilities=[1/2,0,1/2,0,0,0,0,0], bound=0, out=x)\n", - " \n", - " res|=x+y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'int' object has no attribute 'get_handle_binding'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[11], line 22\u001b[0m\n\u001b[1;32m 19\u001b[0m z\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m\n\u001b[1;32m 20\u001b[0m within_apply(\u001b[38;5;28;01mlambda\u001b[39;00m: inplace_linear_attempt_a(x,y), \u001b[38;5;28;01mlambda\u001b[39;00m: linear_func_a(z,res))\n\u001b[0;32m---> 22\u001b[0m qmod \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmain\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 23\u001b[0m qprog \u001b[38;5;241m=\u001b[39m synthesize(qmod)\n\u001b[1;32m 24\u001b[0m show(qprog)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:43\u001b[0m, in \u001b[0;36mcreate_model\u001b[0;34m(entry_point, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m entry_point\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmain\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqError(\n\u001b[1;32m 41\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe entry point function must be named \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmain\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, got \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mentry_point\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 42\u001b[0m )\n\u001b[0;32m---> 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mentry_point\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[43m \u001b[49m\u001b[43mconstraints\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mexecution_preferences\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpreferences\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclassical_execution_function\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mget_model()\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:78\u001b[0m, in \u001b[0;36mQFunc.create_model\u001b[0;34m(self, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mconstants \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m()\n\u001b[1;32m 77\u001b[0m QConstant\u001b[38;5;241m.\u001b[39mset_current_model(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule)\n\u001b[0;32m---> 78\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_add_native_func_def\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 79\u001b[0m model_extra_settings: List[Tuple[\u001b[38;5;28mstr\u001b[39m, Any]] \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 80\u001b[0m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mconstraints\u001b[39m\u001b[38;5;124m\"\u001b[39m, constraints),\n\u001b[1;32m 81\u001b[0m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mexecution_preferences\u001b[39m\u001b[38;5;124m\"\u001b[39m, execution_preferences),\n\u001b[1;32m 82\u001b[0m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpreferences\u001b[39m\u001b[38;5;124m\"\u001b[39m, preferences),\n\u001b[1;32m 83\u001b[0m ]\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m classical_execution_function \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:99\u001b[0m, in \u001b[0;36mQFunc._add_native_func_def\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mnative_defs:\n\u001b[1;32m 98\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m---> 99\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexpand\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 100\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mnative_defs[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname] \u001b[38;5;241m=\u001b[39m NativeFunctionDefinition(\n\u001b[1;32m 101\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m{\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mdict(), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbody\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbody}}\n\u001b[1;32m 102\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:86\u001b[0m, in \u001b[0;36mQExpandable.expand\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m QExpandable\u001b[38;5;241m.\u001b[39mSTACK:\n\u001b[1;32m 85\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m---> 86\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_py_callable\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_positional_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[11], line 20\u001b[0m, in \u001b[0;36mmain\u001b[0;34m(temp, res)\u001b[0m\n\u001b[1;32m 18\u001b[0m y\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m\n\u001b[1;32m 19\u001b[0m z\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m\n\u001b[0;32m---> 20\u001b[0m \u001b[43mwithin_apply\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43minplace_linear_attempt_a\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlinear_func_a\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m,\u001b[49m\u001b[43mres\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/builtins/operations.py:149\u001b[0m, in \u001b[0;36mwithin_apply\u001b[0;34m(compute, action)\u001b[0m\n\u001b[1;32m 144\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m QCallable\u001b[38;5;241m.\u001b[39mCURRENT_EXPANDABLE \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 145\u001b[0m source_ref \u001b[38;5;241m=\u001b[39m get_source_ref(sys\u001b[38;5;241m.\u001b[39m_getframe(\u001b[38;5;241m1\u001b[39m))\n\u001b[1;32m 146\u001b[0m QCallable\u001b[38;5;241m.\u001b[39mCURRENT_EXPANDABLE\u001b[38;5;241m.\u001b[39mappend_statement_to_body(\n\u001b[1;32m 147\u001b[0m WithinApply(\n\u001b[1;32m 148\u001b[0m compute\u001b[38;5;241m=\u001b[39m_operand_to_body(compute),\n\u001b[0;32m--> 149\u001b[0m action\u001b[38;5;241m=\u001b[39m\u001b[43m_operand_to_body\u001b[49m\u001b[43m(\u001b[49m\u001b[43maction\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m 150\u001b[0m source_ref\u001b[38;5;241m=\u001b[39msource_ref,\n\u001b[1;32m 151\u001b[0m )\n\u001b[1;32m 152\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/builtins/operations.py:254\u001b[0m, in \u001b[0;36m_operand_to_body\u001b[0;34m(callable_)\u001b[0m\n\u001b[1;32m 253\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_operand_to_body\u001b[39m(callable_: Union[QCallable, Callable[[], \u001b[38;5;28;01mNone\u001b[39;00m]]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m StatementBlock:\n\u001b[0;32m--> 254\u001b[0m to_operand \u001b[38;5;241m=\u001b[39m \u001b[43mprepare_arg\u001b[49m\u001b[43m(\u001b[49m\u001b[43mQuantumOperandDeclaration\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallable_\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 255\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(to_operand, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 256\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m [QuantumFunctionCall(function\u001b[38;5;241m=\u001b[39mto_operand)]\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:230\u001b[0m, in \u001b[0;36mprepare_arg\u001b[0;34m(arg_decl, val)\u001b[0m\n\u001b[1;32m 227\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(val, QExpandable):\n\u001b[1;32m 228\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m val\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname\n\u001b[0;32m--> 230\u001b[0m \u001b[43mval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexpand\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 231\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m QuantumLambdaFunction(\n\u001b[1;32m 232\u001b[0m rename_params\u001b[38;5;241m=\u001b[39mval\u001b[38;5;241m.\u001b[39minfer_rename_params(), body\u001b[38;5;241m=\u001b[39mval\u001b[38;5;241m.\u001b[39mbody\n\u001b[1;32m 233\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:86\u001b[0m, in \u001b[0;36mQExpandable.expand\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m QExpandable\u001b[38;5;241m.\u001b[39mSTACK:\n\u001b[1;32m 85\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m---> 86\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_py_callable\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_positional_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[11], line 20\u001b[0m, in \u001b[0;36mmain..\u001b[0;34m()\u001b[0m\n\u001b[1;32m 18\u001b[0m y\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m\n\u001b[1;32m 19\u001b[0m z\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m\n\u001b[0;32m---> 20\u001b[0m within_apply(\u001b[38;5;28;01mlambda\u001b[39;00m: inplace_linear_attempt_a(x,y), \u001b[38;5;28;01mlambda\u001b[39;00m: \u001b[43mlinear_func_a\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m,\u001b[49m\u001b[43mres\u001b[49m\u001b[43m)\u001b[49m)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:64\u001b[0m, in \u001b[0;36mQFunc.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 64\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_add_native_func_def()\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_callable.py:50\u001b[0m, in \u001b[0;36mQCallable.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m QCallable\u001b[38;5;241m.\u001b[39mCURRENT_EXPANDABLE \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 48\u001b[0m source_ref \u001b[38;5;241m=\u001b[39m get_source_ref(sys\u001b[38;5;241m.\u001b[39m_getframe(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mFRAME_DEPTH))\n\u001b[1;32m 49\u001b[0m QCallable\u001b[38;5;241m.\u001b[39mCURRENT_EXPANDABLE\u001b[38;5;241m.\u001b[39mappend_statement_to_body(\n\u001b[0;32m---> 50\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_quantum_function_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43msource_ref\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 51\u001b[0m )\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:116\u001b[0m, in \u001b[0;36mQExpandable.create_quantum_function_call\u001b[0;34m(self, source_ref_, *args, **kwargs)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate_quantum_function_call\u001b[39m(\n\u001b[1;32m 114\u001b[0m \u001b[38;5;28mself\u001b[39m, source_ref_: SourceReference, \u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any\n\u001b[1;32m 115\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m QuantumFunctionCall:\n\u001b[0;32m--> 116\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_create_quantum_function_call\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 117\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc_decl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msource_ref_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 118\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:292\u001b[0m, in \u001b[0;36m_create_quantum_function_call\u001b[0;34m(decl_, index_, source_ref_, *args, **kwargs)\u001b[0m\n\u001b[1;32m 290\u001b[0m arg_decls \u001b[38;5;241m=\u001b[39m decl_\u001b[38;5;241m.\u001b[39mget_positional_arg_decls()\n\u001b[1;32m 291\u001b[0m arg_list \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(args)\n\u001b[0;32m--> 292\u001b[0m prepared_args \u001b[38;5;241m=\u001b[39m \u001b[43m_prepare_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdecl_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marg_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 294\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m kwargs:\n\u001b[1;32m 295\u001b[0m bad_kwarg \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mnext\u001b[39m(\u001b[38;5;28miter\u001b[39m(kwargs))\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:278\u001b[0m, in \u001b[0;36m_prepare_args\u001b[0;34m(decl, arg_list, kwargs)\u001b[0m\n\u001b[1;32m 276\u001b[0m error_message \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m _get_operand_hint(decl, arg_decl)\n\u001b[1;32m 277\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqValueError(error_message)\n\u001b[0;32m--> 278\u001b[0m result\u001b[38;5;241m.\u001b[39mappend(\u001b[43mprepare_arg\u001b[49m\u001b[43m(\u001b[49m\u001b[43marg_decl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marg\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 280\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:214\u001b[0m, in \u001b[0;36mprepare_arg\u001b[0;34m(arg_decl, val)\u001b[0m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m Expression(expr\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mstr\u001b[39m(val))\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(arg_decl, PortDeclaration):\n\u001b[0;32m--> 214\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_handle_binding\u001b[49m()\n\u001b[1;32m 215\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 216\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(val, \u001b[38;5;28mlist\u001b[39m):\n", - "\u001b[0;31mAttributeError\u001b[0m: 'int' object has no attribute 'get_handle_binding'" - ] - } - ], - "source": [ - "@qfunc\n", - "def inplace_linear_attempt_a(x:CInt,y:CInt) -> None:\n", - " temp = QNum(\"tmp\")\n", - " temp |= x + y\n", - " \n", - " \n", - "\n", - "@qfunc\n", - "def linear_func_a(temp: QNum, z: CInt, res: Output[QNum]):\n", - " res |= temp +z\n", - "\n", - "@qfunc\n", - "def main(temp: Output[QNum],res: Output[QNum] ) -> None:\n", - " #x = QNum(\"x\")\n", - " #y = QNum(\"y\")\n", - " #z = QNum(\"z\")\n", - " x=3\n", - " y=5\n", - " z=2\n", - " within_apply(lambda: inplace_linear_attempt_a(x,y), lambda: linear_func_a(z,res))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "ename": "ClassiqValueError", - "evalue": "'linear_add_s1' is missing required argument for 'y'\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mClassiqValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[25], line 21\u001b[0m\n\u001b[1;32m 18\u001b[0m within_apply(\u001b[38;5;28;01mlambda\u001b[39;00m: linear_add_s1(x,y,z), \u001b[38;5;28;01mlambda\u001b[39;00m: linear_add_s1(z))\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m#within\u001b[39;00m\n\u001b[0;32m---> 21\u001b[0m qmod \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmain\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 22\u001b[0m qprog \u001b[38;5;241m=\u001b[39m synthesize(qmod)\n\u001b[1;32m 23\u001b[0m show(qprog)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:44\u001b[0m, in \u001b[0;36mcreate_model\u001b[0;34m(entry_point, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m entry_point\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmain\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqError(\n\u001b[1;32m 42\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe entry point function must be named \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmain\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, got \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mentry_point\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 43\u001b[0m )\n\u001b[0;32m---> 44\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mentry_point\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[43m \u001b[49m\u001b[43mconstraints\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mexecution_preferences\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpreferences\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclassical_execution_function\u001b[49m\n\u001b[1;32m 46\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mget_model()\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:89\u001b[0m, in \u001b[0;36mQFunc.create_model\u001b[0;34m(self, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[1;32m 87\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mconstants \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m()\n\u001b[1;32m 88\u001b[0m QConstant\u001b[38;5;241m.\u001b[39mset_current_model(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule)\n\u001b[0;32m---> 89\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_add_native_func_def\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 90\u001b[0m model_extra_settings: List[Tuple[\u001b[38;5;28mstr\u001b[39m, Any]] \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 91\u001b[0m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mconstraints\u001b[39m\u001b[38;5;124m\"\u001b[39m, constraints),\n\u001b[1;32m 92\u001b[0m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mexecution_preferences\u001b[39m\u001b[38;5;124m\"\u001b[39m, execution_preferences),\n\u001b[1;32m 93\u001b[0m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpreferences\u001b[39m\u001b[38;5;124m\"\u001b[39m, preferences),\n\u001b[1;32m 94\u001b[0m ]\n\u001b[1;32m 95\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m classical_execution_function \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:110\u001b[0m, in \u001b[0;36mQFunc._add_native_func_def\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mnative_defs:\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m--> 110\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexpand\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 111\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mnative_defs[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname] \u001b[38;5;241m=\u001b[39m NativeFunctionDefinition(\n\u001b[1;32m 112\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__dict__\u001b[39m, body\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbody\n\u001b[1;32m 113\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:85\u001b[0m, in \u001b[0;36mQExpandable.expand\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexpand\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m---> 85\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_py_callable\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_positional_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[25], line 18\u001b[0m, in \u001b[0;36mmain\u001b[0;34m(res)\u001b[0m\n\u001b[1;32m 16\u001b[0m prepare_int(\u001b[38;5;241m5\u001b[39m,y)\n\u001b[1;32m 17\u001b[0m prepare_int(\u001b[38;5;241m2\u001b[39m,z)\n\u001b[0;32m---> 18\u001b[0m \u001b[43mwithin_apply\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlinear_add_s1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mlambda\u001b[39;49;00m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlinear_add_s1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/builtins/operations.py:182\u001b[0m, in \u001b[0;36mwithin_apply\u001b[0;34m(compute, action)\u001b[0m\n\u001b[1;32m 177\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m QCallable\u001b[38;5;241m.\u001b[39mCURRENT_EXPANDABLE \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 178\u001b[0m source_ref \u001b[38;5;241m=\u001b[39m get_source_ref(sys\u001b[38;5;241m.\u001b[39m_getframe(\u001b[38;5;241m1\u001b[39m))\n\u001b[1;32m 179\u001b[0m QCallable\u001b[38;5;241m.\u001b[39mCURRENT_EXPANDABLE\u001b[38;5;241m.\u001b[39mappend_statement_to_body(\n\u001b[1;32m 180\u001b[0m WithinApply(\n\u001b[1;32m 181\u001b[0m compute\u001b[38;5;241m=\u001b[39m_operand_to_body(compute),\n\u001b[0;32m--> 182\u001b[0m action\u001b[38;5;241m=\u001b[39m\u001b[43m_operand_to_body\u001b[49m\u001b[43m(\u001b[49m\u001b[43maction\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m 183\u001b[0m source_ref\u001b[38;5;241m=\u001b[39msource_ref,\n\u001b[1;32m 184\u001b[0m )\n\u001b[1;32m 185\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/builtins/operations.py:284\u001b[0m, in \u001b[0;36m_operand_to_body\u001b[0;34m(callable_)\u001b[0m\n\u001b[1;32m 283\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_operand_to_body\u001b[39m(callable_: Union[QCallable, Callable[[], \u001b[38;5;28;01mNone\u001b[39;00m]]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m StatementBlock:\n\u001b[0;32m--> 284\u001b[0m to_operand \u001b[38;5;241m=\u001b[39m \u001b[43mprepare_arg\u001b[49m\u001b[43m(\u001b[49m\u001b[43mQuantumOperandDeclaration\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallable_\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 285\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(to_operand, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 286\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m [QuantumFunctionCall(function\u001b[38;5;241m=\u001b[39mto_operand)]\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:229\u001b[0m, in \u001b[0;36mprepare_arg\u001b[0;34m(arg_decl, val)\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(val, QExpandable):\n\u001b[1;32m 227\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m val\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname\n\u001b[0;32m--> 229\u001b[0m \u001b[43mval\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexpand\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 230\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m QuantumLambdaFunction(\n\u001b[1;32m 231\u001b[0m rename_params\u001b[38;5;241m=\u001b[39mval\u001b[38;5;241m.\u001b[39minfer_rename_params(), body\u001b[38;5;241m=\u001b[39mval\u001b[38;5;241m.\u001b[39mbody\n\u001b[1;32m 232\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:85\u001b[0m, in \u001b[0;36mQExpandable.expand\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexpand\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m---> 85\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_py_callable\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_positional_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[25], line 18\u001b[0m, in \u001b[0;36mmain..\u001b[0;34m()\u001b[0m\n\u001b[1;32m 16\u001b[0m prepare_int(\u001b[38;5;241m5\u001b[39m,y)\n\u001b[1;32m 17\u001b[0m prepare_int(\u001b[38;5;241m2\u001b[39m,z)\n\u001b[0;32m---> 18\u001b[0m within_apply(\u001b[38;5;28;01mlambda\u001b[39;00m: linear_add_s1(x,y,z), \u001b[38;5;28;01mlambda\u001b[39;00m: \u001b[43mlinear_add_s1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:75\u001b[0m, in \u001b[0;36mQFunc.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 75\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_add_native_func_def()\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_callable.py:49\u001b[0m, in \u001b[0;36mQCallable.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m QCallable\u001b[38;5;241m.\u001b[39mCURRENT_EXPANDABLE \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 47\u001b[0m source_ref \u001b[38;5;241m=\u001b[39m get_source_ref(sys\u001b[38;5;241m.\u001b[39m_getframe(\u001b[38;5;241m1\u001b[39m))\n\u001b[1;32m 48\u001b[0m QCallable\u001b[38;5;241m.\u001b[39mCURRENT_EXPANDABLE\u001b[38;5;241m.\u001b[39mappend_statement_to_body(\n\u001b[0;32m---> 49\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_quantum_function_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43msource_ref\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 50\u001b[0m )\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:115\u001b[0m, in \u001b[0;36mQExpandable.create_quantum_function_call\u001b[0;34m(self, source_ref_, *args, **kwargs)\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate_quantum_function_call\u001b[39m(\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28mself\u001b[39m, source_ref_: SourceReference, \u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any\n\u001b[1;32m 114\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m QuantumFunctionCall:\n\u001b[0;32m--> 115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_create_quantum_function_call\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 116\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc_decl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msource_ref_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 117\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:291\u001b[0m, in \u001b[0;36m_create_quantum_function_call\u001b[0;34m(decl_, index_, source_ref_, *args, **kwargs)\u001b[0m\n\u001b[1;32m 289\u001b[0m arg_decls \u001b[38;5;241m=\u001b[39m decl_\u001b[38;5;241m.\u001b[39mget_positional_arg_decls()\n\u001b[1;32m 290\u001b[0m arg_list \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(args)\n\u001b[0;32m--> 291\u001b[0m prepared_args \u001b[38;5;241m=\u001b[39m \u001b[43m_prepare_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdecl_\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43marg_list\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 293\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m kwargs:\n\u001b[1;32m 294\u001b[0m bad_kwarg \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mnext\u001b[39m(\u001b[38;5;28miter\u001b[39m(kwargs))\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_expandable.py:276\u001b[0m, in \u001b[0;36m_prepare_args\u001b[0;34m(decl, arg_list, kwargs)\u001b[0m\n\u001b[1;32m 274\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(arg_decl, QuantumOperandDeclaration):\n\u001b[1;32m 275\u001b[0m error_message \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m _get_operand_hint(decl, arg_decl)\n\u001b[0;32m--> 276\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqValueError(error_message)\n\u001b[1;32m 277\u001b[0m result\u001b[38;5;241m.\u001b[39mappend(prepare_arg(arg_decl, arg))\n\u001b[1;32m 279\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "\u001b[0;31mClassiqValueError\u001b[0m: 'linear_add_s1' is missing required argument for 'y'\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def linear_add_s1(x:CInt, y:CInt, z:CInt) -> None:\n", - " temp = QNum(\"temp\")\n", - " res = QNum(\"res\")\n", - " temp |= x + y\n", - " res |= temp +z\n", - " \n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - " within_apply(lambda: linear_add_s1(x,y,z), lambda: linear_add_s1(z))\n", - " #within\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "object of type 'int' has no len()", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[26], line 28\u001b[0m\n\u001b[1;32m 24\u001b[0m X(label)\n\u001b[1;32m 25\u001b[0m control(label, \u001b[38;5;28;01mlambda\u001b[39;00m: linear_func(\u001b[38;5;241m2.0\u001b[39m, \u001b[38;5;241m1.0\u001b[39m, x, res)) \u001b[38;5;66;03m# 0.0 <= x < 0.5\u001b[39;00m\n\u001b[0;32m---> 28\u001b[0m qmod \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmain\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 29\u001b[0m qprog \u001b[38;5;241m=\u001b[39m synthesize(qmod)\n\u001b[1;32m 30\u001b[0m show(qprog)\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:40\u001b[0m, in \u001b[0;36mcreate_model\u001b[0;34m(entry_point, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate_model\u001b[39m(\n\u001b[1;32m 34\u001b[0m entry_point: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mQFunc\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 35\u001b[0m constraints: Optional[Constraints] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 38\u001b[0m classical_execution_function: Optional[CFunc] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 39\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m SerializedModel:\n\u001b[0;32m---> 40\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[43mentry_point\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc_decl\u001b[49m\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmain\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 41\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqError(\n\u001b[1;32m 42\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe entry point function must be named \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmain\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, got \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mentry_point\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 43\u001b[0m )\n\u001b[1;32m 44\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m entry_point\u001b[38;5;241m.\u001b[39mcreate_model(\n\u001b[1;32m 45\u001b[0m constraints, execution_preferences, preferences, classical_execution_function\n\u001b[1;32m 46\u001b[0m )\u001b[38;5;241m.\u001b[39mget_model()\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:71\u001b[0m, in \u001b[0;36mQFunc.func_decl\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 67\u001b[0m \u001b[38;5;129m@property\u001b[39m\n\u001b[1;32m 68\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfunc_decl\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m QuantumFunctionDeclaration:\n\u001b[1;32m 69\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mnative_defs\u001b[38;5;241m.\u001b[39mget(\n\u001b[1;32m 70\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_py_callable\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m,\n\u001b[0;32m---> 71\u001b[0m \u001b[43minfer_func_decl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_py_callable\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mqmodule\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_qmodule\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m 72\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/declaration_inferrer.py:160\u001b[0m, in \u001b[0;36minfer_func_decl\u001b[0;34m(py_func, qmodule)\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minfer_func_decl\u001b[39m(\n\u001b[1;32m 156\u001b[0m py_func: Callable, qmodule: ModelStateContainer\n\u001b[1;32m 157\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m QuantumFunctionDeclaration:\n\u001b[1;32m 158\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m QuantumFunctionDeclaration(\n\u001b[1;32m 159\u001b[0m name\u001b[38;5;241m=\u001b[39munmangle_keyword(py_func\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m),\n\u001b[0;32m--> 160\u001b[0m positional_arg_declarations\u001b[38;5;241m=\u001b[39m\u001b[43m_extract_positional_args\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 161\u001b[0m \u001b[43m \u001b[49m\u001b[43mpy_func\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__annotations__\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mqmodule\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mqmodule\u001b[49m\n\u001b[1;32m 162\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m 163\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/declaration_inferrer.py:146\u001b[0m, in \u001b[0;36m_extract_positional_args\u001b[0;34m(args, qmodule)\u001b[0m\n\u001b[1;32m 144\u001b[0m result\u001b[38;5;241m.\u001b[39mappend(_extract_param_decl(name, py_type, qmodule\u001b[38;5;241m=\u001b[39mqmodule))\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m QVar\u001b[38;5;241m.\u001b[39mfrom_type_hint(py_type) \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m result\u001b[38;5;241m.\u001b[39mappend(\u001b[43m_extract_port_decl\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpy_type\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m (get_origin(py_type) \u001b[38;5;129;01mor\u001b[39;00m py_type) \u001b[38;5;129;01mis\u001b[39;00m QCallable \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m 149\u001b[0m get_origin(py_type) \u001b[38;5;129;01mor\u001b[39;00m py_type\n\u001b[1;32m 150\u001b[0m ) \u001b[38;5;129;01mis\u001b[39;00m QCallableList\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/declaration_inferrer.py:111\u001b[0m, in \u001b[0;36m_extract_port_decl\u001b[0;34m(name, py_type)\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(py_type, _AnnotatedAlias):\n\u001b[1;32m 107\u001b[0m py_type \u001b[38;5;241m=\u001b[39m py_type\u001b[38;5;241m.\u001b[39m__args__[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m PortDeclaration(\n\u001b[1;32m 109\u001b[0m name\u001b[38;5;241m=\u001b[39mname,\n\u001b[1;32m 110\u001b[0m direction\u001b[38;5;241m=\u001b[39mdirection,\n\u001b[0;32m--> 111\u001b[0m quantum_type\u001b[38;5;241m=\u001b[39m\u001b[43mqtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_qmod_quantum_type\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpy_type\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[1;32m 112\u001b[0m )\n", - "File \u001b[0;32m~/opt/anaconda3/envs/Classiq/lib/python3.9/site-packages/classiq/qmod/qmod_variable.py:256\u001b[0m, in \u001b[0;36mQNum.to_qmod_quantum_type\u001b[0;34m(cls, type_hint)\u001b[0m\n\u001b[1;32m 254\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mQMOD_TYPE()\n\u001b[1;32m 255\u001b[0m type_args \u001b[38;5;241m=\u001b[39m type_args[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m--> 256\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtype_args\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m3\u001b[39m:\n\u001b[1;32m 257\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqValueError(\n\u001b[1;32m 258\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mQNum receives three type arguments: QNum[size: int | CInt, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 259\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mis_signed: bool | CBool, fraction_digits: int | CInt]\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 260\u001b[0m )\n\u001b[1;32m 261\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mQMOD_TYPE(\n\u001b[1;32m 262\u001b[0m size\u001b[38;5;241m=\u001b[39mExpression(expr\u001b[38;5;241m=\u001b[39mget_type_hint_expr(type_args[\u001b[38;5;241m0\u001b[39m])),\n\u001b[1;32m 263\u001b[0m is_signed\u001b[38;5;241m=\u001b[39mExpression(expr\u001b[38;5;241m=\u001b[39mget_type_hint_expr(type_args[\u001b[38;5;241m1\u001b[39m])),\n\u001b[1;32m 264\u001b[0m fraction_digits\u001b[38;5;241m=\u001b[39mExpression(expr\u001b[38;5;241m=\u001b[39mget_type_hint_expr(type_args[\u001b[38;5;241m2\u001b[39m])),\n\u001b[1;32m 265\u001b[0m )\n", - "\u001b[0;31mTypeError\u001b[0m: object of type 'int' has no len()" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/303cab63-53d9-4088-ab6c-63ca4022558d?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.18" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Noah_Nzeki_William_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Noah_Nzeki_William_HW2_QClass2024.ipynb deleted file mode 100755 index c016b0bc..00000000 --- a/community/QClass_2024/Submissions/HW2/Noah_Nzeki_William_HW2_QClass2024.ipynb +++ /dev/null @@ -1,781 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/946ff782-cf9a-4021-b5b8-50f8aa846fbf?version=0.41.2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[0526/215345.162702:ERROR:file_io_posix.cc(153)] open /home/noah/.config/BraveSoftware/Brave-Browser/Crash Reports/pending/1de95ac3-f687-4fe5-bee0-5fd5e91b4c38.lock: File exists (17)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None: \n", - " allocate(4, q) \n", - " suzuki_trotter( \n", - " \n", - " [ \n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5), \n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25), \n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3), \n", - " ], \n", - " \n", - " evolution_coefficient=3, \n", - " repetitions=4, \n", - " order=2, \n", - " qbv=q, \n", - " )\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/2e9c6e49-3ad0-4635-81b6-423947b61d44?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], res: Output[QNum]) -> None:\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], res: Output[QNum]) -> None: \n", - " prepare_int(2, x) \n", - " prepare_int(7, y) \n", - " res |= x * y\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog) " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], res: Output[QNum]) -> None:\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - " res |= (x * y) - z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for +: 'QArray' and 'QArray'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[36], line 46\u001b[0m\n\u001b[1;32m 41\u001b[0m res\u001b[38;5;241m|\u001b[39m\u001b[38;5;241m=\u001b[39m x \u001b[38;5;241m+\u001b[39m y\n\u001b[1;32m 42\u001b[0m \u001b[38;5;66;03m#add(x, y, res)\u001b[39;00m\n\u001b[1;32m 43\u001b[0m \n\u001b[1;32m 44\u001b[0m \u001b[38;5;66;03m#return res\u001b[39;00m\n\u001b[0;32m---> 46\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmain\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 47\u001b[0m qprog \u001b[38;5;241m=\u001b[39m synthesize(model)\n\u001b[1;32m 48\u001b[0m show(qprog)\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/classiq/qmod/quantum_function.py:43\u001b[0m, in \u001b[0;36mcreate_model\u001b[0;34m(entry_point, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m entry_point\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmain\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqError(\n\u001b[1;32m 41\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe entry point function must be named \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmain\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, got \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mentry_point\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 42\u001b[0m )\n\u001b[0;32m---> 43\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mentry_point\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_model\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 44\u001b[0m \u001b[43m \u001b[49m\u001b[43mconstraints\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mexecution_preferences\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpreferences\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclassical_execution_function\u001b[49m\n\u001b[1;32m 45\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mget_model()\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/classiq/qmod/quantum_function.py:78\u001b[0m, in \u001b[0;36mQFunc.create_model\u001b[0;34m(self, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mconstants \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m()\n\u001b[1;32m 77\u001b[0m QConstant\u001b[38;5;241m.\u001b[39mset_current_model(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule)\n\u001b[0;32m---> 78\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_add_native_func_def\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 79\u001b[0m model_extra_settings: List[Tuple[\u001b[38;5;28mstr\u001b[39m, Any]] \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 80\u001b[0m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mconstraints\u001b[39m\u001b[38;5;124m\"\u001b[39m, constraints),\n\u001b[1;32m 81\u001b[0m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mexecution_preferences\u001b[39m\u001b[38;5;124m\"\u001b[39m, execution_preferences),\n\u001b[1;32m 82\u001b[0m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpreferences\u001b[39m\u001b[38;5;124m\"\u001b[39m, preferences),\n\u001b[1;32m 83\u001b[0m ]\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m classical_execution_function \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/classiq/qmod/quantum_function.py:99\u001b[0m, in \u001b[0;36mQFunc._add_native_func_def\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mnative_defs:\n\u001b[1;32m 98\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m---> 99\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexpand\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 100\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_qmodule\u001b[38;5;241m.\u001b[39mnative_defs[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mname] \u001b[38;5;241m=\u001b[39m NativeFunctionDefinition(\n\u001b[1;32m 101\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m{\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc_decl\u001b[38;5;241m.\u001b[39mdict(), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbody\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbody}}\n\u001b[1;32m 102\u001b[0m )\n", - "File \u001b[0;32m~/.local/lib/python3.10/site-packages/classiq/qmod/quantum_expandable.py:86\u001b[0m, in \u001b[0;36mQExpandable.expand\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m QExpandable\u001b[38;5;241m.\u001b[39mSTACK:\n\u001b[1;32m 85\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[0;32m---> 86\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_py_callable\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_positional_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[36], line 41\u001b[0m, in \u001b[0;36mmain\u001b[0;34m(res)\u001b[0m\n\u001b[1;32m 37\u001b[0m prepare_state(prob_x, \u001b[38;5;241m0.0\u001b[39m, x) \n\u001b[1;32m 39\u001b[0m prepare_state(prob_y, \u001b[38;5;241m0.0\u001b[39m, y) \n\u001b[0;32m---> 41\u001b[0m res\u001b[38;5;241m|\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\n", - "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'QArray' and 'QArray'" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "\n", - "@qfunc(external=True)\n", - "def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - ") -> None:\n", - " pass\n", - "\n", - "#@qfunc\n", - "#def add(x1: Output[QArray], y1: Output[QArray], res1: Output[QArray]):\n", - "# res1 = []\n", - "# for i in x1:\n", - "# for j in y1:\n", - "# res1.append(i + j)\n", - "# return res1\n", - "\n", - "prob_x = [0.5, 0.0, 0.5, 0.0] \n", - "prob_y = [0.0, 0.25, 0.25, 0.25, 0.0, 0.0, 0.25, 0.0] \n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray]) -> None:\n", - " \n", - " #x = (QNum, False,0,\"x\") \n", - " x = QArray(\"x\")\n", - " #x: QArray[QBit] = QArray(\"x\")\n", - " # allocate(2, x)\n", - " #x: QArray[QBit] = QArray(\"x\")\n", - "\n", - " \n", - " #y = (QNum, False,0,\"y\")\n", - " y = QArray(\"y\")\n", - " #y: QArray[QBit] = QArray(\"y\")\n", - "\n", - " allocate(2, x)\n", - " allocate(3, y)\n", - " \n", - " prepare_state(prob_x, 0.0, x) \n", - " \n", - " prepare_state(prob_y, 0.0, y) \n", - "\n", - " #res|= x + y\n", - " #add(x, y, res)\n", - " \n", - " #return res\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/97d691e6-72da-486a-9996-f222c3e2b2b0?version=0.41.2\n", - "Synthesized circuit width: 16, depth: 100\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import * \n", - "# Your code here:\n", - "@qfunc\n", - "def linear_func(x:QNum, y:QNum, res: Output[QNum]):\n", - " res |= x + y\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z') \n", - " prepare_int(3, x) \n", - " prepare_int(5, y) \n", - " prepare_int(2, z) \n", - " \n", - " res1 = QNum('res1')\n", - "\n", - " within_apply(compute= lambda: linear_func(x, y, res1), \n", - " #action= lambda: inplace_xor(res1,z)) \n", - " action= lambda: linear_func(res1,z,res)) \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "def print_depth_width(quantum_program): \n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program) \n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a983d0b8-ebd3-4496-9a4c-90af7ad5f361?version=0.41.2\n", - "Opening in existing browser session.\n", - "{'res': 14.0}\n", - "Synthesized circuit width: 16, depth: 165\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def linear_func(x:QNum, y:QNum, res: Output[QNum]):\n", - " res |= x + y\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " w = QNum('w')\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - "\n", - "\n", - " \n", - " res1 = QNum('res1')\n", - " res2 = QNum('res2')\n", - " within_apply(compute= lambda: linear_func(x, y, res1),\n", - " action= lambda: linear_func(res1, z, res2))\n", - "\n", - "\n", - " res |= w + res2\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "\n", - "def print_parsed_counts(job):\n", - " results = job.result()\n", - " parsed_counts = results[0].value.parsed_counts\n", - " for parsed_state in parsed_counts: print(parsed_state.state)\n", - "\n", - "\n", - "job = execute(qprog)\n", - "print_parsed_counts(job)\n", - "\n", - "\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - "print_depth_width(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " w = QNum('w')\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - "\n", - " res |= x + y + z + w\n", - "\n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "def print_parsed_counts(job):\n", - " results = job.result()\n", - " parsed_counts = results[0].value.parsed_counts\n", - " for parsed_state in parsed_counts: print(parsed_state.state)\n", - "\n", - "job = execute(qprog)\n", - "print_parsed_counts(job)\n", - "\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - "print_depth_width(qprog)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/820a33c8-8d74-40f1-910d-bc58a9036ae0?version=0.40.0\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d73b0ff9-bbc6-45d8-8dd8-6b8704e3b4b4?version=0.41.2\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/93ba2b8f-8a93-4ee6-9602-b7261094baab?version=0.41.2\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *from classiq.qmod.symbolic import sqrtfrom math import piprob_list= [ 1 / 8, 1 / 8, 1 / 8-sqrt(3) / 16, 1 / 8 + sqrt(3) / 16, 1 / 8, 1 / 8, 1 / 8, 1 / 8, ]@qfuncdef pre_prepared_state(q: QArray) -> None: prepare_state( [ 1 / 8, 1 / 8, 1 / 8-sqrt(3) / 16, 1 / 8 + sqrt(3) / 16, 1 / 8, 1 / 8, 1 / 8, 1 / 8, ], 0.0, q, )@qfuncdef main(validate_res: Output[QArray]) -> None: prepare_state(prob_list,0,validate_res) model = create_model(main)qprog = synthesize(model)show(qprog)#========================" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening in existing browser session.\n", - "Opening: https://platform.classiq.io/circuit/23bac3ff-480f-4622-bfe6-00940d44c4f5?version=0.41.2\n", - "Opening in existing browser session.\n" - ] - } - ], - "source": [ - "from classiq import *from classiq.qmod.symbolic import sqrtfrom math import pi@qfuncdef main(res: Output[QArray[QBit]]) -> None: x: QArray[QBit] = QArray(\"x\") allocate(3, x) hadamard_transform(x) lsb = QBit(\"lsb\") msb = QNum(\"msb\", 2, False, 0) bind(x, [lsb, msb]) condition = (msb == 1) # (msb == 2) control(condition, lambda: RY(pi / 3, lsb)) bind([lsb, msb], res)model = create_model(main)qprog = synthesize(model)show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Otmane_ainelkitane_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Otmane_ainelkitane_HW2_QClass2024.ipynb deleted file mode 100644 index 5e38de38..00000000 --- a/community/QClass_2024/Submissions/HW2/Otmane_ainelkitane_HW2_QClass2024.ipynb +++ /dev/null @@ -1,891 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "imduW-SQtOk3" - }, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "source": [ - "!pip install -q Classiq -U" - ], - "metadata": { - "id": "ksc8X3m-taCi", - "collapsed": true - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "import classiq\n", - "classiq.authenticate()" - ], - "metadata": { - "id": "1KBSbB9Mt8QJ", - "collapsed": true - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "NQdAHnfItOk8" - }, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "DESOvCuxtOk9" - }, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": { - "id": "-Pjd0uDjtOk-" - }, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "DaJq2DowtOk-" - }, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": { - "id": "S--dmztutOk_" - }, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "pCyWGBFwtOk_" - }, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "KLrQLKW9tOlA", - "outputId": "269fab4f-40e6-44e4-fc39-2bd2719c540a" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/9b2f6f62-9b9a-47d4-9c80-4bb9eea4f36d?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [ PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3)\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "GAOxjxHwtOlA" - }, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "LEnJN9oqtOlB", - "outputId": "f1c33b87-9631-4773-96c0-5a360929e193" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/99dd77a9-a738-42dc-bf30-556d559377e4?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum('x')\n", - " prepare_int(2, x)\n", - " y = QNum('y')\n", - " prepare_int(7, y)\n", - "\n", - " #1. Initialize variables x=2, y=7 and computes res = x + y.\n", - " res |= x+y\n", - "\n", - " #2. Initialize variables x=2, y=7 and computes res = x * y.\n", - " # res |= x*y\n", - "\n", - " #3. Initialize variables x=2, y=7, z=1 and computes res = x * y - z\n", - " # res |= x*y-z\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "5rNeEIQVtOlB" - }, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "EncRsH-mtOlB", - "outputId": "7686bc6d-8325-4037-a757-a293ff81f62e" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/6c198e8d-ea40-4032-94e2-69c8449b5e96?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - "\n", - " prepare_state(probabilities=[0.5,0,0.5,0], bound=0.01, out=x)\n", - " prepare_state(probabilities=[0,1/4,1/4,1/4,0,0,1/4,0], bound=0.01, out=y)\n", - "\n", - " res |= x+y\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "VcU1kBm4tOlC" - }, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": { - "id": "JVLoMCuWtOlC", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "4050a82a-e7f8-4ff1-fae5-379df2127d5a" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/28c69eee-98a2-47e8-ad3d-1470d6246a4d?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def my_add_two(a: QNum, b:QNum, res:Output[QNum]) -> None:\n", - " res |= a+b\n", - "\n", - "@qfunc\n", - "def my_adder(a: QNum, b:QNum, c:QNum, res:Output[QNum]):\n", - " tmp = QNum('tmp')\n", - " within_apply(lambda : my_add_two(a,b,tmp), lambda :my_add_two(tmp,c, res))\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x, y, z = QNum('x'), QNum('y'), QNum('z')\n", - " prepare_int(3,x), prepare_int(5,y), prepare_int(2,z)\n", - "\n", - " my_adder(x,y,z,res)\n", - "\n", - "qmod = create_model(main)\n", - "#qprog_with_constraints = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "\n", - "# Depth: 65\n", - "# Width: 16" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-m0WKdCbtOlC" - }, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": { - "id": "0EwSOXhLtOlD", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "b8d0e892-a68f-40dc-e320-6ad6d31951e6" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/55299895-1b7a-4dff-b847-a7e594076344?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x, y, z, w = QNum('x'), QNum('y'), QNum('z'), QNum('w')\n", - " prepare_int(3,x) , prepare_int(5,y), prepare_int(2,z), prepare_int(4,w)\n", - " tmp1 = QNum('tmp1')\n", - " my_adder(x,y,z,tmp1)\n", - " my_add_two(tmp1,w,res)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog_with_constraints = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", - "qprog = synthesize(qprog_with_constraints)\n", - "show(qprog)\n", - "\n", - "# Depth: 97\n", - "# Width: 21" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "HSMf4U8ptOlD" - }, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": { - "id": "jP9iD-qstOlD", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "90f1cecf-e0ec-46cb-8f5b-e2800c6bb139" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/179fdc1e-9ada-4bac-8292-7a246e70f023?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x, y, z, w = QNum('x'), QNum('y'), QNum('z'), QNum('w')\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - " prepare_int(4,w)\n", - "\n", - " res |= x+y+z+w\n", - "\n", - "qmod = create_model(main)\n", - "qprog_with_constraints = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", - "qprog = synthesize(qprog_with_constraints)\n", - "show(qprog)\n", - "\n", - "# Depth: 67\n", - "# Width: 12" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "XcqaODbxtOlE" - }, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": { - "id": "VkxjMFsCtOlE", - "outputId": "3a3f6e3a-b7a6-46cf-d6e8-6abe6ea450d3", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/26f2d5dc-3152-422b-8ec4-e392feba9a7c?version=0.41.2\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QBit(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "9GbmiIYHtOlE" - }, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": { - "id": "AyyS1z4HtOlE", - "outputId": "c51b3f58-b6df-466b-c97b-3b5b2524576e", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/dec84951-50f2-46d1-a9ab-b1456a4f718c?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "uPIUoUZTtOlE" - }, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8 -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": { - "id": "smLm2XzvtOlF", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "237504a4-9fe5-4e3d-83a0-d844ab258017" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/b523045c-7081-4d6a-b6cd-592f6702394b?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "from math import pi\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8-sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8-sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - "\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - " control(msb == 1, lambda: RY(pi / 3, lsb))\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)\n", - "job = execute(qprog)\n" - ] - }, - { - "cell_type": "code", - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "# Ploting a bar chart to see\n", - "# total shots uesed\n", - "shots = sum([sampled_state.shots for sampled_state in parsed_counts])\n", - "histo =dict([(sampled_state.state['res'], round(sampled_state.shots/shots,2)) for sampled_state in parsed_counts])\n", - "\n", - "values = list(histo.keys())\n", - "prob = list(histo.values())\n", - "plt.bar(values, prob, color ='dodgerblue',\n", - " width = 0.4)\n", - "\n", - "plt.xlabel(\"Values\")\n", - "plt.ylabel(\"Probability\")\n", - "\n", - "plt.show()\n", - "\n", - "# We notice clearly that both 2(010) & 3(011) have diffrent probabilities, as these the only cases where MSB = 1(01)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "collapsed": true, - "id": "6WCsWqyWcu06", - "outputId": "ab5ccf1a-deac-449b-f8c2-c4ad27ae6e25" - }, - "execution_count": 74, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoQ0lEQVR4nO3df1TVdZ7H8dcFAlQUNJQfhoA/Sh0VFZLRdGyK08XKldU1JBsRWa0Wypasho6Jrc1gah10dHWtEevsmlZTzs7sDI6RaDNhpmamZknjCKngjxQUV1C4+0fHO3NXdPhxL1/g83ycc8/Al+/93vdnrPE53++Xe20Oh8MhAAAAg3hZPQAAAEBrI4AAAIBxCCAAAGAcAggAABiHAAIAAMYhgAAAgHEIIAAAYBwfqwdoi+rr63XixAl17dpVNpvN6nEAAEAjOBwOXbhwQeHh4fLyuvk5HgKoASdOnFBERITVYwAAgGYoKyvTbbfddtN9CKAGdO3aVdL3/wV269bN4mkAAEBjVFVVKSIiwvn3+M0QQA24dtmrW7duBBAAAO1MY25f4SZoAABgHAIIAAAYhwACAADGIYAAAIBxCCAAAGAcAggAABiHAAIAAMYhgAAAgHEIIAAAYBwCCAAAGIcAAgAAxiGAAACAcQggAABgHAIIAAAYhwACAADG8bF6AAAdQ+Ryz7/Gsbmefw0AZuAMEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwTpsIoFWrVikqKkr+/v6Kj4/Xrl27brjva6+9pnHjxql79+7q3r27EhISrtvf4XBowYIFCgsLU6dOnZSQkKAjR454ehkAAKCdsDyANm3apKysLOXk5Gjv3r2KiYmR3W7XqVOnGty/qKhIKSkp2rZtm4qLixUREaH77rtPx48fd+6zZMkSrVixQmvWrNEnn3yiLl26yG636/Lly621LAAA0IbZHA6Hw8oB4uPjdeedd2rlypWSpPr6ekVEROiJJ57QT3/607/7/Lq6OnXv3l0rV67UjBkz5HA4FB4erqefflrz5s2TJFVWViokJETr16/XtGnT/u4xq6qqFBgYqMrKSnXr1q1lCwQMEbnc869xbK7nXwNA+9WUv78tPQNUW1urPXv2KCEhwbnNy8tLCQkJKi4ubtQxLl26pCtXrqhHjx6SpKNHj6q8vNzlmIGBgYqPj7/hMWtqalRVVeXyAAAAHZelAXTmzBnV1dUpJCTEZXtISIjKy8sbdYznnntO4eHhzuC59rymHDM3N1eBgYHOR0RERFOXAgAA2hHL7wFqicWLF2vjxo16//335e/v3+zjZGdnq7Ky0vkoKytz45QAAKCt8bHyxYODg+Xt7a2KigqX7RUVFQoNDb3pc5ctW6bFixfrgw8+0LBhw5zbrz2voqJCYWFhLsccPnx4g8fy8/OTn59fM1cBAADaG0vPAPn6+io2NlaFhYXObfX19SosLNTo0aNv+LwlS5Zo0aJFKigoUFxcnMvPoqOjFRoa6nLMqqoqffLJJzc9JgAAMIelZ4AkKSsrS6mpqYqLi9OoUaOUl5en6upqpaWlSZJmzJih3r17Kzc3V5L08ssva8GCBdqwYYOioqKc9/UEBAQoICBANptNTz31lF566SUNGDBA0dHReuGFFxQeHq6kpCSrlgkAANoQywMoOTlZp0+f1oIFC1ReXq7hw4eroKDAeRNzaWmpvLz+eqJq9erVqq2t1T/90z+5HCcnJ0cLFy6UJD377LOqrq7WnDlzdP78eY0dO1YFBQUtuk8IAAB0HJa/D1BbxPsAAU3H+wABsFq7eR8gAAAAKxBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4lgfQqlWrFBUVJX9/f8XHx2vXrl033PfgwYOaMmWKoqKiZLPZlJeXd90+CxculM1mc3kMHDjQgysAAADtjaUBtGnTJmVlZSknJ0d79+5VTEyM7Ha7Tp061eD+ly5dUt++fbV48WKFhobe8Lg/+MEPdPLkSefjj3/8o6eWAAAA2iFLA+jVV1/V7NmzlZaWpsGDB2vNmjXq3Lmz1q1b1+D+d955p5YuXapp06bJz8/vhsf18fFRaGio8xEcHHzTOWpqalRVVeXyAAAAHZdlAVRbW6s9e/YoISHhr8N4eSkhIUHFxcUtOvaRI0cUHh6uvn37avr06SotLb3p/rm5uQoMDHQ+IiIiWvT6AACgbbMsgM6cOaO6ujqFhIS4bA8JCVF5eXmzjxsfH6/169eroKBAq1ev1tGjRzVu3DhduHDhhs/Jzs5WZWWl81FWVtbs1wcAAG2fj9UDuNuECROcXw8bNkzx8fGKjIzU22+/rfT09Aaf4+fnd9NLagAAoGOx7AxQcHCwvL29VVFR4bK9oqLipjc4N1VQUJBuv/12lZSUuO2YAACgfbMsgHx9fRUbG6vCwkLntvr6ehUWFmr06NFue52LFy/qm2++UVhYmNuOCQAA2jdLL4FlZWUpNTVVcXFxGjVqlPLy8lRdXa20tDRJ0owZM9S7d2/l5uZK+v7G6UOHDjm/Pn78uPbt26eAgAD1799fkjRv3jxNnDhRkZGROnHihHJycuTt7a2UlBRrFgkAANocSwMoOTlZp0+f1oIFC1ReXq7hw4eroKDAeWN0aWmpvLz+epLqxIkTGjFihPP7ZcuWadmyZRo/fryKiookSd9++61SUlJ09uxZ9ezZU2PHjtXOnTvVs2fPVl0bAABou2wOh8Nh9RBtTVVVlQIDA1VZWalu3bpZPQ7QLkQu9/xrHJvr+dcA0H415e9vyz8KAwAAoLURQAAAwDgEEAAAMA4BBAAAjNOsANq2bZu75wAAAGg1zQqgxMRE9evXTy+99BKfmwUAANqdZgXQ8ePHlZmZqXfffVd9+/aV3W7X22+/rdraWnfPBwAA4HYtfh+gvXv3Kj8/X2+99ZYk6eGHH1Z6erpiYmLcMqAVeB8goOl4HyAz8OeMtqxV3wdo5MiRys7OVmZmpi5evKh169YpNjZW48aN08GDB1t6eAAAALdrdgBduXJF7777ru6//35FRkZqy5YtWrlypSoqKlRSUqLIyEhNnTrVnbMCAAC4RbM+C+yJJ57QW2+9JYfDoZ/85CdasmSJhgwZ4vx5ly5dtGzZMoWHh7ttUAAAAHdpVgAdOnRIv/jFLzR58mT5+fk1uE9wcDC/Lg8AANqkZl0Cy8nJ0dSpU6+Ln6tXr2rHjh2SJB8fH40fP77lEwIAALhZswLoxz/+sb777rvrtldWVurHP/5xi4cCAADwpGYFkMPhkM1mu2772bNn1aVLlxYPBQAA4ElNugdo8uTJkiSbzaaZM2e6XAKrq6vT/v37NWbMGPdOCAAA4GZNCqDAwEBJ358B6tq1qzp16uT8ma+vr374wx9q9uzZ7p0QAADAzZoUQPn5+ZKkqKgozZs3j8tdAACgXWrWr8Hn5OS4ew4AAIBW0+gAGjlypAoLC9W9e3eNGDGiwZugr9m7d69bhgMAAPCERgfQpEmTnDc9JyUleWoeAAAAj2t0AP3tZS8ugQEAgPasxZ8GDwAA0N40+gxQ9+7db3rfz99q6F2i8VeRyz17/GNzPXt8AEDHZsLfU40OoLy8PA+OAQAA0HoaHUCpqamenAMAAKDVNDqAqqqq1K1bN+fXN3NtPwAAgLaoSfcAnTx5Ur169VJQUFCD9wNd+5DUuro6tw4JAADgTo0OoA8//FA9evSQJG3bts1jAwEAAHhaowNo/PjxDX4NAADQ3jTrs8Ak6dy5c/rlL3+pL7/8UpI0ePBgpaWlOc8SAQAAtFXNeiPEHTt2KCoqSitWrNC5c+d07tw5rVixQtHR0dqxY4e7ZwQAAHCrZp0BysjIUHJyslavXi1vb29JUl1dnf7lX/5FGRkZ+uKLL9w6JAAAgDs16wxQSUmJnn76aWf8SJK3t7eysrJUUlLituEAAAA8oVkBNHLkSOe9P3/ryy+/VExMTIuHAgAA8KRGXwLbv3+/8+snn3xSc+fOVUlJiX74wx9Kknbu3KlVq1Zp8eLF7p8SAADAjRodQMOHD5fNZpPD4XBue/bZZ6/b7+GHH1ZycrJ7pgMAAPCARgfQ0aNHPTkHAABAq2l0AEVGRnpyDnRwkcs9e/xjcz17fKAhnv7nWuKf7baAP+eOqdlvhChJhw4dUmlpqWpra122/8M//EOLhgIAAPCkZgXQn//8Z/3jP/6jvvjiC5f7gq59QCofhgoAANqyZv0a/Ny5cxUdHa1Tp06pc+fOOnjwoHbs2KG4uDgVFRW5eUQAAAD3atYZoOLiYn344YcKDg6Wl5eXvLy8NHbsWOXm5urJJ5/UZ5995u45AQAA3KZZZ4Dq6urUtWtXSVJwcLBOnDgh6fsbpb/66iv3TQcAAOABzToDNGTIEH3++eeKjo5WfHy8lixZIl9fX61du1Z9+/Z194wAAABu1awAmj9/vqqrqyVJ//Zv/6YHH3xQ48aN06233qpNmza5dUAAAAB3a1YA2e1259f9+/fX4cOH9d1336l79+7O3wQDAABoq1r0PkCSVFZWJkmKiIho8TAAAACtoVk3QV+9elUvvPCCAgMDFRUVpaioKAUGBmr+/Pm6cuWKu2cEAABwq2adAXriiSf03nvvacmSJRo9erSk7381fuHChTp79qxWr17t1iEBAADcqVkBtGHDBm3cuFETJkxwbhs2bJgiIiKUkpJCAAEAgDatWZfA/Pz8FBUVdd326Oho+fr6tnQmAAAAj2pWAGVmZmrRokWqqalxbqupqdHPfvYzZWZmum04AAAAT2j0JbDJkye7fP/BBx/otttuU0xMjCTp888/V21tre699173TggAAOBmjQ6gwMBAl++nTJni8j2/Bg8AANqLRgdQfn6+J+cAAABoNS16I8TTp087P/z0jjvuUM+ePd0yFAAAgCc16ybo6upqzZo1S2FhYfrRj36kH/3oRwoPD1d6erouXbrk7hkBAADcqlkBlJWVpe3bt+s3v/mNzp8/r/Pnz+vXv/61tm/frqefftrdMwIAALhVsy6B/epXv9K7776ru+++27nt/vvvV6dOnfTQQw/xRogAAKBNa9YZoEuXLikkJOS67b169eISGAAAaPOaFUCjR49WTk6OLl++7Nz2v//7v3rxxRednw0GAADQVjXrElheXp4SExOveyNEf39/bdmyxa0DAgAAuFuzAmjo0KE6cuSI/uu//kuHDx+WJKWkpGj69Onq1KmTWwcEAABwtyYH0JUrVzRw4ED99re/1ezZsz0xEwAAgEc1+R6gW265xeXen5ZatWqVoqKi5O/vr/j4eO3ateuG+x48eFBTpkxRVFSUbDab8vLyWnxMAABgnmbdBJ2RkaGXX35ZV69ebdGLb9q0SVlZWcrJydHevXsVExMju92uU6dONbj/pUuX1LdvXy1evFihoaFuOSYAADBPswLo008/1Xvvvac+ffrIbrdr8uTJLo/GevXVVzV79mylpaVp8ODBWrNmjTp37qx169Y1uP+dd96ppUuXatq0afLz83PLMQEAgHmadRN0UFDQdZ8G31S1tbXas2ePsrOzndu8vLyUkJCg4uLiVj1mTU2NampqnN9XVVU16/UBAED70KQAqq+v19KlS/X111+rtrZW99xzjxYuXNis3/w6c+aM6urqrntDxZCQEOdvlrXWMXNzc/Xiiy826zUBAED706RLYD/72c/0/PPPKyAgQL1799aKFSuUkZHhqdlaTXZ2tiorK52PsrIyq0cCAAAe1KQzQG+++ab+/d//XY8++qgk6YMPPtADDzyg119/XV5eTbudKDg4WN7e3qqoqHDZXlFRccMbnD11TD8/vxveUwQAADqeJlVLaWmp7r//fuf3CQkJstlsOnHiRJNf2NfXV7GxsSosLHRuq6+vV2FhYbM/TsMTxwQAAB1Pk84AXb16Vf7+/i7bbrnlFl25cqVZL56VlaXU1FTFxcVp1KhRysvLU3V1tdLS0iRJM2bMUO/evZWbmyvp+5ucDx065Pz6+PHj2rdvnwICAtS/f/9GHRMAAKBJAeRwODRz5kyXy0WXL1/WY489pi5duji3vffee406XnJysk6fPq0FCxaovLxcw4cPV0FBgfMm5tLSUpdLaydOnNCIESOc3y9btkzLli3T+PHjVVRU1KhjAgAANCmAUlNTr9v2yCOPtGiAzMxMZWZmNviza1FzTVRUlBwOR4uOCQAA0KQAys/P99QcAAAAraZZ7wQNAADQnhFAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjEEAAAMA4BBAAADAOAQQAAIxDAAEAAOMQQAAAwDgEEAAAMA4BBAAAjEMAAQAA4xBAAADAOAQQAAAwDgEEAACMQwABAADjtIkAWrVqlaKiouTv76/4+Hjt2rXrpvu/8847GjhwoPz9/TV06FD97ne/c/n5zJkzZbPZXB6JiYmeXAIAAGhHLA+gTZs2KSsrSzk5Odq7d69iYmJkt9t16tSpBvf/+OOPlZKSovT0dH322WdKSkpSUlKSDhw44LJfYmKiTp486Xy89dZbrbEcAADQDlgeQK+++qpmz56ttLQ0DR48WGvWrFHnzp21bt26Bvdfvny5EhMT9cwzz2jQoEFatGiRRo4cqZUrV7rs5+fnp9DQUOeje/fuN5yhpqZGVVVVLg8AANBxWRpAtbW12rNnjxISEpzbvLy8lJCQoOLi4gafU1xc7LK/JNnt9uv2LyoqUq9evXTHHXfo8ccf19mzZ284R25urgIDA52PiIiIFqwKAAC0dZYG0JkzZ1RXV6eQkBCX7SEhISovL2/wOeXl5X93/8TERL355psqLCzUyy+/rO3bt2vChAmqq6tr8JjZ2dmqrKx0PsrKylq4MgAA0Jb5WD2AJ0ybNs359dChQzVs2DD169dPRUVFuvfee6/b38/PT35+fq05IgAAsJClZ4CCg4Pl7e2tiooKl+0VFRUKDQ1t8DmhoaFN2l+S+vbtq+DgYJWUlLR8aAAA0O5ZGkC+vr6KjY1VYWGhc1t9fb0KCws1evToBp8zevRol/0laevWrTfcX5K+/fZbnT17VmFhYe4ZHAAAtGuW/xZYVlaWXnvtNb3xxhv68ssv9fjjj6u6ulppaWmSpBkzZig7O9u5/9y5c1VQUKBXXnlFhw8f1sKFC7V7925lZmZKki5evKhnnnlGO3fu1F/+8hcVFhZq0qRJ6t+/v+x2uyVrBAAAbYvl9wAlJyfr9OnTWrBggcrLyzV8+HAVFBQ4b3QuLS2Vl9dfO23MmDHasGGD5s+fr+eff14DBgzQ5s2bNWTIEEmSt7e39u/frzfeeEPnz59XeHi47rvvPi1atIj7fAAAgKQ2EECSlJmZ6TyD8/8VFRVdt23q1KmaOnVqg/t36tRJW7Zsced4AACgg7H8EhgAAEBrI4AAAIBxCCAAAGAcAggAABiHAAIAAMYhgAAAgHEIIAAAYBwCCAAAGIcAAgAAxiGAAACAcQggAABgHAIIAAAYhwACAADGIYAAAIBxCCAAAGAcAggAABiHAAIAAMYhgAAAgHEIIAAAYBwCCAAAGIcAAgAAxiGAAACAcQggAABgHAIIAAAYhwACAADGIYAAAIBxCCAAAGAcAggAABiHAAIAAMYhgAAAgHEIIAAAYBwCCAAAGIcAAgAAxiGAAACAcQggAABgHAIIAAAYhwACAADGIYAAAIBxfKweAOiIIpd7/jWOzfX8awBAR8UZIAAAYBwCCAAAGIcAAgAAxiGAAACAcQggAABgHAIIAAAYhwACAADGIYAAAIBxCCAAAGAcAggAABiHAAIAAMYhgAAAgHEIIAAAYBwCCAAAGIcAAgAAxiGAAACAcQggAABgHAIIAAAYhwACAADGIYAAAIBxCCAAAGAcAggAABiHAAIAAMYhgAAAgHEIIAAAYBwCCAAAGKdNBNCqVasUFRUlf39/xcfHa9euXTfd/5133tHAgQPl7++voUOH6ne/+53Lzx0OhxYsWKCwsDB16tRJCQkJOnLkiCeXAAAA2hHLA2jTpk3KyspSTk6O9u7dq5iYGNntdp06darB/T/++GOlpKQoPT1dn332mZKSkpSUlKQDBw4491myZIlWrFihNWvW6JNPPlGXLl1kt9t1+fLl1loWAABowywPoFdffVWzZ89WWlqaBg8erDVr1qhz585at25dg/svX75ciYmJeuaZZzRo0CAtWrRII0eO1MqVKyV9f/YnLy9P8+fP16RJkzRs2DC9+eabOnHihDZv3tyKKwMAAG2Vj5UvXltbqz179ig7O9u5zcvLSwkJCSouLm7wOcXFxcrKynLZZrfbnXFz9OhRlZeXKyEhwfnzwMBAxcfHq7i4WNOmTbvumDU1NaqpqXF+X1lZKUmqqqpq9tpupt7DJ6I8NHaLmLZmT69XYs1tAWv2DNZsvfb6v9nX/t52OBx/d19LA+jMmTOqq6tTSEiIy/aQkBAdPny4weeUl5c3uH95ebnz59e23Wif/y83N1cvvvjiddsjIiIat5A2JvCnVk/Q+lizGVizGVhzx+fp9V64cEGBgYE33cfSAGorsrOzXc4q1dfX67vvvtOtt94qm81m4WTf12xERITKysrUrVs3S2dpLayZNXdEpq1XYs2sufU5HA5duHBB4eHhf3dfSwMoODhY3t7eqqiocNleUVGh0NDQBp8TGhp60/2v/WdFRYXCwsJc9hk+fHiDx/Tz85Ofn5/LtqCgoKYsxeO6detm+T9YrY01m8G0NZu2Xok1m6KtrPnvnfm5xtKboH19fRUbG6vCwkLntvr6ehUWFmr06NENPmf06NEu+0vS1q1bnftHR0crNDTUZZ+qqip98sknNzwmAAAwi+WXwLKyspSamqq4uDiNGjVKeXl5qq6uVlpamiRpxowZ6t27t3JzcyVJc+fO1fjx4/XKK6/ogQce0MaNG7V7926tXbtWkmSz2fTUU0/ppZde0oABAxQdHa0XXnhB4eHhSkpKsmqZAACgDbE8gJKTk3X69GktWLBA5eXlGj58uAoKCpw3MZeWlsrL668nqsaMGaMNGzZo/vz5ev755zVgwABt3rxZQ4YMce7z7LPPqrq6WnPmzNH58+c1duxYFRQUyN/fv9XX11J+fn7Kycm57hJdR8aazWDamk1br8SaTdFe12xzNOZ3xQAAADoQy98IEQAAoLURQAAAwDgEEAAAMA4BBAAAjEMAtWGrVq1SVFSU/P39FR8fr127dlk9kkft2LFDEydOVHh4uGw2W4f/8Nrc3Fzdeeed6tq1q3r16qWkpCR99dVXVo/lUatXr9awYcOcb5g2evRo/f73v7d6rFa1ePFi59t1dFQLFy6UzWZzeQwcONDqsTzu+PHjeuSRR3TrrbeqU6dOGjp0qHbv3m31WB4TFRV13Z+zzWZTRkaG1aM1CgHURm3atElZWVnKycnR3r17FRMTI7vdrlOnTlk9msdUV1crJiZGq1atsnqUVrF9+3ZlZGRo586d2rp1q65cuaL77rtP1dXVVo/mMbfddpsWL16sPXv2aPfu3brnnns0adIkHTx40OrRWsWnn36q//iP/9CwYcOsHsXjfvCDH+jkyZPOxx//+EerR/Koc+fO6a677tItt9yi3//+9zp06JBeeeUVde/e3erRPObTTz91+TPeunWrJGnq1KkWT9ZIDrRJo0aNcmRkZDi/r6urc4SHhztyc3MtnKr1SHK8//77Vo/Rqk6dOuWQ5Ni+fbvVo7Sq7t27O15//XWrx/C4CxcuOAYMGODYunWrY/z48Y65c+daPZLH5OTkOGJiYqweo1U999xzjrFjx1o9hqXmzp3r6Nevn6O+vt7qURqFM0BtUG1trfbs2aOEhATnNi8vLyUkJKi4uNjCyeBJlZWVkqQePXpYPEnrqKur08aNG1VdXW3Ex9RkZGTogQcecPn3uiM7cuSIwsPD1bdvX02fPl2lpaVWj+RR//3f/624uDhNnTpVvXr10ogRI/Taa69ZPVarqa2t1X/+539q1qxZln+IeGMRQG3QmTNnVFdX53w37GtCQkJUXl5u0VTwpPr6ej311FO66667XN7VvCP64osvFBAQID8/Pz322GN6//33NXjwYKvH8qiNGzdq7969zo/06eji4+O1fv16FRQUaPXq1Tp69KjGjRunCxcuWD2ax/z5z3/W6tWrNWDAAG3ZskWPP/64nnzySb3xxhtWj9YqNm/erPPnz2vmzJlWj9Joln8UBoDvzw4cOHCgw98nIUl33HGH9u3bp8rKSr377rtKTU3V9u3bO2wElZWVae7cudq6dWu7/Die5pgwYYLz62HDhik+Pl6RkZF6++23lZ6ebuFknlNfX6+4uDj9/Oc/lySNGDFCBw4c0Jo1a5SammrxdJ73y1/+UhMmTFB4eLjVozQaZ4DaoODgYHl7e6uiosJle0VFhUJDQy2aCp6SmZmp3/72t9q2bZtuu+02q8fxOF9fX/Xv31+xsbHKzc1VTEyMli9fbvVYHrNnzx6dOnVKI0eOlI+Pj3x8fLR9+3atWLFCPj4+qqurs3pEjwsKCtLtt9+ukpISq0fxmLCwsOsiftCgQR3+0p8kHTt2TB988IH++Z//2epRmoQAaoN8fX0VGxurwsJC57b6+noVFhYaca+EKRwOhzIzM/X+++/rww8/VHR0tNUjWaK+vl41NTVWj+Ex9957r7744gvt27fP+YiLi9P06dO1b98+eXt7Wz2ix128eFHffPONwsLCrB7FY+66667r3sbi66+/VmRkpEUTtZ78/Hz16tVLDzzwgNWjNAmXwNqorKwspaamKi4uTqNGjVJeXp6qq6uVlpZm9Wgec/HiRZf/h3j06FHt27dPPXr0UJ8+fSyczDMyMjK0YcMG/frXv1bXrl2d93cFBgaqU6dOFk/nGdnZ2ZowYYL69OmjCxcuaMOGDSoqKtKWLVusHs1junbtet19XV26dNGtt97aYe/3mjdvniZOnKjIyEidOHFCOTk58vb2VkpKitWjecy//uu/asyYMfr5z3+uhx56SLt27dLatWu1du1aq0fzqPr6euXn5ys1NVU+Pu0sKaz+NTTc2C9+8QtHnz59HL6+vo5Ro0Y5du7cafVIHrVt2zaHpOseqampVo/mEQ2tVZIjPz/f6tE8ZtasWY7IyEiHr6+vo2fPno57773X8Yc//MHqsVpdR/81+OTkZEdYWJjD19fX0bt3b0dycrKjpKTE6rE87je/+Y1jyJAhDj8/P8fAgQMda9eutXokj9uyZYtDkuOrr76yepQmszkcDoc16QUAAGAN7gECAADGIYAAAIBxCCAAAGAcAggAABiHAAIAAMYhgAAAgHEIIAAAYBwCCAAAGIcAAtCh3X333XrqqaesHgNAG0MAAWizJk6cqMTExAZ/9tFHH8lms2n//v2tPBWAjoAAAtBmpaena+vWrfr222+v+1l+fr7i4uI0bNgwCyYD0N4RQADarAcffFA9e/bU+vXrXbZfvHhR77zzjpKSkpSSkqLevXurc+fOGjp0qN56662bHtNms2nz5s0u24KCglxeo6ysTA899JCCgoLUo0cPTZo0SX/5y1+cPy8qKtKoUaPUpUsXBQUF6a677tKxY8dauFoArYkAAtBm+fj4aMaMGVq/fr3+9nOb33nnHdXV1emRRx5RbGys/ud//kcHDhzQnDlz9JOf/ES7du1q9mteuXJFdrtdXbt21UcffaQ//elPCggIUGJiompra3X16lUlJSVp/Pjx2r9/v4qLizVnzhzZbDZ3LBlAK/GxegAAuJlZs2Zp6dKl2r59u+6++25J31/+mjJliiIjIzVv3jznvk888YS2bNmit99+W6NGjWrW623atEn19fV6/fXXnVGTn5+voKAgFRUVKS4uTpWVlXrwwQfVr18/SdKgQYNatkgArY4zQADatIEDB2rMmDFat26dJKmkpEQfffSR0tPTVVdXp0WLFmno0KHq0aOHAgICtGXLFpWWljb79T7//HOVlJSoa9euCggIUEBAgHr06KHLly/rm2++UY8ePTRz5kzZ7XZNnDhRy5cv18mTJ921XACthAAC0Oalp6frV7/6lS5cuKD8/Hz169dP48eP19KlS7V8+XI999xz2rZtm/bt2ye73a7a2tobHstms7lcTpO+v+x1zcWLFxUbG6t9+/a5PL7++ms9/PDDkr4/I1RcXKwxY8Zo06ZNuv3227Vz507PLB6ARxBAANq8hx56SF5eXtqwYYPefPNNzZo1SzabTX/60580adIkPfLII4qJiVHfvn319ddf3/RYPXv2dDljc+TIEV26dMn5/ciRI3XkyBH16tVL/fv3d3kEBgY69xsxYoSys7P18ccfa8iQIdqwYYP7Fw7AYwggAG1eQECAkpOTlZ2drZMnT2rmzJmSpAEDBmjr1q36+OOP9eWXX+rRRx9VRUXFTY91zz33aOXKlfrss8+0e/duPfbYY7rlllucP58+fbqCg4M1adIkffTRRzp69KiKior05JNP6ttvv9XRo0eVnZ2t4uJiHTt2TH/4wx905MgR7gMC2hkCCEC7kJ6ernPnzslutys8PFySNH/+fI0cOVJ2u1133323QkNDlZSUdNPjvPLKK4qIiNC4ceP08MMPa968eercubPz5507d9aOHTvUp08fTZ48WYMGDVJ6erouX76sbt26qXPnzjp8+LCmTJmi22+/XXPmzFFGRoYeffRRTy4fgJvZHP//YjgAAEAHxxkgAABgHAIIAAAYhwACAADGIYAAAIBxCCAAAGAcAggAABiHAAIAAMYhgAAAgHEIIAAAYBwCCAAAGIcAAgAAxvk/fOlEHMaRmb4AAAAASUVORK5CYII=\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# verifying the results\n", - "@qfunc\n", - "def main(y: Output[QNum]) -> None:\n", - " prepare_state(prob_list,0.0,y)\n", - "\n", - "model2 = create_model(main)\n", - "qprog2 = synthesize(model2)\n", - "show(qprog2)\n", - "\n", - "" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "r5mFbwU9d76-", - "outputId": "3b85e8f8-2cd7-4196-f2f6-65883a4f8553" - }, - "execution_count": 75, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/fddc8354-cc2c-4afc-badf-126cd268f47c?version=0.41.2\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "job = execute(qprog2)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "# Ploting a bar chart to see\n", - "# total shots uesed\n", - "shots = sum([sampled_state.shots for sampled_state in parsed_counts])\n", - "histo =dict([(sampled_state.state['y'], round(sampled_state.shots/shots,2)) for sampled_state in parsed_counts])\n", - "\n", - "values = list(histo.keys())\n", - "prob = list(histo.values())\n", - "plt.bar(values, prob, color ='dodgerblue',\n", - " width = 0.4)\n", - "\n", - "plt.xlabel(\"Values\")\n", - "plt.ylabel(\"Probability\")\n", - "\n", - "plt.show()\n", - "\n", - "# We notice clearly that both 2(010) & 3(011) have diffrent probabilties, as these the only cases where MSB = 1(01)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "id": "xcvNmvmMrMcC", - "outputId": "d661366e-5faa-48d1-b651-e2c7e3a4d32e" - }, - "execution_count": 76, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - }, - "colab": { - "provenance": [] - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/community/QClass_2024/Submissions/HW2/Priyabrata_Bag_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Priyabrata_Bag_HW2_QClass2024.ipynb deleted file mode 100644 index 48f7fe3c..00000000 --- a/community/QClass_2024/Submissions/HW2/Priyabrata_Bag_HW2_QClass2024.ipynb +++ /dev/null @@ -1,705 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/89144896-1454-482f-8985-05845d44b7fc?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " pauli_operator=[PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3)],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/840709ad-cd68-42e5-af15-0ae101c220c0?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "# @qfunc\n", - "# def main(x: Output[QNum], y: Output[QNum], res: Output[QNum]):\n", - "# prepare_int(2, x)\n", - "# prepare_int(7, y)\n", - "# res |= x + y\n", - "\n", - "\n", - "# @qfunc\n", - "# def main(x: Output[QNum], y: Output[QNum], res: Output[QNum]):\n", - "# prepare_int(2, x)\n", - "# prepare_int(7, y)\n", - "# res |= x * y\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], res: Output[QNum]):\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - " res |= x * y - z\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/cad13e3b-359f-48e5-8cc5-4a89a639d809?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum[2, False, 0]], y: Output[QNum[3, False, 0]], res: Output[QNum]):\n", - " # allocate_num(num_qubits=2,is_signed=False,fraction_digits=0,out=x)\n", - " # allocate_num(num_qubits=3,is_signed=False,fraction_digits=0,out=y)\n", - " prepare_state(probabilities=[1/2, 0, 1/2, 0], bound=0, out=x)\n", - " prepare_state(probabilities=[0, 1/4, 1/4, 1/4, 0, 0, 1/4, 0], bound=0, out=y)\n", - " res |= x + y\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/ff20131e-6826-4503-86ca-8ec2a7864b35?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def addition(a: QNum, b: QNum, add: Output[QNum]):\n", - " add |= a + b\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], res: Output[QNum]):\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " tmp = QNum('tmp')\n", - " \n", - " within_apply(compute= lambda: addition(x,y,tmp), action= lambda: addition(tmp,z,res))\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/54328ccb-81c6-4a13-a884-285f58138344?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def addition(a: QNum, b: QNum, add: Output[QNum]):\n", - " add |= a + b\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], w: Output[QNum], res: Output[QNum]):\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - " tmp = QNum('tmp')\n", - " sumxyz = QNum('sumxyz')\n", - " \n", - " within_apply(compute= lambda: addition(x,y,tmp), action= lambda: addition(tmp,z,sumxyz))\n", - " res |= sumxyz + w\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/800056c0-14dd-4b2f-86ce-5e61d558ec5b?version=0.41.2\n" - ] - } - ], - "source": [ - "qmod = set_constraints(qmod, Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a734214a-a8ed-4cb3-987a-1c89ca418360?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], w: Output[QNum], res: Output[QNum]):\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - " \n", - " res |= x + y + z + w\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/2739f41b-ae73-46c7-a266-fdae868b9b43?version=0.41.2\n" - ] - } - ], - "source": [ - "qmod = set_constraints(qmod, Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5fe2877a-a5e5-4983-acba-1c9d6cb1d381?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "# @qfunc\n", - "# def linear_func(a: CReal, b: CReal, x: QNum, res: Output[QNum]):\n", - "# res |= a * x + b\n", - "\n", - "@qfunc\n", - "def inplace_linear_func(a: CReal, b: CReal, x: QNum, res: QNum):\n", - " tmp = QNum('tmp')\n", - " allocate_num(num_qubits=5,is_signed=False,fraction_digits=3,out=tmp)\n", - " within_apply(compute= lambda: linear_func(a, b, x, tmp), action= lambda: inplace_xor(tmp, res))\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: inplace_linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: inplace_linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/246b2b1c-bd49-4849-a5f0-fc5979cae7d3?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/907625f6-c374-46ed-8039-71c8deeab08e?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 2, lambda: RY(symbolic.pi / 3, lsb))\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Rajana_Rama_Satya_Sai_Durga_Prasad_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Rajana_Rama_Satya_Sai_Durga_Prasad_HW2_QClass2024.ipynb deleted file mode 100644 index df3b7469..00000000 --- a/community/QClass_2024/Submissions/HW2/Rajana_Rama_Satya_Sai_Durga_Prasad_HW2_QClass2024.ipynb +++ /dev/null @@ -1,692 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c31a02ed-6501-4ed8-b1a0-3a559eacc899?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3)\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/6bead2a5-e0b5-4ca9-b594-c203073f37c7?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def addition(res: Output[QNum]):\n", - " x = QNum(\"x\") \n", - " prepare_int(2,x)\n", - " y = QNum(\"y\")\n", - " prepare_int(7,y)\n", - " res|=x+y\n", - " \n", - "@qfunc\n", - "def multiply(res: Output[QNum]):\n", - " x = QNum(\"x\") \n", - " prepare_int(2,x)\n", - " y = QNum(\"y\")\n", - " prepare_int(7,y)\n", - " res|=x*y\n", - "\n", - "@qfunc\n", - "def mixed_op(res: Output[QNum]):\n", - " x = QNum(\"x\") \n", - " prepare_int(2,x)\n", - " y = QNum(\"y\")\n", - " prepare_int(7,y)\n", - " z = QNum(\"z\")\n", - " prepare_int(1,z)\n", - " res|=x*y-z\n", - " \n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " #addition(res)\n", - " multiply(res)\n", - " #mixed_op(res)\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d5b5f2ce-4fc4-489c-9bc2-54599be2a3f0?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc(external=True)\n", - "def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - ") -> None:\n", - " pass\n", - "#x: Output[QArray[QBit]],y: Output[QArray[QBit]],\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " prepare_state(probabilities=[0.5, 0, 0.5, 0], bound=0, out=x)\n", - " y = QNum(\"y\") \n", - " prepare_state(probabilities=[0, 0.25, 0.25, 0.25, 0, 0, 0.25,0], bound=0, out=y)\n", - " \n", - " res|= x+y\n", - " \n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/1ffa5d8d-2c07-489c-8cdb-87c71fb50178?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def addition_fun(x:QNum, y: QNum,res: Output[QNum]):\n", - " res|=x+y\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " \n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " tmp = QNum('tmp')\n", - " within_apply(compute= lambda: addition_fun(x,y,tmp),\n", - " action= lambda: addition_fun(tmp,z,res))\n", - "\n", - " \n", - " \n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5916e27b-bbb9-4805-893b-0fd402b123d6?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def addition_fun(x:QNum, y: QNum,res: Output[QNum]):\n", - " res|=x+y\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - "\n", - " w = QNum('w')\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " tmp1 = QNum('tmp1')\n", - " tmp2 = QNum('tmp2')\n", - " within_apply(compute= lambda: addition_fun(x,y,tmp1),\n", - " action= lambda: addition_fun(tmp1,z,tmp2))\n", - " res|= tmp2+w\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d0955720-e6c8-4067-b8cb-feb616b14e28?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - "\n", - " w = QNum('w')\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " z = QNum('z')\n", - " prepare_int(4, w)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - "\n", - " res|=w+x+y+z\n", - "\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/94b1e4ac-25d4-46d9-99e0-380a2b4b6260?version=0.41.2\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d865c2f7-c7ab-4092-8192-602cf2de60dc?version=0.40.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/258b4944-0bbb-4642-b8af-d8969349efbf?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt,pi\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1/8 -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1/8-sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " prepare_state(probabilities=prob_list, bound=0, out=res)\n", - " \n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)\n", - "\n", - " \n", - " \n", - " \n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Razeen_Ud_Din_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Razeen_Ud_Din_HW2_QClass2024.ipynb deleted file mode 100644 index e2d1e012..00000000 --- a/community/QClass_2024/Submissions/HW2/Razeen_Ud_Din_HW2_QClass2024.ipynb +++ /dev/null @@ -1,658 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/80c5a839-8aae-4997-af10-c8b6645f0c60?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3),\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a7aec343-f19c-4a69-859e-dc4d7876a8ec?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], res: Output[QNum]) -> None:\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/7c8f2135-1669-4e24-9608-bf68ea70a29f?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], res: Output[QNum]) -> None:\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x * y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/b276f7d5-89a5-487b-adcc-aa49ed5e9d8a?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum], z: Output[QNum], res: Output[QNum]) -> None:\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - " res |= x + y - z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for +: 'QArray' and 'QArray'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10168\\4234725309.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 17\u001b[0m \u001b[1;31m# Your code here:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 19\u001b[1;33m \u001b[0mqmod\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcreate_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmain\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 20\u001b[0m \u001b[0mqprog\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msynthesize\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mqmod\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 21\u001b[0m \u001b[0mshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mqprog\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\classiq\\qmod\\quantum_function.py\u001b[0m in \u001b[0;36mcreate_model\u001b[1;34m(entry_point, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[0;32m 41\u001b[0m \u001b[1;34mf\"The entry point function must be named 'main', got '{entry_point.func_decl.name}'\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 42\u001b[0m )\n\u001b[1;32m---> 43\u001b[1;33m return entry_point.create_model(\n\u001b[0m\u001b[0;32m 44\u001b[0m \u001b[0mconstraints\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mexecution_preferences\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpreferences\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mclassical_execution_function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 45\u001b[0m ).get_model()\n", - "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\classiq\\qmod\\quantum_function.py\u001b[0m in \u001b[0;36mcreate_model\u001b[1;34m(self, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[0;32m 76\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_qmodule\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconstants\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 77\u001b[0m \u001b[0mQConstant\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_current_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_qmodule\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 78\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_add_native_func_def\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 79\u001b[0m model_extra_settings: List[Tuple[str, Any]] = [\n\u001b[0;32m 80\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"constraints\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mconstraints\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\classiq\\qmod\\quantum_function.py\u001b[0m in \u001b[0;36m_add_native_func_def\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 97\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfunc_decl\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_qmodule\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnative_defs\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 98\u001b[0m \u001b[1;32mreturn\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 99\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexpand\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 100\u001b[0m self._qmodule.native_defs[self.func_decl.name] = NativeFunctionDefinition(\n\u001b[0;32m 101\u001b[0m \u001b[1;33m**\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfunc_decl\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m\"body\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\classiq\\qmod\\quantum_expandable.py\u001b[0m in \u001b[0;36mexpand\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 84\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mQExpandable\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mSTACK\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 85\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 86\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_py_callable\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_positional_args\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 87\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 88\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0minfer_rename_params\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[0mDict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10168\\4234725309.py\u001b[0m in \u001b[0;36mmain\u001b[1;34m(x, y, res)\u001b[0m\n\u001b[0;32m 10\u001b[0m \u001b[0mprepare_state\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mprobabilities\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mprobabilities2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbound\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0.01\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mres\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'QArray' and 'QArray'" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]],y: Output[QArray[QBit]],res: Output[QArray[QBit]]):\n", - " probabilities1 = [1/2, 0, 0, 1/2]\n", - " prepare_state(probabilities=probabilities1, bound=0.01, out=x)\n", - " probabilities2 = [0,1/4,1/4,1/4, 0, 0, 1/4,0]\n", - " prepare_state(probabilities=probabilities2, bound=0.01, out=y)\n", - " \n", - " res = x + y\n", - "\n", - " \n", - " \n", - " \n", - "# Your code here:\n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "ename": "ValidationError", - "evalue": "1 validation error for Model\n__root__\n Handle 'x' was errored with \"At the end of the function, in port x is expected to be HandleState.INITIALIZED but it isn't\"\nHandle 'y' was errored with \"At the end of the function, in port y is expected to be HandleState.INITIALIZED but it isn't\"\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support (type=value_error.classiqvalue; _raw_message=Handle 'x' was errored with \"At the end of the function, in port x is expected to be HandleState.INITIALIZED but it isn't\"\nHandle 'y' was errored with \"At the end of the function, in port y is expected to be HandleState.INITIALIZED but it isn't\")", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValidationError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10168\\4146049375.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 19\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 21\u001b[1;33m \u001b[0mqmod\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcreate_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmain\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 22\u001b[0m \u001b[0mqprog\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msynthesize\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mqmod\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 23\u001b[0m \u001b[0mshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mqprog\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\classiq\\qmod\\quantum_function.py\u001b[0m in \u001b[0;36mcreate_model\u001b[1;34m(entry_point, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[0;32m 41\u001b[0m \u001b[1;34mf\"The entry point function must be named 'main', got '{entry_point.func_decl.name}'\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 42\u001b[0m )\n\u001b[1;32m---> 43\u001b[1;33m return entry_point.create_model(\n\u001b[0m\u001b[0;32m 44\u001b[0m \u001b[0mconstraints\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mexecution_preferences\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpreferences\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mclassical_execution_function\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 45\u001b[0m ).get_model()\n", - "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\classiq\\qmod\\quantum_function.py\u001b[0m in \u001b[0;36mcreate_model\u001b[1;34m(self, constraints, execution_preferences, preferences, classical_execution_function)\u001b[0m\n\u001b[0;32m 87\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"classical_execution_code\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mclassical_execution_function\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 88\u001b[0m )\n\u001b[1;32m---> 89\u001b[1;33m return Model(\n\u001b[0m\u001b[0;32m 90\u001b[0m \u001b[0mconstants\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_qmodule\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconstants\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 91\u001b[0m \u001b[0mfunctions\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_qmodule\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnative_defs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\Anaconda3\\lib\\site-packages\\pydantic\\main.cp39-win_amd64.pyd\u001b[0m in \u001b[0;36mpydantic.main.BaseModel.__init__\u001b[1;34m()\u001b[0m\n", - "\u001b[1;31mValidationError\u001b[0m: 1 validation error for Model\n__root__\n Handle 'x' was errored with \"At the end of the function, in port x is expected to be HandleState.INITIALIZED but it isn't\"\nHandle 'y' was errored with \"At the end of the function, in port y is expected to be HandleState.INITIALIZED but it isn't\"\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support (type=value_error.classiqvalue; _raw_message=Handle 'x' was errored with \"At the end of the function, in port x is expected to be HandleState.INITIALIZED but it isn't\"\nHandle 'y' was errored with \"At the end of the function, in port y is expected to be HandleState.INITIALIZED but it isn't\")" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def prep_plus(x: Output[QNum], y: Output[QNum] , Add: Output[QNum]) -> None:\n", - " Add |= x+y \n", - "\n", - "@qfunc\n", - "def main_plus(Add: Output[QNum], z: Output[QNum] , res: Output[QNum]) -> None:\n", - " res |= Add+z \n", - " \n", - " \n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum] , z: Output[QNum], Add: Output[QNum], res: Output[QNum]) -> None:\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(1, z)\n", - " \n", - " within_apply(lambda: prep_plus(x,y,Add), lambda: main_plus(Add,z,res))\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/820a33c8-8d74-40f1-910d-bc58a9036ae0?version=0.40.0\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/7b2bd311-2a76-4bc6-8904-8f470ce01f88?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.13" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Samyak_Jain_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Samyak_Jain_HW2_QClass2024.ipynb deleted file mode 100644 index a782215c..00000000 --- a/community/QClass_2024/Submissions/HW2/Samyak_Jain_HW2_QClass2024.ipynb +++ /dev/null @@ -1,720 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/3954d784-f033-4b7c-9057-aae0d861767d?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3)\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/20a1aa71-8b21-4605-9b53-52152229ebe8?version=0.42.0\n", - "Opening: https://platform.classiq.io/circuit/f7310431-f729-4402-a55d-b562fb8c7598?version=0.42.0\n", - "Opening: https://platform.classiq.io/circuit/eccb46b4-41df-42b9-8850-3119a29cc55f?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(result: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - "\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - "\n", - " result |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "# %%\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - "\n", - " res |= x * y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "# %%\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - " prepare_int(1,z)\n", - "\n", - " res |= x * y -z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/672dc63b-991f-45a1-aeca-cee51d46c835?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " \n", - " prepare_state(probabilities=[0.5,0,0.5,0], bound=0, out=x)\n", - " prepare_state(probabilities=[0,0.25,0.25,0.25,0,0,0.25,0], bound=0, out=y)\n", - " \n", - " res|=x+y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a4f86787-d712-43aa-b0c9-3cb96442d2e3?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def two_sum(x: QNum, y:QNum, res: Output[QNum]):\n", - " res |= x + y\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " tmp = QNum(\"tmp\")\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - "\n", - " within_apply(compute= lambda: two_sum(x,y,tmp),\n", - " action= lambda: two_sum(tmp,z,res))\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/6d97d4c4-13a2-4e02-893b-52e0685a6693?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " w = QNum(\"w\")\n", - " tmp = QNum(\"tmp\")\n", - " aux = QNum(\"aux\")\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - " prepare_int(4,w)\n", - "\n", - "\n", - " within_apply(compute= lambda: two_sum(x,y,tmp),\n", - " action= lambda: two_sum(tmp,z,aux))\n", - "\n", - " two_sum(aux,w,res)\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'res': 14.0}\n" - ] - } - ], - "source": [ - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "for sampled_state in parsed_counts: print(sampled_state.state)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/481d5262-abd0-4491-acfa-2903adde02de?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " w = QNum(\"w\")\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - " prepare_int(4,w)\n", - "\n", - " res |= x + y + z + w\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "ename": "ClassiqAPIError", - "evalue": "Error number 22102 occurred. Size mismatch for port 'result__temp__' between declared size 4 and assigned size 5\n\tat file C:\\Users\\HP\\AppData\\Local\\Temp\\ipykernel_1564\\2419106230.py line 5 character 4\n\nError identifier: E50C921F3-E14B-4C30-8E89-40E137DEAD68.\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mClassiqAPIError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[11], line 29\u001b[0m\n\u001b[0;32m 25\u001b[0m control(label, \u001b[38;5;28;01mlambda\u001b[39;00m: linear_func(\u001b[38;5;241m2.0\u001b[39m, \u001b[38;5;241m1.0\u001b[39m, x, res)) \u001b[38;5;66;03m# 0.0 <= x < 0.5\u001b[39;00m\n\u001b[0;32m 28\u001b[0m qmod \u001b[38;5;241m=\u001b[39m create_model(main)\n\u001b[1;32m---> 29\u001b[0m qprog \u001b[38;5;241m=\u001b[39m \u001b[43msynthesize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqmod\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 30\u001b[0m show(qprog)\n", - "File \u001b[1;32mc:\\Users\\HP\\Documents\\GitHub\\classiq-library\\.conda\\Lib\\site-packages\\classiq\\_internals\\async_utils.py:45\u001b[0m, in \u001b[0;36msyncify_function..async_wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 43\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(async_func)\n\u001b[0;32m 44\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21masync_wrapper\u001b[39m(\u001b[38;5;241m*\u001b[39margs: Any, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Any) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T:\n\u001b[1;32m---> 45\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43masync_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32mc:\\Users\\HP\\Documents\\GitHub\\classiq-library\\.conda\\Lib\\site-packages\\classiq\\_internals\\async_utils.py:39\u001b[0m, in \u001b[0;36mrun\u001b[1;34m(coro)\u001b[0m\n\u001b[0;32m 34\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun\u001b[39m(coro: Awaitable[T]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T:\n\u001b[0;32m 35\u001b[0m \u001b[38;5;66;03m# Use this function instead of asyncio.run, since it ALWAYS\u001b[39;00m\n\u001b[0;32m 36\u001b[0m \u001b[38;5;66;03m# creates a new event loop and clears the thread event loop.\u001b[39;00m\n\u001b[0;32m 37\u001b[0m \u001b[38;5;66;03m# Never use asyncio.run in library code.\u001b[39;00m\n\u001b[0;32m 38\u001b[0m loop \u001b[38;5;241m=\u001b[39m get_event_loop()\n\u001b[1;32m---> 39\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mloop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_until_complete\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcoro\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32mc:\\Users\\HP\\Documents\\GitHub\\classiq-library\\.conda\\Lib\\site-packages\\nest_asyncio.py:98\u001b[0m, in \u001b[0;36m_patch_loop..run_until_complete\u001b[1;34m(self, future)\u001b[0m\n\u001b[0;32m 95\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m f\u001b[38;5;241m.\u001b[39mdone():\n\u001b[0;32m 96\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[0;32m 97\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mEvent loop stopped before Future completed.\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m---> 98\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresult\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32mc:\\Users\\HP\\Documents\\GitHub\\classiq-library\\.conda\\Lib\\asyncio\\futures.py:203\u001b[0m, in \u001b[0;36mFuture.result\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 201\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__log_traceback \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m 202\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m--> 203\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception\u001b[38;5;241m.\u001b[39mwith_traceback(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_exception_tb)\n\u001b[0;32m 204\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_result\n", - "File \u001b[1;32mc:\\Users\\HP\\Documents\\GitHub\\classiq-library\\.conda\\Lib\\asyncio\\tasks.py:277\u001b[0m, in \u001b[0;36mTask.__step\u001b[1;34m(***failed resolving arguments***)\u001b[0m\n\u001b[0;32m 273\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m 274\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m exc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m 275\u001b[0m \u001b[38;5;66;03m# We use the `send` method directly, because coroutines\u001b[39;00m\n\u001b[0;32m 276\u001b[0m \u001b[38;5;66;03m# don't have `__iter__` and `__next__` methods.\u001b[39;00m\n\u001b[1;32m--> 277\u001b[0m result \u001b[38;5;241m=\u001b[39m coro\u001b[38;5;241m.\u001b[39msend(\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m 278\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 279\u001b[0m result \u001b[38;5;241m=\u001b[39m coro\u001b[38;5;241m.\u001b[39mthrow(exc)\n", - "File \u001b[1;32mc:\\Users\\HP\\Documents\\GitHub\\classiq-library\\.conda\\Lib\\site-packages\\classiq\\synthesis.py:20\u001b[0m, in \u001b[0;36msynthesize_async\u001b[1;34m(serialized_model)\u001b[0m\n\u001b[0;32m 16\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msynthesize_async\u001b[39m(\n\u001b[0;32m 17\u001b[0m serialized_model: SerializedModel,\n\u001b[0;32m 18\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m SerializedQuantumProgram:\n\u001b[0;32m 19\u001b[0m model \u001b[38;5;241m=\u001b[39m pydantic\u001b[38;5;241m.\u001b[39mparse_raw_as(Model, serialized_model)\n\u001b[1;32m---> 20\u001b[0m quantum_program \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m ApiWrapper\u001b[38;5;241m.\u001b[39mcall_generation_task(model)\n\u001b[0;32m 21\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m SerializedQuantumProgram(quantum_program\u001b[38;5;241m.\u001b[39mjson(indent\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m))\n", - "File \u001b[1;32mc:\\Users\\HP\\Documents\\GitHub\\classiq-library\\.conda\\Lib\\site-packages\\classiq\\_internals\\api_wrapper.py:108\u001b[0m, in \u001b[0;36mApiWrapper.call_generation_task\u001b[1;34m(cls, model)\u001b[0m\n\u001b[0;32m 106\u001b[0m poller \u001b[38;5;241m=\u001b[39m JobPoller(base_url\u001b[38;5;241m=\u001b[39mroutes\u001b[38;5;241m.\u001b[39mTASKS_GENERATE_FULL_PATH)\n\u001b[0;32m 107\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m poller\u001b[38;5;241m.\u001b[39mrun_pydantic(model, timeout_sec\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m--> 108\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_parse_job_response\u001b[49m\u001b[43m(\u001b[49m\u001b[43mresult\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgenerator_result\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mQuantumProgram\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32mc:\\Users\\HP\\Documents\\GitHub\\classiq-library\\.conda\\Lib\\site-packages\\classiq\\_internals\\api_wrapper.py:58\u001b[0m, in \u001b[0;36m_parse_job_response\u001b[1;34m(job_result, output_type)\u001b[0m\n\u001b[0;32m 56\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m output_type\u001b[38;5;241m.\u001b[39mparse_obj(job_result\u001b[38;5;241m.\u001b[39mdescription)\n\u001b[0;32m 57\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(job_result, JobDescriptionFailure):\n\u001b[1;32m---> 58\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqAPIError(job_result\u001b[38;5;241m.\u001b[39mdescription\u001b[38;5;241m.\u001b[39mdetails)\n\u001b[0;32m 60\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m ClassiqAPIError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUnexpected response from server\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[1;31mClassiqAPIError\u001b[0m: Error number 22102 occurred. Size mismatch for port 'result__temp__' between declared size 4 and assigned size 5\n\tat file C:\\Users\\HP\\AppData\\Local\\Temp\\ipykernel_1564\\2419106230.py line 5 character 4\n\nError identifier: E50C921F3-E14B-4C30-8E89-40E137DEAD68.\nIf you need further assistance, please reach out on our Community Slack channel at: https://short.classiq.io/join-slack\nIf the error persists feel free to open a ticket at: https://short.classiq.io/support" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0e9d2e13-0910-499e-aadd-ec87b4b87a64?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c25cd6ea-4855-4212-8a68-bf52c1e5d168?version=0.42.0\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "import numpy as np\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]):\n", - " x = QArray(\"x\")\n", - " allocate(3, x)\n", - " #pre_prepared_state(x)\n", - " hadamard_transform(x)\n", - " \n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - " \n", - " control(msb == 0, lambda: RY(np.pi / 3, lsb)) \n", - " control(msb == 1, lambda: RY(np.pi / 3, lsb)) \n", - " bind([lsb, msb], res)\n", - " \n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/Yasir_Mansour_HW2_QClass2024.pdf b/community/QClass_2024/Submissions/HW2/Yasir_Mansour_HW2_QClass2024.pdf deleted file mode 100644 index a7729a24..00000000 Binary files a/community/QClass_2024/Submissions/HW2/Yasir_Mansour_HW2_QClass2024.pdf and /dev/null differ diff --git a/community/QClass_2024/Submissions/HW2/Yue(Leslie)_Xu_HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/Yue(Leslie)_Xu_HW2_QClass2024.ipynb deleted file mode 100644 index 46835818..00000000 --- a/community/QClass_2024/Submissions/HW2/Yue(Leslie)_Xu_HW2_QClass2024.ipynb +++ /dev/null @@ -1,949 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/2b2ce9eb-badb-4fef-84ca-eadc0326f1ba?version=0.41.1\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "HAMILTONIAN = [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z,Pauli.X,Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I,Pauli.Z,Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I,Pauli.Z,Pauli.Y], coefficient=0.3),\n", - "]\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " HAMILTONIAN,\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/36d40def-902e-472d-b9fa-517f778cb3c0?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x + y \n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d04eec41-3220-4651-9627-be90ae12682b?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x * y \n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/16764d23-2152-428f-a902-12fb642c8108?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - " res |= x * y - z # should be 8\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/56c673b5-8a5a-494c-89cb-572e64d37366?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc(external=True)\n", - "def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum] ) -> None:\n", - "\n", - " \n", - " x = QNum(\"x\",2, False, 0)\n", - " # x = QArray(\"x\")\n", - " # allocate(2, x)\n", - " # allocate_num(num_qubits=2,is_signed=False,fraction_digits=0,out=x)\n", - " prepare_state([0.5, 0, 0.5, 0], 0, x)\n", - " \n", - " y = QNum(\"y\",3, False, 0)\n", - " # y = QBit(\"y\") \n", - " # allocate(3, y)\n", - " prepare_state([0, 0.25, 0.25, 0.25, 0, 0, 0.25, 0], 0, y)\n", - " \n", - " res |= x + y\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [], - "source": [ - "job = execute(qprog)\n", - "# job.open_in_ide()" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [], - "source": [ - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "counts = results[0].value.counts\n", - "# for sampled_state in parsed_counts: print(sampled_state.state)\n", - "# print(results)" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'0100': 276, '0010': 230, '0101': 277, '0011': 534, '0110': 256, '0001': 240, '1000': 235}\n" - ] - } - ], - "source": [ - "print(counts)" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'res': 3.0}: 534, {'res': 5.0}: 277, {'res': 4.0}: 276, {'res': 6.0}: 256, {'res': 1.0}: 240, {'res': 8.0}: 235, {'res': 2.0}: 230]\n" - ] - } - ], - "source": [ - "print(parsed_counts)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/19a9a6d2-9565-4387-9442-c849bfbaeb62?version=0.41.2\n" - ] - } - ], - "source": [ - "# from classiq import *\n", - "\n", - "# # def within_apply(compute: Callable, action: Callable) -> None:\n", - "# # pass\n", - "\n", - "# # Your code here:\n", - "# @qfunc\n", - "# def add(x:QNum, y: QNum, a:Output[QNum]) :\n", - "# a |= x + y\n", - "\n", - "# def sum(t: QNum, z: QNum, s:Output[QNum]):\n", - "# s |= t + z\n", - "\n", - "# @qfunc\n", - "# def main(res: Output[QNum]) -> None:\n", - "# x = QNum(\"x\")\n", - "# prepare_int(3, x)\n", - "# y = QNum(\"y\")\n", - "# prepare_int(5, y)\n", - "# z = QNum(\"z\")\n", - "# prepare_int(2, z)\n", - "# tmp = QNum(\"tmp\")\n", - " \n", - "# within_apply(lambda:add(x,y,tmp), lambda:sum(tmp, z, res))\n", - "\n", - "\n", - "# qmod = create_model(main)\n", - "# qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 85, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/6ee39773-a9c4-408a-ae80-69afce0ab748?version=0.41.2\n" - ] - } - ], - "source": [ - "\n", - "# def within_apply(compute: Callable, action: Callable) -> None:\n", - "# pass\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def add(x:QNum, y: QNum, a:Output[QNum]) :\n", - " a |= x + y\n", - "@qfunc\n", - "def inplace_add(x:QNum, y: QNum, z: QNum, res:Output[QNum]):\n", - " tmp = QNum(\"tmp\")\n", - " within_apply(lambda:add(x,y,tmp), lambda:add(tmp, z, res))\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " prepare_int(3, x)\n", - " y = QNum(\"y\")\n", - " prepare_int(5, y)\n", - " z = QNum(\"z\")\n", - " prepare_int(2, z)\n", - " \n", - " inplace_add(x,y,z,res)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/705a1fe2-ea48-4b1b-8ace-73072304c4bd?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "@qfunc\n", - "def add(x:QNum, y: QNum, a:Output[QNum]) :\n", - " a |= x + y\n", - "\n", - "\n", - "@qfunc\n", - "def inplace_add(x:QNum, y: QNum, z: QNum, res:Output[QNum]):\n", - " tmp = QNum(\"tmp\")\n", - " within_apply(lambda:add(x,y,tmp), lambda:add(tmp, z, res))\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " prepare_int(3, x)\n", - " y = QNum(\"y\")\n", - " prepare_int(5, y)\n", - " z = QNum(\"z\")\n", - " prepare_int(2, z)\n", - " tr= QNum(\"tr\")\n", - " inplace_add(x,y,z,tr)\n", - " \n", - " w = QNum(\"w\")\n", - " prepare_int(4, w)\n", - " add(tr,w, res)\n", - "\n", - "\n", - " \n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 20, depth: 147\n" - ] - } - ], - "source": [ - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/d53e7f16-7c4b-4af3-8b45-f4ec97312489?version=0.41.2\n" - ] - } - ], - "source": [ - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " prepare_int(3, x)\n", - " y = QNum(\"y\")\n", - " prepare_int(5, y)\n", - " z = QNum(\"z\")\n", - " prepare_int(2, z)\n", - " w = QNum(\"w\")\n", - " prepare_int(4, w)\n", - " \n", - " res |= x + y + z + w\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 12, depth: 155\n" - ] - } - ], - "source": [ - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)\n", - "#Not sure if I am using the within_apply correct, but it seems the within_apply complicate the quantum circuit..." - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/9b6eea8a-21d3-46ac-9611-0512f1bec2aa?version=0.41.2\n" - ] - } - ], - "source": [ - "# Your code here:\n", - "\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " prepare_int(3, x)\n", - " y = QNum(\"y\")\n", - " prepare_int(5, y)\n", - " z = QNum(\"z\")\n", - " prepare_int(2, z)\n", - " w = QNum(\"w\")\n", - " prepare_int(4, w)\n", - " tr1= QNum(\"tr1\")\n", - " tr2= QNum(\"tr2\")\n", - "\n", - " add(x,y, tr1)\n", - " add(tr1,z, tr2)\n", - " add(tr2,w, res)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 13, depth: 169\n" - ] - } - ], - "source": [ - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)\n", - "#" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5cd98615-e0a6-4cda-8e18-e61efad270ba?version=0.41.2\n" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - " \n", - "\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 106, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/59d2185e-2a15-41d0-a00c-1013bbc7e6d4?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/bogachan_arslan-HW2_QClass2024.ipynb b/community/QClass_2024/Submissions/HW2/bogachan_arslan-HW2_QClass2024.ipynb deleted file mode 100644 index 7488af2c..00000000 --- a/community/QClass_2024/Submissions/HW2/bogachan_arslan-HW2_QClass2024.ipynb +++ /dev/null @@ -1,878 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T22:09:22.231289Z", - "start_time": "2024-05-26T22:09:22.209148Z" - } - }, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T22:09:25.591971Z", - "start_time": "2024-05-26T22:09:25.577439Z" - } - }, - "outputs": [], - "source": [ - "@struct\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T22:09:28.645410Z", - "start_time": "2024-05-26T22:09:28.621424Z" - } - }, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T22:09:34.148522Z", - "start_time": "2024-05-26T22:09:30.302077Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/4741ece5-671b-41b8-a421-cd6094af0669?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " suzuki_trotter(\n", - " [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5), \n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3)\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of arithmetic expression.\n", - "* To initialize the variables, use the function `prepare_int`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T16:24:23.563715Z", - "start_time": "2024-05-26T16:24:19.794537Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/1f2b1ee3-5763-4c37-b9d7-8ebcaedef07d?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "# 1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\", 2, False, 0)\n", - " y = QNum(\"y\", 3, False, 0)\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x + y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/fa0232f9-2c91-42ef-b564-86f5afe126e9?version=0.41.2\n" - ] - } - ], - "source": [ - "# 2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\", 2, False, 0)\n", - " y = QNum(\"y\", 3, False, 0)\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " res |= x * y\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-05-26T16:26:34.590082Z", - "start_time": "2024-05-26T16:26:30.828338Z" - } - }, - "execution_count": 9 - }, - { - "cell_type": "code", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5d6f1e2d-d6b2-4781-bd76-e37416ee207b?version=0.41.2\n" - ] - } - ], - "source": [ - "# 3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\", 2, False, 0)\n", - " y = QNum(\"y\", 3, False, 0)\n", - " z = QNum(\"z\", 1, False, 0)\n", - " prepare_int(2, x)\n", - " prepare_int(7, y)\n", - " prepare_int(1, z)\n", - " res |= x * y - z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-05-26T16:27:29.729189Z", - "start_time": "2024-05-26T16:27:25.952134Z" - } - }, - "execution_count": 10 - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T16:32:36.149627Z", - "start_time": "2024-05-26T16:32:32.435232Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/758e7261-9010-4074-892a-b51add9d6631?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\", 2, False, 0)\n", - " y = QNum(\"y\", 3, False, 0)\n", - " prepare_state([0.5,0,0.5,0], 0, x)\n", - " prepare_state([0,0.25,0.25,0.25,0,0,0.25,0], 0, y)\n", - " res |= x + y\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T16:59:29.969734Z", - "start_time": "2024-05-26T16:59:26.122712Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/42a51d5a-6496-4b09-8939-06acb3affa7a?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "@qfunc\n", - "def add(x: QNum, y: QNum, tmp: Output[QNum]):\n", - " tmp |= x + y\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\", 2, False, 0)\n", - " y = QNum(\"y\", 3, False, 0)\n", - " z = QNum(\"z\", 2, False, 0)\n", - " tmp = QNum(\"tmp\", 4, False, 0)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " \n", - " within_apply(lambda: add(x, y, tmp), lambda: add(tmp, z, res))\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T17:17:42.572608Z", - "start_time": "2024-05-26T17:17:37.254529Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 18, depth: 147\n", - "Opening: https://platform.classiq.io/circuit/9411868e-e419-4ec1-8326-1415200bb04d?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "def print_depth_width(quantum_program):\n", - " generated_circuit = QuantumProgram.parse_raw(quantum_program)\n", - " print(f\"Synthesized circuit width: {generated_circuit.data.width}, depth: {generated_circuit.transpiled_circuit.depth}\")\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def add(x: QNum, y: QNum, res: Output[QNum]):\n", - " res |= x + y\n", - " \n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\", 2, False, 0)\n", - " y = QNum(\"y\", 3, False, 0)\n", - " z = QNum(\"z\", 2, False, 0)\n", - " w = QNum(\"w\", 3, False, 0)\n", - " tmp = QNum(\"tmp\", 4, False, 0)\n", - " tmp2 = QNum(\"tmp2\", 5, False, 0)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - " \n", - " within_apply(lambda: add(x, y, tmp), lambda: add(z, tmp, tmp2))\n", - " res |= tmp2 + w\n", - "\n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T17:19:06.347632Z", - "start_time": "2024-05-26T17:19:02.589362Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized circuit width: 12, depth: 155\n", - "Opening: https://platform.classiq.io/circuit/9b721435-34b1-4487-96fd-f06a021f8247?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\", 2, False, 0)\n", - " y = QNum(\"y\", 3, False, 0)\n", - " z = QNum(\"z\", 2, False, 0)\n", - " w = QNum(\"w\", 3, False, 0)\n", - " prepare_int(3, x)\n", - " prepare_int(5, y)\n", - " prepare_int(2, z)\n", - " prepare_int(4, w)\n", - " res |= x + y + z + w\n", - "\n", - "qmod = create_model(main)\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "print_depth_width(qprog)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T21:06:37.494727Z", - "start_time": "2024-05-26T21:06:37.412072Z" - } - }, - "outputs": [ - { - "ename": "TypeError", - "evalue": "object of type 'int' has no len()", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mTypeError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[0;32mIn[39], line 28\u001B[0m\n\u001B[1;32m 24\u001B[0m X(label)\n\u001B[1;32m 25\u001B[0m control(label, \u001B[38;5;28;01mlambda\u001B[39;00m: linear_func(\u001B[38;5;241m2.0\u001B[39m, \u001B[38;5;241m1.0\u001B[39m, x, res)) \u001B[38;5;66;03m# 0.0 <= x < 0.5\u001B[39;00m\n\u001B[0;32m---> 28\u001B[0m qmod \u001B[38;5;241m=\u001B[39m \u001B[43mcreate_model\u001B[49m\u001B[43m(\u001B[49m\u001B[43mmain\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 29\u001B[0m qprog \u001B[38;5;241m=\u001B[39m synthesize(qmod)\n\u001B[1;32m 30\u001B[0m show(qprog)\n", - "File \u001B[0;32m~/.pyenv/versions/3.9.7/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:39\u001B[0m, in \u001B[0;36mcreate_model\u001B[0;34m(entry_point, constraints, execution_preferences, preferences, classical_execution_function)\u001B[0m\n\u001B[1;32m 32\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mcreate_model\u001B[39m(\n\u001B[1;32m 33\u001B[0m entry_point: \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mQFunc\u001B[39m\u001B[38;5;124m\"\u001B[39m,\n\u001B[1;32m 34\u001B[0m constraints: Optional[Constraints] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 37\u001B[0m classical_execution_function: Optional[CFunc] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m,\n\u001B[1;32m 38\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m SerializedModel:\n\u001B[0;32m---> 39\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[43mentry_point\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfunc_decl\u001B[49m\u001B[38;5;241m.\u001B[39mname \u001B[38;5;241m!=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mmain\u001B[39m\u001B[38;5;124m\"\u001B[39m:\n\u001B[1;32m 40\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m ClassiqError(\n\u001B[1;32m 41\u001B[0m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mThe entry point function must be named \u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mmain\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m, got \u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mentry_point\u001B[38;5;241m.\u001B[39mfunc_decl\u001B[38;5;241m.\u001B[39mname\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 42\u001B[0m )\n\u001B[1;32m 43\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m entry_point\u001B[38;5;241m.\u001B[39mcreate_model(\n\u001B[1;32m 44\u001B[0m constraints, execution_preferences, preferences, classical_execution_function\n\u001B[1;32m 45\u001B[0m )\u001B[38;5;241m.\u001B[39mget_model()\n", - "File \u001B[0;32m~/.pyenv/versions/3.9.7/lib/python3.9/site-packages/classiq/qmod/quantum_function.py:60\u001B[0m, in \u001B[0;36mQFunc.func_decl\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 56\u001B[0m \u001B[38;5;129m@property\u001B[39m\n\u001B[1;32m 57\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mfunc_decl\u001B[39m(\u001B[38;5;28mself\u001B[39m) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m QuantumFunctionDeclaration:\n\u001B[1;32m 58\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_qmodule\u001B[38;5;241m.\u001B[39mnative_defs\u001B[38;5;241m.\u001B[39mget(\n\u001B[1;32m 59\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_py_callable\u001B[38;5;241m.\u001B[39m\u001B[38;5;18m__name__\u001B[39m,\n\u001B[0;32m---> 60\u001B[0m \u001B[43minfer_func_decl\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_py_callable\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mqmodule\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_qmodule\u001B[49m\u001B[43m)\u001B[49m,\n\u001B[1;32m 61\u001B[0m )\n", - "File \u001B[0;32m~/.pyenv/versions/3.9.7/lib/python3.9/site-packages/classiq/qmod/declaration_inferrer.py:153\u001B[0m, in \u001B[0;36minfer_func_decl\u001B[0;34m(py_func, qmodule)\u001B[0m\n\u001B[1;32m 148\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21minfer_func_decl\u001B[39m(\n\u001B[1;32m 149\u001B[0m py_func: Callable, qmodule: ModelStateContainer\n\u001B[1;32m 150\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m QuantumFunctionDeclaration:\n\u001B[1;32m 151\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m QuantumFunctionDeclaration(\n\u001B[1;32m 152\u001B[0m name\u001B[38;5;241m=\u001B[39munmangle_keyword(py_func\u001B[38;5;241m.\u001B[39m\u001B[38;5;18m__name__\u001B[39m),\n\u001B[0;32m--> 153\u001B[0m positional_arg_declarations\u001B[38;5;241m=\u001B[39m\u001B[43m_extract_positional_args\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 154\u001B[0m \u001B[43m \u001B[49m\u001B[43mpy_func\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[38;5;18;43m__annotations__\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mqmodule\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mqmodule\u001B[49m\n\u001B[1;32m 155\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m,\n\u001B[1;32m 156\u001B[0m )\n", - "File \u001B[0;32m~/.pyenv/versions/3.9.7/lib/python3.9/site-packages/classiq/qmod/declaration_inferrer.py:139\u001B[0m, in \u001B[0;36m_extract_positional_args\u001B[0;34m(args, qmodule)\u001B[0m\n\u001B[1;32m 132\u001B[0m result\u001B[38;5;241m.\u001B[39mappend(\n\u001B[1;32m 133\u001B[0m ClassicalParameterDeclaration(\n\u001B[1;32m 134\u001B[0m name\u001B[38;5;241m=\u001B[39mname,\n\u001B[1;32m 135\u001B[0m classical_type\u001B[38;5;241m=\u001B[39mpython_type_to_qmod(py_type, qmodule\u001B[38;5;241m=\u001B[39mqmodule),\n\u001B[1;32m 136\u001B[0m )\n\u001B[1;32m 137\u001B[0m )\n\u001B[1;32m 138\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m QVar\u001B[38;5;241m.\u001B[39mfrom_type_hint(py_type) \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m--> 139\u001B[0m result\u001B[38;5;241m.\u001B[39mappend(\u001B[43m_extract_port_decl\u001B[49m\u001B[43m(\u001B[49m\u001B[43mname\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mpy_type\u001B[49m\u001B[43m)\u001B[49m)\n\u001B[1;32m 140\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 141\u001B[0m \u001B[38;5;28;01massert\u001B[39;00m (get_origin(py_type) \u001B[38;5;129;01mor\u001B[39;00m py_type) \u001B[38;5;129;01mis\u001B[39;00m QCallable \u001B[38;5;129;01mor\u001B[39;00m (\n\u001B[1;32m 142\u001B[0m get_origin(py_type) \u001B[38;5;129;01mor\u001B[39;00m py_type\n\u001B[1;32m 143\u001B[0m ) \u001B[38;5;129;01mis\u001B[39;00m QCallableList\n", - "File \u001B[0;32m~/.pyenv/versions/3.9.7/lib/python3.9/site-packages/classiq/qmod/declaration_inferrer.py:99\u001B[0m, in \u001B[0;36m_extract_port_decl\u001B[0;34m(name, py_type)\u001B[0m\n\u001B[1;32m 94\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(py_type, _AnnotatedAlias):\n\u001B[1;32m 95\u001B[0m py_type \u001B[38;5;241m=\u001B[39m py_type\u001B[38;5;241m.\u001B[39m__args__[\u001B[38;5;241m0\u001B[39m]\n\u001B[1;32m 96\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m PortDeclaration(\n\u001B[1;32m 97\u001B[0m name\u001B[38;5;241m=\u001B[39mname,\n\u001B[1;32m 98\u001B[0m direction\u001B[38;5;241m=\u001B[39mdirection,\n\u001B[0;32m---> 99\u001B[0m quantum_type\u001B[38;5;241m=\u001B[39m\u001B[43mqtype\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mto_qmod_quantum_type\u001B[49m\u001B[43m(\u001B[49m\u001B[43mpy_type\u001B[49m\u001B[43m)\u001B[49m,\n\u001B[1;32m 100\u001B[0m )\n", - "File \u001B[0;32m~/.pyenv/versions/3.9.7/lib/python3.9/site-packages/classiq/qmod/qmod_variable.py:256\u001B[0m, in \u001B[0;36mQNum.to_qmod_quantum_type\u001B[0;34m(cls, type_hint)\u001B[0m\n\u001B[1;32m 254\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m.\u001B[39mQMOD_TYPE()\n\u001B[1;32m 255\u001B[0m type_args \u001B[38;5;241m=\u001B[39m type_args[\u001B[38;5;241m0\u001B[39m]\n\u001B[0;32m--> 256\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28;43mlen\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mtype_args\u001B[49m\u001B[43m)\u001B[49m \u001B[38;5;241m!=\u001B[39m \u001B[38;5;241m3\u001B[39m:\n\u001B[1;32m 257\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m ClassiqValueError(\n\u001B[1;32m 258\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mQNum receives three type arguments: QNum[size: int | CInt, \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 259\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mis_signed: bool | CBool, fraction_digits: int | CInt]\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m 260\u001B[0m )\n\u001B[1;32m 261\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mcls\u001B[39m\u001B[38;5;241m.\u001B[39mQMOD_TYPE(\n\u001B[1;32m 262\u001B[0m size\u001B[38;5;241m=\u001B[39mExpression(expr\u001B[38;5;241m=\u001B[39mget_type_hint_expr(type_args[\u001B[38;5;241m0\u001B[39m])),\n\u001B[1;32m 263\u001B[0m is_signed\u001B[38;5;241m=\u001B[39mExpression(expr\u001B[38;5;241m=\u001B[39mget_type_hint_expr(type_args[\u001B[38;5;241m1\u001B[39m])),\n\u001B[1;32m 264\u001B[0m fraction_digits\u001B[38;5;241m=\u001B[39mExpression(expr\u001B[38;5;241m=\u001B[39mget_type_hint_expr(type_args[\u001B[38;5;241m2\u001B[39m])),\n\u001B[1;32m 265\u001B[0m )\n", - "\u001B[0;31mTypeError\u001B[0m: object of type 'int' has no len()" - ] - } - ], - "source": [ - "\n", - "from classiq import *\n", - "\n", - "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", - " CX(qba[qba.len - 1], msb)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", - " allocate(5, res)\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " label = QArray(\"label\")\n", - " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n", - "\n", - "# No idea why I'm receiving the error" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T21:13:18.785358Z", - "start_time": "2024-05-26T21:13:15.434650Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/021c1f73-e815-447b-b9c5-106cd4460e23?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": { - "ExecuteTime": { - "end_time": "2024-05-26T21:24:07.288911Z", - "start_time": "2024-05-26T21:24:03.287314Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/5413423e-d9c7-44d4-9896-e5f01b2054e2?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: QArray[QBit]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - " \n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) \n", - "\n", - " bind([lsb, msb], res)\n", - " \n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n" - ] - }, - { - "cell_type": "code", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/a9b38449-c2b7-4781-8cd7-a463c5dd929c?version=0.41.2\n" - ] - } - ], - "source": [ - "from classiq import *\n", - "from classiq.qmod.symbolic import sqrt\n", - "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", - "@qfunc\n", - "def pre_prepared_state(q: Output[QArray[QBit]]) -> None:\n", - " prepare_state(\n", - " [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8 - sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1/8\n", - " ],\n", - " 0.0,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]):\n", - " pre_prepared_state(res)\n", - " \n", - " \n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)\n" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-05-26T22:03:42.729351Z", - "start_time": "2024-05-26T22:03:38.467856Z" - } - }, - "execution_count": 54 - }, - { - "cell_type": "code", - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-05-26T22:09:58.027692Z", - "start_time": "2024-05-26T22:09:58.020707Z" - } - }, - "execution_count": 58 - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Submissions/HW2/index.md b/community/QClass_2024/Submissions/HW2/index.md index f93767e0..ed49372d 100644 --- a/community/QClass_2024/Submissions/HW2/index.md +++ b/community/QClass_2024/Submissions/HW2/index.md @@ -1,7 +1,9 @@ # Submitting HW2 ## Submission: Rules & Instructions + To keep track of submissions, we kindly ask you to: + 1. Complete `HW2_QClass2024.ipynb`. 2. Rename the files to include your full name, for example: `Nadav_Ben-Ami_HW2_QClass2024.ipynb`. 3. Navigate to your local clone of the `classiq-library`. @@ -14,7 +16,7 @@ To keep track of submissions, we kindly ask you to: **Please ensure you follow these steps carefully to properly submit your assignment!** ## Support + If you need help or have questions, feel free to reach out in our Slack channel! ## Enjoy your learning journey at QClass 2024! - diff --git a/community/QClass_2024/Submissions/HW3/Amon_Koike_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Amon_Koike_HW3_VQE.ipynb index eda8e0b6..b106ce1a 100644 --- a/community/QClass_2024/Submissions/HW3/Amon_Koike_HW3_VQE.ipynb +++ b/community/QClass_2024/Submissions/HW3/Amon_Koike_HW3_VQE.ipynb @@ -76,15 +76,20 @@ "outputs": [], "source": [ "from typing import List\n", + "\n", "from classiq import *\n", "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [\n", - " PauliTerm([Pauli.I, Pauli.I],-1.0523),\n", - " PauliTerm([Pauli.I, Pauli.Z],0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.I],-0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.Z],-0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X],0.1809)\n", - "])" + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [\n", + " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", + " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", + " PauliTerm([Pauli.X, Pauli.X], 0.1809),\n", + " ],\n", + ")" ] }, { @@ -102,22 +107,20 @@ } ], "source": [ - "\n", - "\n", "@qfunc\n", "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", " allocate(2, q)\n", " U(angles[0], angles[1], angles[2], 0, q[0])\n", " U(angles[0], angles[1], angles[2], 0, q[1])\n", - " \n", - " \n", + "\n", + "\n", "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", " HAMILTONIAN,\n", " False,\n", " [],\n", - " optimizer=Optimizer.COBYLA, # Constrained Optimization by Linear Approximation\n", + " optimizer=Optimizer.COBYLA, # Constrained Optimization by Linear Approximation\n", " max_iteration=1000,\n", " tolerance=0.001,\n", " step_size=0,\n", @@ -126,6 +129,7 @@ " )\n", " save({\"result\": res})\n", "\n", + "\n", "qmod = create_model(main, classical_execution_function=cmain)\n", "qprog = synthesize(qmod)\n", "show(qprog)" @@ -211,16 +215,17 @@ ], "source": [ "from typing import List\n", + "\n", "from classiq import *\n", "\n", + "\n", "@qfunc\n", "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", " allocate(2, q)\n", " U(angles[0], angles[1], angles[2], 0, q[0]) # Apply U gate to the first qubit\n", " U(angles[0], angles[1], angles[2], 0, q[1]) # Apply U gate to the second qubit\n", - " #Entangling after the two U gates \n", - " CX(q[0], q[1]) # Apply CNOT gate to create entanglement \n", - "\n", + " # Entangling after the two U gates\n", + " CX(q[0], q[1]) # Apply CNOT gate to create entanglement\n", "\n", "\n", "@cfunc\n", @@ -229,7 +234,7 @@ " HAMILTONIAN,\n", " False,\n", " [],\n", - " optimizer=Optimizer.COBYLA, # Constrained Optimization by Linear Approximation\n", + " optimizer=Optimizer.COBYLA, # Constrained Optimization by Linear Approximation\n", " max_iteration=1000,\n", " tolerance=0.001,\n", " step_size=0,\n", @@ -238,6 +243,7 @@ " )\n", " save({\"result\": res})\n", "\n", + "\n", "qmod = create_model(main, classical_execution_function=cmain)\n", "qprog = synthesize(qmod)\n", "show(qprog)" diff --git a/community/QClass_2024/Submissions/HW3/Aniekan_Afangideh_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Aniekan_Afangideh_HW3_VQE.ipynb deleted file mode 100644 index 3d44e2b7..00000000 --- a/community/QClass_2024/Submissions/HW3/Aniekan_Afangideh_HW3_VQE.ipynb +++ /dev/null @@ -1,317 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], \n", - " [\n", - " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X], 0.1809),]) #TODO: Complete Hamiltonian" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/cdeb3942-86af-4118-9adc-42ca3414dc37?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0]) \n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - " #U(angles[0], angles[1], angles[2], 0, q[2])\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod =create_model (main, classical_execution_function=cmain)#TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.063741015625\n", - "Optimal parameters: {'angles_0': 2.7905108249302994, 'angles_1': 1.628892707107819, 'angles_2': -0.35058382992185155}\n", - "Eigenstate: {'00': (0.02209708691207961+0j), '10': (0.17258376589355096+0j), '01': (0.1711632992203644+0j), '11': (0.9697575405739313+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\ No\n", - "Does it similar to the `total energy` we calculated in class? Different too." - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/3f71fe36-ce7b-409f-be1b-cfaeabb43b47?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0]) \n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - " CX(q[0],q[1])\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model (main, classical_execution_function=cmain)#TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value#TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.8483884765625\n", - "Optimal parameters: {'angles_0': -2.9967764181949375, 'angles_1': 5.573021041013109, 'angles_2': -3.0558759903455814}\n", - "Eigenstate: {'11': (0.05846339666834283+0j), '10': (0.05412658773652741+0j), '01': (0.9968211192335363+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\ Yes, they are close\n", - "Does it similar to the `total energy` we calculated in class? \\ No, not at all\n", - "What can we learn about the provided from this result Hamiltonian? It would seem that the local simulators do not operate the VQE as effectively as the Classiq simulator engine or the in-built methods" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e885dda4-55d2-4489-ba32-dcc52eff6402", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Submissions/HW3/Christopher_vanBommel_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Christopher_vanBommel_HW3_VQE.ipynb deleted file mode 100644 index 0de75524..00000000 --- a/community/QClass_2024/Submissions/HW3/Christopher_vanBommel_HW3_VQE.ipynb +++ /dev/null @@ -1,332 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [\n", - " PauliTerm([Pauli.I, Pauli.I], -1.0523), \n", - " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X], 0.1809)\n", - "]) #TODO: Complete Hamiltonian" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/fcced4ef-95d5-43c9-b6c2-b5d02a9d8469?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.05943232421875\n", - "Optimal parameters: {'angles_0': 3.514522776666379, 'angles_1': 8.328553557070341, 'angles_2': 3.3726503432589316}\n", - "Eigenstate: {'01': (0.1875+0j), '00': (0.04419417382415922+0j), '10': (0.17399263633843817+0j), '11': (0.9657210712726527+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class?" - ] - }, - { - "cell_type": "markdown", - "id": "3005f05e", - "metadata": {}, - "source": [ - "The result is not similar to the optimal energy we calculated in class.\n", - "The result is somewhat similar to the total energy we calculated in class." - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/7d518ebf-6bb0-42a9-804f-416ca8b610a7?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - " CX(q[0], q[1])\n", - "\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": { - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.8381455078125\n", - "Optimal parameters: {'angles_0': 3.061526068748429, 'angles_1': 4.3511081831333325, 'angles_2': -0.5730647670171045}\n", - "Eigenstate: {'10': (0.02209708691207961+0j), '11': (0.03125+0j), '01': (0.9992673097074676+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" - ] - }, - { - "cell_type": "markdown", - "id": "1b983b46", - "metadata": {}, - "source": [ - "The result is similar to the optimal energy we calculated in class.\n", - "It is not related to the total energy we calculated in class.\n", - "The result suggests the Hamiltonian is a good representation of the hydrogen molecule." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Submissions/HW3/Christos_Koromilas_HW3_QClass2024.ipynb b/community/QClass_2024/Submissions/HW3/Christos_Koromilas_HW3_QClass2024.ipynb deleted file mode 100644 index db72314e..00000000 --- a/community/QClass_2024/Submissions/HW3/Christos_Koromilas_HW3_QClass2024.ipynb +++ /dev/null @@ -1 +0,0 @@ -{"cells":[{"cell_type":"markdown","id":"fc72d98f-8993-4bd4-a545-23d122f3df71","metadata":{"id":"fc72d98f-8993-4bd4-a545-23d122f3df71"},"source":["# H₂ Molecule Homework Assignment\n","### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n","\n","- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n","- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian."]},{"cell_type":"markdown","id":"56eda6d8-76c4-4862-b914-0c4598d67274","metadata":{"id":"56eda6d8-76c4-4862-b914-0c4598d67274"},"source":["## Submission\n","- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n","- Use the Typeform link provided in the submission folder to confirm your submission.\n","\n","## Additional Resources\n","- [Classiq Documentation](https://docs.classiq.io/latest/)\n","- The notebook from live session #3\n","\n","## Important Dates\n","- **Assignment Release:** 22.5.2024\n","- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n","\n","---\n","\n","Happy coding and good luck!"]},{"cell_type":"markdown","id":"d41e969d-f6a7-4ff7-9660-19ce6c97ba6b","metadata":{"id":"d41e969d-f6a7-4ff7-9660-19ce6c97ba6b"},"source":["### Part 1"]},{"cell_type":"markdown","id":"f710d6f4-d40b-42d5-b524-c6acb8059fe2","metadata":{"id":"f710d6f4-d40b-42d5-b524-c6acb8059fe2"},"source":["Given the following Hamiltonian:"]},{"cell_type":"markdown","id":"6ba8a6f1-3259-4492-a1ca-3abde7530cd4","metadata":{"id":"6ba8a6f1-3259-4492-a1ca-3abde7530cd4"},"source":["$$\n","\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n","$$"]},{"cell_type":"markdown","id":"736d275c-9a5a-4c08-b891-3078430dc6c1","metadata":{"id":"736d275c-9a5a-4c08-b891-3078430dc6c1"},"source":["Complete the following code"]},{"cell_type":"code","source":["# !pip install -U -q classiq\n","import classiq\n","classiq.authenticate()\n","from classiq import *"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"4Fnc5WqGypxB","executionInfo":{"status":"ok","timestamp":1717329207855,"user_tz":-120,"elapsed":91946,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"aa98eadb-631f-4ad6-b8b2-8aee5d0edb9c"},"id":"4Fnc5WqGypxB","execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m398.1/398.1 kB\u001b[0m \u001b[31m2.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m48.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m72.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m8.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m75.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m4.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m93.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m72.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m9.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n","torch 2.3.0+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-nccl-cu12==2.20.5; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n","torch 2.3.0+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n","\u001b[0mYour user code: GZHQ-NPBB\n","If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=GZHQ-NPBB\n"]}]},{"cell_type":"code","execution_count":5,"id":"19266c11-6acc-4edb-910f-2d0dfe80a6c8","metadata":{"id":"19266c11-6acc-4edb-910f-2d0dfe80a6c8","executionInfo":{"status":"ok","timestamp":1717329272619,"user_tz":-120,"elapsed":3,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}}},"outputs":[],"source":["from typing import List\n","HAMILTONIAN = QConstant(\"HAMILTONIAN\",\n"," List[PauliTerm],\n"," [\n"," PauliTerm([Pauli.I, Pauli.I], -1.0523),\n"," PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n"," PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n"," PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n"," PauliTerm([Pauli.X, Pauli.X], 0.1809),\n"," ])"]},{"cell_type":"code","execution_count":6,"id":"0bb68899-2076-45c0-8868-131f38aa3b78","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"0bb68899-2076-45c0-8868-131f38aa3b78","executionInfo":{"status":"ok","timestamp":1717329277215,"user_tz":-120,"elapsed":2498,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"ad0c9969-6048-43e6-b2e6-78489e9c9597"},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/1ff23650-9aac-412f-94ec-c9dfdbaa7a6e?version=0.41.2\n"]}],"source":["@qfunc\n","def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n"," allocate(2, q)\n"," U(angles[0], angles[1], angles[2], 0, q[0])\n"," U(angles[0], angles[1], angles[2], 0, q[1])\n","\n","\n","\n","@cfunc\n","def cmain() -> None:\n"," res = vqe(\n"," HAMILTONIAN,\n"," False,\n"," [],\n"," optimizer=Optimizer.COBYLA,\n"," max_iteration=1000,\n"," tolerance=0.001,\n"," step_size=0,\n"," skip_compute_variance=False,\n"," alpha_cvar=1.0,\n"," )\n"," save({\"result\": res})\n","\n","qmod = create_model(main, classical_execution_function=cmain)\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"code","execution_count":7,"id":"0563c1a8-7aec-4da9-9105-6b16c5c24382","metadata":{"id":"0563c1a8-7aec-4da9-9105-6b16c5c24382","executionInfo":{"status":"ok","timestamp":1717329283986,"user_tz":-120,"elapsed":2574,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}}},"outputs":[],"source":["execution = execute(qprog)\n","res = execution.result()\n","# execution.open_in_ide()\n","vqe_result = res[0].value"]},{"cell_type":"code","execution_count":8,"id":"de17cfc0-8e64-4493-b4c2-4a97fc9797a0","metadata":{"scrolled":true,"colab":{"base_uri":"https://localhost:8080/"},"id":"de17cfc0-8e64-4493-b4c2-4a97fc9797a0","executionInfo":{"status":"ok","timestamp":1717329286246,"user_tz":-120,"elapsed":202,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"28870970-3f8e-4ff0-d94d-64d6cd306987"},"outputs":[{"output_type":"stream","name":"stdout","text":["Optimal energy: -1.0768361328125\n","Optimal parameters: {'angles_0': 1.9429837733198028, 'angles_1': 4.856944464295574, 'angles_2': 4.0415675677515015}\n","Eigenstate: {'01': (0.45821494683172437+0j), '00': (0.3262595784034547+0j), '10': (0.46770717334674267+0j), '11': (0.6817945071647321+0j)}\n"]}],"source":["print(f\"Optimal energy: {vqe_result.energy}\")\n","print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n","print(f\"Eigenstate: {vqe_result.eigenstate}\")"]},{"cell_type":"markdown","id":"5df11dfc-3e3a-4191-bd47-d522ca3dcbfa","metadata":{"id":"5df11dfc-3e3a-4191-bd47-d522ca3dcbfa"},"source":["Does it similar to the `optimal energy` we calculated in class? NO \\\n","Does it similar to the `total energy` we calculated in class?"]},{"cell_type":"markdown","id":"4f0e0bea-b12f-43ad-94e8-100fedf2b57f","metadata":{"id":"4f0e0bea-b12f-43ad-94e8-100fedf2b57f"},"source":["### Part 2"]},{"cell_type":"markdown","id":"66882248-de08-4a6e-b33c-647f015f7d79","metadata":{"id":"66882248-de08-4a6e-b33c-647f015f7d79"},"source":["**Now, we want to have a more interesting ansatz in our `main`.** \n","Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n","Which gate should you use?"]},{"cell_type":"code","execution_count":9,"id":"bb39be9e-4994-44e5-84d8-c99bc8b77145","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"bb39be9e-4994-44e5-84d8-c99bc8b77145","executionInfo":{"status":"ok","timestamp":1717329417332,"user_tz":-120,"elapsed":2484,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"b79d41d2-b8d7-4076-ec09-c56972612395"},"outputs":[{"output_type":"stream","name":"stdout","text":["Opening: https://platform.classiq.io/circuit/d08ae872-3de0-40d6-a66e-db1fcc1a096a?version=0.41.2\n"]}],"source":["@qfunc\n","def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n"," allocate(2, q)\n"," U(angles[0], angles[1], angles[2], 0, q[0])\n"," CX(q[0], q[1])\n"," U(angles[0], angles[1], angles[2], 0, q[1])\n","\n","\n","\n","@cfunc\n","def cmain() -> None:\n"," res = vqe(\n"," HAMILTONIAN,\n"," False,\n"," [],\n"," optimizer=Optimizer.COBYLA,\n"," max_iteration=1000,\n"," tolerance=0.001,\n"," step_size=0,\n"," skip_compute_variance=False,\n"," alpha_cvar=1.0,\n"," )\n"," save({\"result\": res})\n","\n","qmod = create_model(main, classical_execution_function=cmain)\n","qprog = synthesize(qmod)\n","show(qprog)"]},{"cell_type":"code","execution_count":10,"id":"112a1590-283c-4f79-8035-72936561102d","metadata":{"id":"112a1590-283c-4f79-8035-72936561102d","executionInfo":{"status":"ok","timestamp":1717329433362,"user_tz":-120,"elapsed":3487,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}}},"outputs":[],"source":["execution = execute(qprog)\n","res = execution.result()\n","# execution.open_in_ide()\n","vqe_result = res[0].value"]},{"cell_type":"code","execution_count":11,"id":"06500e4c-a04b-4cfa-a84d-41f96a0c68eb","metadata":{"collapsed":true,"jupyter":{"outputs_hidden":true},"colab":{"base_uri":"https://localhost:8080/"},"id":"06500e4c-a04b-4cfa-a84d-41f96a0c68eb","executionInfo":{"status":"ok","timestamp":1717329433363,"user_tz":-120,"elapsed":3,"user":{"displayName":"Christos Koromilas","userId":"17599903479737751299"}},"outputId":"11e4d470-38be-4918-e309-90209c8679b8"},"outputs":[{"output_type":"stream","name":"stdout","text":["Optimal energy: -1.84172490234375\n","Optimal parameters: {'angles_0': -3.2337677964973515, 'angles_1': 5.719762730583857, 'angles_2': 0.8847642868459891}\n","Eigenstate: {'11': (0.04419417382415922+0j), '10': (0.05846339666834283+0j), '01': (0.9973108373270593+0j)}\n"]}],"source":["print(f\"Optimal energy: {vqe_result.energy}\")\n","print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n","print(f\"Eigenstate: {vqe_result.eigenstate}\")"]},{"cell_type":"markdown","id":"30a635d7-2f15-4c94-a94b-f4270f17aed8","metadata":{"id":"30a635d7-2f15-4c94-a94b-f4270f17aed8"},"source":["Does it similar to the `optimal energy` we calculated in class? YES \\\n","Does it similar to the `total energy` we calculated in class? \\\n","What can we learn about the provided form this result Hamiltonian? The hamiltonian is the right hamiltonian to use!"]},{"cell_type":"code","source":["res[2]"],"metadata":{"id":"_PmeBI7Z0BUH"},"id":"_PmeBI7Z0BUH","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3 (ipykernel)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.9.16"},"colab":{"provenance":[]}},"nbformat":4,"nbformat_minor":5} \ No newline at end of file diff --git a/community/QClass_2024/Submissions/HW3/Claudia_Zendejas-Morales_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Claudia_Zendejas-Morales_HW3_VQE.ipynb index 4c7136f0..ba224d90 100644 --- a/community/QClass_2024/Submissions/HW3/Claudia_Zendejas-Morales_HW3_VQE.ipynb +++ b/community/QClass_2024/Submissions/HW3/Claudia_Zendejas-Morales_HW3_VQE.ipynb @@ -76,14 +76,21 @@ "outputs": [], "source": [ "from typing import List\n", + "\n", "from classiq import *\n", "\n", "# Define Hamiltonian\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [PauliTerm(pauli=[Pauli.I, Pauli.I], coefficient=-1.0523),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z], coefficient=0.3979),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I], coefficient=-0.3979),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.Z], coefficient=-0.0112),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.X], coefficient=0.1809)])" + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [\n", + " PauliTerm(pauli=[Pauli.I, Pauli.I], coefficient=-1.0523),\n", + " PauliTerm(pauli=[Pauli.I, Pauli.Z], coefficient=0.3979),\n", + " PauliTerm(pauli=[Pauli.Z, Pauli.I], coefficient=-0.3979),\n", + " PauliTerm(pauli=[Pauli.Z, Pauli.Z], coefficient=-0.0112),\n", + " PauliTerm(pauli=[Pauli.X, Pauli.X], coefficient=0.1809),\n", + " ],\n", + ")" ] }, { @@ -96,7 +103,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/67cce443-862c-4003-a483-92d42441cfad?version=0.42.0\n" + "Opening: https://platform.classiq.io/circuit/5897752d-7912-4b31-bca8-98d6869c39de?version=0.42.1\n" ] } ], @@ -124,7 +131,10 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod = create_model(main, classical_execution_function=cmain) # complete the line, use classical_execution_function\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # complete the line, use classical_execution_function\n", "qprog = synthesize(qmod)\n", "show(qprog)" ] @@ -152,9 +162,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Optimal energy: -1.0604361328125\n", - "Optimal parameters: {'angles_0': -0.1958825785281677, 'angles_1': -1.8571141405907794, 'angles_2': 2.9043437874754607}\n", - "Eigenstate: {'01': (0.09631896879639025+0j), '10': (0.09375+0j), '00': (0.9909256247317454+0j)}\n" + "Optimal energy: -1.063205078125\n", + "Optimal parameters: {'angles_0': 6.181820728010731, 'angles_1': 4.1946685536401125, 'angles_2': 1.5078000440044168}\n", + "Eigenstate: {'01': (0.05412658773652741+0j), '10': (0.05412658773652741+0j), '00': (0.9970660083464885+0j)}\n" ] } ], @@ -227,8 +237,8 @@ "outputs": [ { "data": { - "image/jpeg": "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", - "image/png": "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", + "image/jpeg": "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", + "image/png": "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", "text/plain": [ "" ] @@ -238,9 +248,10 @@ } ], "source": [ - "from PIL import Image\n", - "import io\n", "import base64\n", + "import io\n", + "\n", + "from PIL import Image\n", "\n", "image_bytes = base64.b64decode(vqe_result.convergence_graph_str)\n", "\n", @@ -251,7 +262,7 @@ "image = Image.open(image_file)\n", "\n", "# Muestra la imagen en el notebook\n", - "display(image)" + "# display(image) # uncomment to display" ] }, { @@ -282,7 +293,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/e57a3c95-4185-4ac7-8eda-0b41e8de8779?version=0.42.0\n" + "Opening: https://platform.classiq.io/circuit/4e6ec74f-825e-4588-b50e-546b95d1b2f9?version=0.42.1\n" ] } ], @@ -311,14 +322,17 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod = create_model(main, classical_execution_function=cmain) # complete the line, use classical_execution_function\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # complete the line, use classical_execution_function\n", "qprog = synthesize(qmod)\n", - "show(qprog)" + "# show(qprog)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "112a1590-283c-4f79-8035-72936561102d", "metadata": {}, "outputs": [], @@ -331,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", "metadata": {}, "outputs": [ @@ -339,9 +353,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Optimal energy: -1.8541486328124999\n", - "Optimal parameters: {'angles_0': 3.2528566097261744, 'angles_1': 6.931253517134524, 'angles_2': -3.1732937057222257}\n", - "Eigenstate: {'10': (0.07328774624724109+0j), '11': (0.0625+0j), '01': (0.9953505192895616+0j)}\n" + "Optimal energy: -1.85614296875\n", + "Optimal parameters: {'angles_0': -3.056840799296021, 'angles_1': -0.7504225570620288, 'angles_2': 1.9166459061480523}\n", + "Eigenstate: {'10': (0.03125+0j), '11': (0.04419417382415922+0j), '01': (0.9985340817919036+0j)}\n" ] } ], @@ -457,14 +471,14 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 16, "id": "bc2604de-0dc3-4615-863c-1aafbda475bf", "metadata": {}, "outputs": [ { "data": { - "image/jpeg": "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", - "image/png": "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", + "image/jpeg": "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", + "image/png": "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", "text/plain": [ "" ] @@ -474,9 +488,10 @@ } ], "source": [ - "from PIL import Image\n", - "import io\n", "import base64\n", + "import io\n", + "\n", + "from PIL import Image\n", "\n", "image_bytes = base64.b64decode(vqe_result.convergence_graph_str)\n", "\n", @@ -487,16 +502,8 @@ "image = Image.open(image_file)\n", "\n", "# Muestra la imagen en el notebook\n", - "display(image)" + "# display(image) # uncomment to display" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9423b5a6-1b73-4979-a6d5-838af4e8f979", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/community/QClass_2024/Submissions/HW3/Csaba_Szilard_Racz-HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Csaba_Szilard_Racz-HW3_VQE.ipynb deleted file mode 100644 index 285ec6b5..00000000 --- a/community/QClass_2024/Submissions/HW3/Csaba_Szilard_Racz-HW3_VQE.ipynb +++ /dev/null @@ -1,389 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to define and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm],\n", - " [PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X], 0.1809)]\n", - " ) #TODO: Complete Hamiltonian" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/490774a2-4a81-468f-b28c-680cd171ca48?version=0.42.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " # TODO: complete the missing argument\n", - " HAMILTONIAN,\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "#TODO: complete the line, use classical_execution_function\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.07021669921875\n", - "Optimal parameters: {'angles_0': -2.7719312634977746, 'angles_1': 4.446680549285845, 'angles_2': 3.477513433640137}\n", - "Eigenstate: {'00': (0.05412658773652741+0j), '10': (0.18221724671391565+0j), '01': (0.19008632907181935+0j), '11': (0.9631896879639026+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class?" - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/bc8784d2-6c13-4f36-840e-ca36485adca6?version=0.42.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - " \n", - " # create entanglement between the two qubits\n", - " CX(q[0], q[1])\n", - "\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " # TODO: complete the missing argument\n", - " HAMILTONIAN,\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "#TODO: complete the line, use classical_execution_function\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.84520302734375\n", - "Optimal parameters: {'angles_0': 3.2017515243271615, 'angles_1': -5.448452277177368, 'angles_2': -3.027587294714585}\n", - "Eigenstate: {'11': (0.03125+0j), '10': (0.03125+0j), '01': (0.9990229601966113+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "a7824e45", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "energy=-1.84520302734375 time=0.4464535713195801 solution=None eigenstate={'11': (0.03125+0j), '10': (0.03125+0j), '01': (0.9990229601966113+0j)} reduced_probabilities={'11': 0.0009765625, '10': 0.0009765625, '01': 0.998046875} optimized_circuit_sample_results=ExecutionDetails(vendor_format_result={}, counts={'11': 2, '10': 2, '01': 2044}, counts_lsb_right=True, parsed_states={'11': {'q': 3.0}, '10': {'q': 2.0}, '01': {'q': 1.0}}, histogram=None, output_qubits_map={'q': (0, 1)}, state_vector=None, parsed_state_vector_states=None, physical_qubits_map={'q': (0, 1)}, num_shots=2048) intermediate_results=[VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 758414, tzinfo=datetime.timezone.utc), iteration_number=1, parameters=[2.591176246955154, -5.62624493452543, -3.026748767095255], mean_all_solutions=-1.6016041015625, solutions=[], standard_deviation=0.378010120085899), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 773212, tzinfo=datetime.timezone.utc), iteration_number=2, parameters=[3.591176246955154, -5.62624493452543, -3.026748767095255], mean_all_solutions=-1.7835126953124998, solutions=[], standard_deviation=0.3353871483673314), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 792071, tzinfo=datetime.timezone.utc), iteration_number=3, parameters=[3.591176246955154, -4.62624493452543, -3.026748767095255], mean_all_solutions=-1.7193850585937498, solutions=[], standard_deviation=0.34049937265490965), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 805220, tzinfo=datetime.timezone.utc), iteration_number=4, parameters=[3.591176246955154, -5.62624493452543, -2.026748767095255], mean_all_solutions=-1.7835126953124998, solutions=[], standard_deviation=0.3353871483673314), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 818623, tzinfo=datetime.timezone.utc), iteration_number=5, parameters=[4.534289197595433, -5.958717433139357, -3.026748767095255], mean_all_solutions=-1.3073765625, solutions=[], standard_deviation=0.5615424423558852), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 832066, tzinfo=datetime.timezone.utc), iteration_number=6, parameters=[4.062732722275293, -5.792481183832393, -3.026748767095255], mean_all_solutions=-1.55428916015625, solutions=[], standard_deviation=0.5056342397245829), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 844981, tzinfo=datetime.timezone.utc), iteration_number=7, parameters=[3.3431392774380595, -5.6575125176232, -3.026748767095255], mean_all_solutions=-1.83837626953125, solutions=[], standard_deviation=0.22633583253549727), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 857573, tzinfo=datetime.timezone.utc), iteration_number=8, parameters=[3.2268152262568046, -5.436223758042464, -3.026748767095255], mean_all_solutions=-1.8445676757812501, solutions=[], standard_deviation=0.18729033409038648), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 875596, tzinfo=datetime.timezone.utc), iteration_number=9, parameters=[3.2268152262568046, -5.436223758042464, -2.901748767095255], mean_all_solutions=-1.8445676757812501, solutions=[], standard_deviation=0.18729033409038648), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 891550, tzinfo=datetime.timezone.utc), iteration_number=10, parameters=[2.9941314913478547, -5.527647384686902, -3.026748767095255], mean_all_solutions=-1.8108190429687498, solutions=[], standard_deviation=0.1971209656563929), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 904967, tzinfo=datetime.timezone.utc), iteration_number=11, parameters=[3.325497578895095, -5.359498317165451, -3.026748767095255], mean_all_solutions=-1.8361275390624998, solutions=[], standard_deviation=0.21893409874005848), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 918301, tzinfo=datetime.timezone.utc), iteration_number=12, parameters=[3.2603126158808133, -5.488989039131239, -3.026748767095255], mean_all_solutions=-1.84418837890625, solutions=[], standard_deviation=0.19660479594710784), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 938686, tzinfo=datetime.timezone.utc), iteration_number=13, parameters=[3.171296302671158, -5.464927401084613, -3.026748767095255], mean_all_solutions=-1.84237646484375, solutions=[], standard_deviation=0.18081708529012178), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 955445, tzinfo=datetime.timezone.utc), iteration_number=14, parameters=[3.2500212740031085, -5.415294308742584, -3.026748767095255], mean_all_solutions=-1.8430465820312498, solutions=[], standard_deviation=0.19441739923500487), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 968573, tzinfo=datetime.timezone.utc), iteration_number=15, parameters=[3.2268152262568046, -5.436223758042464, -3.011123767095255], mean_all_solutions=-1.8445676757812501, solutions=[], standard_deviation=0.18729033409038648), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 984559, tzinfo=datetime.timezone.utc), iteration_number=16, parameters=[3.1986195961055737, -5.449698510002148, -3.026748767095255], mean_all_solutions=-1.84484970703125, solutions=[], standard_deviation=0.18072523940533955), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 22, 997082, tzinfo=datetime.timezone.utc), iteration_number=17, parameters=[3.2102642410300346, -5.478697902143764, -3.026748767095255], mean_all_solutions=-1.84435537109375, solutions=[], standard_deviation=0.18406340596878584), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 12864, tzinfo=datetime.timezone.utc), iteration_number=18, parameters=[3.1732342784852783, -5.4314735779222545, -3.026748767095255], mean_all_solutions=-1.84237646484375, solutions=[], standard_deviation=0.18081708529012178), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 25677, tzinfo=datetime.timezone.utc), iteration_number=19, parameters=[3.185926937295426, -5.440586043962201, -3.026748767095255], mean_all_solutions=-1.843259765625, solutions=[], standard_deviation=0.18078817268061279), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 38419, tzinfo=datetime.timezone.utc), iteration_number=20, parameters=[3.1986195961055737, -5.449698510002148, -3.018936267095255], mean_all_solutions=-1.84484970703125, solutions=[], standard_deviation=0.18072523940533955), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 54146, tzinfo=datetime.timezone.utc), iteration_number=21, parameters=[3.2042902102445594, -5.4642582064374015, -3.026748767095255], mean_all_solutions=-1.8441787109375, solutions=[], standard_deviation=0.18407196828067413), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 66667, tzinfo=datetime.timezone.utc), iteration_number=22, parameters=[3.2053213272750813, -5.445683294493405, -3.026748767095255], mean_all_solutions=-1.8441787109375, solutions=[], standard_deviation=0.18407196828067413), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 82224, tzinfo=datetime.timezone.utc), iteration_number=23, parameters=[3.194719350789295, -5.449482002414873, -3.026748767095255], mean_all_solutions=-1.84414306640625, solutions=[], standard_deviation=0.18075493904464865), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 95474, tzinfo=datetime.timezone.utc), iteration_number=24, parameters=[3.199962592591955, -5.453366636158657, -3.026748767095255], mean_all_solutions=-1.84484970703125, solutions=[], standard_deviation=0.18072523940533955), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 108114, tzinfo=datetime.timezone.utc), iteration_number=25, parameters=[3.2004536591838284, -5.449027011758957, -3.026748767095255], mean_all_solutions=-1.8450263671875, solutions=[], standard_deviation=0.18071738199833995), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 123912, tzinfo=datetime.timezone.utc), iteration_number=26, parameters=[3.202287722262083, -5.448355513515767, -3.026748767095255], mean_all_solutions=-1.8453796875, solutions=[], standard_deviation=0.18070114803150075), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 137062, tzinfo=datetime.timezone.utc), iteration_number=27, parameters=[3.204215762026098, -5.448150392901527, -3.026513638475947], mean_all_solutions=-1.8441787109375, solutions=[], standard_deviation=0.18407196828067413), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 149810, tzinfo=datetime.timezone.utc), iteration_number=28, parameters=[3.2024117660313935, -5.448413069051517, -3.027715708055193], mean_all_solutions=-1.8446025390625, solutions=[], standard_deviation=0.18240355711064926), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 162686, tzinfo=datetime.timezone.utc), iteration_number=29, parameters=[3.200964098765243, -5.447555772709687, -3.02555581581908], mean_all_solutions=-1.8450263671875, solutions=[], standard_deviation=0.18071738199833995), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 178398, tzinfo=datetime.timezone.utc), iteration_number=30, parameters=[3.201957976817865, -5.45017117313695, -3.0261089660733367], mean_all_solutions=-1.84520302734375, solutions=[], standard_deviation=0.1807093515480838), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 16, 17, 23, 191348, tzinfo=datetime.timezone.utc), iteration_number=31, parameters=[3.2017515243271615, -5.448452277177368, -3.027587294714585], mean_all_solutions=-1.84520302734375, solutions=[], standard_deviation=0.1807093515480838)] optimal_parameters={'angles_0': 3.2017515243271615, 'angles_1': -5.448452277177368, 'angles_2': -3.027587294714585} convergence_graph_str='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' num_solutions=None num_shots=2048\n" - ] - } - ], - "source": [ - "print(res[0].value)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "d3fd78b2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Difference in Optimal energy: 0.02051206583780174\n" - ] - } - ], - "source": [ - "print(f\"Difference in Optimal energy: {vqe_result.energy - (-1.8657150931815518)}\")" - ] - }, - { - "cell_type": "markdown", - "id": "2c749e5e", - "metadata": {}, - "source": [ - "## Discussion:\n", - "\n", - "* The `optimal energy` from class was $-1.8657150931815518$ (Ha) which gives a difference of $\\sim 0.0205$.\n", - "* Can't tell as directly as in class but if we could figure out the nuclear repulsion energy, then we would know a `total energy` for this case as well (by the difference with the optimal one).\n", - "* The provided `Hamiltonian` describes the molecular system defined in class quite well. I suppose we could trace back what each term means physically in the molecule itself.\n", - "In the following you can see my assumption on that." - ] - }, - { - "cell_type": "markdown", - "id": "782d5963", - "metadata": {}, - "source": [ - "\\begin{aligned}\n", - " - \\sum_{i=1}^{2} \\frac{\\nabla_i^2}{2} &= -1.0523 \\cdot (I \\otimes I)\\\\\n", - " - \\frac{1}{|\\mathbf{r}_1 - \\mathbf{R}_A|} - \\frac{1}{|\\mathbf{r}_2 - \\mathbf{R}_A|} &= + 0.3979 \\cdot (I \\otimes Z)\\\\\n", - " - \\frac{1}{|\\mathbf{r}_1 - \\mathbf{R}_B|} - \\frac{1}{|\\mathbf{r}_2 - \\mathbf{R}_B|} &= - 0.3979 \\cdot (Z \\otimes I)\\\\\n", - " \\frac{1}{|\\mathbf{r}_1 - \\mathbf{r}_2|} &= - 0.0112 \\cdot (Z \\otimes Z)\\\\\n", - " \\frac{1}{|\\mathbf{R}_A - \\mathbf{R}_B|} &= + 0.1809 \\cdot (X \\otimes X)\\\\\n", - "\\end{aligned}" - ] - }, - { - "cell_type": "markdown", - "id": "a5d20c48", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Submissions/HW3/HW3_VQE - Bill Wisotsky.ipynb b/community/QClass_2024/Submissions/HW3/HW3_VQE - Bill Wisotsky.ipynb deleted file mode 100644 index 864b6210..00000000 --- a/community/QClass_2024/Submissions/HW3/HW3_VQE - Bill Wisotsky.ipynb +++ /dev/null @@ -1,297 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], \n", - " [\n", - " PauliTerm([Pauli.I,Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I,Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z,Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z,Pauli.Z], -0.0112), \n", - " PauliTerm([Pauli.X,Pauli.X], 0.1809) \n", - " ]) " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0]) \n", - " U(angles[0], angles[1], angles[2], 0, q[1]) \n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN,\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.0814723632812502\n", - "Optimal parameters: {'angles_0': 7.508357374349873, 'angles_1': 1.5234985297105201, 'angles_2': -3.7348062779253675}\n", - "Eigenstate: {'01': (0.4708287241662301+0j), '11': (0.31868871959954903+0j), '00': (0.6709659547994965+0j), '10': (0.4759858191164943+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class?" - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0]) \n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - " CX(control=q[0],target=q[1])\n", - "\n", - "\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN,\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "#show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "#execution.open_in_ide()\n", - "vqe_result = res[0].value" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": { - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.8574645507812502\n", - "Optimal parameters: {'angles_0': 2.9798423376870504, 'angles_1': 3.1863311123330353, 'angles_2': 2.5094137236487097}\n", - "Eigenstate: {'10': (0.0625+0j), '11': (0.09375+0j), '01': (0.9936320684740404+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.18" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Submissions/HW3/Priyabrata_Bag_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Hisham_Mansour_HW3_VQE.ipynb similarity index 65% rename from community/QClass_2024/Submissions/HW3/Priyabrata_Bag_HW3_VQE.ipynb rename to community/QClass_2024/Submissions/HW3/Hisham_Mansour_HW3_VQE.ipynb index 92e832c6..32a0927e 100644 --- a/community/QClass_2024/Submissions/HW3/Priyabrata_Bag_HW3_VQE.ipynb +++ b/community/QClass_2024/Submissions/HW3/Hisham_Mansour_HW3_VQE.ipynb @@ -3,7 +3,9 @@ { "cell_type": "markdown", "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, + "metadata": { + "id": "fc72d98f-8993-4bd4-a545-23d122f3df71" + }, "source": [ "# H₂ Molecule Homework Assignment\n", "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", @@ -15,7 +17,9 @@ { "cell_type": "markdown", "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, + "metadata": { + "id": "56eda6d8-76c4-4862-b914-0c4598d67274" + }, "source": [ "## Submission\n", "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", @@ -37,7 +41,9 @@ { "cell_type": "markdown", "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, + "metadata": { + "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b" + }, "source": [ "### Part 1" ] @@ -45,7 +51,9 @@ { "cell_type": "markdown", "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, + "metadata": { + "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2" + }, "source": [ "Given the following Hamiltonian:" ] @@ -53,7 +61,9 @@ { "cell_type": "markdown", "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, + "metadata": { + "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4" + }, "source": [ "$$\n", "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", @@ -63,7 +73,9 @@ { "cell_type": "markdown", "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, + "metadata": { + "id": "736d275c-9a5a-4c08-b891-3078430dc6c1" + }, "source": [ "Complete the following code" ] @@ -71,40 +83,78 @@ { "cell_type": "code", "execution_count": 1, + "id": "DQOxbZxjrN5r", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DQOxbZxjrN5r", + "outputId": "ba3dffa0-ff88-4a89-b76f-a0bd6c05f164" + }, + "outputs": [], + "source": [ + "# !pip install -U classiq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "jLanwByIe4eJ", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jLanwByIe4eJ", + "outputId": "dea1c702-533c-492a-f2c7-4406c6fdb7f0" + }, + "outputs": [], + "source": [ + "# import classiq\n", + "# classiq.authenticate()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, + "metadata": { + "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8" + }, "outputs": [], "source": [ "from typing import List\n", + "\n", "from classiq import *\n", "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm],\n", - " [PauliTerm(pauli=[Pauli.I, Pauli.I], coefficient=-1.0523),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z], coefficient=0.3979),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I], coefficient=-0.3979),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.Z], coefficient=-0.0112),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.X], coefficient=0.1809)]) #TODO: Complete Hamiltonian" + "# TODO: Complete Hamiltonian\n", + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [\n", + " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", + " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", + " PauliTerm([Pauli.X, Pauli.X], 0.1809),\n", + " ],\n", + ")" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "The current version of 'classiq' has been deprecated, and will not be supported as of 2024-06-27. Please run \"pip install -U classiq\" to upgrade the classiq SDK to the latest version.\n" - ] - } - ], + "metadata": { + "id": "0bb68899-2076-45c0-8868-131f38aa3b78" + }, + "outputs": [], "source": [ "@qfunc\n", "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", + " # TODO: Create an ansatz which allows each qubit to have\n", + " # arbitrary rotation\n", " allocate(2, q)\n", + "\n", " U(angles[0], angles[1], angles[2], 0, q[0])\n", " U(angles[0], angles[1], angles[2], 0, q[1])\n", "\n", @@ -112,9 +162,9 @@ "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", + " hamiltonian=HAMILTONIAN,\n", + " maximize=False,\n", + " initial_point=[],\n", " optimizer=Optimizer.COBYLA,\n", " max_iteration=1000,\n", " tolerance=0.001,\n", @@ -124,29 +174,39 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" + "\n", + "# TODO: complete the line, use classical_execution_function\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "\n", + "qprog = synthesize(qmod)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": {}, + "metadata": { + "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382" + }, "outputs": [], "source": [ "execution = execute(qprog)\n", "res = execution.result()\n", "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" + "vqe_result = res[0].value" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", + "outputId": "5b400695-8faf-4aae-e8b8-bdc477e211e1", "scrolled": true }, "outputs": [ @@ -154,9 +214,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Optimal energy: -1.0646799804687501\n", - "Optimal parameters: {'angles_0': -6.164185814953359, 'angles_1': -5.172941087398459, 'angles_2': -5.722759806197389}\n", - "Eigenstate: {'01': (0.05846339666834283+0j), '10': (0.05412658773652741+0j), '00': (0.9968211192335363+0j)}\n" + "Optimal energy: -1.0619871093750002\n", + "Optimal parameters: {'angles_0': -3.2808520260537106, 'angles_1': 5.294346105087447, 'angles_2': -3.360401698136923}\n", + "Eigenstate: {'10': (0.07967217989988726+0j), '01': (0.08267972847076846+0j), '11': (0.9933863328282708+0j)}\n" ] } ], @@ -166,29 +226,12 @@ "print(f\"Eigenstate: {vqe_result.eigenstate}\")" ] }, - { - "cell_type": "code", - "execution_count": 5, - "id": "97b01b87", - "metadata": {}, - "outputs": [], - "source": [ - "# Optimal parameters: {'angles_0': -3.0292653800801213, 'angles_1': 0.13084292242999915, 'angles_2': -5.614248543217801}\n", - "# Eigenstate: {'10': (0.07328774624724109+0j), '11': (0.07328774624724109+0j), '01': (0.9946144039274718+0j)}" - ] - }, - { - "cell_type": "markdown", - "id": "452ac946", - "metadata": {}, - "source": [ - "The optimal energy is different from what was calculated in class." - ] - }, { "cell_type": "markdown", "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, + "metadata": { + "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa" + }, "source": [ "Does it similar to the `optimal energy` we calculated in class? \\\n", "Does it similar to the `total energy` we calculated in class?" @@ -197,7 +240,9 @@ { "cell_type": "markdown", "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, + "metadata": { + "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f" + }, "source": [ "### Part 2" ] @@ -205,7 +250,9 @@ { "cell_type": "markdown", "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, + "metadata": { + "id": "66882248-de08-4a6e-b33c-647f015f7d79" + }, "source": [ "**Now, we want to have a more interesting ansatz in our `main`.** \n", "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", @@ -214,24 +261,29 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": {}, + "metadata": { + "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145" + }, "outputs": [], "source": [ "@qfunc\n", "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", + " # TODO: Create an ansatz which allows each qubit to have\n", + " # arbitrary rotation\n", " allocate(2, q)\n", + "\n", " U(angles[0], angles[1], angles[2], 0, q[0])\n", " U(angles[0], angles[1], angles[2], 0, q[1])\n", + "\n", " CX(q[0], q[1])\n", "\n", "\n", "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", + " HAMILTONIAN, # TODO: complete the missing argument\n", " False,\n", " [],\n", " optimizer=Optimizer.COBYLA,\n", @@ -243,41 +295,48 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" + "\n", + "# TODO: complete the line, use classical_execution_function\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "\n", + "qprog = synthesize(qmod)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, + "metadata": { + "id": "112a1590-283c-4f79-8035-72936561102d" + }, "outputs": [], "source": [ "execution = execute(qprog)\n", "res = execution.result()\n", "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" + "vqe_result = res[0].value" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", "metadata": { - "jupyter": { - "outputs_hidden": true - } + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", + "outputId": "c406023c-627c-468c-d48c-cddf2d234297" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Optimal energy: -1.8396752929687499\n", - "Optimal parameters: {'angles_0': -3.3237005318854607, 'angles_1': 3.9061632465634935, 'angles_2': -0.840172938028935}\n", - "Eigenstate: {'11': (0.07328774624724109+0j), '00': (0.02209708691207961+0j), '10': (0.09375+0j), '01': (0.9926487608917869+0j)}\n" + "Optimal energy: -1.0626466796875\n", + "Optimal parameters: {'angles_0': 6.128115986875437, 'angles_1': -1.2908504032221542, 'angles_2': -0.0016859821535950559}\n", + "Eigenstate: {'11': (0.07654655446197431+0j), '10': (0.07967217989988726+0j), '00': (0.9938777433618282+0j)}\n" ] } ], @@ -287,18 +346,12 @@ "print(f\"Eigenstate: {vqe_result.eigenstate}\")" ] }, - { - "cell_type": "markdown", - "id": "38a85725", - "metadata": {}, - "source": [ - "The optimal energy is close to what was calculated in class." - ] - }, { "cell_type": "markdown", "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, + "metadata": { + "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8" + }, "source": [ "Does it similar to the `optimal energy` we calculated in class? \\\n", "Does it similar to the `total energy` we calculated in class? \\\n", @@ -307,6 +360,9 @@ } ], "metadata": { + "colab": { + "provenance": [] + }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", @@ -322,7 +378,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.11.9" } }, "nbformat": 4, diff --git "a/community/QClass_2024/Submissions/HW3/Jos\303\251_Alejandro_Garc\303\255a_Gonz\303\241lez_HW3_VQE.ipynb" "b/community/QClass_2024/Submissions/HW3/Jos\303\251_Alejandro_Garc\303\255a_Gonz\303\241lez_HW3_VQE.ipynb" deleted file mode 100644 index af5eb304..00000000 --- "a/community/QClass_2024/Submissions/HW3/Jos\303\251_Alejandro_Garc\303\255a_Gonz\303\241lez_HW3_VQE.ipynb" +++ /dev/null @@ -1,292 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [ \n", - " PauliTerm([Pauli.I,Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I,Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z,Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z,Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X,Pauli.X], 0.1809)]) #TODO: Complete Hamiltonian" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0]) \n", - " U(angles[0], angles[1], angles[2], 0, q[1]) \n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.0703087890625\n", - "Optimal parameters: {'angles_0': -3.0050128659641677, 'angles_1': 5.201094170771723, 'angles_2': 5.307885496575592}\n", - "Eigenstate: {'01': (0.07967217989988726+0j), '10': (0.08267972847076846+0j), '11': (0.9933863328282708+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class?" - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0]) \n", - " U(angles[0], angles[1], angles[2], 0, q[1]) \n", - " CX(q[0],q[1])\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - "\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.8458964843749999\n", - "Optimal parameters: {'angles_0': -3.3280394699556823, 'angles_1': -3.598660471331964, 'angles_2': 1.6530907975027636}\n", - "Eigenstate: {'11': (0.09882117688026186+0j), '10': (0.09882117688026186+0j), '01': (0.9901862198596787+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Submissions/HW3/Mohammadreza_Khodajou_Masouleh_HW3_QClass2024.ipynb b/community/QClass_2024/Submissions/HW3/Mohammadreza_Khodajou_Masouleh_HW3_QClass2024.ipynb index e4bbf492..fe53d468 100644 --- a/community/QClass_2024/Submissions/HW3/Mohammadreza_Khodajou_Masouleh_HW3_QClass2024.ipynb +++ b/community/QClass_2024/Submissions/HW3/Mohammadreza_Khodajou_Masouleh_HW3_QClass2024.ipynb @@ -1,506 +1,400 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": { - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71" - }, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": { - "id": "56eda6d8-76c4-4862-b914-0c4598d67274" - }, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "XvJSENg4UQeh", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "XvJSENg4UQeh", - "outputId": "e25318b0-f308-4e3d-a898-681c900d09b8" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting classiq\n", - " Downloading classiq-0.42.0-py3-none-any.whl (401 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m401.5/401.5 kB\u001b[0m \u001b[31m2.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting ConfigArgParse<2.0.0,>=1.5.3 (from classiq)\n", - " Downloading ConfigArgParse-1.7-py3-none-any.whl (25 kB)\n", - "Collecting Pyomo<6.6,>=6.5 (from classiq)\n", - " Downloading Pyomo-6.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (10.7 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m26.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting black<25.0,>=24.0 (from classiq)\n", - " Downloading black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.8 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m39.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting httpx<1,>=0.23.0 (from classiq)\n", - " Downloading httpx-0.27.0-py3-none-any.whl (75 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: keyring<24.0.0,>=23.5.0 in /usr/lib/python3/dist-packages (from classiq) (23.5.0)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.4.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (3.7.1)\n", - "Collecting networkx<3.0.0,>=2.5.1 (from classiq)\n", - " Downloading networkx-2.8.8-py3-none-any.whl (2.0 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m40.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: numexpr<3.0.0,>=2.7.3 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.10.0)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.20.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.25.2)\n", - "Collecting packaging<23.0,>=22.0 (from classiq)\n", - " Downloading packaging-22.0-py3-none-any.whl (42 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m3.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: pandas<3.0.0,>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (2.0.3)\n", - "Requirement already satisfied: plotly<6.0.0,>=5.7.0 in /usr/local/lib/python3.10/dist-packages (from classiq) (5.15.0)\n", - "Collecting pydantic<2.0.0,>=1.9.1 (from classiq)\n", - " Downloading pydantic-1.10.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m37.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: scipy<2.0.0,>=1.10.1 in /usr/local/lib/python3.10/dist-packages (from classiq) (1.11.4)\n", - "Collecting sympy<1.11.0,>=1.9.0 (from classiq)\n", - " Downloading sympy-1.10.1-py3-none-any.whl (6.4 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m18.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: tabulate<1,>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from classiq) (0.9.0)\n", - "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (8.1.7)\n", - "Collecting mypy-extensions>=0.4.3 (from black<25.0,>=24.0->classiq)\n", - " Downloading mypy_extensions-1.0.0-py3-none-any.whl (4.7 kB)\n", - "Collecting pathspec>=0.9.0 (from black<25.0,>=24.0->classiq)\n", - " Downloading pathspec-0.12.1-py3-none-any.whl (31 kB)\n", - "Requirement already satisfied: platformdirs>=2 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.2.2)\n", - "Requirement already satisfied: tomli>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (2.0.1)\n", - "Requirement already satisfied: typing-extensions>=4.0.1 in /usr/local/lib/python3.10/dist-packages (from black<25.0,>=24.0->classiq) (4.12.1)\n", - "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7.1)\n", - "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (2024.6.2)\n", - "Collecting httpcore==1.* (from httpx<1,>=0.23.0->classiq)\n", - " Downloading httpcore-1.0.5-py3-none-any.whl (77 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (3.7)\n", - "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx<1,>=0.23.0->classiq) (1.3.1)\n", - "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx<1,>=0.23.0->classiq)\n", - " Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.2.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (4.53.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (1.4.5)\n", - "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (9.4.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (3.1.2)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib<4.0.0,>=3.4.3->classiq) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2023.4)\n", - "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas<3.0.0,>=1.4.0->classiq) (2024.1)\n", - "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from plotly<6.0.0,>=5.7.0->classiq) (8.3.0)\n", - "Collecting ply (from Pyomo<6.6,>=6.5->classiq)\n", - " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy<1.11.0,>=1.9.0->classiq) (1.3.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.4.3->classiq) (1.16.0)\n", - "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx<1,>=0.23.0->classiq) (1.2.1)\n", - "Installing collected packages: ply, sympy, Pyomo, pydantic, pathspec, packaging, networkx, mypy-extensions, h11, ConfigArgParse, httpcore, black, httpx, classiq\n", - " Attempting uninstall: sympy\n", - " Found existing installation: sympy 1.12.1\n", - " Uninstalling sympy-1.12.1:\n", - " Successfully uninstalled sympy-1.12.1\n", - " Attempting uninstall: pydantic\n", - " Found existing installation: pydantic 2.7.3\n", - " Uninstalling pydantic-2.7.3:\n", - " Successfully uninstalled pydantic-2.7.3\n", - " Attempting uninstall: packaging\n", - " Found existing installation: packaging 24.0\n", - " Uninstalling packaging-24.0:\n", - " Successfully uninstalled packaging-24.0\n", - " Attempting uninstall: networkx\n", - " Found existing installation: networkx 3.3\n", - " Uninstalling networkx-3.3:\n", - " Successfully uninstalled networkx-3.3\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "torch 2.3.0+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-nccl-cu12==2.20.5; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n", - "\u001b[0mSuccessfully installed ConfigArgParse-1.7 Pyomo-6.5.0 black-24.4.2 classiq-0.42.0 h11-0.14.0 httpcore-1.0.5 httpx-0.27.0 mypy-extensions-1.0.0 networkx-2.8.8 packaging-22.0 pathspec-0.12.1 ply-3.11 pydantic-1.10.15 sympy-1.10.1\n" - ] - } - ], - "source": [ - " !pip install -U classiq" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "HryEIcq_UWzG", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "HryEIcq_UWzG", - "outputId": "cba0edbf-73c1-46ea-d967-f020003e3a37" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Your user code: ZCPV-PRDZ\n", - "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=ZCPV-PRDZ\n" - ] - } - ], - "source": [ - "import classiq\n", - "classiq.authenticate()" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": { - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b" - }, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": { - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2" - }, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": { - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4" - }, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": { - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1" - }, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": { - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8" - }, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\",\n", - " List[PauliTerm],\n", - " [PauliTerm(pauli=[Pauli.I, Pauli.I], coefficient=-1.0523),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z], coefficient=0.3979),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I], coefficient=-0.3979),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.Z], coefficient=-0.0112),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.X], coefficient=0.1809)]) #TODO: Complete Hamiltonian" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": { - "id": "0bb68899-2076-45c0-8868-131f38aa3b78" - }, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " repeat (q.len, lambda i: U(angles[0], angles[1], angles[2], 0, q[i]))\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)#TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "#show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": { - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382" - }, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "#print(res)\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "XYbvABk_FwQJ", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "XYbvABk_FwQJ", - "outputId": "16644151-f0a9-4995-e6b4-d66e543f118e", - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.062161328125\n", - "Optimal parameters: {'angles_0': 0.13568678083490543, 'angles_1': -5.744986654083372, 'angles_2': 5.700228943470761}\n", - "Eigenstate: {'01': (0.07654655446197431+0j), '10': (0.09375+0j), '00': (0.9926487608917869+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": { - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa" - }, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class?" - ] - }, - { - "cell_type": "markdown", - "id": "70pHpqecuObf", - "metadata": { - "id": "70pHpqecuObf" - }, - "source": [ - "*No! The value in the session was derived, according to different contributions, associated with the two-atom H_2 molecule, having taken into account various ways of communication through potential between them (atoms being effectively the qubits). This problem doesn't cover for those. Qubits are not talking to each other!*" - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": { - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f" - }, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": { - "id": "66882248-de08-4a6e-b33c-647f015f7d79" - }, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": { - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145" - }, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - "\n", - " allocate(2, q)\n", - " repeat (q.len, lambda i: U(angles[0], angles[1], angles[2], 0, q[i]))\n", - " CX(q[0], q[1])\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)#TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": { - "id": "112a1590-283c-4f79-8035-72936561102d" - }, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] + "cells": [ + { + "cell_type": "markdown", + "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", + "metadata": { + "id": "fc72d98f-8993-4bd4-a545-23d122f3df71" + }, + "source": [ + "# H₂ Molecule Homework Assignment\n", + "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", + "\n", + "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", + "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." + ] + }, + { + "cell_type": "markdown", + "id": "56eda6d8-76c4-4862-b914-0c4598d67274", + "metadata": { + "id": "56eda6d8-76c4-4862-b914-0c4598d67274" + }, + "source": [ + "## Submission\n", + "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", + "- Use the Typeform link provided in the submission folder to confirm your submission.\n", + "\n", + "## Additional Resources\n", + "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", + "- The notebook from live session #3\n", + "\n", + "## Important Dates\n", + "- **Assignment Release:** 22.5.2024\n", + "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", + "\n", + "---\n", + "\n", + "Happy coding and good luck!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "XvJSENg4UQeh", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, - { - "cell_type": "code", - "execution_count": 42, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "collapsed": true, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "jupyter": { - "outputs_hidden": true - }, - "outputId": "51f2aa86-143f-4e92-a3b3-3b900e42fd83" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.8525221679687498\n", - "Optimal parameters: {'angles_0': 3.00289263258954, 'angles_1': -3.506224563747043, 'angles_2': -4.715418449895681}\n", - "Eigenstate: {'11': (0.06987712429686843+0j), '10': (0.05846339666834283+0j), '01': (0.995840960570512+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] + "id": "XvJSENg4UQeh", + "outputId": "e25318b0-f308-4e3d-a898-681c900d09b8" + }, + "outputs": [], + "source": [ + "# !pip install -U classiq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "HryEIcq_UWzG", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, - { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": { - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8" - }, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" - ] + "id": "HryEIcq_UWzG", + "outputId": "cba0edbf-73c1-46ea-d967-f020003e3a37" + }, + "outputs": [], + "source": [ + "# import classiq\n", + "# classiq.authenticate()" + ] + }, + { + "cell_type": "markdown", + "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", + "metadata": { + "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b" + }, + "source": [ + "### Part 1" + ] + }, + { + "cell_type": "markdown", + "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", + "metadata": { + "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2" + }, + "source": [ + "Given the following Hamiltonian:" + ] + }, + { + "cell_type": "markdown", + "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", + "metadata": { + "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4" + }, + "source": [ + "$$\n", + "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", + "metadata": { + "id": "736d275c-9a5a-4c08-b891-3078430dc6c1" + }, + "source": [ + "Complete the following code" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", + "metadata": { + "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8" + }, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from classiq import *\n", + "\n", + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [\n", + " PauliTerm(pauli=[Pauli.I, Pauli.I], coefficient=-1.0523),\n", + " PauliTerm(pauli=[Pauli.I, Pauli.Z], coefficient=0.3979),\n", + " PauliTerm(pauli=[Pauli.Z, Pauli.I], coefficient=-0.3979),\n", + " PauliTerm(pauli=[Pauli.Z, Pauli.Z], coefficient=-0.0112),\n", + " PauliTerm(pauli=[Pauli.X, Pauli.X], coefficient=0.1809),\n", + " ],\n", + ") # TODO: Complete Hamiltonian" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0bb68899-2076-45c0-8868-131f38aa3b78", + "metadata": { + "id": "0bb68899-2076-45c0-8868-131f38aa3b78" + }, + "outputs": [], + "source": [ + "@qfunc\n", + "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", + " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", + " allocate(2, q)\n", + " repeat(q.len, lambda i: U(angles[0], angles[1], angles[2], 0, q[i]))\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " res = vqe(\n", + " HAMILTONIAN, # TODO: complete the missing argument\n", + " False,\n", + " [],\n", + " optimizer=Optimizer.COBYLA,\n", + " max_iteration=1000,\n", + " tolerance=0.001,\n", + " step_size=0,\n", + " skip_compute_variance=False,\n", + " alpha_cvar=1.0,\n", + " )\n", + " save({\"result\": res})\n", + "\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # TODO: complete the line, use classical_execution_function\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", + "metadata": { + "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382" + }, + "outputs": [], + "source": [ + "execution = execute(qprog)\n", + "res = execution.result()\n", + "# execution.open_in_ide()\n", + "# print(res)\n", + "vqe_result = res[0].value # TODO: complete the line" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "XYbvABk_FwQJ", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "XYbvABk_FwQJ", + "outputId": "16644151-f0a9-4995-e6b4-d66e543f118e", + "scrolled": true + }, + "outputs": [ { - "cell_type": "markdown", - "id": "j4jmzMoL186t", - "metadata": { - "id": "j4jmzMoL186t" - }, - "source": [ - "*Evidently, the value of the optimal energy here bears a striking resemblence to the value of the problem discussed in the session. Almost surprisingly so, even though running the cell more than once introduces minimal differences. The entangling two-qubit gate CNOT is responsible for the conversation between the qubits, and that is the reason behind this similarity in values. Nevertheless, it's quite surprising admittedly to be able to simulate the impact of those sophisticated potential terms + the solid ansatz by a CNOT!*" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal energy: -1.0736828125\n", + "Optimal parameters: {'angles_0': 6.723999211067887, 'angles_1': -4.787549480657028, 'angles_2': 0.01835345840038345}\n", + "Eigenstate: {'11': (0.05846339666834283+0j), '01': (0.2275034340400162+0j), '10': (0.18619336387207788+0j), '00': (0.9540210951546092+0j)}\n" + ] } - ], - "metadata": { + ], + "source": [ + "print(f\"Optimal energy: {vqe_result.energy}\")\n", + "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", + "print(f\"Eigenstate: {vqe_result.eigenstate}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", + "metadata": { + "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa" + }, + "source": [ + "Does it similar to the `optimal energy` we calculated in class? \\\n", + "Does it similar to the `total energy` we calculated in class?" + ] + }, + { + "cell_type": "markdown", + "id": "70pHpqecuObf", + "metadata": { + "id": "70pHpqecuObf" + }, + "source": [ + "*No! The value in the session was derived, according to different contributions, associated with the two-atom H_2 molecule, having taken into account various ways of communication through potential between them (atoms being effectively the qubits). This problem doesn't cover for those. Qubits are not talking to each other!*" + ] + }, + { + "cell_type": "markdown", + "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", + "metadata": { + "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f" + }, + "source": [ + "### Part 2" + ] + }, + { + "cell_type": "markdown", + "id": "66882248-de08-4a6e-b33c-647f015f7d79", + "metadata": { + "id": "66882248-de08-4a6e-b33c-647f015f7d79" + }, + "source": [ + "**Now, we want to have a more interesting ansatz in our `main`.** \n", + "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", + "Which gate should you use?" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", + "metadata": { + "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145" + }, + "outputs": [], + "source": [ + "@qfunc\n", + "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", + " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", + "\n", + " allocate(2, q)\n", + " repeat(q.len, lambda i: U(angles[0], angles[1], angles[2], 0, q[i]))\n", + " CX(q[0], q[1])\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " res = vqe(\n", + " HAMILTONIAN, # TODO: complete the missing argument\n", + " False,\n", + " [],\n", + " optimizer=Optimizer.COBYLA,\n", + " max_iteration=1000,\n", + " tolerance=0.001,\n", + " step_size=0,\n", + " skip_compute_variance=False,\n", + " alpha_cvar=1.0,\n", + " )\n", + " save({\"result\": res})\n", + "\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # TODO: complete the line, use classical_execution_function\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "112a1590-283c-4f79-8035-72936561102d", + "metadata": { + "id": "112a1590-283c-4f79-8035-72936561102d" + }, + "outputs": [], + "source": [ + "execution = execute(qprog)\n", + "res = execution.result()\n", + "# execution.open_in_ide()\n", + "vqe_result = res[0].value # TODO: complete the line" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", + "metadata": { "colab": { - "provenance": [] + "base_uri": "https://localhost:8080/" }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.9" + "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", + "outputId": "51f2aa86-143f-4e92-a3b3-3b900e42fd83" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal energy: -1.8497781249999998\n", + "Optimal parameters: {'angles_0': -2.9205748677970176, 'angles_1': -0.5854301692243206, 'angles_2': -3.1640158800495723}\n", + "Eigenstate: {'11': (0.11048543456039805+0j), '10': (0.12303137303143455+0j), '01': (0.9862333648787187+0j)}\n" + ] } + ], + "source": [ + "print(f\"Optimal energy: {vqe_result.energy}\")\n", + "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", + "print(f\"Eigenstate: {vqe_result.eigenstate}\")" + ] + }, + { + "cell_type": "markdown", + "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", + "metadata": { + "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8" + }, + "source": [ + "Does it similar to the `optimal energy` we calculated in class? \\\n", + "Does it similar to the `total energy` we calculated in class? \\\n", + "What can we learn about the provided form this result Hamiltonian?" + ] + }, + { + "cell_type": "markdown", + "id": "j4jmzMoL186t", + "metadata": { + "id": "j4jmzMoL186t" + }, + "source": [ + "*Evidently, the value of the optimal energy here bears a striking resemblence to the value of the problem discussed in the session. Almost surprisingly so, even though running the cell more than once introduces minimal differences. The entangling two-qubit gate CNOT is responsible for the conversation between the qubits, and that is the reason behind this similarity in values. Nevertheless, it's quite surprising admittedly to be able to simulate the impact of those sophisticated potential terms + the solid ansatz by a CNOT!*" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/community/QClass_2024/Submissions/HW3/Noah_Nzeki_William_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Noah_Nzeki_William_HW3_VQE.ipynb old mode 100755 new mode 100644 index 80563254..49c257c6 --- a/community/QClass_2024/Submissions/HW3/Noah_Nzeki_William_HW3_VQE.ipynb +++ b/community/QClass_2024/Submissions/HW3/Noah_Nzeki_William_HW3_VQE.ipynb @@ -76,15 +76,20 @@ "outputs": [], "source": [ "from typing import List\n", + "\n", "from classiq import *\n", "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], #[...]) #TODO: Complete Hamiltonian\n", - " [ \n", - " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X], 0.1809)])\n" + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm], # [...]) #TODO: Complete Hamiltonian\n", + " [\n", + " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", + " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", + " PauliTerm([Pauli.X, Pauli.X], 0.1809),\n", + " ],\n", + ")" ] }, { @@ -105,15 +110,16 @@ "@qfunc\n", "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " \n", - " allocate(2, q) \n", - " U(angles[0], angles[1], angles[2], 0, q[0]) \n", - " U(angles[0], angles[1], angles[2], 0, q[1]) \n", + "\n", + " allocate(2, q)\n", + " U(angles[0], angles[1], angles[2], 0, q[0])\n", + " U(angles[0], angles[1], angles[2], 0, q[1])\n", + "\n", "\n", "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", - " HAMILTONIAN, #.TODO: complete the missing argument\n", + " HAMILTONIAN, # .TODO: complete the missing argument\n", " False,\n", " [],\n", " optimizer=Optimizer.COBYLA,\n", @@ -125,7 +131,10 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # TODO: complete the line, use classical_execution_function\n", "qprog = synthesize(qmod)\n", "show(qprog)" ] @@ -139,8 +148,8 @@ "source": [ "execution = execute(qprog)\n", "res = execution.result()\n", - "#execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" + "# execution.open_in_ide()\n", + "vqe_result = res[0].value # TODO: complete the line" ] }, { @@ -212,16 +221,17 @@ "@qfunc\n", "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " \n", - " allocate(2, q) \n", - " U(angles[0], angles[1], angles[2], 0, q[0]) \n", - " U(angles[0], angles[1], angles[2], 0, q[1]) \n", - " CX(q[1],q[0])\n", + "\n", + " allocate(2, q)\n", + " U(angles[0], angles[1], angles[2], 0, q[0])\n", + " U(angles[0], angles[1], angles[2], 0, q[1])\n", + " CX(q[1], q[0])\n", + "\n", "\n", "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", + " HAMILTONIAN, # TODO: complete the missing argument\n", " False,\n", " [],\n", " optimizer=Optimizer.COBYLA,\n", @@ -233,7 +243,10 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # TODO: complete the line, use classical_execution_function\n", "qprog = synthesize(qmod)\n", "show(qprog)" ] @@ -257,7 +270,7 @@ "execution = execute(qprog)\n", "res = execution.result()\n", "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" + "vqe_result = res[0].value # TODO: complete the line" ] }, { diff --git a/community/QClass_2024/Submissions/HW3/Otmane_Ainelkitane_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Otmane_Ainelkitane_HW3_VQE.ipynb index d9fc502d..c1bee5d6 100644 --- a/community/QClass_2024/Submissions/HW3/Otmane_Ainelkitane_HW3_VQE.ipynb +++ b/community/QClass_2024/Submissions/HW3/Otmane_Ainelkitane_HW3_VQE.ipynb @@ -1,419 +1,382 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": { - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71" - }, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": { - "id": "56eda6d8-76c4-4862-b914-0c4598d67274" - }, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": { - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b" - }, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": { - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2" - }, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": { - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4" - }, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": { - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1" - }, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "source": [ - "!pip install -U -q classiq" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "collapsed": true, - "id": "imjx_MjrLbGs", - "outputId": "41671177-4fd4-4eef-d299-b5edab53a274" - }, - "id": "imjx_MjrLbGs", - "execution_count": 2, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m398.1/398.1 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m25.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m33.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m4.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m26.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 kB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m41.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.4/6.4 MB\u001b[0m \u001b[31m41.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m4.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m4.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 kB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "torch 2.3.0+cu121 requires nvidia-cublas-cu12==12.1.3.1; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cuda-cupti-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cuda-nvrtc-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cuda-runtime-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cudnn-cu12==8.9.2.26; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cufft-cu12==11.0.2.54; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-curand-cu12==10.3.2.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cusolver-cu12==11.4.5.107; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-cusparse-cu12==12.1.0.106; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-nccl-cu12==2.20.5; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\n", - "torch 2.3.0+cu121 requires nvidia-nvtx-cu12==12.1.105; platform_system == \"Linux\" and platform_machine == \"x86_64\", which is not installed.\u001b[0m\u001b[31m\n", - "\u001b[0m" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "import classiq\n", - "classiq.authenticate()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "UjUn859jLcaS", - "outputId": "1d9eb96e-fefe-42c3-c71d-cd24bfb5d4cb" - }, - "id": "UjUn859jLcaS", - "execution_count": 3, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Your user code: JPTW-QDSJ\n", - "If a browser doesn't automatically open, please visit this URL from any trusted device: https://auth.classiq.io/activate?user_code=JPTW-QDSJ\n" - ] - } - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": { - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8" - }, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm],\n", - " [PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I,Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z,Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z,Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X], 0.1809)])" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": { - "id": "0bb68899-2076-45c0-8868-131f38aa3b78" - }, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN,\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": { - "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382" - }, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "\n", - "vqe_result = res[0].value" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "metadata": { - "scrolled": true, - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "outputId": "695489b1-dcff-431b-8f8a-b90daaa26ff5" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Optimal energy: -1.06546357421875\n", - "Optimal parameters: {'angles_0': 6.139678585190387, 'angles_1': 4.976498216901541, 'angles_2': -4.571133358645985}\n", - "Eigenstate: {'01': (0.06629126073623882+0j), '10': (0.07328774624724109+0j), '00': (0.9951052080056662+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": { - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa" - }, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class?" - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": { - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f" - }, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": { - "id": "66882248-de08-4a6e-b33c-647f015f7d79" - }, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": { - "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145" - }, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "\n", - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - " CX(q[0], q[1])\n", - "\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] + "cells": [ + { + "cell_type": "markdown", + "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", + "metadata": { + "id": "fc72d98f-8993-4bd4-a545-23d122f3df71" + }, + "source": [ + "# H₂ Molecule Homework Assignment\n", + "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", + "\n", + "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", + "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." + ] + }, + { + "cell_type": "markdown", + "id": "56eda6d8-76c4-4862-b914-0c4598d67274", + "metadata": { + "id": "56eda6d8-76c4-4862-b914-0c4598d67274" + }, + "source": [ + "## Submission\n", + "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", + "- Use the Typeform link provided in the submission folder to confirm your submission.\n", + "\n", + "## Additional Resources\n", + "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", + "- The notebook from live session #3\n", + "\n", + "## Important Dates\n", + "- **Assignment Release:** 22.5.2024\n", + "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", + "\n", + "---\n", + "\n", + "Happy coding and good luck!" + ] + }, + { + "cell_type": "markdown", + "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", + "metadata": { + "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b" + }, + "source": [ + "### Part 1" + ] + }, + { + "cell_type": "markdown", + "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", + "metadata": { + "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2" + }, + "source": [ + "Given the following Hamiltonian:" + ] + }, + { + "cell_type": "markdown", + "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", + "metadata": { + "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4" + }, + "source": [ + "$$\n", + "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", + "metadata": { + "id": "736d275c-9a5a-4c08-b891-3078430dc6c1" + }, + "source": [ + "Complete the following code" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "imjx_MjrLbGs", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, - { - "cell_type": "code", - "execution_count": 16, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": { - "id": "112a1590-283c-4f79-8035-72936561102d" - }, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value" - ] + "id": "imjx_MjrLbGs", + "outputId": "41671177-4fd4-4eef-d299-b5edab53a274" + }, + "outputs": [], + "source": [ + "# !pip install -U -q classiq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "UjUn859jLcaS", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, - { - "cell_type": "code", - "execution_count": 17, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "outputId": "32d0ab57-094e-495d-fe1e-6be7c916b9d8" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Optimal energy: -1.8593486328125\n", - "Optimal parameters: {'angles_0': -3.344661707239267, 'angles_1': 2.9341114783374493, 'angles_2': -2.868211044897404}\n", - "Eigenstate: {'11': (0.10126157341262282+0j), '10': (0.11481983169296148+0j), '01': (0.9882117688026185+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] + "id": "UjUn859jLcaS", + "outputId": "1d9eb96e-fefe-42c3-c71d-cd24bfb5d4cb" + }, + "outputs": [], + "source": [ + "# import classiq\n", + "# classiq.authenticate()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", + "metadata": { + "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8" + }, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from classiq import *\n", + "\n", + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [\n", + " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", + " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", + " PauliTerm([Pauli.X, Pauli.X], 0.1809),\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0bb68899-2076-45c0-8868-131f38aa3b78", + "metadata": { + "id": "0bb68899-2076-45c0-8868-131f38aa3b78" + }, + "outputs": [], + "source": [ + "@qfunc\n", + "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", + " # Create an ansatz which allows each qubit to have arbitrary rotation\n", + " allocate(2, q)\n", + " U(angles[0], angles[1], angles[2], 0, q[0])\n", + " U(angles[0], angles[1], angles[2], 0, q[1])\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " res = vqe(\n", + " HAMILTONIAN,\n", + " False,\n", + " [],\n", + " optimizer=Optimizer.COBYLA,\n", + " max_iteration=1000,\n", + " tolerance=0.001,\n", + " step_size=0,\n", + " skip_compute_variance=False,\n", + " alpha_cvar=1.0,\n", + " )\n", + " save({\"result\": res})\n", + "\n", + "\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", + "metadata": { + "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382" + }, + "outputs": [], + "source": [ + "execution = execute(qprog)\n", + "res = execution.result()\n", + "# execution.open_in_ide()\n", + "\n", + "vqe_result = res[0].value" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", + "outputId": "695489b1-dcff-431b-8f8a-b90daaa26ff5", + "scrolled": true + }, + "outputs": [ { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": { - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8" - }, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal energy: -1.0636766601562502\n", + "Optimal parameters: {'angles_0': -3.0998518759918956, 'angles_1': -4.166656695234214, 'angles_2': -3.433961156376651}\n", + "Eigenstate: {'01': (0.03125+0j), '10': (0.03125+0j), '11': (0.9990229601966113+0j)}\n" + ] } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.16" - }, + ], + "source": [ + "print(f\"Optimal energy: {vqe_result.energy}\")\n", + "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", + "print(f\"Eigenstate: {vqe_result.eigenstate}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", + "metadata": { + "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa" + }, + "source": [ + "Does it similar to the `optimal energy` we calculated in class? \\\n", + "Does it similar to the `total energy` we calculated in class?" + ] + }, + { + "cell_type": "markdown", + "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", + "metadata": { + "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f" + }, + "source": [ + "### Part 2" + ] + }, + { + "cell_type": "markdown", + "id": "66882248-de08-4a6e-b33c-647f015f7d79", + "metadata": { + "id": "66882248-de08-4a6e-b33c-647f015f7d79" + }, + "source": [ + "**Now, we want to have a more interesting ansatz in our `main`.** \n", + "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", + "Which gate should you use?" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", + "metadata": { + "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145" + }, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from classiq import *\n", + "\n", + "\n", + "@qfunc\n", + "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", + " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", + " allocate(2, q)\n", + " U(angles[0], angles[1], angles[2], 0, q[0])\n", + " U(angles[0], angles[1], angles[2], 0, q[1])\n", + " CX(q[0], q[1])\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " res = vqe(\n", + " HAMILTONIAN, # TODO: complete the missing argument\n", + " False,\n", + " [],\n", + " optimizer=Optimizer.COBYLA,\n", + " max_iteration=1000,\n", + " tolerance=0.001,\n", + " step_size=0,\n", + " skip_compute_variance=False,\n", + " alpha_cvar=1.0,\n", + " )\n", + " save({\"result\": res})\n", + "\n", + "\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "112a1590-283c-4f79-8035-72936561102d", + "metadata": { + "id": "112a1590-283c-4f79-8035-72936561102d" + }, + "outputs": [], + "source": [ + "execution = execute(qprog)\n", + "res = execution.result()\n", + "# execution.open_in_ide()\n", + "vqe_result = res[0].value" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", + "metadata": { "colab": { - "provenance": [] + "base_uri": "https://localhost:8080/" + }, + "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", + "outputId": "32d0ab57-094e-495d-fe1e-6be7c916b9d8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal energy: -1.83778330078125\n", + "Optimal parameters: {'angles_0': 3.1609114395373816, 'angles_1': 1.6474535058684903, 'angles_2': -6.267889810614212}\n", + "Eigenstate: {'01': (1+0j)}\n" + ] } + ], + "source": [ + "print(f\"Optimal energy: {vqe_result.energy}\")\n", + "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", + "print(f\"Eigenstate: {vqe_result.eigenstate}\")" + ] + }, + { + "cell_type": "markdown", + "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", + "metadata": { + "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8" + }, + "source": [ + "Does it similar to the `optimal energy` we calculated in class? \\\n", + "Does it similar to the `total energy` we calculated in class? \\\n", + "What can we learn about the provided form this result Hamiltonian?" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/community/QClass_2024/Submissions/HW3/Samyak_Jain_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Samyak_Jain_HW3_VQE.ipynb index 43f2a6cf..15bc864b 100644 --- a/community/QClass_2024/Submissions/HW3/Samyak_Jain_HW3_VQE.ipynb +++ b/community/QClass_2024/Submissions/HW3/Samyak_Jain_HW3_VQE.ipynb @@ -76,13 +76,20 @@ "outputs": [], "source": [ "from typing import List\n", + "\n", "from classiq import *\n", "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [ PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X], 0.1809)]) #TODO: Complete Hamiltonian" + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [\n", + " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", + " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", + " PauliTerm([Pauli.X, Pauli.X], 0.1809),\n", + " ],\n", + ") # TODO: Complete Hamiltonian" ] }, { @@ -99,10 +106,12 @@ " allocate(2, q)\n", " U(angles[0], angles[1], angles[2], 0, q[0])\n", " U(angles[0], angles[1], angles[2], 0, q[1])\n", + "\n", + "\n", "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", + " HAMILTONIAN, # TODO: complete the missing argument\n", " False,\n", " [],\n", " optimizer=Optimizer.COBYLA,\n", @@ -114,7 +123,10 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod =create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # TODO: complete the line, use classical_execution_function\n", "qprog = synthesize(qmod)\n", "# show(qprog)" ] @@ -129,7 +141,7 @@ "execution = execute(qprog)\n", "res = execution.result()\n", "# execution.open_in_ide()\n", - "vqe_result =res[0].value #TODO: complete the line" + "vqe_result = res[0].value # TODO: complete the line" ] }, { @@ -202,7 +214,7 @@ "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", + " HAMILTONIAN, # TODO: complete the missing argument\n", " False,\n", " [],\n", " optimizer=Optimizer.COBYLA,\n", @@ -214,7 +226,10 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod =create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # TODO: complete the line, use classical_execution_function\n", "qprog = synthesize(qmod)\n", "# show(qprog)" ] @@ -229,7 +244,7 @@ "execution = execute(qprog)\n", "res = execution.result()\n", "# execution.open_in_ide()\n", - "vqe_result =res[0].value #TODO: complete the line" + "vqe_result = res[0].value # TODO: complete the line" ] }, { diff --git a/community/QClass_2024/Submissions/HW3/Razeen_Ud_Din_HW3_QClass2024.ipynb b/community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.ipynb similarity index 59% rename from community/QClass_2024/Submissions/HW3/Razeen_Ud_Din_HW3_QClass2024.ipynb rename to community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.ipynb index fb58bad5..274c8e70 100644 --- a/community/QClass_2024/Submissions/HW3/Razeen_Ud_Din_HW3_QClass2024.ipynb +++ b/community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.ipynb @@ -3,7 +3,9 @@ { "cell_type": "markdown", "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, + "metadata": { + "id": "fc72d98f-8993-4bd4-a545-23d122f3df71" + }, "source": [ "# H₂ Molecule Homework Assignment\n", "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", @@ -15,7 +17,9 @@ { "cell_type": "markdown", "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, + "metadata": { + "id": "56eda6d8-76c4-4862-b914-0c4598d67274" + }, "source": [ "## Submission\n", "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", @@ -37,7 +41,9 @@ { "cell_type": "markdown", "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, + "metadata": { + "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b" + }, "source": [ "### Part 1" ] @@ -45,7 +51,9 @@ { "cell_type": "markdown", "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, + "metadata": { + "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2" + }, "source": [ "Given the following Hamiltonian:" ] @@ -53,7 +61,9 @@ { "cell_type": "markdown", "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, + "metadata": { + "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4" + }, "source": [ "$$\n", "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", @@ -63,7 +73,9 @@ { "cell_type": "markdown", "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, + "metadata": { + "id": "736d275c-9a5a-4c08-b891-3078430dc6c1" + }, "source": [ "Complete the following code" ] @@ -71,42 +83,86 @@ { "cell_type": "code", "execution_count": 1, + "id": "DQOxbZxjrN5r", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DQOxbZxjrN5r", + "outputId": "7ffed65a-717f-4f7a-d969-d999a1fa6611" + }, + "outputs": [], + "source": [ + "# !pip install classiq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "o13wIglSeo7y", + "metadata": { + "id": "o13wIglSeo7y" + }, + "outputs": [], + "source": [ + "# import classiq\n", + "# classiq.authenticate()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, + "metadata": { + "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8" + }, "outputs": [], "source": [ - "from typing import List\n", + "from typing import List, cast\n", + "\n", "from classiq import *\n", + "from classiq import Pauli, PauliTerm\n", "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [ \n", - " PauliTerm([Pauli.I,Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I,Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z,Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z,Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X,Pauli.X], 0.1809)]) " + "# TODO: Complete Hamiltonian\n", + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [\n", + " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", + " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", + " PauliTerm([Pauli.X, Pauli.X], 0.1809),\n", + " ],\n", + ")" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, + "metadata": { + "id": "0bb68899-2076-45c0-8868-131f38aa3b78" + }, "outputs": [], "source": [ "@qfunc\n", "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", + " # TODO: Create an ansatz which allows each qubit to have\n", + " # arbitrary rotation\n", + "\n", " allocate(2, q)\n", " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1]) \n", - " \n", + " U(angles[0], angles[1], angles[2], 0, q[1])\n", + " # CX(q[0], q[1])\n", "\n", "\n", "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", - " HAMILTONIAN, \n", - " False,\n", - " [],\n", + " hamiltonian=HAMILTONIAN,\n", + " maximize=False,\n", + " initial_point=[],\n", " optimizer=Optimizer.COBYLA,\n", " max_iteration=1000,\n", " tolerance=0.001,\n", @@ -116,46 +172,39 @@ " )\n", " save({\"result\": res})\n", "\n", + "\n", "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "31d195f5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/782787a6-d49c-46b9-a6bd-de2396f089cc?version=0.42.0\n" - ] - } - ], - "source": [ - "show(qprog)" + "# TODO: complete the line, use classical_execution_function\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382", - "metadata": {}, + "metadata": { + "id": "0563c1a8-7aec-4da9-9105-6b16c5c24382" + }, "outputs": [], "source": [ "execution = execute(qprog)\n", "res = execution.result()\n", - "execution.open_in_ide()\n", - "vqe_result = res[0].value" + "# execution.open_in_ide()\n", + "vqe_result = res[0].value\n", + "# TODO: complete the line" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", + "outputId": "67a7bccc-f67c-4dfc-aad2-7011fc51905c", "scrolled": true }, "outputs": [ @@ -163,9 +212,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Optimal energy: -1.07299384765625\n", - "Optimal parameters: {'angles_0': 2.7671730204901652, 'angles_1': -4.637402240588757, 'angles_2': 0.44346041595166863}\n", - "Eigenstate: {'01': (0.19640320453088336+0j), '00': (0.03125+0j), '10': (0.20009763241977652+0j), '11': (0.959380089563047+0j)}\n" + "Optimal energy: -1.0754688476562502\n", + "Optimal parameters: {'angles_0': 0.7985412460405645, 'angles_1': 4.821416635411074, 'angles_2': -2.4351340720501597}\n", + "Eigenstate: {'11': (0.14986973510352247+0j), '10': (0.33874192794810626+0j), '00': (0.8600849340326803+0j), '01': (0.350780380010057+0j)}\n" ] } ], @@ -175,10 +224,27 @@ "print(f\"Eigenstate: {vqe_result.eigenstate}\")" ] }, + { + "cell_type": "markdown", + "id": "Yy49RbSEytVl", + "metadata": { + "id": "Yy49RbSEytVl" + }, + "source": [ + "Optimal energy: -1.0711231445312501\n", + "Optimal parameters:\n", + "{'angles_0': -3.0914206855935538, 'angles_1': -0.23729943557563232, 'angles_2': -2.5756826635214636}\n", + "Eigenstate:\n", + "{'01': (0.02209708691207961+0j),\n", + "'11': (0.9997558295653994+0j)}" + ] + }, { "cell_type": "markdown", "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, + "metadata": { + "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa" + }, "source": [ "Does it similar to the `optimal energy` we calculated in class? \\\n", "Does it similar to the `total energy` we calculated in class?" @@ -187,7 +253,9 @@ { "cell_type": "markdown", "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, + "metadata": { + "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f" + }, "source": [ "### Part 2" ] @@ -195,42 +263,42 @@ { "cell_type": "markdown", "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, + "metadata": { + "id": "66882248-de08-4a6e-b33c-647f015f7d79" + }, "source": [ "**Now, we want to have a more interesting ansatz in our `main`.** \n", "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", "Which gate should you use?" ] }, - { - "cell_type": "markdown", - "id": "0437ee4d", - "metadata": {}, - "source": [ - "### Solution 1" - ] - }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145", - "metadata": {}, + "metadata": { + "id": "bb39be9e-4994-44e5-84d8-c99bc8b77145" + }, "outputs": [], "source": [ "@qfunc\n", "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", + " # TODO: Create an ansatz which allows each qubit to have\n", + " # arbitrary rotation\n", + "\n", " allocate(2, q)\n", " U(angles[0], angles[1], angles[2], 0, q[0])\n", " U(angles[0], angles[1], angles[2], 0, q[1])\n", - " H(q[0])\n", - " CX(q[0],q[1])\n", - "\n", + " CX(q[0], q[1])\n", + " # H(q[0])\n", + " # X(q[1])\n", + " # CX(q[0], q[1])\n", "\n", "\n", "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", - " HAMILTONIAN, \n", + " HAMILTONIAN, # TODO: complete the missing argument\n", " False,\n", " [],\n", " optimizer=Optimizer.COBYLA,\n", @@ -242,39 +310,27 @@ " )\n", " save({\"result\": res})\n", "\n", + "\n", "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "fca45f9a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/0e5f9032-45e2-4bf2-a5eb-51c168aeb53c?version=0.42.0\n" - ] - } - ], - "source": [ - "show(qprog)" + "# TODO: complete the line, use classical_execution_function\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" ] }, { "cell_type": "code", "execution_count": 8, "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, + "metadata": { + "id": "112a1590-283c-4f79-8035-72936561102d" + }, "outputs": [], "source": [ "execution = execute(qprog)\n", "res = execution.result()\n", - "execution.open_in_ide()\n", - "vqe_result = res[0].value" + "# execution.open_in_ide()\n", + "vqe_result = res[0].value\n", + "# TODO: complete the line" ] }, { @@ -282,18 +338,20 @@ "execution_count": 9, "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", "metadata": { - "jupyter": { - "outputs_hidden": true - } + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", + "outputId": "dcaccb41-a8ff-4e1d-eb1e-8f110ed93820" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Optimal energy: -1.65881845703125\n", - "Optimal parameters: {'angles_0': -2.182793283451631, 'angles_1': -6.251915442399786, 'angles_2': 4.115336690961199}\n", - "Eigenstate: {'00': (0.13258252147247765+0j), '10': (0.2872621298570349+0j), '11': (0.42676563386711447+0j), '01': (0.8472151069828724+0j)}\n" + "Optimal energy: -1.8512822265625002\n", + "Optimal parameters: {'angles_0': -2.953247896519252, 'angles_1': 6.104234752928836, 'angles_2': 4.463845345952442}\n", + "Eigenstate: {'10': (0.08838834764831845+0j), '11': (0.0855816496101822+0j), '01': (0.992402781762526+0j)}\n" ] } ], @@ -305,106 +363,41 @@ }, { "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, + "id": "-7V3qnVRzFmJ", + "metadata": { + "id": "-7V3qnVRzFmJ" + }, "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" + "Optimal energy: -1.8452896484374999\n", + "Optimal parameters:\n", + "{'angles_0': -2.9812026284028255, 'angles_1': 0.8040137892002661, 'angles_2': 5.77426479151465}\n", + "\n", + "Eigenstate:\n", + "{'11': (0.08267972847076846+0j),\n", + "'10': (0.07967217989988726+0j),\n", + "'01': (0.9933863328282708+0j)}\n" ] }, { "cell_type": "markdown", - "id": "c1dd1833", - "metadata": {}, - "source": [ - "### Solution 2" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "ca9c23eb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.2444000000000002\n", - "Optimal parameters: {'angles_0': -0.03187332262996506, 'angles_1': -2.1542451838198264, 'angles_2': 3.7340992609226835}\n", - "Eigenstate: {'11': (0.722138750518209+0j), '00': (0.691748238161833+0j)}\n" - ] - } - ], + "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", + "metadata": { + "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8" + }, "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " allocate(2, q)\n", - " H(q[0])\n", - " CX(q[0],q[1])\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - "\n", - "\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, \n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", + "Does it similar to the `optimal energy` we calculated in class? \\\n", + "Does it similar to the `total energy` we calculated in class? \\\n", + "What can we learn about the provided form this result Hamiltonian?\n", "\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "886f51fa", - "metadata": {}, - "outputs": [], - "source": [ - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9d1ecad7", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "execution.open_in_ide()\n", - "vqe_result = res[0].value" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "48665eff", - "metadata": {}, - "outputs": [], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" + "With entanglement one gets better results." ] } ], "metadata": { + "colab": { + "include_colab_link": true, + "provenance": [] + }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", @@ -420,7 +413,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.11.9" } }, "nbformat": 4, diff --git a/community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.pdf b/community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.pdf deleted file mode 100644 index 2d668382..00000000 Binary files a/community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.pdf and /dev/null differ diff --git a/community/QClass_2024/Submissions/HW3/Yue(Leslie)_HW3_VQE.ipynb b/community/QClass_2024/Submissions/HW3/Yue(Leslie)_HW3_VQE.ipynb deleted file mode 100644 index 91eb5f43..00000000 --- a/community/QClass_2024/Submissions/HW3/Yue(Leslie)_HW3_VQE.ipynb +++ /dev/null @@ -1,417 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "fc72d98f-8993-4bd4-a545-23d122f3df71", - "metadata": {}, - "source": [ - "# H₂ Molecule Homework Assignment\n", - "### Quantum Software Development Journey: From Theory to Application with Classiq - Part 3\n", - "\n", - "- Similarly to what we have done in class, in this exercise we will implement the VQE on H2 molecule.\n", - "- This time instead of using the built-in methods and functions (such as `Molecule` and `MoleculeProblem`) to difne and solve the problem, you will be provided with a two qubits Hamiltonian." - ] - }, - { - "cell_type": "markdown", - "id": "56eda6d8-76c4-4862-b914-0c4598d67274", - "metadata": {}, - "source": [ - "## Submission\n", - "- Submit the completed Jupyter notebook and report via GitHub. Ensure all files are correctly named and organized.\n", - "- Use the Typeform link provided in the submission folder to confirm your submission.\n", - "\n", - "## Additional Resources\n", - "- [Classiq Documentation](https://docs.classiq.io/latest/)\n", - "- The notebook from live session #3\n", - "\n", - "## Important Dates\n", - "- **Assignment Release:** 22.5.2024\n", - "- **Submission Deadline:** 3.6.2024 (7 A.M GMT+3)\n", - "\n", - "---\n", - "\n", - "Happy coding and good luck!" - ] - }, - { - "cell_type": "markdown", - "id": "d41e969d-f6a7-4ff7-9660-19ce6c97ba6b", - "metadata": {}, - "source": [ - "### Part 1" - ] - }, - { - "cell_type": "markdown", - "id": "f710d6f4-d40b-42d5-b524-c6acb8059fe2", - "metadata": {}, - "source": [ - "Given the following Hamiltonian:" - ] - }, - { - "cell_type": "markdown", - "id": "6ba8a6f1-3259-4492-a1ca-3abde7530cd4", - "metadata": {}, - "source": [ - "$$\n", - "\\hat{H} = -1.0523 \\cdot (I \\otimes I) + 0.3979 \\cdot (I \\otimes Z) - 0.3979 \\cdot (Z \\otimes I) - 0.0112 \\cdot (Z \\otimes Z) + 0.1809 \\cdot (X \\otimes X)\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "736d275c-9a5a-4c08-b891-3078430dc6c1", - "metadata": {}, - "source": [ - "Complete the following code" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "19266c11-6acc-4edb-910f-2d0dfe80a6c8", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [ \n", - " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X], 0.1809)])" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "0bb68899-2076-45c0-8868-131f38aa3b78", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1]) \n", - " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "9b7d8b7e-9fc6-439a-b5b9-72814b6e388f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/9efa2f60-600d-4c2f-babb-82784b4f9a2b?version=0.41.2\n" - ] - } - ], - "source": [ - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "9a1a0eea-da21-41ee-a5dd-8d373e5a37a3", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "2d572b27-94a6-42aa-bd57-da65bfb37bad", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "3a7dbf73-5a29-4cdd-9ab2-19af167f873c", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[TaggedVQESolverResult(value_type=, name='result', value=VQESolverResult(energy=-1.0636216796875, time=0.52120041847229, solution=None, eigenstate={'01': (0.09631896879639025+0j), '10': (0.09631896879639025+0j), '00': (0.9906792177592099+0j)}, reduced_probabilities={'01': 0.00927734375, '10': 0.00927734375, '00': 0.9814453125}, optimized_circuit_sample_results=ExecutionDetails(vendor_format_result={}, counts={'01': 19, '10': 19, '00': 2010}, counts_lsb_right=True, parsed_states={'01': {'q': 1.0}, '10': {'q': 2.0}, '00': {'q': 0.0}}, histogram=None, output_qubits_map={'q': (0, 1)}, state_vector=None, parsed_state_vector_states=None, physical_qubits_map={'q': (0, 1)}, num_shots=2048), intermediate_results=[VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 839290, tzinfo=datetime.timezone.utc), iteration_number=1, parameters=[0.7523622954851401, 6.142877755751039, -1.2550017986926845], mean_all_solutions=-0.9595899414062501, solutions=[], standard_deviation=0.41369528009922096), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 852164, tzinfo=datetime.timezone.utc), iteration_number=2, parameters=[1.75236229548514, 6.142877755751039, -1.2550017986926845], mean_all_solutions=-0.8654404296875, solutions=[], standard_deviation=0.5571767911431977), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 869533, tzinfo=datetime.timezone.utc), iteration_number=3, parameters=[0.7523622954851401, 7.142877755751039, -1.2550017986926845], mean_all_solutions=-1.0056982421875, solutions=[], standard_deviation=0.42003596754330086), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 886719, tzinfo=datetime.timezone.utc), iteration_number=4, parameters=[0.7523622954851401, 7.142877755751039, -0.25500179869268447], mean_all_solutions=-1.0056982421875, solutions=[], standard_deviation=0.42003596754330086), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 905241, tzinfo=datetime.timezone.utc), iteration_number=5, parameters=[-0.14572206232409834, 7.582701000087178, -1.2550017986926845], mean_all_solutions=-1.0635908203125, solutions=[], standard_deviation=0.20179041877572876), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 923279, tzinfo=datetime.timezone.utc), iteration_number=6, parameters=[-0.8180855181726773, 8.32292217192662, -1.2550017986926845], mean_all_solutions=-1.02379228515625, solutions=[], standard_deviation=0.44388492215658343), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 940725, tzinfo=datetime.timezone.utc), iteration_number=7, parameters=[-0.46004638486959115, 7.193856274963747, -1.2550017986926845], mean_all_solutions=-1.04698359375, solutions=[], standard_deviation=0.3135429139733092), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 961204, tzinfo=datetime.timezone.utc), iteration_number=8, parameters=[-0.14572206232409834, 7.582701000087178, -1.5050017986926845], mean_all_solutions=-1.0635908203125, solutions=[], standard_deviation=0.20179041877572876), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 973754, tzinfo=datetime.timezone.utc), iteration_number=9, parameters=[0.3536937054702961, 7.558537165988767, -1.2550017986926845], mean_all_solutions=-1.05553759765625, solutions=[], standard_deviation=0.267698329129115), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 986321, tzinfo=datetime.timezone.utc), iteration_number=10, parameters=[-0.20685850037974207, 7.825110438727402, -1.2550017986926845], mean_all_solutions=-1.06360224609375, solutions=[], standard_deviation=0.22184087245712253), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 55, 998912, tzinfo=datetime.timezone.utc), iteration_number=11, parameters=[-0.32814582305280393, 7.79487163321527, -1.2550017986926845], mean_all_solutions=-1.05730498046875, solutions=[], standard_deviation=0.26055143022744964), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 15840, tzinfo=datetime.timezone.utc), iteration_number=12, parameters=[-0.20685850037974207, 7.825110438727402, -1.3175017986926845], mean_all_solutions=-1.06360224609375, solutions=[], standard_deviation=0.22184087245712253), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 33697, tzinfo=datetime.timezone.utc), iteration_number=13, parameters=[-0.08568156229643936, 7.855788601592141, -1.2550017986926845], mean_all_solutions=-1.06037685546875, solutions=[], standard_deviation=0.19004432572269353), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 53896, tzinfo=datetime.timezone.utc), iteration_number=14, parameters=[-0.26748783646929336, 7.809933693182319, -1.2550017986926845], mean_all_solutions=-1.0594783203125, solutions=[], standard_deviation=0.23935672770209793), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 71245, tzinfo=datetime.timezone.utc), iteration_number=15, parameters=[-0.21444687315228414, 7.855425106772178, -1.2550017986926845], mean_all_solutions=-1.0618494140625, solutions=[], standard_deviation=0.2231962091717916), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 94419, tzinfo=datetime.timezone.utc), iteration_number=16, parameters=[-0.15083470598200438, 7.797405124051695, -1.2550017986926845], mean_all_solutions=-1.06288662109375, solutions=[], standard_deviation=0.20404623306233025), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 111334, tzinfo=datetime.timezone.utc), iteration_number=17, parameters=[-0.19584067813562436, 7.854353730146069, -1.2550017986926845], mean_all_solutions=-1.0626921875000002, solutions=[], standard_deviation=0.21910613783662028), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 128088, tzinfo=datetime.timezone.utc), iteration_number=18, parameters=[-0.21827683580847798, 7.81444450037033, -1.2550017986926845], mean_all_solutions=-1.062158984375, solutions=[], standard_deviation=0.22587602387593633), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 148533, tzinfo=datetime.timezone.utc), iteration_number=19, parameters=[-0.20685850037974207, 7.825110438727402, -1.2628142986926845], mean_all_solutions=-1.06360224609375, solutions=[], standard_deviation=0.22184087245712253), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 165764, tzinfo=datetime.timezone.utc), iteration_number=20, parameters=[-0.1929194344266117, 7.818050476591932, -1.2550017986926845], mean_all_solutions=-1.0636216796875, solutions=[], standard_deviation=0.21841698149054273), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 187744, tzinfo=datetime.timezone.utc), iteration_number=21, parameters=[-0.1893012005709727, 7.824974603974924, -1.2550017986926845], mean_all_solutions=-1.062333984375, solutions=[], standard_deviation=0.21492844244558598), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 205045, tzinfo=datetime.timezone.utc), iteration_number=22, parameters=[-0.1929194344266117, 7.818050476591932, -1.2589080486926845], mean_all_solutions=-1.0636216796875, solutions=[], standard_deviation=0.21841698149054273), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 225705, tzinfo=datetime.timezone.utc), iteration_number=23, parameters=[-0.1963967345422016, 7.811054510600297, -1.2550017986926845], mean_all_solutions=-1.0630455078125, solutions=[], standard_deviation=0.21910756220152733), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 243564, tzinfo=datetime.timezone.utc), iteration_number=24, parameters=[-0.1910959437303572, 7.821504991137157, -1.2550017986926845], mean_all_solutions=-1.062312109375, solutions=[], standard_deviation=0.21633208368007564), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 265345, tzinfo=datetime.timezone.utc), iteration_number=25, parameters=[-0.19119217715399903, 7.817138731243804, -1.2550017986926845], mean_all_solutions=-1.0624887695312502, solutions=[], standard_deviation=0.21633258860153015), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 284737, tzinfo=datetime.timezone.utc), iteration_number=26, parameters=[-0.19682280819421086, 7.817900602334907, -1.2550017986926845], mean_all_solutions=-1.0632221679687501, solutions=[], standard_deviation=0.21910806072705727), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 305301, tzinfo=datetime.timezone.utc), iteration_number=27, parameters=[-0.1924104650166947, 7.816164834153558, -1.2550017986926845], mean_all_solutions=-1.0636216796875, solutions=[], standard_deviation=0.21841698149054273), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 326182, tzinfo=datetime.timezone.utc), iteration_number=28, parameters=[-0.19195398549816464, 7.818311068929809, -1.2550017986926845], mean_all_solutions=-1.0636216796875, solutions=[], standard_deviation=0.21841698149054273), VQEIntermediateData(utc_time=datetime.datetime(2024, 6, 2, 8, 18, 56, 342414, tzinfo=datetime.timezone.utc), iteration_number=29, parameters=[-0.1929194344266117, 7.818050476591932, -1.2555017986926844], mean_all_solutions=-1.0636216796875, solutions=[], standard_deviation=0.21841698149054273)], optimal_parameters={'angles_0': -0.1929194344266117, 'angles_1': 7.818050476591932, 'angles_2': -1.2550017986926845}, convergence_graph_str='/9j/4AAQSkZJRgABAQEAZABkAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAHgAoADASIAAhEBAxEB/8QAGwABAQADAQEBAAAAAAAAAAAAAAYCBAUDBwH/xABWEAABAwMBAgUQBwUDCgQHAAAAAQIDBAURBhIhExQxM3EVFiI3QVFVVmF1kZOVs9PUByMyUoGxwSRCU3KhYpLRFyU0REVUc4Ki8CZkstJjZYSUwuHx/8QAGAEBAQEBAQAAAAAAAAAAAAAAAAMEAQL/xAAyEQEAAQMABQwCAQUBAAAAAAAAAQIDERIhUWGhEzEyQVJxgZGx0eHwM8EjBCIkYvFC/9oADAMBAAIRAxEAPwD7+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnNU6krLFUWikt9rjuFVcqh0EbJKrgGt2WOeqq7Yd3Gr3DYtt1uyQ1dRqK2UNopoGbfDNuPDNwmdpXKrGI1EROUm/pFpqesvmjqeqqJaeB9xlR0sM7oXN+oeu57VRU9I1Da7bbPo61YlvuVXWLJbJlelTcZKrZxG7GNty7PKvJy7u8BYU17tNZWvoqW6UU9Wxu26CKoY6Rre+rUXON6CrvlooKyKjrLrQ01VLjg4ZqhjHvz3mquVIOttFvs9N9Hc9vo4aedLhDAssbER7mSU0u2iryrtKiKueVSepLfU3SbV1JX3LTFPPLcahlUy60avqGxqv1bkesrew2NnZVEwmO/kD7BWXe2W5+xXXGkpXcGsuJ52sXYRURXb15EVUTPlQ8pL/ZoVpElu9BGtY1H0qPqWIs7V5FZleyRfIQMNmpqjXejKa4TQ3ZKSwSvbUOajmTuRYmpJhcouUXKcvfMqFmnItXa1j1KygY9iwtjbVo1ESiSFuykaL+7nbzs93ygfQYLvbal1MkFxpJVqketOkczXcKjNzlbheyx3cch7JWUzq11GlRCtU2NJXQI9NtGKqojlby4VUVM+Q+RWWJ1J9DWl9R07XrNYp3Vi7uzdAsr2TN9W5y9LULHQWLrJedVu3pdqtW0q/8AlYcxx+lUe7/mAqa640VrplqbhWU9JTouFlqJWxtRelVRDzZeLZJbVuTLjSOoETK1STtWJE7+3nH9SN1HxD/KpY+r3AdTep0/EuM44Lje2zPLu2uD5M+XBr6v6icd0pniPW51WfxzgtjgOG4J3B8Jjd9vGc93GQLqnvFrrLfJcKa5Uc9FGjnPqYp2ujaiJlVVyLhMJymFNfbRWVvEqW60M9VsJJwEVQxz9lUyjtlFzjCouT5rcuI9WtfdQuB6ndba8c4tjguNbMuOTdtcHjOPJk95bRb7Vpn6O6mio4YKhLhRNWZjER7kkjckmXcq7WVz3wPpkFdSVUMk1PVQTRRucx745Ec1rmrhyKqcioqKip3DWmvtoprbFcZ7rQxUMqIsdTJUMbE9F5MOVcL6T5nqWrnsF01LpakcrJtTPhlt2P3XzqkNQv4Y2/8AmPXUNDLRfSNaLfBUWijoqeypDbuq1Os0W21+Hozs2okmwkflx+IH0xbrbm0MdctfSpSSq1sc6zN4N6uXDUR2cLlVwnfU1+uKx8SmrerNv4pBJwUs/GmcHG/d2LnZwi703L3z5Zd7FHS/R7c6N90t1fT1d/pXPjtrNiGnV8sW3G1Np2zy7WM/veUo9TUVooNc6QgrKajp7KiVWwx0bWQcZ2GJHtJ9nOyj9nP4AXFHdLfcVelFXU1SrGte5IJmv2WuyrVXC7kXC47+Dzor5aLlVS0tDdaGqqIucigqGPezpRFyh8iq+A4P6VutXY2eL0uOKfZzsP4XYx/z5x3c906tqtDKu5aarafUGk4oqWZr6Vtso1hlmYrFR0SKsq5RWrvTGcp5APokupLFDKkUt6t0cjpXQIx9UxFWRq4VmM/aRVTKcps19yoLVTcZuNbTUcGccLUStjbnvZcqIfLqCx2ur0l9JFVU0ME1RJcbkiyyMRzkRqKrURV5MLlUx3Vye9JNR1GsdKzajdC+mk02x9E6sVFjWqVWrKqbW7b2Nny4yB9IS7W11t6pJcKRaDG1xpJm8Fjkzt5x/UyoLlQ3WmSpt1bTVkCrjhaeVsjc97LVVD5xrxKZanSaWyezwWXj8/CyTwpLRtqNhdjbaxzUztbeMr9rGTr6NtD6PVN1rnXmyVElTTxNmo7VDwTWuartmRzdt29UVUzuzjyAXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABi/KMcqLhcAZAh9MW293nSloulRrK8smrKKGokbHDR7KOexHKiZgVcZXvnV62rr463z1NH8ACjBOdbV18db56mj+AOtq6+Ot89TR/AAowTnW1dfHW+epo/gDrauvjrfPU0fwAKME51tXXx1vnqaP4A62rr463z1NH8ACjBOdbV18db56mj+AOtq6+Ot89TR/AAowTnW1dfHW+epo/gDrauvjrfPU0fwAKME51tXXx1vnqaP4A62rr463z1NH8ACjBOdbV18db56mj+AOtq6+Ot89TR/AAowTnW1dfHW+epo/gDrauvjrfPU0fwAKME51tXXx1vnqaP4A62rr463z1NH8ADrXKzWu8xMiutto66NjtpjKqBsqNXvojkXCmtSaW09QQ1ENHYrZTxVLODnZDSRsSVn3XIidkm9dyml1tXXx1vnqaP4A62rr463z1NH8ADtyUNHM2nbJSwPbTPSSBHRoqRORFRHN+6qIqplO4qmtX2CzXSoZUXC0UFZNGmGSVFMyRzehVRVQ5vW1dfHW+epo/gDrauvjrfPU0fwAO2lDSJUxVKUsCVEUaxRy8Gm0xi4y1F5UTcm7yITOp7NfLjco57dbdM1CRxpwFTc4nOmpn5XLm4aqKnIqJlu82+tq6+Ot89TR/AHW1dfHW+epo/gAaE+lrrb/o/ptLWKoo1Vad1LUVdYrkVrXIu3I1rUXLlVVVEVUTfylPbLdT2i1UltpW7NPSwshjT+y1ERPyOP1tXXx1vnqaP4A62rr463z1NH8ADtV1uobpTLTXCjp6unVcrFURNkaq9CoqHm2z2xltW2st1I2gVMLSpA1IlTvbGMf0OT1tXXx1vnqaP4A62rr463z1NH8ADrU1ntdHbn2+lttHBRSI5r6aKBrY3IqYVFaiYXKcp6Pt9FJDTwvo6d0VM5r4GLE1WxObuarUx2Kp3Mchxetq6+Ot89TR/AHW1dfHW+epo/gAdqe3UNVWU9ZUUVPLVU21wE8kTXPizuXZcqZbnu4PyvtlBdabi9xoaasgzngqiJsjc9/DkVDjdbV18db56mj+AOtq6+Ot89TR/AA6rLJaY6FtDHbKJlI16SNp207UjRyKio5G4xlFRFz5DS1PQV1ytjKeiobRXZkRZae6tcsT24XkwjsLnHKi901+tq6+Ot89TR/AHW1dfHW+epo/gAeOjtM1Vjfcq64LRJW3B8e1DQMVkEEcbdlkbEXCrhMqq4TevIdem07ZKKudW0tnt8FW5VVZ4qVjZFzy9kiZOd1tXXx1vnqaP4A62rr463z1NH8ADtMt1DHBUQMoqdsNS57542xNRsrnfaVyY7JV7qrynnVWe2V1Aygq7bR1FHGiIynlga+NqImEw1UwmEOT1tXXx1vnqaP4A62rr463z1NH8ADrttVubbeprbfSpQY2eKpC3gscuNnGMfgflus9ss8bo7ZbqOiY9cubTQNjRelGohyetq6+Ot89TR/AHW1dfHW+epo/gAUYJzrauvjrfPU0fwB1tXXx1vnqaP4AFGCc62rr463z1NH8AdbV18db56mj+ABRgnOtq6+Ot89TR/AHW1dfHW+epo/gAUYJzrauvjrfPU0fwB1tXXx1vnqaP4AFGCc62rr463z1NH8AdbV18db56mj+ABRgnOtq6+Ot89TR/AHW1dfHW+epo/gAUYJzrauvjrfPU0fwB1tXXx1vnqaP4AFGCc62rr463z1NH8AdbV18db56mj+ABRgnOtq6+Ot89TR/AHW1dfHW+epo/gAUYJzrauvjrfPU0fwD8dpu7I1V69b5uT+DR/AApAcXR9bU3LRdjr6yVZaqpoIJpZFRE2nuYiquE3JvXuHaAAAAAAAAAAAAAAAAAAAAYv5t3QpkYv5t3QoE/oHtd6a8103umlETuge13przXTe6aUQAAAATGu7tUWbT7KilmWKV1RGzaTlxvVU9CFOepomKYq2vEVxNU07AAHl7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxfzbuhTIxfzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAAAAAAAAA07ky4yUattVRSwVO0mH1UDpWY7vYte1c/icbiWr5I5Y6q62Z8T4nt2ae3yxPyrVRuHLM5E347igbVv1dYrrceIUVekk7tvg8xPayXZXDuDeqI2THd2VXBvXW70NlpEqrhPwUSvSNuGue5715Gta1FVyr3kRVPnNmr6S50egbNQIqXO1SRuroEaqPo2x00kciSfdy5yNTP2s5OvrW6UdwtVrqKasWCmhvHBy3RrFXiD40ka5+FTH2kWPLkVvZ5XIFHDqq0VFsnuEEtRNDBJwUzI6OZ00b93YuiRnCIu9F3t5FzyHhT62sNRT3OZtRUxstcKT1iVFDPC6Jioqouy9iKu5qruReQ42hquFjtS1jq7qhRpVNl6svajeMokTdrOMNVGIiNyxEbu5M5VfOyUlFWaFu931AqwQahWSpqlcqosdO9EZE3PKmIkZ0KqgVVpv9Delk4m2tTg0RVWpoZ6dFReTCyMbtcncydF/Nu6FIfSdbC/VdTSWO7VV0sLaJHvllqHVDIajbwjWSuyq5blVblcYTkyUt3gvsytW03G30saMXhG1VE+dXL5FbKzHoUDS0D2u9Nea6b3TSiJ3QPa7015rpvdNKIAAAPn30sy4s1BB9+oV+P5Wqn/5F1RycNQ08n342u9KEN9IcfG7jRU/KkNFWTqnRHu/qhX6fk4XTlrk+9SRL/wBCGq5H8FHj94Mlqf8AIr8PvF0QAZWsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADF/Nu6FMjF/Nu6FAn9A9rvTXmum900oid0D2u9Nea6b3TSiAAAAAAAAAAAAAAAAAAAAYv5t3QpkYv5t3QoE/oHtd6a8103umlETuge13przXTe6aUQAAARN6j45rSsi5WxWKVP+ZzlT8lO1o6ThdH2t3egRvo3foc+3s43rzUa8qRU0EGf5m5Pb6P37eibfnlbwjV/CRxqu/jxsxxiWS1+XO3S4TEKYAGVrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxfzbuhTIxfzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAAAAAAAAAAAAAAAAGL+bd0KZGL+bd0KBP6B7XemvNdN7ppRE7oHtd6a8103umlEAAAEtpX6296mqfvV3BZ/kTH6jQPY6fmh/g1k0f/Vn9RoT6y1V9V/vNwnlz38qifoNF9h1eg/h3afHQuMGu5/7jZjhqZLXPRO3PHWqQAZGsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADF/Nu6FMjF/Nu6FAn9A9rvTXmum900oid0D2u9Nea6b3TSiAAAAAAAAAAADTuVbLQUazw26qr3o5E4Gl4Pb6ezc1MficbrluUscrW6VvNK5InubNUcWVjXI1VTOxM529URNyLylKAPllmoKS2UegbzQKq3O6yRtrp0eqvrGyU0kkiyfew5qOTP2cYKvWtrq7lT23gqF1yooKvhK23NkaxamPYciJ2So12HK12y5URdk3bfpGxWq48foqFI527fB5le5kW0uXcGxVVsee7soh6SaZtUludQcFPHA6ofUrwVVLG7hHuVznI9rkcmVcu5FxvA+aR1FUygvlnSkltdodfqClSmSZFWmhm4LhY9piqjc5TKNVUbwiobeoGppZ+rLdYVWhoepVLUOZAuy2mkklkje9icjFWNM7u63J9Cj01ZorHLZm2+LqfLlZYnZdtqq5VznKuVdnftKucpymNBpiz26jq6SCjR0VYmKnjEj5nTJjZw9z1Vzkxuwq4RAJ+3Wuh059IlLbrNA2mo6u1TS1NPGq7O3HJGjJFT7yo96KvKvdzgorvdKy3q1lNYrhcWvYqq+lfA1GeReEkavoRT8s+mbRYZJZLfSuZJK1rHSSTPldsN5Go57lVGplcNTd5DqP5t3QoE/oHtd6a8103umlETuge13przXTe6aUQA8qiVIKWWZeSNiu9CZPU5epJuA0xdJM4VKWTHTsqiHqmM1RDzVOKZlz9AxLFoq35+09HvVe/l7lPLS/1eodTw96sbJ/ebn9DqaZh4DS9qjxhUpY1XpVqKv5nLsv1WvdSx9yRtNIn9xUUvM6U3PvXDPEaMW/vVKpABmagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMX827oUyMX827oUCf0D2u9Nea6b3TSiJ3QPa7015rpvdNKIAAAAAAAAAAAAAAAAAAABi/m3dCmRi/m3dCgT+ge13przXTe6aURO6B7XemvNdN7ppRACc15NwOiriqcrmtYn4van6lGS2vPrLNR0v+818EWO/lc/oVsfkp70r/wCKruUlLDxekhh/hxtZ6EwTdJ9X9JdwZ/Ft8cnodgqSWl+q+k+nd/FtTmeiTJ21r0u6XLurR74VIAIrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYv5t3QpkYv5t3QoE/oHtd6a8103umlETuge13przXTe6aUQAAAAAAAAAAAADzqJ2U1NLPKuI4mK9y95ETKgegIi1apvj32CuulPQMtl+dsU8cCPSWmc6N0saPcqqj8taqLhG4VU5TsamvVXa32qkoEpm1Vyq+LMnqsrFFhjn5VEVFcq7GEblMqvKB3wSVqv93u8d4tsD7Wt5tdU2nlmRHrTua5rXo5Gou0i4VUVu1uVq7zXdqi901s1XFLDRVdzslOksUlNG9IpnujV7WKzaVyOTCZRHLucnJkC1MX827oUmdJX6ovElVHV3ShqZ4msctPDbpqOWLOd7myvcqouNyoiJuXlOpdtRWSyq2K63igoZJGq5jamoZGrk76I5UyBo6B7XemvNdN7ppRE7oHtd6a8103umlEAJbVn1t401TfeuCS4/kTP6lSS13+v+kDT0XchiqJlTpbhPyK2elndPojf6GN8esKklrp9X9Idgf/ABYKiP0NyVJLaj+r1ZpebvTzR/3mIgs9KY3T6SX+jE749YVIAJLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYv5t3QpkYv5t3QoE/oHtd6a8103umlETuge13przXTe6aUQAAAAAAAAAAAadytVvvNGtJc6KnrKZXI5Yp40e3Kci4U5cGhdK0knC0unrbTzbLmpLDTMY9qORWrhUTKblVPxKAARFq0tfGPsFDdKigfbLC7bp5IFestS5sboo1e1URGYa5VXCuyqJyHXuVFdbjY5aarttkuErqh37NUuekDodpdjKqxy7eNnPYqmc4KAAQ9HpW92TT12WydSaa93GVrkaxro6WlY1qMRrERq5VGoq5Vu9yqqpjcdDT9tvVnsVRRx26109Q3D4XJXyz8YkVVV75nrE1dpd29Edy9zCIVAAmrVaLvLqh9/vPEYZW0fE4aajkdI3ZV6Pc5z3NaqrlERE2d2/lyUUjUVjsoi7l5UMzF/Nu6FAn9A9rvTXmum900oid0D2u9Nea6b3TSiAEtz/wBJ/wDZp7V/1Ok/wKklrR9fr/UMvchip4kXpblfyK2uaqd3tCN3npjf7yqSW1h9XWacn+7dI2Z/mRf8CpJbXfY2q3zfwbjBJ/VU/UWPyQX/AMcqkAElgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMX827oUyMX827oUCf0D2u9Nea6b3TSiJ3QPa7015rpvdNKIAAAAAAAAAAAAAAAAAAABi/m3dCmRi/m3dCgT+ge13przXTe6aURO6B7XemvNdN7ppRACW0n9bd9S1X3rgsWf5Ex+pUktoP6yy1dT/vNfPLnv5XH6FaPx1T3feCNeu5THf8AeKpJf6QkVNG1UqcsUkT0/vtT9SoJ/W8fC6Mube9EjvQ5F/QWZxcp74dvxm1V3S76Kjmoqcipk/TWt0nDWykk+/Cx3pahsk5jE4UicxkABx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxfzbuhTIxfzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAAAAAAOVXaks9sucVur6+KkqZmI+JJ8sa/KqmEevYq7cvY5zybt6HVRUVMouUUAfiqjUVVVERN6qpqXKkqa2jWGluNRb5dpF4eBkbnInexI1zf6HHTTl2VkrZ9W3KqjfE9iwzU9M1rtpqomVZE127OdypyAflr1vb7rW0kDKSvghr9viNXPEjYqvZRVXYVHKqZaiuTaRuURVTJ0r1fKeyRU/CQ1FTUVUvA09NTNR0kr8K5UTKoiYa1VVVVERE5SJtUdwuFPoyyvtFdST2ORkldNNArIm8FA+JEY9d0m05yY2VXdnODvX99JdbXBXTU99o5qGuelPNSUivqInt241ejEa/ajcmeVqoqOTcB7S61oYLBXXSSjrmvoZ2U9RQqxiTske5iNbhXbO/hGrnawqLym43ULYbRW3O626ttNPSMV8nHFicqtRMqqcE9+e9jlz3CQstnjgtuorjfrfdLhRXWrhclPVU/C1MrI2tRJHxMRMZcmUajUw1G7u4aq2Crr7LquCxWuqorVPFTuoKKpY6DhJ43K6TYjdhY2uRI270RFVFUC2s+p4LtXyUElBX26sbClQ2Ctja10kSrjbbsucmEXCKiqiplMomTtP5t3QpIW6ae/65prvHbq+jo6K2y07nVtO6Bz5ZZI3bKNdvVGpGuVTdlUwqncu9rrLgrX019uFuaxiorKVkDkf5V4SNy+hUA0tA9rvTXmum900oid0D2u9Nea6b3TSiA8aubi9HPN/Djc/0Jk4Wg4eB0VbUXlc1z1/F7l/U3tTTcBpa6yZwqUsiJ0q1UT8z903DxfTNrixhUpY89OymSsarU75/XyjOu9G6PWfh1Dlamj4XS11Z/5SVU/BqqdU1LnHw1prI/vwPb6WqeKJxVEqVxmmYa2m5OF0xan91aSLPTsodQ4OipOF0ba3d6HZ9Cqn6HeO3IxXMb3m1OaKZ3AAPCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABi/m3dCmRi/m3dCgT+ge13przXTe6aURO6B7XemvNdN7ppRAAAAAAAAAResrrE2sbaKvUOnbTRTQI+XqgrJJ35c5OxjeqM2d32l2t+d241NH2ix0NXSs0lqtK2nhV611Ilcydj2K12FaxvYxqj9j7KNTCKmOQ2r3HVN1wtVRWykvMkdujY+kllSOSnR0kmJGK5qtVH4VqplF+rQ87HpCsp7nRXaemoaGZtfPUvp6ddrgYZIdhIUcjUyivxI7kTazgC5AAAAAAAAMX827oUyMX827oUCf0D2u9Nea6b3TSiJ3QPa7015rpvdNKICb19KsWirhj7T0YxE7+XtQoKeJIKaKFOSNiN9CYNO8WiC90KUlQ+RsaSNk+rVEVVauUTei7joFJqjQinfP6TimeUmrdH7D8c1Hsc1eRUwp+gmomPo9cq6LomL9qN0rF9Y7/EpyW0H2NmrIf4NfPH/AFz+pUlb/wCWrvR/p/xU9wACSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABi/m3dCmRi/m3dCgT+ge13przXTe6aURO6B7XemvNdN7ppRAAAAAAAAAfPda8QZqmimWq1BFW8FDBI61zsjjhiln4NjpNrly92ERMr2KrhMKpS6Y4KOG40bK25VclJWOhlfcJGvejthjsNVv7qtc1U7vZKTWv4KCW5wsiuFzp7s+KF74rfb3Viviim4SNz2I1dlEkRcLlM5cm/ud/RbIW2iokYlzdPNUukqZrlSup5ZpVa3LthUTDcI1qYTGG47gFGAAAAAAAAYv5t3QpkYv5t3QoE/oHtd6a8103umlETuge13przXTe6aUQAAAAABLaN+rqNRQfdusrkTyOx/gVJLaa+r1RqiHvVEUn95ir+hUlb/T8vRGx0PP1AASWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMX827oUyMX827oUCf0D2u9Nea6b3TSiJ3QPa7015rpvdNKIAAAAAAAACDuL6yv1DSXiy32K2rVSyWZYp7bw/CywPnVVVeEbhqbEmOlc8uEoNNVVbM25Utxr462qoazgHyxUnF274o5ERG7b87pE35TlxjdleHNoS68aZJS6pkp4YbjPcaeHiMb+CklWRXJlVy5PrnpvO9p2yVFljr3VdxdcKmuquMyzLC2LfwccaIjW7uSNAN65VstBRrPDbqqvejkTgaXg9vp7NzUx+JxuuW5SxytbpW80rkie5s1RxZWNcjVVM7Eznb1RE3IvKUoA+WWagpLZR6BvNAqrc7rJG2unR6q+sbJTSSSLJ97Dmo5M/Zxgq9a2uruVPbeCoXXKigq+Erbc2RrFqY9hyInZKjXYcrXbLlRF2Tdt+kbFarjx+ioUjnbt8HmV7mRbS5dwbFVWx57uyiHpJpm1SW51BwU8cDqh9SvBVUsbuEe5XOcj2uRyZVy7kXG8CT0bRQXOTVFkuFlijs8FbEtPbanYmZBmJj1ZhFc1N+HbKKqNV+ENTTulKG8aZ1dUWmlpLdDf+FpKPgYUYxsDGrEx+y37ztt/lRyF9RWO3W61PttHTJDSyI7ba17tpyu+05X52lcv3s58p+pZbeljZZmU+xb44mwsiY9zdljURERHIu0mMJvzkCV0nRx6c1NPYH2qy0881ElWyqtdLwHCMa/YVsjVVVyiuRUXKouV3JgpLvPfYValpt1vqo1YvCOqq18CtXyI2J+fSgtOnLXZJZpqKnek8yI2SeaeSaRyJyIr5HOdhMruzg6b+bd0KBP6B7XemvNdN7ppRE7oHtd6a8103umlEAAAAAAS1p+r+kHULP4sNPJ6G4KkloPq/pOq2/wAW2Nk9EmCpK3ueJ3R6I2eaY3z6gAJLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGL+bd0KZGL+bd0KBP6B7XemvNdN7ppRE7oHtd6a8103umlEAAAAAAAAAAAAAAAAAAAAxfzbuhTIxfzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAACWqfq/pNon/wAW2vj9D8lSS14+q1/px/8AFjqY/QzJUlbvNTO79yja56o3/qAAElgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADF/Nu6FMjF/Nu6FAn9A9rvTXmum900oid0D2u9Nea6b3TSiAAAAAAAAAAAADVuFzoLTSrVXKupqOnRUastTK2NmV5Ey5UTJoUWrdNXKrjpKHUNpqqmTKMhgrY3vdhMrhqOyu5FUDsglNN1N2Zq2/wBruV1fcIqaGllhV0EcewsnC7SJsomU7BvKqmzqq411M60W22zpTVV0rUp+MKxHrCxI3yPciLuV2GYTKKm/OFwBRA+e1GpL1bYbrZXVjKm5Q3GkoqWvlhanYVOzh72Nw1XMy/kREXDd3Kftx1JedLJf6GprEuk9NQwVdDUTxNY7MsjotmRGIiKiPai7kTcuO5kD6CYv5t3QpK2ypu9q1dDZLndXXOKsoJKqKaSBkT45I3sa9uGIibKpIipnKphd6nYu2orJZVbFdbxQUMkjVcxtTUMjVyd9EcqZA0dA9rvTXmum900oid0D2u9Nea6b3TSiAAAAAAJbU31epdMTd6qkj/vNx+hUktrP6uXT8/3LtCi9C5z+RUla+hT4+qNHTr8PQABJYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxfzbuhTIxfzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAAAAAAAAxcxr27L2o5O8qZMWwQscjmxMaqcio1EPQASls03faLVVZeai+0U8dY2OOenZbXMVWR7ewjXcMuF7Ncrhc45ENq5adrbnRx8Ld8V9LXuraGqSmbiFMuRsbmZ7NEY9WKuUVeXcpQgCSXRK1FsuDa25vlutbVRVjq+KFGJFLFs8FsMVVw1uwm5VXOXZXefvWUtfT3hb5cVray6U7KZ80EPANhjZtKxI27TsKjnK7KquV8iYKwAT1p09W096W73e7NuNaym4rCsdMkDI41cjnLs7TsucrW5XKJ2KYRDvSNRWOyiLuXlQzMX827oUCf0D2u9Nea6b3TSiJ3QPa7015rpvdNKIAAAAAAltfKkdipp1XCQVsMiqvcwuP1Oz1fs3hag/8AuWf4m1VUlPXU7qergjnhdjaZI1HIuN/Ic3rU0/4GovUoWiqiaIpqzqRmmuK5qpxrbDb7aHORrbrQq5VwiJUMyv8AU6BH6q0taI9LXGWktlNDPHCsjZI40RybO9d/QilLbKnjtpo6rOeGgZJ6WopyumnRiql2iurSmmptgAkqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGL+bd0KZGL+bd0KBP6B7XemvNdN7ppRE7oHtd6a8103umlEAAAAAAAAAAAAAAAAAAAAxfzbuhTIxfzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAAAAAPGsp0q6KemdySxujX8UwcLQlQs+jqBH/biR0Tk72y5U/LBRkto39nmvtv/AN3uMjmp3mPwqfkpWnXbqjulGrVdpnvj9qkAElgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxfzbuhTIxfzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAAAAAAAAA07lborrRrTTTVUTFcjtqlqZIH7v7TFRceTJz6DStFb62OqirrzI+PKoyou1TMxcpjex71avL3UA8rDqGuud7utruFqZQTULIJE2apJuEbLt4zhqI1U2O+vKbWoL4tlp6VIaRautrahtNS06PRiPeqK5cuwuy1GtcqrheTkODZnXtuvbtXVOmq2noq+KnhbO+op3IzguFy5yNkV2F20xhFXv4Nm+Ut4uLbdc4LXs1louj5Y6VahirUwbMkW013I1XNftojlTGMKqAbFFqS411LcIY7K1LzQTthmolq04Psmo5r0l2d7Faufs53KmDWk1nUUlq1HNX2lsNfY6bjMtPHU8JHK1WOc3Zk2UXfsqi5blO8pqRxaloabUV/pbIj7vcpYkpbc6ojzExjEYjnu2kaq52nK1HcmEz3TY09TVdDZLhw2nbhJXyqktQ6umplfcJHbnY2JHNaiIiIjVwiJhE7oHR0xf6m/wyzyMtPAtwjX2658b3ryo76tmyqbu+d1/Nu6FJOyW6vn1lUX2az9R6daFKVYHyRuknft7SPckaq1EamUTeq9kvIdm72CjvCtkqZrgx0bFREpbhPTovSkb2ov4gaWge13przXTe6aURO6B7XemvNdN7ppRAAAAAAAAACWt37J9It4g5ErKSGpRP5ewX8ypJa6/sv0g2Kp5G1UE1M5ehNpP6qVta9KNsT7/pG9q0atkxx1ftUgAks1bhcKW1UUlZWypFTx42nqirjK4Tcm/lU2Wua9iPaqOa5MoqcioSeuI+qTrPY0crePVeZNnl4NiZd+aeg2dFVkr7O+21S/tdslWlk8qJ9lejG78C02v4or6/1/1GLv8s0dX7/4pAARWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMX827oUyMX827oUCf0D2u9Nea6b3TSiJ3QPa7015rpvdNKIAAAAAAAAAAAAAAAAAAABi/m3dCmRi/m3dCgT+ge13przXTe6aURO6B7XemvNdN7ppRAAAAAAAAACW1r+zss1wT/VbjErl/sOyi/oVJPa4plqtG3FqfaZGkqL3tlyO/JFK2ZxchK/Gbc4UINe31KVltpapOSaFknpRF/U2CcxicKROYylW/wCcPpKevLHbKJG9Eki5/wDSY1v+Y9eUtanY0t3ZxabvJM37C/im70mWi/2tbxd138drXcGvfjZub+p0NVWp1309UwRZSpjRJoFTlSRu9MdPJ+JpmYpuaE82MffFlimarenHPnP3wdoHNsF1berFSV7cbUrOzRO49Nzk9KKdIzVRNM4lqpqiqImAAHHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxfzbuhTIxfzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAAAAAAAAAAADSobvbLnJPHQXGkq5KdUSZtPO2RY1XONpEXdnC8veU96qqp6Gmkqauoip6eNMvllejGtTvqq7kA9gaC3u0paluq3Si6momVq+MM4FN+Pt5xy7uXlFuvdpvEMk1sulFWxRLiR9NUMkaxeXCq1VwBvmL+bd0Katvu9tuzJH2240la2N2y91NM2RGr3l2VXCm0/m3dCgT+ge13przXTe6aURO6B7XemvNdN7ppRAAAAAAAAADXr6ZKy3VVKvJNE+P0oqfqbAOxOJy5MZjCe0PUrU6Ntzl+1GxYlTvbLlb+SIb2oq7qbp24VaLh0cDthf7Sphv9VQ5Oiv2dL1b1/wBVuMuyneY7Cp+p+a4/aqS22hvLcK2ON6f2EXacv4YQ0TTE38dWc+HOzxVMf0+evGPHmdPS1D1N0vbqVUw5sDXOTvOd2S/1VTrjGEwgIVVTVMzPWvTTFNMUx1JOxf5l1Zc7I7saeq/bqRO5v3Pan49zvIVhL6zhkpoaK/UzFdPbJke9G8ronbnp6P1KSnniqqeOogej4pWo9jk5FRUyilLv90RXt9YTtf2zNvZzd0vQAEVgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxfzbuhTIxfzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAAAAAAAA07lLcIaNX2yjp6up2kRIp6hYW47q7SMd6MHPoK3U8tbGyvsdtp6Vc7csN0fK5u7dhqwNzvx3UO4AI3T7aOn+kXU0NMkETOKUGyyJEamfr84RBrCpo6mr0y6WaCW2svSR1S7SOY2RsUqMa/uJiXZTC8jsd07dNpTTlFXNrqWwWqCra5XNnio42yIq8qo5EznevpNx1qtz6SekdQUrqaoe580KwtVkjnLlyubjCqq71VeVQISO1UV7q9aW6OtbR22a4Uitmh2dltQ1sb37Oex2lVrEXy57ppX243BdPa0sslwS5Q0NNBI6rjjax6RyKvCxv4NEarkYxV3Im5+8+idQ7T1L6l9S6Lqen+qcXZwXLn7GMcvkPWittBbaTilBRU1LTb/qYImsZv5dyJgCVpuIf5TqLqRxfgeoknGeLY2NnhY+Azjd/Fx5Mnfu8F9mVq2m42+ljRi8I2qonzq5fIrZWY9Cmzb7RbbSyRltt1JRNkdtPSmhbGjl767KJlTafzbuhQJ/QPa7015rpvdNKIndA9rvTXmum900ogAAAAAAAAAAAlrX+yfSDfKfkSqp4alqfypsr/AFU/Kj/OH0kUcXLHbaN8y+R712cejCn7cv2T6RbNPyJV0s1Mq/y9mn5n5pP9tu2oLuu9Jqvi8a99kaYRU6c/0Nc82n/r8Mcc/J/7fPsqgAZGxjJGyWN8cjUcx6K1zVTKKi8qEppqR9ju1TpiocqxtzPQPcv2olXe3pav6laT2rbXPV0MVwoExcrc/h4FT95E+0zoVO4VtTE5onmn1RuxMYrp549OtQg0bPdILzaaevp17CZuVbne1e6i9C7jeJzExOJViYmMwA4N81LHa546Gjp3V90l+xSxLvRPvOX91P8AvymxYtQUl9p3LEjoamJdmemk3Pid3lTveU9TbqinSxqeIu0TVoZ1usADwoA8aqqp6KndUVU0cMLPtPkcjUT8TOKaOeJksMjZI3plr2LlFTvop3E4y5mM4ZgA46AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABi/m3dCmRi/m3dCgT+ge13przXTe6aURO6B7XemvNdN7ppRAAAAAAAAAAAAAAAAAAAAMX827oUyMX827oUCf0D2u9Nea6b3TSiJ3QPa7015rpvdNKIAAAAAAAAAAAI76QZn2+jtl3ibmSjrEX/lc1c/kh1NGUS0OkrfG5OzfHwz1XlVXrtb/Sbl7s9PfrVJb6lz2xvVq7TMbSKi53ZN9jGxxtjYmGtRERE7iIWm5E2oo68/fWUItTF6a+rH30hkACK4AAJCl/8L6ufRL2Nsu7lkg70U/7zfJnufgh73XUNVV1z7Lp1rZq5N09Su+KlTyr3XeT/wDh173Zaa/W51HUq9ibSPZJGuHMcnIqL/3ymdqtNFZaFlJQwpHG3eq8rnr31XuqaOUomIqmM1cO9n5OuJmiJxTx7mtYtPU1jherXOnrJl2qiql3vld09xPIa1903x6obc7bNxK7xJ2E7eSRPuvTuoUAJxdq0tLOtSbVGjoY1OBYtScfnfbblDxK7wp9ZA7ken3mL3U/78p+3nVFPbqhKCkifX3R/wBilh3qnlcv7qGze9P0d9hYk+3FURLtQ1MK7Mka+RTKzWG32KnWOjhw92+SZ67Uki99zv8AtD3m10seHzseMXejnx+Nrj0umKm61LK/VEzaqRq5ioWcxD+H7y9P9TCXT9x09M+r0zIj6dV2pbZM7sHd/YVfsr/35CuBzl687tnU7yFGN+3rcay6lor0roGo+mro90tJOmzIxe7u7qeX8joVlwo7dDwtbVQ08f3pXo3PRnlNG9aboL3sSTI+Grj3xVUC7MjF8i938TUo9E2amm4xUxSXCp7s1a9ZVX8F3f0GLU68zG75M3Y1Yid/w8H61iq3rFYrZWXV6LjbYzg4kXyvdyegce1pNzdmt1P/AMapV+P7pUMY2NiMY1GtRMIiJhEP05ylEdGnzOTrnpVeX2UtxfW83262zU//AAo3vx/ePzjmsrdz9uobpGn71NKsT8eVHbvQVQHK7aYOR2VT5pZuuqGByMutFX2x/JmogXZXoVM5OjDqqwVGODvFHv7j5Ub+eDrua17Va5Ec1dyoqZRTnzWCzVGeGtVE9V7qwNz6cDNqeeJgxdjmmJ8G1DW0tTzFTDL/ACSI78j3J2bQmmp/tWqNq/8Aw3uZ+Snj/k80x3aB7umok/8AcMWts+XyZu7I859lKssbeWRqdKni+4UUXOVdOz+aRE/U4SfR9pdP9lp+M8n/ALj2ZofTUf2bTCv8znO/NRi1tnyj3M3tkec+zffqCyxfbu9A3pqWf4ntTXW3VmOK19LPn+HM135KabNK2CP7NmoV/mha78zwqdF6cqs8JaKduf4SLH/6VQfxb+B/Nsji7wJbrFood9BcrrQ45Egqlx6FyOtO4eNV2/vINC31VcDTuddPFUglutS4+NV1/vIOslk3+m3281Xfa6p2W+hEGhR2uBp3OzxhSTVVPTN2p54ok773o38zCCupKr/R6qCb/hyI78jhw6C03C7aW3JK/uulle/PpXBnPoXTVRvda42L343OZj0Kgxa2z5fJm9sjzn2UIJbrGpYf9Cu13o+8kNWuPQqDrPqX89qi9r/JUbH6DQt9rgadzs8VSfiqiJlVwnlJfrFonc9dbzN/xKxV/JD9T6PtOquZqaade/JUPX8lQaNvtT5fJpXezHn8O/LcqGHna2nj/mlan6ngl9tC8l1oV/8AqGf4mhFonTcX2bTAv8yud+ansuktPr/sej9Ugxa2zwM3tkcfZuJeLY7kuNIvRO3/ABPaOspZuaqYX/yvRTlLo7Tq8topfwaeMmhNMy/atUafyve38lGLW2fKPcze2R5z7KIEt/k/sTOYSrp/+FUvT81UdY8Debvl9j/krf8A9DRt9rh8mld7PH4VIJbrPqG83qi+J/PU7X6DrUuPjVdfSg0KO1wk06+zxhUglutS4+Nd19KDrUuPjXdfSg0KO1wk5SvscYVIJbrUuPjXdfSh3LXRS2+iSCatmrHo5V4Wb7S57h5qppiNVWXqmqqZ1048m6Yv5t3QpkYv5t3Qp4UT+ge13przXTe6aURO6B7XemvNdN7ppRAAAAAAAAAAAAAAAAAAAAMX827oUyPxybTVRFxlMAT2ge13przXTe6aURH2iwats1lobXT6gszoKOnZTxrJaJFcrWNRqZVKhN+E7yG7xLWfh6x+x5fmQKMEXfp9Z2PTtyu3VixzcSpZKjgupMrdvYarsZ4wuM45cHQbR6zVqL1ese9PA8vzIFICc4lrPw9Y/Y8vzI4lrPw9Y/Y8vzIFGCc4lrPw9Y/Y8vzI4lrPw9Y/Y8vzIFGCc4lrPw9Y/Y8vzI4lrPw9Y/Y8vzIFGCLv0+s7Hp25XbqxY5uJUslRwXUmVu3sNV2M8YXGccuDoNo9Zq1F6vWPengeX5kCkBOcS1n4esfseX5kcS1n4esfseX5kCjBOcS1n4esfseX5kcS1n4esfseX5kCjBOcS1n4esfseX5kcS1n4esfseX5kCjBF36fWdj07crt1Ysc3EqWSo4LqTK3b2Gq7GeMLjOOXB0G0es1ai9XrHvTwPL8yBSAnOJaz8PWP2PL8yOJaz8PWP2PL8yBRgnOJaz8PWP2PL8yOJaz8PWP2PL8yBRgnOJaz8PWP2PL8yOJaz8PWP2PL8yBRgm3Ues0aq9XrHuTwPL8yc+wz6zvmnbbdurFjh47Sx1HBdSZXbG21HYzxhM4zy4AtATnEtZ+HrH7Hl+ZHEtZ+HrH7Hl+ZAowTnEtZ+HrH7Hl+ZHEtZ+HrH7Hl+ZAowTnEtZ+HrH7Hl+ZHEtZ+HrH7Hl+ZAowTbqPWaNVer1j3J4Hl+ZOfYZ9Z3zTttu3Vixw8dpY6jgupMrtjbajsZ4wmcZ5cAWgJziWs/D1j9jy/MjiWs/D1j9jy/MgUYJziWs/D1j9jy/MjiWs/D1j9jy/MgUYJziWs/D1j9jy/MjiWs/D1j9jy/MgUYJziWs/D1j9jy/MnNslRrO80EtV1YscOxVVFNs9SZXZ4KZ8W1njCcuxnHczjeBagnOJaz8PWP2PL8yOJaz8PWP2PL8yBRgnOJaz8PWP2PL8yOJaz8PWP2PL8yBRgnOJaz8PWP2PL8yOJaz8PWP2PL8yBRgnOJaz8PWP2PL8yc2yVGs7zQS1XVixw7FVUU2z1JldngpnxbWeMJy7GcdzON4FqCc4lrPw9Y/Y8vzI4lrPw9Y/Y8vzIFGCc4lrPw9Y/Y8vzI4lrPw9Y/Y8vzIFGCc4lrPw9Y/Y8vzI4lrPw9Y/Y8vzIFGCc4lrPw9Y/Y8vzJzbJUazvNBLVdWLHDsVVRTbPUmV2eCmfFtZ4wnLsZx3M43gWpi/m3dCk9xLWfh6x+x5fmT8Wh1mqKnV6x7/AP5PL8yBloHtd6a8103umlEc3T9rWx6ctlpWZJloqWKn4VG7O3sNRucZXGcd86QAAAAAAAAAAAAAAAAAAAAAAAAHMvV4tdopWdVJMR1DuCZEkLpnSqqKqtRjUVztyLnCLuNi23Kju9virqCds9NLnYe3Kci4VFRd6KioqKi70VCa1RVQWjWWnbxcZGw2yKGrp31Em5kMr+DViuXkblGPTK9/HdPXQaLLb7rXMY5tLXXWoqaXaardqJVREeiL3HKjnJ30dnugVYAAAAAAANevnpKa31E9e6NtJHG50zpEy1GIm/PkwedqulHerZBcbfKstJO3ajerHMymccjkRU5O6hxNVUN8rq22pQUVHW2+B6zT09RVug4SRqoseVSN+WouXY3b0b3sLqfRZJVyfR7beNU8UOztpHwcqybbNpd65amFzlMb+RFzvwgWQAAAAAAAOZerxa7TTsbc5OxqVWJkLYXTPmXCqqJG1Fc7dnOE5D3td1obzQtrLfOk0CuVmURWq1yLhWuaqIrVReVFRFJPXszILxp2WavdaIWSTq67oiLxddhESNdpFYm3ld70VOw3b1RTZ+jpyusVa5HLPGtxndHXK1WrWoqovDKi7t6qqbsN7HciJhAK8AAAAAAAHJj1LaZr+6xMqXLcUa53BLBIjVRuNrD1bsrjabuRe6a8OrLBHXx2qOpWKRJeKxotNIyFZE3cG2RWoxVymMIvcJ6/ansVJ9KNgiqLvRRSU1LWxTtfM1Fje9adWNdv3KuFwndweNy1XY9Taqisb7zQUtFba6N0yTVDGy1dVG9FZFG1VzsteiZdjeqbKd1QPooAAAAAAAOTHqW0zX91iZUuW4o1zuCWCRGqjcbWHq3ZXG03ci9085NSWWhuLbQ2V/DxqyNYqelkkZCq42WvcxqtZuVNzlTcqE1ftT2Kk+lGwRVF3oopKalrYp2vmaixvetOrGu37lXC4Tu4Jlr5rPPfI2Xevj1Qt8klorc2VyMniklRWrwXI9isVcvXOzjGU2QPsoAAAAAAAOH14WNLmlvdWPZOs/Fkc+nlbEsucbCSK3YV2UxjOcn5Xaq0/ZK5bfU1jIJUVHyIyF6si213LI9rVbHtLne5UyS931XY9R6nbp+S80FJQ26tjWq4aoYyWpqI3o5sMbVXOyj0Tad3VTZTuqmlea+ktcGvrRccrcbq9z6GBWKr6xslNHGxsafvYe1zVxycoH1IGrbYZae10kE7tqaOFjJFznLkaiL/AFNoAAAAAA4fXhY0uaW91Y9k6z8WRz6eVsSy5xsJIrdhXZTGM5ybF0vdo05FTrX1EdKyqqEhiRsartyPd3movKq715MrvXeR131XY9R6nbp+S80FJQ26tjWq4aoYyWpqI3o5sMbVXOyj0Tad3VTZTuqnP19R6hjbcbjPbqCogdWUUNHMtc5roYkqYVRvB8EqZe9E2nbXJs7l2URQ+qg84HSugjdPG2OVWor2MdtI12N6IuEyme7hOg9AAAAAADh3DV9jtddJSVtW+KSJWpK/i8qxRK5EVNuRG7DdypyqnKZ3LUdlsEzKWqmdHLI10/A09NJK5G53vVsbVVEyq9kuEzklta6rtFZX1GjJrxQ29kkSJdKmqnZGscL05uNHL2T3tXl5GoueXCGvqappafWSSPv7tOQLaGMhr42tclWivevBor0VvYblRETbXhNy4A+iUlXT19HDV0kzJqeZiSRyMXLXtVMoqKexP6GR7dDWZr6JKJW0rG8AiOTZRNyLh2XJlMLhVzv3lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+V6MuV+umpKNaaottFbnWmKd1BHSycE1vGJWu2ESVEa9dleywvc3LjeH1QHze2/SJcblV0dTT0azUFVVpC2mjtlVwjIlfsJKs+OCXG5yoiYRM9kqodS26ivdZHfLhVTWiitltqquna6Vj8uSJVRr3O2sNRMJncucLjAFoD5xT6zuVx6r2pKindUJapa2lrI7fU0rU2VRqpsyrl32mqjmu9B6224XWGwaIkuz7fcZK6qp2sldTPR8SLSyO29p0jsy9jhX7so527eB9CBBx6vvbqOC/ugoOoM9wSjSBGv4y1jpuAbKr9rZXssLsbPIvLk8qnWGooKe93VIbZ1MtNydSviVknDTRo5iK5HbWGuRHd5c47gH0EEZNqi4x6xktlRUW+20zamOKCOsppdusYrWqro5tpI0XKuajcOXLd/KWYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJi36Ho7VPb5rfcbhTvo4Up1Vro14xEkiybEiOYu7Lnb27K4Vd5TgCdo9IxW6qa6hu10p6JsyzJb45WcAjldtKiZZto1VVexR2N/Jg9utS2usl1tEqzSUtzmnmn2nojkdK5XO2VRExhV3fqdwATdFoylprs+51VyuVxqn0T6FzqyRiosTnNcqYY1qIuW8qd9c53YUejaelpbVTPudxqYbVUsqKNs7o/q9mJ0TWZaxFVuy9eXK5RN5SACYZoa3R1rJErK9aKOrWtZbVlbxZs21t7SJs7X2l2tna2UXfg2J9IW+os92tj5qlILpUuqZnI5u01zlaqo3scInYpyop3wBP1+lIrnW8LWXa5y0nDsqFoFkZwG2xyOb+5t4RzUXG1jcUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/9k=', num_solutions=None, num_shots=2048))]\n" - ] - } - ], - "source": [ - "print(res)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "de17cfc0-8e64-4493-b4c2-4a97fc9797a0", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.0636216796875\n", - "Optimal parameters: {'angles_0': -0.1929194344266117, 'angles_1': 7.818050476591932, 'angles_2': -1.2550017986926845}\n", - "Eigenstate: {'01': (0.09631896879639025+0j), '10': (0.09631896879639025+0j), '00': (0.9906792177592099+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5df11dfc-3e3a-4191-bd47-d522ca3dcbfa", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4631460f-1f90-4fd0-944b-dec61dcb298c", - "metadata": {}, - "outputs": [], - "source": [ - "This is not similar to neither the optimal energy nor the total energy." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "ae650e09-6c10-4442-abcc-731253a13d5b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on function vqe in module classiq.qmod.builtins.classical_execution_primitives:\n", - "\n", - "vqe(hamiltonian: List[Mapping[str, Any]], maximize: bool, initial_point: List[float], optimizer: classiq.interface.generator.expressions.enums.optimizers.Optimizer, max_iteration: int, tolerance: float, step_size: float, skip_compute_variance: bool, alpha_cvar: float) -> classiq.interface.executor.vqe_result.VQESolverResult\n", - "\n" - ] - } - ], - "source": [ - "help(vqe)" - ] - }, - { - "cell_type": "markdown", - "id": "4f0e0bea-b12f-43ad-94e8-100fedf2b57f", - "metadata": {}, - "source": [ - "### Part 2" - ] - }, - { - "cell_type": "markdown", - "id": "66882248-de08-4a6e-b33c-647f015f7d79", - "metadata": {}, - "source": [ - "**Now, we want to have a more interesting ansatz in our `main`.** \n", - "Add **one** line of code to the `main` function you created in Part 1 that creates **entanglement** between the two qubits. \n", - "Which gate should you use?" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "ddd4b2ad-153d-45ad-82ac-f6355a1914f6", - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", - " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2], 0, q[0])\n", - " U(angles[0], angles[1], angles[2], 0, q[1])\n", - " CX(q[0],q[1]) \n", - "# TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", - "\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN, # TODO: complete the missing argument\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=1000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", - "qprog = synthesize(qmod)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "16e9b199-8447-4856-826c-152cf57ea4bb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/22272543-36e8-48fe-8fab-dc076e0d239e?version=0.41.2\n" - ] - } - ], - "source": [ - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "112a1590-283c-4f79-8035-72936561102d", - "metadata": {}, - "outputs": [], - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "2d3bd73e-bb89-49d6-a3a8-1488e0459565", - "metadata": {}, - "outputs": [], - "source": [ - "execution.open_in_ide()" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "06500e4c-a04b-4cfa-a84d-41f96a0c68eb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Optimal energy: -1.082470703125\n", - "Optimal parameters: {'angles_0': -6.039443074452129, 'angles_1': 2.1121611522056556, 'angles_2': 5.197782449297897}\n", - "Eigenstate: {'01': (0.02209708691207961+0j), '11': (0.1269381000724369+0j), '10': (0.10126157341262282+0j), '00': (0.9864808823540373+0j)}\n" - ] - } - ], - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ] - }, - { - "cell_type": "markdown", - "id": "30a635d7-2f15-4c94-a94b-f4270f17aed8", - "metadata": {}, - "source": [ - "Does it similar to the `optimal energy` we calculated in class? \\\n", - "Does it similar to the `total energy` we calculated in class? \\\n", - "What can we learn about the provided form this result Hamiltonian?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9c1e58f2-4031-4104-86c6-8ec78ea4d867", - "metadata": {}, - "outputs": [], - "source": [ - "The calculation result is not similar to the optimal energy we calculated in class. \n", - "\n", - "It gets closer but is not similar to the total energy.\n", - "\n", - "From this calculation, we can recognize the significance of the Ansatz and Hamiltonian. To obtain a\n", - "meaningful result, we should carefully select and justify our Ansatz and Hamiltonian.\n", - "They should be able to represent the problem we would like to solve on the quantum computer." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Submissions/HW3/bogachan_arslan-HW3_QClass2024.ipynb b/community/QClass_2024/Submissions/HW3/bogachan_arslan-HW3_QClass2024.ipynb index 6895bcbe..99e8539f 100644 --- a/community/QClass_2024/Submissions/HW3/bogachan_arslan-HW3_QClass2024.ipynb +++ b/community/QClass_2024/Submissions/HW3/bogachan_arslan-HW3_QClass2024.ipynb @@ -79,15 +79,20 @@ }, "source": [ "from typing import List\n", + "\n", "from classiq import *\n", "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], [\n", - " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", - " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", - " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", - " PauliTerm([Pauli.X, Pauli.X], 0.1809),\n", - "]) " + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [\n", + " PauliTerm([Pauli.I, Pauli.I], -1.0523),\n", + " PauliTerm([Pauli.I, Pauli.Z], 0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.I], -0.3979),\n", + " PauliTerm([Pauli.Z, Pauli.Z], -0.0112),\n", + " PauliTerm([Pauli.X, Pauli.X], 0.1809),\n", + " ],\n", + ")" ], "outputs": [], "execution_count": 16 @@ -106,8 +111,8 @@ "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2],0 ,q[0])\n", - " U(angles[0], angles[1], angles[2],0 ,q[1])\n", + " U(angles[0], angles[1], angles[2], 0, q[0])\n", + " U(angles[0], angles[1], angles[2], 0, q[1])\n", "\n", "\n", "@cfunc\n", @@ -125,7 +130,10 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # TODO: complete the line, use classical_execution_function\n", "qprog = synthesize(qmod)\n", "show(qprog)" ], @@ -237,10 +245,11 @@ "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 3]) -> None:\n", " # TODO: Create an ansatz which allows each qubit to have arbitrary rotation\n", " allocate(2, q)\n", - " U(angles[0], angles[1], angles[2],0 ,q[0])\n", - " U(angles[0], angles[1], angles[2],0 ,q[1])\n", + " U(angles[0], angles[1], angles[2], 0, q[0])\n", + " U(angles[0], angles[1], angles[2], 0, q[1])\n", " CX(q[0], q[1])\n", "\n", + "\n", "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", @@ -256,7 +265,10 @@ " )\n", " save({\"result\": res})\n", "\n", - "qmod = create_model(main, classical_execution_function=cmain) #TODO: complete the line, use classical_execution_function\n", + "\n", + "qmod = create_model(\n", + " main, classical_execution_function=cmain\n", + ") # TODO: complete the line, use classical_execution_function\n", "qprog = synthesize(qmod)\n", "show(qprog)" ], @@ -284,7 +296,7 @@ "execution = execute(qprog)\n", "res = execution.result()\n", "# execution.open_in_ide()\n", - "vqe_result = res[0].value #TODO: complete the line" + "vqe_result = res[0].value # TODO: complete the line" ], "outputs": [], "execution_count": 19 diff --git a/community/QClass_2024/Submissions/HW3/index.md b/community/QClass_2024/Submissions/HW3/index.md deleted file mode 100644 index 975f8be0..00000000 --- a/community/QClass_2024/Submissions/HW3/index.md +++ /dev/null @@ -1,20 +0,0 @@ -# Submitting HW2 - -## Submission: Rules & Instructions -To keep track of submissions, we kindly ask you to: -1. Complete `HW3_VQE.ipynb`. -2. Rename the files to include your full name, for example: `Nadav_Ben-Ami_HW3_VQE.ipynb`. -3. Navigate to your local clone of the `classiq-library`. -4. Go to `community/QClass_2024`. -5. Place your solutions in the `HW2` folder. -6. Use the command line to `add`, `commit`, and `push` those changes to the remote (your fork of the `classiq-library`). -7. Navigate to your GitHub repository `classiq-library` and create a new Pull Request to merge the changes from your fork to the original repository (`Classiq/classiq-library`). -8. After you are done, please let us know by submitting the form here: [Typfeorm HW3](https://fvrn0h72gwo.typeform.com/to/pEJ5iRIS) - -**Please ensure you follow these steps carefully to properly submit your assignment!** - -## Support -If you need help or have questions, feel free to reach out in our Slack channel! - -## Enjoy your learning journey at QClass 2024! - diff --git a/community/QClass_2024/Submissions/HW4/Amon_Koike_HW4_QClass2024.ipynb b/community/QClass_2024/Submissions/HW4/Amon_Koike_HW4_QClass2024.ipynb deleted file mode 100644 index 912e7817..00000000 --- a/community/QClass_2024/Submissions/HW4/Amon_Koike_HW4_QClass2024.ipynb +++ /dev/null @@ -1,1023 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "d0b64d66-c3e4-4da8-9736-b05bf9a32409", - "metadata": {}, - "source": [ - "# The Project\n", - "- QNN for XOR Problem:\n", - "\n", - " Classiq has an available dataset for training PQC to imitate the XOR gate, similar to how we trained a U-gate to act as a NOT gate. Design a QNN to solve the XOR problem. Read more on the dataset [here](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/qml/qnn/datasets/#datasetxor).\n", - "\n", - " Click [here](https://en.wikipedia.org/wiki/XOR_gate) for more information about XOR gates\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "b17bf52c-0cda-49ff-a883-0f090061f2e3", - "metadata": {}, - "source": [ - "## Setting The Scene" - ] - }, - { - "cell_type": "markdown", - "id": "45633e16-7f1d-4e4f-9346-5524091ed072", - "metadata": {}, - "source": [ - "When running from Google Colab, we need to install Classiq's SDK and authenticate the remote device:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "161ccbd8-538b-4589-a168-e981b49c7b50", - "metadata": {}, - "outputs": [], - "source": [ - "#!pip install classiq numpy torchvision torch\n" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "4dffbfa1-4e29-4896-84a4-cb38592ca748", - "metadata": {}, - "outputs": [], - "source": [ - "# import classiq\n", - "# classiq.authenticate(overwrite=True)" - ] - }, - { - "cell_type": "markdown", - "id": "61c6620f-a42c-44ac-89d7-67a2a259f975", - "metadata": {}, - "source": [ - "# Step 1 - Create our `torch.nn.Module`" - ] - }, - { - "cell_type": "markdown", - "id": "630ba942-3e8f-4eab-88b7-1638fb26f977", - "metadata": { - "id": "dae15b1c-0d3f-4807-ae48-edfba8425962" - }, - "source": [ - "## Step 1.1 - Create Dataset" - ] - }, - { - "cell_type": "markdown", - "id": "0d973e3d-b381-4607-80c1-f669e256e4f7", - "metadata": { - "id": "5105b43a-340e-4f79-8d54-f6e898ba415c" - }, - "source": [ - "We will use the DATALOADER_NOT dataset." - ] - }, - { - "cell_type": "code", - "execution_count": 127, - "id": "d644402d-4f61-41b6-8427-b45d0c5df1b0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--> Data for training:\n", - "tensor([[0., 1.],\n", - " [1., 1.],\n", - " [0., 0.],\n", - " [1., 0.]])\n", - "--> Corresponding labels:\n", - "tensor([1., 0., 0., 1.])\n" - ] - } - ], - "source": [ - "\n", - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from torch.utils.data import DataLoader, Dataset\n", - "# XORゲートのデータセット\n", - "from torch.utils.data import DataLoader\n", - "from classiq.applications.qnn.datasets import DATALOADER_XOR\n", - "\n", - "for data, label in DATALOADER_XOR:\n", - " print(f\"--> Data for training:\\n{data}\")\n", - " print(f\"--> Corresponding labels:\\n{label}\")\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "b015f2a7-4641-4fc8-b6d1-8e0b8d2b751c", - "metadata": { - "id": "dae15b1c-0d3f-4807-ae48-edfba8425962" - }, - "source": [ - "## Step 1.2 - Create our parametric quantum program" - ] - }, - { - "cell_type": "markdown", - "id": "35de5a77-06b2-40c3-97cb-07352de1bc7c", - "metadata": {}, - "source": [ - "Our quantum model will be defined and synthesized as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "id": "fb04f41e-0016-4cd3-a798-9a36321a49cd", - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "import numpy as np\n", - "\n", - "\n", - "# 量子プログラムの作成\n", - "@qfunc\n", - "def encoding(input_0: CInt, input_1: CInt, q: QArray[QBit]) -> None:\n", - " RX(theta=input_0*np.pi, target=q[0])\n", - " RX(theta=input_1*np.pi, target=q[1])\n", - "\n", - "\n", - "@qfunc\n", - "def mixing(theta: CReal, q: QArray[QBit]) -> None:\n", - " CRX(theta, q[1], q[0])\n", - "\n", - "@qfunc\n", - "def main(input_0: CReal, input_1: CReal, weight_0: CReal, weight_1: CReal, res: Output[QArray[QBit]]) -> None:\n", - " allocate(2, res)\n", - " encoding(input_0, input_1, res) # Loading input\n", - " mixing(weight_0, res) # Adjustable parameter\n", - "\n", - "\n", - "model = create_model(main)\n", - "quantum_program = synthesize(model)\n", - "\n", - "\n", - "#show(quantum_program)\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "3615654e-fed1-4bfd-bf9d-318557de79ad", - "metadata": { - "id": "bef15105-d942-45a6-a615-7b5458241703" - }, - "source": [ - "## Step 1.3 - Create the Execution and Post-processing" - ] - }, - { - "cell_type": "markdown", - "id": "5a10a9b0-d994-4d67-a071-157898793c2e", - "metadata": { - "id": "69875135-2a3d-4d8a-91df-ee501f01eac2" - }, - "source": [ - "The following example defines a function that takes in a parametric quantum program plus parameters, executes the program, and returns the result. Notes:\n", - "\n", - "1. The code can be executed on a physical computer or on a simulator. In any case, implement the execution using `execute_qnn`.\n", - "2. Post-process the result of the execution to obtain a single number (`float`) and a single dimension `Tensor`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 183, - "id": "0ec5e0af-a44f-44c4-a7af-7c256858364e", - "metadata": {}, - "outputs": [], - "source": [ - "from classiq.applications.qnn.types import (\n", - " MultipleArguments,\n", - " SavedResult,\n", - " ResultsCollection,\n", - ")\n", - "\n", - "from classiq.execution import execute_qnn\n", - "from classiq.synthesis import SerializedQuantumProgram\n", - "\n", - "from classiq.applications.qnn.datasets import DATALOADER_NOT\n", - "import torch\n", - "\n", - "# 実行およびポストプロセス関数の作成\n", - "def execute(\n", - " quantum_program: SerializedQuantumProgram, arguments: MultipleArguments\n", - ") -> ResultsCollection:\n", - " return execute_qnn(quantum_program, arguments)\n", - "\n", - "def post_process(result: SavedResult) -> torch.Tensor:\n", - " \"\"\"\n", - " \n", - " probability of measuring \n", - " p_one |01> + |11> \n", - " p_zero |00> + |10>\n", - " \"\"\"\n", - " counts: dict = result.value.counts\n", - " p_one:float = counts.get(\"01\", 0.0) / sum(counts.values()) + counts.get(\"11\", 0.0) / sum(counts.values()) \n", - " p_zero:float = counts.get(\"00\", 0.0) / sum(counts.values()) + counts.get(\"10\", 0.0) / sum(counts.values())\n", - " p_xor: float = p_one - p_zero\n", - " \n", - " return torch.tensor(0.0 if p_xor < 0 else p_xor)\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "69934d9a-1245-4739-b267-d8eef8489f8a", - "metadata": { - "id": "aa6a64b5-bdff-4e66-b16c-6ede1d69877d" - }, - "source": [ - "## Step 1.4 - Create a network" - ] - }, - { - "cell_type": "markdown", - "id": "ed1b92e8-a8f0-411a-9831-2398599adb84", - "metadata": { - "id": "1937b4d5-abfa-40bd-b26e-32c93936be18" - }, - "source": [ - "Now we're going to define a network, just like any other PyTorch network, only that this time, we will have only 1 layer, and it will be a quantum layer." - ] - }, - { - "cell_type": "code", - "execution_count": 205, - "id": "b11021d4-bc80-4421-a8f3-e635b0a6fc17", - "metadata": {}, - "outputs": [], - "source": [ - "import torch.nn as nn\n", - "from classiq.applications.qnn import QLayer\n", - "# ネットワークの作成\n", - "\n", - "class Net(torch.nn.Module):\n", - " def __init__(self, *args, **kwargs) -> None:\n", - " super().__init__()\n", - " self.qlayer = QLayer(\n", - " quantum_program, # the quantum program, the result of `synthesize()`\n", - " execute, # a callable that takes\n", - " # - a quantum program\n", - " # - parameters to that program (a tuple of dictionaries)\n", - " # and returns a `ResultsCollection`\n", - " post_process, # a callable that takes\n", - " # - a single `SavedResult`\n", - " # and returns a `torch.Tensor`\n", - " *args,\n", - " **kwargs\n", - " )\n", - " \n", - "\n", - " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", - " # return the new parameter\n", - " return self.qlayer(x)\n", - "\n", - "model = Net()\n" - ] - }, - { - "cell_type": "markdown", - "id": "7600a642-b863-4eb8-9b8b-6040482b6b4f", - "metadata": { - "id": "a94ff1bc-58f5-4743-aa09-0cc77dcfecd6" - }, - "source": [ - "# Step 2 - Choose a dataset, loss function, and optimizer" - ] - }, - { - "cell_type": "markdown", - "id": "69e3927a-4276-4c1d-b5ed-a343e75a73dc", - "metadata": { - "id": "8ac9fb68-bbf5-48c1-ba7a-2af0d9219b74" - }, - "source": [ - "We will use optimizer,defined [here](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/qml/qnn/datasets/) as well as [L1Loss](https://pytorch.org/docs/stable/generated/torch.nn.L1Loss.html) and [SGD](https://pytorch.org/docs/stable/generated/torch.optim.SGD.html)" - ] - }, - { - "cell_type": "code", - "execution_count": 206, - "id": "24ac42c2-31a8-4726-a065-1f88b7be3744", - "metadata": {}, - "outputs": [], - "source": [ - "from classiq.applications.qnn.datasets import DATALOADER_NOT\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from classiq.applications.qnn.datasets import DATALOADER_XOR\n", - "\n", - "data_loader=DATALOADER_XOR \n", - "\n", - "# 損失関数とオプティマイザの定義\n", - "loss_func = nn.L1Loss() # Mean Absolute Error (MAE)\n", - "optimizer = optim.SGD(model.parameters(), lr=1)" - ] - }, - { - "cell_type": "markdown", - "id": "09aa079e-5edd-40a6-ab24-5acb891da094", - "metadata": { - "id": "b0087ab6-addd-41ac-b609-f60b0b4591cd" - }, - "source": [ - "# Step 3 - Train" - ] - }, - { - "cell_type": "markdown", - "id": "ca05190d-dde4-4f33-8389-5a85aa70ca23", - "metadata": { - "id": "ae072cf7-431f-4583-b5c7-a21be4ef56f2" - }, - "source": [ - "For the training process, we will use a loop similar to [the one recommended by PyTorch](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#update-the-weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 207, - "id": "26b387e2-75d1-49b0-800e-9f87586d5c1b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 Parameter containing:\n", - "tensor([0.7832], requires_grad=True)\n", - "Grad for qlayer.weight: 0.048828125\n", - "Epoch 1/100, Loss: 0.427001953125\n", - "1 Parameter containing:\n", - "tensor([0.8320], requires_grad=True)\n", - "Grad for qlayer.weight: 0.18310546875\n", - "Epoch 2/100, Loss: 0.419677734375\n", - "2 Parameter containing:\n", - "tensor([1.0151], requires_grad=True)\n", - "Grad for qlayer.weight: 0.35400390625\n", - "Epoch 3/100, Loss: 0.376708984375\n", - "3 Parameter containing:\n", - "tensor([1.3691], requires_grad=True)\n", - "Grad for qlayer.weight: 0.732421875\n", - "Epoch 4/100, Loss: 0.299560546875\n", - "4 Parameter containing:\n", - "tensor([2.1016], requires_grad=True)\n", - "Grad for qlayer.weight: 0.30517578125\n", - "Epoch 5/100, Loss: 0.119140625\n", - "5 Parameter containing:\n", - "tensor([2.4067], requires_grad=True)\n", - "Grad for qlayer.weight: 0.52490234375\n", - "Epoch 6/100, Loss: 0.059814453125\n", - "6 Parameter containing:\n", - "tensor([2.9316], requires_grad=True)\n", - "Grad for qlayer.weight: 0.09765625\n", - "Epoch 7/100, Loss: 0.00390625\n", - "7 Parameter containing:\n", - "tensor([3.0293], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0244140625\n", - "Epoch 8/100, Loss: 0.00146484375\n", - "8 Parameter containing:\n", - "tensor([3.0049], requires_grad=True)\n", - "Grad for qlayer.weight: 0.06103515625\n", - "Epoch 9/100, Loss: 0.001708984375\n", - "9 Parameter containing:\n", - "tensor([2.9438], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 10/100, Loss: 0.00537109375\n", - "10 Parameter containing:\n", - "tensor([2.9438], requires_grad=True)\n", - "Grad for qlayer.weight: 0.08544921875\n", - "Epoch 11/100, Loss: 0.00390625\n", - "11 Parameter containing:\n", - "tensor([2.8584], requires_grad=True)\n", - "Grad for qlayer.weight: 0.1220703125\n", - "Epoch 12/100, Loss: 0.01123046875\n", - "12 Parameter containing:\n", - "tensor([2.7363], requires_grad=True)\n", - "Grad for qlayer.weight: 0.06103515625\n", - "Epoch 13/100, Loss: 0.021240234375\n", - "13 Parameter containing:\n", - "tensor([2.7974], requires_grad=True)\n", - "Grad for qlayer.weight: 0.10986328125\n", - "Epoch 14/100, Loss: 0.015625\n", - "14 Parameter containing:\n", - "tensor([2.6875], requires_grad=True)\n", - "Grad for qlayer.weight: 0.10986328125\n", - "Epoch 15/100, Loss: 0.02392578125\n", - "15 Parameter containing:\n", - "tensor([2.7974], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0244140625\n", - "Epoch 16/100, Loss: 0.01611328125\n", - "16 Parameter containing:\n", - "tensor([2.8218], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0732421875\n", - "Epoch 17/100, Loss: 0.013427734375\n", - "17 Parameter containing:\n", - "tensor([2.8950], requires_grad=True)\n", - "Grad for qlayer.weight: 0.1220703125\n", - "Epoch 18/100, Loss: 0.007568359375\n", - "18 Parameter containing:\n", - "tensor([3.0171], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0244140625\n", - "Epoch 19/100, Loss: 0.001220703125\n", - "19 Parameter containing:\n", - "tensor([3.0415], requires_grad=True)\n", - "Grad for qlayer.weight: 0.01220703125\n", - "Epoch 20/100, Loss: 0.00146484375\n", - "20 Parameter containing:\n", - "tensor([3.0537], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 21/100, Loss: 0.001220703125\n", - "21 Parameter containing:\n", - "tensor([3.0537], requires_grad=True)\n", - "Grad for qlayer.weight: 0.03662109375\n", - "Epoch 22/100, Loss: 0.001220703125\n", - "22 Parameter containing:\n", - "tensor([3.0171], requires_grad=True)\n", - "Grad for qlayer.weight: 0.048828125\n", - "Epoch 23/100, Loss: 0.001708984375\n", - "23 Parameter containing:\n", - "tensor([2.9683], requires_grad=True)\n", - "Grad for qlayer.weight: 0.048828125\n", - "Epoch 24/100, Loss: 0.00439453125\n", - "24 Parameter containing:\n", - "tensor([2.9194], requires_grad=True)\n", - "Grad for qlayer.weight: 0.08544921875\n", - "Epoch 25/100, Loss: 0.005615234375\n", - "25 Parameter containing:\n", - "tensor([2.8340], requires_grad=True)\n", - "Grad for qlayer.weight: 0.048828125\n", - "Epoch 26/100, Loss: 0.01220703125\n", - "26 Parameter containing:\n", - "tensor([2.7851], requires_grad=True)\n", - "Grad for qlayer.weight: 0.01220703125\n", - "Epoch 27/100, Loss: 0.016357421875\n", - "27 Parameter containing:\n", - "tensor([2.7974], requires_grad=True)\n", - "Grad for qlayer.weight: 0.3173828125\n", - "Epoch 28/100, Loss: 0.012451171875\n", - "28 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 29/100, Loss: 0.0\n", - "29 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 30/100, Loss: 0.0\n", - "30 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 31/100, Loss: 0.0\n", - "31 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 32/100, Loss: 0.000244140625\n", - "32 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 33/100, Loss: 0.0\n", - "33 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 34/100, Loss: 0.0\n", - "34 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 35/100, Loss: 0.000244140625\n", - "35 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 36/100, Loss: 0.0\n", - "36 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 37/100, Loss: 0.0\n", - "37 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 38/100, Loss: 0.0\n", - "38 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 39/100, Loss: 0.0\n", - "39 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 40/100, Loss: 0.0\n", - "40 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 41/100, Loss: 0.0\n", - "41 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 42/100, Loss: 0.0\n", - "42 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 43/100, Loss: 0.0\n", - "43 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 44/100, Loss: 0.000244140625\n", - "44 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 45/100, Loss: 0.0\n", - "45 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 46/100, Loss: 0.000244140625\n", - "46 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 47/100, Loss: 0.0\n", - "47 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 48/100, Loss: 0.000244140625\n", - "48 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 49/100, Loss: 0.0\n", - "49 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 50/100, Loss: 0.0\n", - "50 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 51/100, Loss: 0.0\n", - "51 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 52/100, Loss: 0.0\n", - "52 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 53/100, Loss: 0.0\n", - "53 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 54/100, Loss: 0.000244140625\n", - "54 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 55/100, Loss: 0.0\n", - "55 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 56/100, Loss: 0.0\n", - "56 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 57/100, Loss: 0.000244140625\n", - "57 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 58/100, Loss: 0.000244140625\n", - "58 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 59/100, Loss: 0.000244140625\n", - "59 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 60/100, Loss: 0.0\n", - "60 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 61/100, Loss: 0.0\n", - "61 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 62/100, Loss: 0.0\n", - "62 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 63/100, Loss: 0.000244140625\n", - "63 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 64/100, Loss: 0.0\n", - "64 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 65/100, Loss: 0.000244140625\n", - "65 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 66/100, Loss: 0.000244140625\n", - "66 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 67/100, Loss: 0.000244140625\n", - "67 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 68/100, Loss: 0.0\n", - "68 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 69/100, Loss: 0.000244140625\n", - "69 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 70/100, Loss: 0.0\n", - "70 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 71/100, Loss: 0.000244140625\n", - "71 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 72/100, Loss: 0.0\n", - "72 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 73/100, Loss: 0.0\n", - "73 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 74/100, Loss: 0.0\n", - "74 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 75/100, Loss: 0.000244140625\n", - "75 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 76/100, Loss: 0.0\n", - "76 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 77/100, Loss: 0.0\n", - "77 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 78/100, Loss: 0.0\n", - "78 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 79/100, Loss: 0.0\n", - "79 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 80/100, Loss: 0.0\n", - "80 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 81/100, Loss: 0.0\n", - "81 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 82/100, Loss: 0.0\n", - "82 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 83/100, Loss: 0.0\n", - "83 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 84/100, Loss: 0.0\n", - "84 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 85/100, Loss: 0.0\n", - "85 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 86/100, Loss: 0.0\n", - "86 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 87/100, Loss: 0.000244140625\n", - "87 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 88/100, Loss: 0.0\n", - "88 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 89/100, Loss: 0.0\n", - "89 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 90/100, Loss: 0.0\n", - "90 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 91/100, Loss: 0.0\n", - "91 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 92/100, Loss: 0.0\n", - "92 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 93/100, Loss: 0.000244140625\n", - "93 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 94/100, Loss: 0.000244140625\n", - "94 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 95/100, Loss: 0.0\n", - "95 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 96/100, Loss: 0.0\n", - "96 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 97/100, Loss: 0.000244140625\n", - "97 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 98/100, Loss: 0.0\n", - "98 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 99/100, Loss: 0.000244140625\n", - "99 Parameter containing:\n", - "tensor([3.1147], requires_grad=True)\n", - "Grad for qlayer.weight: 0.0\n", - "Gradient for qlayer.weight is zero.\n", - "Epoch 100/100, Loss: 0.0\n", - "Trained model saved to trained_model.pth\n" - ] - } - ], - "source": [ - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from torch.utils.data import DataLoader\n", - "\n", - "\n", - "# 学習およびテストの準備\n", - "def train(model, data_loader, loss_func, optimizer, epochs=100):\n", - " model.train()\n", - " for epoch in range(epochs):\n", - " total_loss = 0\n", - " print(epoch, model.qlayer.weight)\n", - " for data, label in data_loader:\n", - " optimizer.zero_grad()\n", - " output = model(data)\n", - " output = output.view(-1) # 出力の形状を修正\n", - " label = label.view(-1) # ラベルの形状を修正\n", - " loss = loss_func(output, label)\n", - " loss.backward()\n", - "\n", - " # 勾配チェックを追加して問題を診断\n", - " for name, param in model.named_parameters():\n", - " if param.grad is not None:\n", - " print(f'Grad for {name}: {param.grad.norm().item()}')\n", - " else:\n", - " print(f'No grad for {name}')\n", - " if param.grad is not None and torch.all(param.grad == 0):\n", - " print(f'Gradient for {name} is zero.')\n", - "\n", - " optimizer.step()\n", - " total_loss += loss.item()\n", - " print(f'Epoch {epoch + 1}/{epochs}, Loss: {total_loss / len(data_loader)}')\n", - "\n", - " # 学習後のモデルを保存\n", - " torch.save(model.state_dict(), './trained_model.pth')\n", - " print(\"Trained model saved to trained_model.pth\")\n", - "train(model, data_loader, loss_func, optimizer, epochs=100)" - ] - }, - { - "cell_type": "markdown", - "id": "0a79f438-539d-4412-a839-45c0cb29b4a9", - "metadata": { - "id": "61fa4f83-8bd2-4290-9ca4-f6c5c1ca0e32" - }, - "source": [ - "# Step 4 - Test" - ] - }, - { - "cell_type": "markdown", - "id": "ccce1b93-7895-4bcd-95dd-330c0ff8669b", - "metadata": { - "id": "7533b162-6214-4606-9e66-ec3332a2f446" - }, - "source": [ - "Lastly, we will test our network accuracy, using [the following answer](https://stackoverflow.com/questions/52176178/pytorch-model-accuracy-test#answer-64838681)" - ] - }, - { - "cell_type": "code", - "execution_count": 208, - "id": "34872f7b-45ab-4d65-ba16-8176c8d7807a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "predictions: tensor([1., 0., 1., 0.], requires_grad=True)\n", - "labels: tensor([1., 0., 1., 0.])\n", - "num_correct: 4, total: 4\n", - "Test Accuracy of the model: 100.00%\n", - "Data: tensor([[1., 0.],\n", - " [0., 0.],\n", - " [1., 1.],\n", - " [0., 1.]]), Label: tensor([1., 0., 0., 1.]), Output: tensor([1., 0., 0., 1.], grad_fn=), Loss: 0.0\n" - ] - } - ], - "source": [ - "# テスト関数\n", - "def check_accuracy(model: nn.Module, data_loader: DataLoader, atol=1e-4) -> float:\n", - " num_correct = 0\n", - " total = 0\n", - " model.eval()\n", - "\n", - " with torch.no_grad(): # temporarily disable gradient calculation\n", - " for data, labels in data_loader:\n", - " # let the model predict\n", - " predictions = model(data)\n", - " print('predictions:', predictions)\n", - " print('labels: ', labels)\n", - "\n", - " # get a tensor of booleans, indicating if each label is close to the real label\n", - " is_prediction_correct = predictions.isclose(labels, atol=atol)\n", - "\n", - " # count the amount of `True` predictions\n", - " num_correct += is_prediction_correct.sum().item()\n", - " # count the total evaluations, the first dimension of `labels` is `batch_size`\n", - " total += labels.size(0)\n", - "\n", - " print(f\"num_correct: {num_correct}, total: {total}\")\n", - " accuracy = float(num_correct) / float(total)\n", - " return accuracy\n", - "\n", - "\n", - "accuracy = check_accuracy(model, data_loader)\n", - "\n", - "print(f\"Test Accuracy of the model: {accuracy*100:.2f}%\")\n", - "\n", - "# デバッグ情報を追加して再度確認\n", - "for data, label in data_loader:\n", - " output = model(data)\n", - " label = label.view(-1) # ラベルの形状を修正\n", - " loss = loss_func(output, label)\n", - " print(f\"Data: {data}, Label: {label}, Output: {output}, Loss: {loss.item()}\")\n", - " break # 最初のバッチのみを確認\n" - ] - }, - { - "cell_type": "markdown", - "id": "66eae25d-cccc-412b-b968-1af7574794a3", - "metadata": {}, - "source": [ - "## Reload model" - ] - }, - { - "cell_type": "code", - "execution_count": 209, - "id": "8ce58b0f-714e-41b4-8e95-7b0be6080a8b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model loaded from trained_model.pth\n", - "predictions: tensor([0., 0., 1., 1.], requires_grad=True)\n", - "labels: tensor([0., 0., 1., 1.])\n", - "num_correct: 4, total: 4\n", - "Test Accuracy of the model: 100.00%\n" - ] - } - ], - "source": [ - "# 新しいモデルインスタンスの作成\n", - "loaded_model = Net()\n", - "\n", - "# モデルの読み込み\n", - "loaded_model.load_state_dict(torch.load(\"trained_model.pth\"))\n", - "print(\"Model loaded from trained_model.pth\")\n", - "\n", - "# モデルのテスト\n", - "accuracy = check_accuracy(model, data_loader)\n", - "print(f\"Test Accuracy of the model: {accuracy*100:.2f}%\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Submissions/HW4/Claudia_Zendejas-Morales_HW4_QClass2024.ipynb b/community/QClass_2024/Submissions/HW4/Claudia_Zendejas-Morales_HW4_QClass2024.ipynb index 9c42b335..94e4387b 100644 --- a/community/QClass_2024/Submissions/HW4/Claudia_Zendejas-Morales_HW4_QClass2024.ipynb +++ b/community/QClass_2024/Submissions/HW4/Claudia_Zendejas-Morales_HW4_QClass2024.ipynb @@ -3,7 +3,13 @@ { "cell_type": "markdown", "id": "d6348096-b55b-42d8-8bad-ba34ab9ff974", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "# QNN for the XOR Problem" ] @@ -68,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "d63f72a0-29b1-43bb-a5ae-04a60c269581", "metadata": {}, "outputs": [ @@ -77,12 +83,12 @@ "output_type": "stream", "text": [ "--> Data for training:\n", - "tensor([[0., 0.],\n", - " [1., 1.],\n", + "tensor([[1., 0.],\n", " [0., 1.],\n", - " [1., 0.]])\n", + " [0., 0.],\n", + " [1., 1.]])\n", "--> Corresponding labels:\n", - "tensor([0., 0., 1., 1.])\n" + "tensor([1., 1., 0., 0.])\n" ] } ], @@ -112,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "dced17d8-bb8f-47c9-b185-c14ce043df01", "metadata": {}, "outputs": [ @@ -120,36 +126,56 @@ "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/9966091d-2f51-4a57-bda1-377af5a4c35e?version=0.42.1\n" + "Opening: https://platform.classiq.io/circuit/570ed46d-be34-442f-a2a5-1ee856e6606d?version=0.42.2\n" ] } ], "source": [ - "from classiq import synthesize, qfunc, QArray, H, RX, CRX, CRZ, Output, allocate, CInt, CReal, QBit, show\n", - "from classiq.qmod.quantum_function import create_model\n", "import numpy as np\n", "\n", + "from classiq import (\n", + " CRX,\n", + " CRZ,\n", + " RX,\n", + " CInt,\n", + " CReal,\n", + " H,\n", + " Output,\n", + " QArray,\n", + " QBit,\n", + " allocate,\n", + " qfunc,\n", + " show,\n", + " synthesize,\n", + ")\n", + "from classiq.qmod.quantum_function import create_model\n", + "\n", + "\n", "@qfunc\n", "def encoding(state0: CInt, state1: CInt, q: QArray[QBit]) -> None:\n", - " RX(theta=state0*np.pi, target=q[0])\n", - " RX(theta=state1*np.pi, target=q[1])\n", + " RX(theta=state0 * np.pi, target=q[0])\n", + " RX(theta=state1 * np.pi, target=q[1])\n", "\n", "\n", "@qfunc\n", "def mixing(theta: CReal, q: QArray[QBit]) -> None:\n", - " \n", - " #H(q[0]) # these three gates are equivalent to CRX,\n", - " #CRZ(theta, q[1], q[0]) # this option also works,\n", - " #H(q[0]) # but takes more iterations\n", - " \n", + "\n", + " # H(q[0]) # these three gates are equivalent to CRX,\n", + " # CRZ(theta, q[1], q[0]) # this option also works,\n", + " # H(q[0]) # but takes more iterations\n", + "\n", " CRX(theta, q[1], q[0])\n", "\n", "\n", "@qfunc\n", - "def main(input_0: CInt, input_1: CInt, weight_0: CReal, res: Output[QArray[QBit]]) -> None:\n", + "def main(\n", + " input_0: CInt, input_1: CInt, weight_0: CReal, res: Output[QArray[QBit]]\n", + ") -> None:\n", " allocate(2, res)\n", - " encoding(state0=input_0, state1=input_1, q=res) # loading input (two values, four possible combinations): 00, 01, 10, 11 \n", - " mixing(theta=weight_0, q=res) # adjustable parameter (an angle)\n", + " encoding(\n", + " state0=input_0, state1=input_1, q=res\n", + " ) # loading input (two values, four possible combinations): 00, 01, 10, 11\n", + " mixing(theta=weight_0, q=res) # adjustable parameter (an angle)\n", "\n", "\n", "model = create_model(main)\n", @@ -176,16 +202,18 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "c5a48c01-2236-47e2-b4b8-f5be40c42bce", "metadata": {}, "outputs": [], "source": [ "import torch\n", "\n", - "from classiq.applications.qnn.types import MultipleArguments, SavedResult, ResultsCollection\n", - "\n", - "\n", + "from classiq.applications.qnn.types import (\n", + " MultipleArguments,\n", + " ResultsCollection,\n", + " SavedResult,\n", + ")\n", "from classiq.execution import execute_qnn\n", "from classiq.synthesis import SerializedQuantumProgram\n", "\n", @@ -198,7 +226,7 @@ "\n", "# Post-process the result\n", "# This function validates if output is 01 or 11 then the result\n", - "# of the XOR operation is '1', and since we don't want the \n", + "# of the XOR operation is '1', and since we don't want the\n", "# other two (00, 10) we substract their probailities\n", "# The returning value will correspond to the XOR result, therefore\n", "# if we calculate a negative value, then we simply return a zero\n", @@ -208,10 +236,14 @@ " probability of measuring |01> + |11> - |00> - |10>\n", " \"\"\"\n", " counts: dict = result.value.counts\n", - " xor_result: float = counts.get(\"01\", 0.0) / sum(counts.values()) + counts.get(\"11\", 0.0) / sum(counts.values()) \\\n", - " - counts.get(\"00\", 0.0) / sum(counts.values()) - counts.get(\"10\", 0.0) / sum(counts.values())\n", - " \n", - " return torch.tensor(0.0 if xor_result < 0 else xor_result)\n" + " xor_result: float = (\n", + " counts.get(\"01\", 0.0) / sum(counts.values())\n", + " + counts.get(\"11\", 0.0) / sum(counts.values())\n", + " - counts.get(\"00\", 0.0) / sum(counts.values())\n", + " - counts.get(\"10\", 0.0) / sum(counts.values())\n", + " )\n", + "\n", + " return torch.tensor(0.0 if xor_result < 0 else xor_result)" ] }, { @@ -230,7 +262,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "55ee6c51-771b-4f31-ae66-c4e1ab8f52e7", "metadata": {}, "outputs": [], @@ -255,7 +287,7 @@ " *args,\n", " **kwargs\n", " )\n", - " #self.qlayer.weight.data.\n", + " # self.qlayer.weight.data.\n", "\n", " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", " # return the new parameter\n", @@ -279,23 +311,24 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "bb37c29f-81a2-4408-b883-73e43378d495", "metadata": {}, "outputs": [], "source": [ - "from classiq.applications.qnn.datasets import DATALOADER_XOR\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "\n", + "from classiq.applications.qnn.datasets import DATALOADER_XOR\n", + "\n", "_LEARNING_RATE = 1\n", "\n", "# choosing our data\n", - "data_loader = DATALOADER_XOR # Dataset to train the XOR operation\n", + "data_loader = DATALOADER_XOR # Dataset to train the XOR operation\n", "# choosing our loss function\n", - "loss_func = nn.L1Loss() # Mean Absolute Error (MAE)\n", + "loss_func = nn.L1Loss() # Mean Absolute Error (MAE)\n", "# choosing our optimizer\n", - "optimizer = optim.SGD(model.parameters(), lr=_LEARNING_RATE)\n" + "optimizer = optim.SGD(model.parameters(), lr=_LEARNING_RATE)" ] }, { @@ -312,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "2103a0ae-1ff8-4402-aeb4-c24e69e401f6", "metadata": {}, "outputs": [ @@ -321,85 +354,125 @@ "output_type": "stream", "text": [ "0 Parameter containing:\n", - "tensor([0.7793], requires_grad=True)\n", + "tensor([0.9503], requires_grad=True)\n", "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.7061, 0.0000], grad_fn=)\n", + "output: tensor([1.0000, 0.0000, 0.5645, 0.0000], grad_fn=)\n", "1 Parameter containing:\n", - "tensor([0.9746], requires_grad=True)\n", + "tensor([0.3521], requires_grad=True)\n", "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([1.0000, 0.0000, 0.5762, 0.0000], grad_fn=)\n", + "output: tensor([1.0000, 0.0000, 0.9404, 0.0000], grad_fn=)\n", "2 Parameter containing:\n", - "tensor([1.0357], requires_grad=True)\n", - "label: tensor([0., 1., 1., 0.])\n", - "output: tensor([0.5244, 1.0000, 0.0000, 0.0000], grad_fn=)\n", + "tensor([0.1812], requires_grad=True)\n", + "label: tensor([1., 1., 0., 0.])\n", + "output: tensor([1.0000, 0.0000, 0.9824, 0.0000], grad_fn=)\n", "3 Parameter containing:\n", - "tensor([0.5840], requires_grad=True)\n", - "label: tensor([1., 0., 1., 0.])\n", - "output: tensor([0.0000, 0.8242, 1.0000, 0.0000], grad_fn=)\n", + "tensor([0.1202], requires_grad=True)\n", + "label: tensor([0., 0., 1., 1.])\n", + "output: tensor([0.0000, 0.9922, 1.0000, 0.0000], grad_fn=)\n", "4 Parameter containing:\n", - "tensor([0.6450], requires_grad=True)\n", - "label: tensor([0., 1., 1., 0.])\n", - "output: tensor([0.0000, 0.0000, 1.0000, 0.7949], grad_fn=)\n", + "tensor([0.1202], requires_grad=True)\n", + "label: tensor([1., 1., 0., 0.])\n", + "output: tensor([1.0000, 0.0000, 0.9961, 0.0000], grad_fn=)\n", "5 Parameter containing:\n", - "tensor([1.0235], requires_grad=True)\n", - "label: tensor([0., 0., 1., 1.])\n", - "output: tensor([0.0000, 0.4824, 1.0000, 0.0000], grad_fn=)\n", + "tensor([0.1080], requires_grad=True)\n", + "label: tensor([0., 1., 1., 0.])\n", + "output: tensor([0.0000, 0.0000, 1.0000, 0.9951], grad_fn=)\n", "6 Parameter containing:\n", - "tensor([1.4507], requires_grad=True)\n", + "tensor([0.1446], requires_grad=True)\n", "label: tensor([1., 0., 1., 0.])\n", - "output: tensor([0.0000, 0.0869, 1.0000, 0.0000], grad_fn=)\n", + "output: tensor([0.0000, 0.0000, 1.0000, 0.9922], grad_fn=)\n", "7 Parameter containing:\n", - "tensor([1.6094], requires_grad=True)\n", + "tensor([0.2179], requires_grad=True)\n", "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([0.0684, 0.0000, 0.0000, 1.0000], grad_fn=)\n", + "output: tensor([0.0000, 0.9775, 0.0000, 1.0000], grad_fn=)\n", "8 Parameter containing:\n", - "tensor([2.5249], requires_grad=True)\n", - "label: tensor([0., 1., 0., 1.])\n", - "output: tensor([0.0000, 0.8057, 0.0000, 1.0000], grad_fn=)\n", + "tensor([0.3033], requires_grad=True)\n", + "label: tensor([1., 0., 0., 1.])\n", + "output: tensor([1.0000, 0.9600, 0.0000, 0.0000], grad_fn=)\n", "9 Parameter containing:\n", - "tensor([2.7935], requires_grad=True)\n", - "label: tensor([1., 0., 1., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.9453, 0.0000], grad_fn=)\n", + "tensor([0.5230], requires_grad=True)\n", + "label: tensor([1., 0., 0., 1.])\n", + "output: tensor([1.0000, 0.0000, 0.8643, 0.0000], grad_fn=)\n", "10 Parameter containing:\n", - "tensor([2.8545], requires_grad=True)\n", - "label: tensor([0., 1., 1., 0.])\n", - "output: tensor([0.0000, 0.9473, 1.0000, 0.0000], grad_fn=)\n", + "tensor([0.2423], requires_grad=True)\n", + "label: tensor([1., 0., 0., 1.])\n", + "output: tensor([1.0000, 0.0000, 0.9766, 0.0000], grad_fn=)\n", "11 Parameter containing:\n", - "tensor([3.0742], requires_grad=True)\n", - "label: tensor([0., 1., 0., 1.])\n", - "output: tensor([0.0000, 1.0000, 0.0000, 0.9990], grad_fn=)\n", + "tensor([0.1446], requires_grad=True)\n", + "label: tensor([1., 1., 0., 0.])\n", + "output: tensor([1.0000, 0.0000, 0.0000, 0.9922], grad_fn=)\n", "12 Parameter containing:\n", - "tensor([3.1231], requires_grad=True)\n", + "tensor([0.2179], requires_grad=True)\n", "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.9990, 0.0000, 0.0000], grad_fn=)\n", + "output: tensor([1.0000, 0.0000, 0.0000, 0.9834], grad_fn=)\n", "13 Parameter containing:\n", - "tensor([3.1353], requires_grad=True)\n", + "tensor([0.3155], requires_grad=True)\n", "label: tensor([1., 0., 1., 0.])\n", - "output: tensor([1., 0., 1., 0.], grad_fn=)\n", + "output: tensor([0.0000, 0.0000, 1.0000, 0.9639], grad_fn=)\n", "14 Parameter containing:\n", - "tensor([3.1353], requires_grad=True)\n", - "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([1., 0., 0., 1.], grad_fn=)\n", + "tensor([0.4620], requires_grad=True)\n", + "label: tensor([1., 1., 0., 0.])\n", + "output: tensor([0.0000, 1.0000, 0.0000, 0.9043], grad_fn=)\n", "15 Parameter containing:\n", - "tensor([3.1353], requires_grad=True)\n", + "tensor([0.6817], requires_grad=True)\n", "label: tensor([0., 0., 1., 1.])\n", - "output: tensor([0., 0., 1., 1.], grad_fn=)\n", + "output: tensor([0.0000, 0.7734, 1.0000, 0.0000], grad_fn=)\n", "16 Parameter containing:\n", - "tensor([3.1353], requires_grad=True)\n", - "label: tensor([0., 0., 1., 1.])\n", - "output: tensor([0., 0., 1., 1.], grad_fn=)\n", + "tensor([1.1456], requires_grad=True)\n", + "label: tensor([1., 0., 0., 1.])\n", + "output: tensor([0.0000, 0.0000, 0.3936, 1.0000], grad_fn=)\n", "17 Parameter containing:\n", - "tensor([3.1353], requires_grad=True)\n", - "label: tensor([0., 0., 1., 1.])\n", - "output: tensor([0., 0., 1., 1.], grad_fn=)\n", + "tensor([0.4864], requires_grad=True)\n", + "label: tensor([0., 1., 0., 1.])\n", + "output: tensor([0.8896, 1.0000, 0.0000, 0.0000], grad_fn=)\n", "18 Parameter containing:\n", - "tensor([3.1353], requires_grad=True)\n", - "label: tensor([1., 0., 1., 0.])\n", - "output: tensor([1., 0., 1., 0.], grad_fn=)\n", + "tensor([0.5841], requires_grad=True)\n", + "label: tensor([0., 1., 0., 1.])\n", + "output: tensor([0.8496, 0.0000, 0.0000, 1.0000], grad_fn=)\n", "19 Parameter containing:\n", - "tensor([3.1353], requires_grad=True)\n", + "tensor([0.5475], requires_grad=True)\n", + "label: tensor([1., 1., 0., 0.])\n", + "output: tensor([0.0000, 1.0000, 0.0000, 0.8682], grad_fn=)\n", + "20 Parameter containing:\n", + "tensor([0.7306], requires_grad=True)\n", "label: tensor([0., 1., 0., 1.])\n", - "output: tensor([0., 1., 0., 1.], grad_fn=)\n" + "output: tensor([0.0000, 1.0000, 0.7402, 0.0000], grad_fn=)\n", + "21 Parameter containing:\n", + "tensor([0.3766], requires_grad=True)\n", + "label: tensor([1., 1., 0., 0.])\n", + "output: tensor([1.0000, 0.0000, 0.9336, 0.0000], grad_fn=)\n", + "22 Parameter containing:\n", + "tensor([0.2179], requires_grad=True)\n", + "label: tensor([1., 0., 1., 0.])\n", + "output: tensor([0.0000, 0.9775, 1.0000, 0.0000], grad_fn=)\n", + "23 Parameter containing:\n", + "tensor([0.3033], requires_grad=True)\n", + "label: tensor([1., 0., 0., 1.])\n", + "output: tensor([0.0000, 0.9600, 0.0000, 1.0000], grad_fn=)\n", + "24 Parameter containing:\n", + "tensor([0.5230], requires_grad=True)\n", + "label: tensor([1., 0., 1., 0.])\n", + "output: tensor([1.0000, 0.0000, 0.0000, 0.8779], grad_fn=)\n", + "25 Parameter containing:\n", + "tensor([0.6817], requires_grad=True)\n", + "label: tensor([1., 1., 0., 0.])\n", + "output: tensor([1.0000, 0.0000, 0.0000, 0.8018], grad_fn=)\n", + "26 Parameter containing:\n", + "tensor([0.9503], requires_grad=True)\n", + "label: tensor([0., 1., 1., 0.])\n", + "output: tensor([0.0000, 0.0000, 1.0000, 0.6113], grad_fn=)\n", + "27 Parameter containing:\n", + "tensor([1.6095], requires_grad=True)\n", + "label: tensor([0., 1., 0., 1.])\n", + "output: tensor([0.0000, 0.0156, 0.0000, 1.0000], grad_fn=)\n", + "28 Parameter containing:\n", + "tensor([1.1578], requires_grad=True)\n", + "label: tensor([1., 1., 0., 0.])\n", + "output: tensor([1.0000, 0.0000, 0.0000, 0.4404], grad_fn=)\n", + "29 Parameter containing:\n", + "tensor([1.8170], requires_grad=True)\n", + "label: tensor([1., 1., 0., 0.])\n", + "output: tensor([0.2246, 1.0000, 0.0000, 0.0000], grad_fn=)\n" ] } ], @@ -414,7 +487,7 @@ " data_loader: DataLoader,\n", " loss_func: nn.modules.loss._Loss,\n", " optimizer: optim.Optimizer,\n", - " epoch: int = 20,\n", + " epoch: int = 1, # To achieve reasonable results, change the value to 20 or more\n", ") -> None:\n", " for index in range(epoch):\n", " print(index, model.qlayer.weight)\n", @@ -422,9 +495,11 @@ " optimizer.zero_grad()\n", "\n", " output = model(data)\n", - " \n", - " print('label:', label) # print the expected values along side with the calculated ones\n", - " print('output:', output)\n", + "\n", + " print(\n", + " \"label:\", label\n", + " ) # print the expected values along side with the calculated ones\n", + " print(\"output:\", output)\n", "\n", " loss = loss_func(output, label)\n", " loss.backward()\n", @@ -432,7 +507,7 @@ " optimizer.step()\n", "\n", "\n", - "train(model, data_loader, loss_func, optimizer)\n" + "train(model, data_loader, loss_func, optimizer)" ] }, { @@ -453,7 +528,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "f62cea58-dac5-4c72-a3af-b62536df8629", "metadata": {}, "outputs": [ @@ -461,9 +536,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "predictions: tensor([1., 0., 0., 1.], requires_grad=True)\n", - "labels: tensor([1., 0., 0., 1.])\n", - "Test Accuracy of the model: 100.00%\n" + "predictions: tensor([0.0000, 0.0000, 1.0000, 0.6318], requires_grad=True)\n", + "labels: tensor([0., 0., 1., 1.])\n", + "Test Accuracy of the model: 75.00%\n" ] } ], @@ -473,12 +548,12 @@ " total = 0\n", " model.eval()\n", "\n", - " with torch.no_grad(): # temporarily disable gradient calculation\n", + " with torch.no_grad(): # temporarily disable gradient calculation\n", " for data, labels in data_loader:\n", " # let the model predict\n", " predictions = model(data)\n", - " print('predictions:', predictions)\n", - " print('labels: ', labels)\n", + " print(\"predictions:\", predictions)\n", + " print(\"labels: \", labels)\n", "\n", " # get a tensor of booleans, indicating if each label is close to the real label\n", " is_prediction_correct = predictions.isclose(labels, atol=atol)\n", @@ -514,7 +589,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.14" + "version": "3.11.9" } }, "nbformat": 4, diff --git a/community/QClass_2024/Submissions/HW4/HW_4 - Bill Wisotsky.ipynb b/community/QClass_2024/Submissions/HW4/HW_4 - Bill Wisotsky.ipynb deleted file mode 100644 index 82e49adb..00000000 --- a/community/QClass_2024/Submissions/HW4/HW_4 - Bill Wisotsky.ipynb +++ /dev/null @@ -1,674 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Kidney Exchange QAOA Example\n", - "Used samples from Classiq github on QAOA and internet for pyomo models \n", - "Modified as needed for specfic problem and limitations based on account. \n", - "\n", - "What is the Problem? \n", - "Currently there are more than 100,000 patients on the waitling list in the United States for a kidney transplant from a deceased donor. This is addressed by the a program called the Kidney Exchange Program. This program won the Nobel Prize in Economics for Alvin E. Roth and Lloyd S. Shapley's contributions to the theory of stable matchings and the design of markets on 2012.\n", - "In summary, in a donor pair there is a recipient who needs a kidney transplant and a donor who is willing to give their kidney to the recipient. About $\\frac{1}{3}$ of those pairs are not compatible for a direct exchange. This is tackled by considering two incompatible pairs together: donor 1 may be compatible with recpient 2 and donor 2 may be compatible with recpient 1. In this example a two-way swap becomes feasible. This is the core of the kideny exchange program. \n", - "\n", - "This is consdered an NP-Hard combinatorial optimization problem that becomes exponetially more difficult as the size of the pool increases. The longest chain in history involved 35 tranplants in the United States in 2015." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "import classiq\n", - "from classiq import *\n", - "\n", - "from pyomo.environ import *\n", - "from itertools import product\n", - "\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import networkx as nx # noqa\n", - "import numpy as np\n", - "import pandas as pd\n", - "import io\n", - "import sys\n", - "import time\n", - "from contextlib import redirect_stdout\n", - "from typing import List, Tuple, cast # noqa\n", - "\n", - "import pyomo.environ as pyo\n", - "from IPython.display import Markdown, display\n", - "\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create the pyomo model for a simple kidney exhange problem \n", - "\n", - "In this very simple example, patients and donors represent sets of patients that receive a kidney from a donor. Compatibility is a dictionary mapping of patient-donor paris to their compatibilty scores. Binary decision variables are defined for each patient-donor pair x[donor,patient]. The objective is to maximize the total compatibility score. $ Maximize \\sum_{d,p\\in A}^{} \\sum_{m\\in M}c_{dp}x_{dpm}$ where d=donors, p=patients and c=compatability score. The contraints are added to ensure that each donor donates only once $\\sum_{d,p\\in A}^{}x_{dpm} = y_{dm}$ and each patient receives once $\\sum_{d,p\\in A}^{}x_{dpm} = y_{pm}$. We are creating a PYOMO model that gets fed into Classiq, as illustrated in Classiq documentation. We also solve initially with a classical solver to get inital results which can be compared to the QAOA results in the end." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m\u001b[4mOptimal solution:\u001b[0m\n", - "donor1 donates kidney to patient1\n", - "donor2 donates kidney to patient3\n", - "donor3 donates kidney to patient2\n", - "\n", - "\u001b[1m\u001b[4mModel Details\u001b[0m\n", - "5 Set Declarations\n", - " donor_constraint_index : Size=1, Index=None, Ordered=Insertion\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 1 : Any : 3 : {1, 2, 3}\n", - " patient_constraint_index : Size=1, Index=None, Ordered=Insertion\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 1 : Any : 3 : {1, 2, 3}\n", - " x_index : Size=1, Index=None, Ordered=True\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 2 : x_index_0*x_index_1 : 9 : {('donor1', 'patient1'), ('donor1', 'patient2'), ('donor1', 'patient3'), ('donor2', 'patient1'), ('donor2', 'patient2'), ('donor2', 'patient3'), ('donor3', 'patient1'), ('donor3', 'patient2'), ('donor3', 'patient3')}\n", - " x_index_0 : Size=1, Index=None, Ordered=Insertion\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 1 : Any : 3 : {'donor1', 'donor2', 'donor3'}\n", - " x_index_1 : Size=1, Index=None, Ordered=Insertion\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 1 : Any : 3 : {'patient1', 'patient2', 'patient3'}\n", - "\n", - "1 Var Declarations\n", - " x : Size=9, Index=x_index\n", - " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", - " ('donor1', 'patient1') : 0 : 1.0 : 1 : False : False : Binary\n", - " ('donor1', 'patient2') : 0 : 0.0 : 1 : False : False : Binary\n", - " ('donor1', 'patient3') : 0 : 0.0 : 1 : False : False : Binary\n", - " ('donor2', 'patient1') : 0 : 0.0 : 1 : False : False : Binary\n", - " ('donor2', 'patient2') : 0 : 0.0 : 1 : False : False : Binary\n", - " ('donor2', 'patient3') : 0 : 1.0 : 1 : False : False : Binary\n", - " ('donor3', 'patient1') : 0 : 0.0 : 1 : False : False : Binary\n", - " ('donor3', 'patient2') : 0 : 1.0 : 1 : False : False : Binary\n", - " ('donor3', 'patient3') : 0 : 0.0 : 1 : False : False : Binary\n", - "\n", - "1 Objective Declarations\n", - " obj : Size=1, Index=None, Active=True\n", - " Key : Active : Sense : Expression\n", - " None : True : maximize : 0.9*x[donor1,patient1] + 0.7*x[donor1,patient2] + 0.6*x[donor1,patient3] + 0.8*x[donor2,patient1] + 0.75*x[donor2,patient2] + 0.65*x[donor2,patient3] + 0.85*x[donor3,patient1] + 0.8*x[donor3,patient2] + 0.7*x[donor3,patient3]\n", - "\n", - "2 Constraint Declarations\n", - " donor_constraint : Size=3, Index=donor_constraint_index, Active=True\n", - " Key : Lower : Body : Upper : Active\n", - " 1 : -Inf : x[donor1,patient1] + x[donor1,patient2] + x[donor1,patient3] : 1.0 : True\n", - " 2 : -Inf : x[donor2,patient1] + x[donor2,patient2] + x[donor2,patient3] : 1.0 : True\n", - " 3 : -Inf : x[donor3,patient1] + x[donor3,patient2] + x[donor3,patient3] : 1.0 : True\n", - " patient_constraint : Size=3, Index=patient_constraint_index, Active=True\n", - " Key : Lower : Body : Upper : Active\n", - " 1 : -Inf : x[donor1,patient1] + x[donor2,patient1] + x[donor3,patient1] : 1.0 : True\n", - " 2 : -Inf : x[donor1,patient2] + x[donor2,patient2] + x[donor3,patient2] : 1.0 : True\n", - " 3 : -Inf : x[donor1,patient3] + x[donor2,patient3] + x[donor3,patient3] : 1.0 : True\n", - "\n", - "9 Declarations: x_index_0 x_index_1 x_index x obj donor_constraint_index donor_constraint patient_constraint_index patient_constraint\n" - ] - } - ], - "source": [ - "from pyomo.environ import *\n", - "\n", - "# Sample data: patient-donor pairs and compatibility scores\n", - "donors = ['donor1', 'donor2', 'donor3']\n", - "patients = ['patient1', 'patient2', 'patient3']\n", - "N=len(patients)\n", - "M=len(donors)\n", - "# Parameters\n", - "compatibility_scores = {\n", - " ('donor1', 'patient1'): 0.9,\n", - " ('donor1', 'patient2'): 0.7,\n", - " ('donor1', 'patient3'): 0.6,\n", - " ('donor2', 'patient1'): 0.8,\n", - " ('donor2', 'patient2'): 0.75,\n", - " ('donor2', 'patient3'): 0.65,\n", - " ('donor3', 'patient1'): 0.85,\n", - " ('donor3', 'patient2'): 0.8,\n", - " ('donor3', 'patient3'): 0.7,\n", - "}\n", - "\n", - "# Create Pyomo model\n", - "model = ConcreteModel()\n", - "\n", - "# Variables\n", - "model.x = Var(donors, patients, within=Binary)\n", - "\n", - "# Objective\n", - "model.obj = Objective(expr=sum(compatibility_scores[donor, patient] * model.x[donor, patient]\n", - " for donor in donors\n", - " for patient in patients),\n", - " sense=maximize)\n", - "\n", - "# Constraints\n", - "model.donor_constraint = ConstraintList()\n", - "for donor in donors:\n", - " model.donor_constraint.add(sum(model.x[donor, patient] for patient in patients) <= 1)\n", - "\n", - "model.patient_constraint = ConstraintList()\n", - "for patient in patients:\n", - " model.patient_constraint.add(sum(model.x[donor, patient] for donor in donors) <= 1)\n", - "\n", - "\n", - "\n", - "# Solve\n", - "solver = SolverFactory('glpk')\n", - "solver.solve(model)\n", - "\n", - "# Output\n", - "print(\"\\033[1m\\033[4mOptimal solution:\\033[0m\")\n", - "for donor in donors:\n", - " for patient in patients:\n", - " if model.x[donor, patient].value == 1:\n", - " print(f\"{donor} donates kidney to {patient}\")\n", - "\n", - "print(\"\\n\\033[1m\\033[4mModel Details\\033[0m\")\n", - "model.pprint()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Start Generatng the QAOA Process\n", - " \n", - "### Create the inital parameters for the quantum circuit. These can me modified as needed.\n", - "1. Defining the number of layers (num_layers) of the QAOA Ansatz. \n", - "2. Define the penalty_energy for invalid solutions, which influences the convergence rate. Smaller positive values are preferred, but shoudl be tweaked. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import (\n", - " Preferences,\n", - " construct_combinatorial_optimization_model,\n", - " set_preferences,\n", - ")\n", - "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", - "\n", - "qaoa_config = QAOAConfig(num_layers=5, penalty_energy=2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Create the classical optimizer part of the QAOA. These parameters can be modified.\n", - "1. opt_type is the classical optimizer type. Choices include, COBYLA, SPSA, ADAM, L_BFGS_B, and NELDER_MEAD\n", - "2. The max_iterations is the maximum number of optimzer iterations and is set to 100. \n", - "3. The alpha_cvar is a parameter that describes the quantile considered in the CVAR expectation value. See https://arxiv.org/abs/1907.04769 for more information." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "optimizer_config = OptimizerConfig(\n", - " #opt_type='COBYLA',\n", - " max_iteration=200,\n", - " alpha_cvar=1,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Combine everthing together to form the entire QAOA model as a QMOD.\n", - "1. PYOMO Model \n", - "2. QAOA quantum circuit \n", - "3. Clasical optimizer " - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "qmod = construct_combinatorial_optimization_model(\n", - " pyo_model=model,\n", - " qaoa_config=qaoa_config,\n", - " optimizer_config=optimizer_config,\n", - ")\n", - "\n", - "# defining cosntraint such as computer and parameters for a quicker and more optimized circuit.\n", - "preferences = Preferences(transpilation_option=\"none\", timeout_seconds=3000)\n", - "\n", - "qmod = set_preferences(qmod, preferences)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "1. Wite out the QMOD and preferences to a JSON file \n", - "2. Synthesize the model in Classiq interface \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import write_qmod\n", - "write_qmod(qmod, \"Kidney Exchange\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "1. Sythesize the quantum model\n", - "2. Show the quantm model in the Classiq platform" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import show, synthesize\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", - "qprog = synthesize(qmod)\n", - "#show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Execute the quantum model and store the result." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import execute\n", - "res = execute(qprog).result()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "View the convergence graph \n", - "Important to remember that this is a maximization problem when looking at the graph" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from classiq.execution import VQESolverResult\n", - "\n", - "vqe_result=res[0].value\n", - "vqe_result.convergence_graph" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Retrieve and Display the Solutions\n", - "- Print them out\n", - "- Graph using a histogram\n", - "- Show Donor - Recipients in Network Graph" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Print out the top 10 solutions with the highest cost or objective" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\u001b[1m\u001b[4mTop 10 Solutions\u001b[0m\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
probabilitycostsolutioncount
50.0126952.35[1, 0, 0, 0, 0, 1, 0, 1, 0]26
140.0087892.35[1, 0, 0, 0, 1, 0, 0, 0, 1]18
330.0058592.20[0, 1, 0, 1, 0, 0, 0, 0, 1]12
110.0102542.20[0, 0, 1, 1, 0, 0, 0, 1, 0]21
90.0107422.20[0, 1, 0, 0, 0, 1, 1, 0, 0]22
130.0092772.20[0, 0, 1, 0, 1, 0, 1, 0, 0]19
800.0039061.70[1, 0, 0, 0, 0, 0, 0, 1, 0]8
1670.0019531.65[1, 0, 0, 0, 1, 0, 0, 0, 0]4
2260.0014651.60[0, 0, 0, 1, 0, 0, 0, 1, 0]3
2410.0014651.60[1, 0, 0, 0, 0, 0, 0, 0, 1]3
\n", - "
" - ], - "text/plain": [ - " probability cost solution count\n", - "5 0.012695 2.35 [1, 0, 0, 0, 0, 1, 0, 1, 0] 26\n", - "14 0.008789 2.35 [1, 0, 0, 0, 1, 0, 0, 0, 1] 18\n", - "33 0.005859 2.20 [0, 1, 0, 1, 0, 0, 0, 0, 1] 12\n", - "11 0.010254 2.20 [0, 0, 1, 1, 0, 0, 0, 1, 0] 21\n", - "9 0.010742 2.20 [0, 1, 0, 0, 0, 1, 1, 0, 0] 22\n", - "13 0.009277 2.20 [0, 0, 1, 0, 1, 0, 1, 0, 0] 19\n", - "80 0.003906 1.70 [1, 0, 0, 0, 0, 0, 0, 1, 0] 8\n", - "167 0.001953 1.65 [1, 0, 0, 0, 1, 0, 0, 0, 0] 4\n", - "226 0.001465 1.60 [0, 0, 0, 1, 0, 0, 0, 1, 0] 3\n", - "241 0.001465 1.60 [1, 0, 0, 0, 0, 0, 0, 0, 1] 3" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "from classiq.applications.combinatorial_optimization import (get_optimization_solution_from_pyo, )\n", - "\n", - "solution = get_optimization_solution_from_pyo(model, vqe_result=vqe_result, penalty_energy=qaoa_config.penalty_energy)\n", - "\n", - "optimization_result = pd.DataFrame.from_records(solution)\n", - "\n", - "print(\"\\n\\033[1m\\033[4mTop 10 Solutions\\033[0m\")\n", - "optimization_result.sort_values(by=\"cost\", ascending=False).head(10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Histogram of Cost and Weighted by Probability" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "optimization_result[\"cost\"].plot(\n", - " kind=\"hist\", bins=30, edgecolor=\"black\", weights=optimization_result[\"probability\"]\n", - ")\n", - "plt.ylabel(\"Probability\", fontsize=12)\n", - "plt.xlabel(\"Cost\", fontsize=12)\n", - "plt.tick_params(axis=\"both\", labelsize=12)\n", - "plt.title(\"Histogram of Cost Weighted by Probability\", fontsize=16)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Create a Network Graph for the Best Solution Found\n", - "$\\star$ Very important to remember that this is a mximization problem and the classical solver of the QAOA process returns all possible results. We need to filter out the solution with the highest cost which would represent the the highest compatability score. " - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m\u001b[4m** QAOA SOLUTION **\u001b[0m\n", - "\u001b[4mHighest Compatibility Score\u001b[0m = 2.3499999999999996\n", - " patient1 patient2 patient3\n", - "donor1 1 0 0\n", - "donor2 0 0 1\n", - "donor3 0 1 0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# This function plots the solution in a table and a graph\n", - "\n", - "\n", - "def plotting_sol(x_sol, cost):\n", - " x_sol_to_mat = np.reshape(np.array(x_sol), [N, M]) # vector to matrix\n", - " print(\"\\033[1m\\033[4m** QAOA SOLUTION **\\033[0m\")\n", - " print(\"\\033[4mHighest Compatibility Score\\033[0m = \" , cost)\n", - "\n", - " # plotting in a table\n", - " df = pd.DataFrame(x_sol_to_mat)\n", - " df.columns = patients\n", - " df.index = donors\n", - " print(df)\n", - " \n", - "\n", - " # plotting in a graph\n", - " graph_sol = nx.DiGraph()\n", - " graph_sol.add_nodes_from(donors+patients)\n", - " for n, m in product(range(N), range(M)):\n", - " if x_sol_to_mat[n, m] > 0:\n", - " graph_sol.add_edges_from(\n", - " [(donors[m], patients[n])] , weight=compatibility_scores[(donors[m], patients[n])]\n", - " )\n", - "\n", - " plt.figure(figsize=(10, 6))\n", - " left = nx.bipartite.sets(graph_sol, top_nodes=patients)[0]\n", - " pos = nx.bipartite_layout(graph_sol, left)\n", - "\n", - " nx.draw_networkx(\n", - " graph_sol, pos=pos, nodelist=patients, font_size=22, font_color=\"None\"\n", - " )\n", - " nx.draw_networkx_nodes(\n", - " graph_sol, pos, nodelist=patients, node_color=\"#119DA4\", node_size=500\n", - " )\n", - " for d in donors:\n", - " x, y = pos[d]\n", - " plt.text(\n", - " x,\n", - " y,\n", - " s=d,\n", - " bbox=dict(facecolor=\"#F43764\", alpha=1),\n", - " horizontalalignment=\"center\",\n", - " fontsize=12,\n", - " )\n", - " \n", - "\n", - " nx.draw_networkx_edges(graph_sol, pos, width=2)\n", - " labels = nx.get_edge_attributes(graph_sol, \"weight\")\n", - " nx.draw_networkx_edge_labels(graph_sol, pos, edge_labels=labels, font_size=12, label_pos=.6)\n", - " nx.draw_networkx_labels(\n", - " graph_sol,\n", - " pos,\n", - " labels={co: co for co in patients},\n", - " font_size=12,\n", - " #font_color=\"#F4F9E9\",\n", - " )\n", - " plt.title(\"Network Graph of the Best Solution\", fontsize=16)\n", - " plt.axis(\"off\")\n", - " plt.show()\n", - "\n", - "\n", - "#best_solution = optimization_result.loc[optimization_result.probability.idxmax()]\n", - "#plotting_sol(best_solution.solution, best_solution.probability)\n", - "\n", - "best_solution = optimization_result.loc[optimization_result.cost.idxmax()]\n", - "plotting_sol(best_solution.solution, best_solution.cost)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Classiq", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.18" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/community/QClass_2024/Submissions/HW4/HW_4_Bill_Wisotsky.ipynb b/community/QClass_2024/Submissions/HW4/HW_4_Bill_Wisotsky.ipynb new file mode 100644 index 00000000..a8bd7ad8 --- /dev/null +++ b/community/QClass_2024/Submissions/HW4/HW_4_Bill_Wisotsky.ipynb @@ -0,0 +1,689 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Kidney Exchange QAOA Example\n", + "Used samples from Classiq github on QAOA and internet for pyomo models \n", + "Modified as needed for specfic problem and limitations based on account. \n", + "\n", + "What is the Problem? \n", + "Currently there are more than 100,000 patients on the waitling list in the United States for a kidney transplant from a deceased donor. This is addressed by the a program called the Kidney Exchange Program. This program won the Nobel Prize in Economics for Alvin E. Roth and Lloyd S. Shapley's contributions to the theory of stable matchings and the design of markets on 2012.\n", + "In summary, in a donor pair there is a recipient who needs a kidney transplant and a donor who is willing to give their kidney to the recipient. About $\\frac{1}{3}$ of those pairs are not compatible for a direct exchange. This is tackled by considering two incompatible pairs together: donor 1 may be compatible with recpient 2 and donor 2 may be compatible with recpient 1. In this example a two-way swap becomes feasible. This is the core of the kideny exchange program. \n", + "\n", + "This is consdered an NP-Hard combinatorial optimization problem that becomes exponetially more difficult as the size of the pool increases. The longest chain in history involved 35 tranplants in the United States in 2015." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import io\n", + "import sys\n", + "import time\n", + "import warnings\n", + "from contextlib import redirect_stdout\n", + "from itertools import product\n", + "from typing import List, Tuple, cast # noqa\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import networkx as nx # noqa\n", + "import numpy as np\n", + "import pandas as pd\n", + "import pyomo.environ as pyo\n", + "from IPython.display import Markdown, display\n", + "from pyomo.environ import *\n", + "\n", + "import classiq\n", + "from classiq import *\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create the pyomo model for a simple kidney exhange problem \n", + "\n", + "In this very simple example, patients and donors represent sets of patients that receive a kidney from a donor. Compatibility is a dictionary mapping of patient-donor paris to their compatibilty scores. Binary decision variables are defined for each patient-donor pair x[donor,patient]. The objective is to maximize the total compatibility score. $ Maximize \\sum_{d,p\\in A}^{} \\sum_{m\\in M}c_{dp}x_{dpm}$ where d=donors, p=patients and c=compatability score. The contraints are added to ensure that each donor donates only once $\\sum_{d,p\\in A}^{}x_{dpm} = y_{dm}$ and each patient receives once $\\sum_{d,p\\in A}^{}x_{dpm} = y_{pm}$. We are creating a PYOMO model that gets fed into Classiq, as illustrated in Classiq documentation. We also solve initially with a classical solver to get inital results which can be compared to the QAOA results in the end." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m\u001b[4mOptimal solution:\u001b[0m\n", + "\n", + "\u001b[1m\u001b[4mModel Details\u001b[0m\n", + "5 Set Declarations\n", + " donor_constraint_index : Size=1, Index=None, Ordered=Insertion\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 1 : Any : 3 : {1, 2, 3}\n", + " patient_constraint_index : Size=1, Index=None, Ordered=Insertion\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 1 : Any : 3 : {1, 2, 3}\n", + " x_index : Size=1, Index=None, Ordered=True\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 2 : x_index_0*x_index_1 : 9 : {('donor1', 'patient1'), ('donor1', 'patient2'), ('donor1', 'patient3'), ('donor2', 'patient1'), ('donor2', 'patient2'), ('donor2', 'patient3'), ('donor3', 'patient1'), ('donor3', 'patient2'), ('donor3', 'patient3')}\n", + " x_index_0 : Size=1, Index=None, Ordered=Insertion\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 1 : Any : 3 : {'donor1', 'donor2', 'donor3'}\n", + " x_index_1 : Size=1, Index=None, Ordered=Insertion\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 1 : Any : 3 : {'patient1', 'patient2', 'patient3'}\n", + "\n", + "1 Var Declarations\n", + " x : Size=9, Index=x_index\n", + " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", + " ('donor1', 'patient1') : 0 : None : 1 : False : True : Binary\n", + " ('donor1', 'patient2') : 0 : None : 1 : False : True : Binary\n", + " ('donor1', 'patient3') : 0 : None : 1 : False : True : Binary\n", + " ('donor2', 'patient1') : 0 : None : 1 : False : True : Binary\n", + " ('donor2', 'patient2') : 0 : None : 1 : False : True : Binary\n", + " ('donor2', 'patient3') : 0 : None : 1 : False : True : Binary\n", + " ('donor3', 'patient1') : 0 : None : 1 : False : True : Binary\n", + " ('donor3', 'patient2') : 0 : None : 1 : False : True : Binary\n", + " ('donor3', 'patient3') : 0 : None : 1 : False : True : Binary\n", + "\n", + "1 Objective Declarations\n", + " obj : Size=1, Index=None, Active=True\n", + " Key : Active : Sense : Expression\n", + " None : True : maximize : 0.9*x[donor1,patient1] + 0.7*x[donor1,patient2] + 0.6*x[donor1,patient3] + 0.8*x[donor2,patient1] + 0.75*x[donor2,patient2] + 0.65*x[donor2,patient3] + 0.85*x[donor3,patient1] + 0.8*x[donor3,patient2] + 0.7*x[donor3,patient3]\n", + "\n", + "2 Constraint Declarations\n", + " donor_constraint : Size=3, Index=donor_constraint_index, Active=True\n", + " Key : Lower : Body : Upper : Active\n", + " 1 : -Inf : x[donor1,patient1] + x[donor1,patient2] + x[donor1,patient3] : 1.0 : True\n", + " 2 : -Inf : x[donor2,patient1] + x[donor2,patient2] + x[donor2,patient3] : 1.0 : True\n", + " 3 : -Inf : x[donor3,patient1] + x[donor3,patient2] + x[donor3,patient3] : 1.0 : True\n", + " patient_constraint : Size=3, Index=patient_constraint_index, Active=True\n", + " Key : Lower : Body : Upper : Active\n", + " 1 : -Inf : x[donor1,patient1] + x[donor2,patient1] + x[donor3,patient1] : 1.0 : True\n", + " 2 : -Inf : x[donor1,patient2] + x[donor2,patient2] + x[donor3,patient2] : 1.0 : True\n", + " 3 : -Inf : x[donor1,patient3] + x[donor2,patient3] + x[donor3,patient3] : 1.0 : True\n", + "\n", + "9 Declarations: x_index_0 x_index_1 x_index x obj donor_constraint_index donor_constraint patient_constraint_index patient_constraint\n" + ] + } + ], + "source": [ + "from pyomo.environ import *\n", + "\n", + "# Sample data: patient-donor pairs and compatibility scores\n", + "donors = [\"donor1\", \"donor2\", \"donor3\"]\n", + "patients = [\"patient1\", \"patient2\", \"patient3\"]\n", + "N = len(patients)\n", + "M = len(donors)\n", + "# Parameters\n", + "compatibility_scores = {\n", + " (\"donor1\", \"patient1\"): 0.9,\n", + " (\"donor1\", \"patient2\"): 0.7,\n", + " (\"donor1\", \"patient3\"): 0.6,\n", + " (\"donor2\", \"patient1\"): 0.8,\n", + " (\"donor2\", \"patient2\"): 0.75,\n", + " (\"donor2\", \"patient3\"): 0.65,\n", + " (\"donor3\", \"patient1\"): 0.85,\n", + " (\"donor3\", \"patient2\"): 0.8,\n", + " (\"donor3\", \"patient3\"): 0.7,\n", + "}\n", + "\n", + "# Create Pyomo model\n", + "model = ConcreteModel()\n", + "\n", + "# Variables\n", + "model.x = Var(donors, patients, within=Binary)\n", + "\n", + "# Objective\n", + "model.obj = Objective(\n", + " expr=sum(\n", + " compatibility_scores[donor, patient] * model.x[donor, patient]\n", + " for donor in donors\n", + " for patient in patients\n", + " ),\n", + " sense=maximize,\n", + ")\n", + "\n", + "# Constraints\n", + "model.donor_constraint = ConstraintList()\n", + "for donor in donors:\n", + " model.donor_constraint.add(\n", + " sum(model.x[donor, patient] for patient in patients) <= 1\n", + " )\n", + "\n", + "model.patient_constraint = ConstraintList()\n", + "for patient in patients:\n", + " model.patient_constraint.add(sum(model.x[donor, patient] for donor in donors) <= 1)\n", + "\n", + "# Install \"glpk\" and unommente for runing this part\n", + "# Solve\n", + "# solver = SolverFactory(\"glpk\")\n", + "# solver.solve(model)\n", + "\n", + "# Output\n", + "print(\"\\033[1m\\033[4mOptimal solution:\\033[0m\")\n", + "for donor in donors:\n", + " for patient in patients:\n", + " if model.x[donor, patient].value == 1:\n", + " print(f\"{donor} donates kidney to {patient}\")\n", + "\n", + "print(\"\\n\\033[1m\\033[4mModel Details\\033[0m\")\n", + "model.pprint()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Start Generatng the QAOA Process\n", + " \n", + "### Create the inital parameters for the quantum circuit. These can me modified as needed.\n", + "1. Defining the number of layers (num_layers) of the QAOA Ansatz. \n", + "2. Define the penalty_energy for invalid solutions, which influences the convergence rate. Smaller positive values are preferred, but shoudl be tweaked. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import (\n", + " Preferences,\n", + " construct_combinatorial_optimization_model,\n", + " set_preferences,\n", + ")\n", + "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", + "\n", + "qaoa_config = QAOAConfig(num_layers=5, penalty_energy=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create the classical optimizer part of the QAOA. These parameters can be modified.\n", + "1. opt_type is the classical optimizer type. Choices include, COBYLA, SPSA, ADAM, L_BFGS_B, and NELDER_MEAD\n", + "2. The max_iterations is the maximum number of optimzer iterations and is set to 100. \n", + "3. The alpha_cvar is a parameter that describes the quantile considered in the CVAR expectation value. See https://arxiv.org/abs/1907.04769 for more information." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer_config = OptimizerConfig(\n", + " # opt_type='COBYLA',\n", + " max_iteration=200,\n", + " alpha_cvar=1,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Combine everthing together to form the entire QAOA model as a QMOD.\n", + "1. PYOMO Model \n", + "2. QAOA quantum circuit \n", + "3. Clasical optimizer " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "qmod = construct_combinatorial_optimization_model(\n", + " pyo_model=model,\n", + " qaoa_config=qaoa_config,\n", + " optimizer_config=optimizer_config,\n", + ")\n", + "\n", + "# defining cosntraint such as computer and parameters for a quicker and more optimized circuit.\n", + "preferences = Preferences(transpilation_option=\"none\", timeout_seconds=3000)\n", + "\n", + "qmod = set_preferences(qmod, preferences)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Wite out the QMOD and preferences to a JSON file \n", + "2. Synthesize the model in Classiq interface \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# from classiq import write_qmod\n", + "# write_qmod(qmod, \"Kidney Exchange\") # optional" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Sythesize the quantum model\n", + "2. Show the quantm model in the Classiq platform" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import show, synthesize\n", + "\n", + "qmod = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Execute the quantum model and store the result." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import execute\n", + "\n", + "res = execute(qprog).result()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "View the convergence graph \n", + "Important to remember that this is a maximization problem when looking at the graph" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from classiq.execution import VQESolverResult\n", + "\n", + "vqe_result = res[0].value\n", + "vqe_result.convergence_graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Retrieve and Display the Solutions\n", + "- Print them out\n", + "- Graph using a histogram\n", + "- Show Donor - Recipients in Network Graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Print out the top 10 solutions with the highest cost or objective" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\u001b[1m\u001b[4mTop 10 Solutions\u001b[0m\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
probabilitycostsolutioncount
500.0048832.35[1, 0, 0, 0, 1, 0, 0, 0, 1]10
450.0048832.35[1, 0, 0, 0, 0, 1, 0, 1, 0]10
410.0053712.20[0, 0, 1, 1, 0, 0, 0, 1, 0]11
1200.0029302.20[0, 1, 0, 1, 0, 0, 0, 0, 1]6
310.0063482.20[0, 1, 0, 0, 0, 1, 1, 0, 0]13
1310.0029302.20[0, 0, 1, 0, 1, 0, 1, 0, 0]6
190.0078121.70[1, 0, 0, 0, 0, 0, 0, 1, 0]16
630.0043951.65[1, 0, 0, 0, 1, 0, 0, 0, 0]9
360.0058591.60[0, 0, 0, 1, 0, 0, 0, 1, 0]12
800.0039061.60[1, 0, 0, 0, 0, 0, 0, 0, 1]8
\n", + "
" + ], + "text/plain": [ + " probability cost solution count\n", + "50 0.004883 2.35 [1, 0, 0, 0, 1, 0, 0, 0, 1] 10\n", + "45 0.004883 2.35 [1, 0, 0, 0, 0, 1, 0, 1, 0] 10\n", + "41 0.005371 2.20 [0, 0, 1, 1, 0, 0, 0, 1, 0] 11\n", + "120 0.002930 2.20 [0, 1, 0, 1, 0, 0, 0, 0, 1] 6\n", + "31 0.006348 2.20 [0, 1, 0, 0, 0, 1, 1, 0, 0] 13\n", + "131 0.002930 2.20 [0, 0, 1, 0, 1, 0, 1, 0, 0] 6\n", + "19 0.007812 1.70 [1, 0, 0, 0, 0, 0, 0, 1, 0] 16\n", + "63 0.004395 1.65 [1, 0, 0, 0, 1, 0, 0, 0, 0] 9\n", + "36 0.005859 1.60 [0, 0, 0, 1, 0, 0, 0, 1, 0] 12\n", + "80 0.003906 1.60 [1, 0, 0, 0, 0, 0, 0, 0, 1] 8" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "from classiq.applications.combinatorial_optimization import (\n", + " get_optimization_solution_from_pyo,\n", + ")\n", + "\n", + "solution = get_optimization_solution_from_pyo(\n", + " model, vqe_result=vqe_result, penalty_energy=qaoa_config.penalty_energy\n", + ")\n", + "\n", + "optimization_result = pd.DataFrame.from_records(solution)\n", + "\n", + "print(\"\\n\\033[1m\\033[4mTop 10 Solutions\\033[0m\")\n", + "optimization_result.sort_values(by=\"cost\", ascending=False).head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Histogram of Cost and Weighted by Probability" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "optimization_result[\"cost\"].plot(\n", + " kind=\"hist\", bins=30, edgecolor=\"black\", weights=optimization_result[\"probability\"]\n", + ")\n", + "plt.ylabel(\"Probability\", fontsize=12)\n", + "plt.xlabel(\"Cost\", fontsize=12)\n", + "plt.tick_params(axis=\"both\", labelsize=12)\n", + "plt.title(\"Histogram of Cost Weighted by Probability\", fontsize=16)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create a Network Graph for the Best Solution Found\n", + "$\\star$ Very important to remember that this is a mximization problem and the classical solver of the QAOA process returns all possible results. We need to filter out the solution with the highest cost which would represent the the highest compatability score. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m\u001b[4m** QAOA SOLUTION **\u001b[0m\n", + "\u001b[4mHighest Compatibility Score\u001b[0m = 2.3499999999999996\n", + " patient1 patient2 patient3\n", + "donor1 1 0 0\n", + "donor2 0 0 1\n", + "donor3 0 1 0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# This function plots the solution in a table and a graph\n", + "\n", + "\n", + "def plotting_sol(x_sol, cost):\n", + " x_sol_to_mat = np.reshape(np.array(x_sol), [N, M]) # vector to matrix\n", + " print(\"\\033[1m\\033[4m** QAOA SOLUTION **\\033[0m\")\n", + " print(\"\\033[4mHighest Compatibility Score\\033[0m = \", cost)\n", + "\n", + " # plotting in a table\n", + " df = pd.DataFrame(x_sol_to_mat)\n", + " df.columns = patients\n", + " df.index = donors\n", + " print(df)\n", + "\n", + " # plotting in a graph\n", + " graph_sol = nx.DiGraph()\n", + " graph_sol.add_nodes_from(donors + patients)\n", + " for n, m in product(range(N), range(M)):\n", + " if x_sol_to_mat[n, m] > 0:\n", + " graph_sol.add_edges_from(\n", + " [(donors[m], patients[n])],\n", + " weight=compatibility_scores[(donors[m], patients[n])],\n", + " )\n", + "\n", + " plt.figure(figsize=(10, 6))\n", + " left = nx.bipartite.sets(graph_sol, top_nodes=patients)[0]\n", + " pos = nx.bipartite_layout(graph_sol, left)\n", + "\n", + " nx.draw_networkx(\n", + " graph_sol, pos=pos, nodelist=patients, font_size=22, font_color=\"None\"\n", + " )\n", + " nx.draw_networkx_nodes(\n", + " graph_sol, pos, nodelist=patients, node_color=\"#119DA4\", node_size=500\n", + " )\n", + " for d in donors:\n", + " x, y = pos[d]\n", + " plt.text(\n", + " x,\n", + " y,\n", + " s=d,\n", + " bbox=dict(facecolor=\"#F43764\", alpha=1),\n", + " horizontalalignment=\"center\",\n", + " fontsize=12,\n", + " )\n", + "\n", + " nx.draw_networkx_edges(graph_sol, pos, width=2)\n", + " labels = nx.get_edge_attributes(graph_sol, \"weight\")\n", + " nx.draw_networkx_edge_labels(\n", + " graph_sol, pos, edge_labels=labels, font_size=12, label_pos=0.6\n", + " )\n", + " nx.draw_networkx_labels(\n", + " graph_sol,\n", + " pos,\n", + " labels={co: co for co in patients},\n", + " font_size=12,\n", + " # font_color=\"#F4F9E9\",\n", + " )\n", + " plt.title(\"Network Graph of the Best Solution\", fontsize=16)\n", + " plt.axis(\"off\")\n", + " plt.show()\n", + "\n", + "\n", + "# best_solution = optimization_result.loc[optimization_result.probability.idxmax()]\n", + "# plotting_sol(best_solution.solution, best_solution.probability)\n", + "\n", + "best_solution = optimization_result.loc[optimization_result.cost.idxmax()]\n", + "plotting_sol(best_solution.solution, best_solution.cost)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/community/QClass_2024/Submissions/HW4/Hisham_Mansour_HW4_qpe_for_molecules.ipynb b/community/QClass_2024/Submissions/HW4/Hisham_Mansour_HW4_qpe_for_molecules.ipynb new file mode 100644 index 00000000..4463eb4d --- /dev/null +++ b/community/QClass_2024/Submissions/HW4/Hisham_Mansour_HW4_qpe_for_molecules.ipynb @@ -0,0 +1,1497 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "75e2c1fe-8a06-4f0b-8fd6-d1b6d10ce82f", + "metadata": { + "id": "75e2c1fe-8a06-4f0b-8fd6-d1b6d10ce82f" + }, + "source": [ + "# Quantum Phase Estimation (QPE) for Solving Molecular Energies\n", + "\n", + "\n", + "Quantum Phase Estimation (QPE) is a key algorithm in quantum computing, allowing one to estimate the phase (or eigenvalue) of an eigenvector of a unitary operation. The algorithm is designed so, that for a given Hamiltonian $H$, and an eigenvalue ${|\\psi\\rangle}$, the output that will be obtained is $\\epsilon$ where\n", + "\n", + "$U{|\\psi\\rangle} = e^{2\\pi i\\epsilon}{|\\psi\\rangle} , U = e^{2\\pi iH}$ .\n", + "\n", + "\n", + "Therefore, by measuring the phase accumulated, the QPE algorithm allows calculating the energies relating to the chosen initial state.\n", + "When using QPE for chemistry problems, it is common to search for the lowest energy of a given molecule. As the molecule can be written in the form of a Hamiltonian (Hermitian matrix which meaning is the energetic forces of the structure), usually symbolized by \"H\", one only need to insert the ground eigenvector in order to obtain the minimal energy value using QPE. However, obtaining the ground state is not a trivial problem. In order to overcome it, it is sufficient to use a state with big overlap with the ground state.\n", + "\n", + "We define a state ${|v\\rangle}$ which will be chosen as the algorithm's initial state. Let us define {$\\psi_i$} to be the set of (unknown) eigenvalues of $H$. Generally, any vector can be rewritten as a superposition of any basis set, thus -\n", + "\n", + "${|v\\rangle} = \\sum_i a_i{|\\psi_i\\rangle}$\n", + "\n", + "and -\n", + "\n", + "$U{|v\\rangle} = \\sum_i a_i e^{2\\pi i\\epsilon_i}{|\\psi_i\\rangle}$.\n", + "\n", + "where ${\\epsilon_i}$ are the eigenvalues of H, i.e. the span of energies relating to the molecule. Using execution with enough shots, one will obtain this set of $\\theta_i$, i.e., a subset of the Hamiltonian's eigenvalues. As we are specifically interested in $\\epsilon_0$, the ground state of H, it is important that there is a large overlap between ${\\psi_0}$ and ${|v\\rangle}$ so the probability to measure ${\\epsilon_0}$ is high, i.e.\n", + "\n", + "$P(\\epsilon_0) = |\\langle v|\\psi_0\\rangle|^2 > \\epsilon $.\n", + "\n", + "How large is $\\epsilon$? After execution, we will obtain a set of ${E_i}$.\n", + "If we have done 1000 shots of execution, and $P(\\epsilon_0)>1$, it should be measured is about 10 times to get a good statistical variance.\n", + "\n", + "A common choice for ${|v\\rangle}$ (the initial state) is the Hartree-Fock (HF) state, which with good probability have a large overlap with the ground state. However, other guesses for the initial state are possibly good or even better fit, and choosing the right initial state is a sort of art and an active field of research.\n", + "\n", + "For further reading about QPE we recommend [[1](#NC)].\n", + "\n", + "\n", + "#### What are the benefits of using QPE algorithm for finding a molecule's ground state?\n", + "\n", + "The two most prominent methods to solve ground energy for molecules are quantum variational algorithm (VQE) and QPE. Those promise better scalability compared to classical counterparts as the molecules becomes more complex, with larger number of electrons manifesting as more degrees of freedom for the problem.\n", + "\n", + "While so, the number of parameters in VQE is closely related to the number of electrons. This may create inherent difficulty achieving high-precision calculations through sampling statistical estimators, and paraphs even not converge for very large systems. While so, the number of parameters in QPE is a flexible value which is directly related to the resolution of the problem, but is not bonded with the number of electrons.\n", + "\n", + "Furthermore, it is known that advanced quantum algorithms based on QPE can perform electronic structure calculations in sub-exponential time with accuracy that rivals exact diagonalization methods. This guarantee of simultaneously achieving high accuracy, efficiency, and generality is a feat that is believed to be impossible for classical algorithms. For those reasons, VQE is applicable in the near term (NISQ) era, while QPE is suited for fault-tolerant design.\n", + "\n", + "#### During this tutorial, we will follow the QPE algorithms steps as following:\n", + "\n", + "a. Define a molecule and convert it into a Hamiltonian H, manifested as a pauli list.\n", + "\n", + "b. Prepare the Hamiltonian for QPE: including normalization and choosing the resolution.\n", + "\n", + "c. Initializing the state for the HF state.\n", + "\n", + "d. Preparing the quantum circuit.\n", + "\n", + "e. Executing the circuit to find the related phases and analyzing the results to find the ground state.\n", + "\n", + "f. Comparing the QPE results with exact solution for the molecule’s ground state." + ] + }, + { + "cell_type": "markdown", + "id": "7cd71faa-1ef3-4d67-8c9a-d66e0a895b9a", + "metadata": { + "id": "7cd71faa-1ef3-4d67-8c9a-d66e0a895b9a" + }, + "source": [ + "## 0. Pre-requirments\n", + "\n", + "The model is using several Classiq's libraries in addition to IBM's simulating tool." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "k3DQRV9GpPSG", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "k3DQRV9GpPSG", + "outputId": "4039a7c0-2b12-4e86-d14a-455090db8a57" + }, + "outputs": [], + "source": [ + "# !pip install -U classiq" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "Nsm3pKlqpZpr", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Nsm3pKlqpZpr", + "outputId": "c7a6175b-bfa2-4b6a-f067-36f48d33d94c" + }, + "outputs": [], + "source": [ + "# import classiq\n", + "# classiq.authenticate()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "11eaf8f8-c06e-443e-ac74-5aa364f5198c", + "metadata": { + "id": "11eaf8f8-c06e-443e-ac74-5aa364f5198c", + "tags": [] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy\n", + "from numpy import linalg as LA\n", + "\n", + "# for state preperation and phase estimation\n", + "from classiq import Constraints, Preferences\n", + "\n", + "# for chemistry\n", + "from classiq.applications.chemistry import Molecule, MoleculeProblem, PauliOperator" + ] + }, + { + "cell_type": "markdown", + "id": "ac537458-568d-4718-9020-408cc7232641", + "metadata": { + "id": "ac537458-568d-4718-9020-408cc7232641" + }, + "source": [ + "## 1. Create Your Molecule" + ] + }, + { + "cell_type": "markdown", + "id": "WC3NKxILHo6H", + "metadata": { + "id": "WC3NKxILHo6H" + }, + "source": [ + "### XYZ cartesian coordinates" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "2b67b2e1-94c2-4c8f-8ee9-577c79a7234f", + "metadata": { + "id": "2b67b2e1-94c2-4c8f-8ee9-577c79a7234f", + "tags": [] + }, + "outputs": [], + "source": [ + "# build your molecule\n", + "\n", + "# hydrogen\n", + "molecule_H2 = Molecule(atoms=[(\"H\", (0.0, 0.0, 0)), (\"H\", (0.0, 0.0, 0.735))])\n", + "# oxygen\n", + "molecule_O2 = Molecule(atoms=[(\"O\", (0.0, 0.0, 0)), (\"O\", (0.0, 0.0, 1.16))])\n", + "# lithium hydride\n", + "molecule_LiH = Molecule(atoms=[(\"H\", (0.0, 0.0, 0.0)), (\"Li\", (0.0, 0.0, 1.596))])\n", + "# water\n", + "molecule_H2O = Molecule(\n", + " atoms=[(\"O\", (0.0, 0.0, 0.0)), (\"H\", (0, 0.586, 0.757)), (\"H\", (0, 0.586, -0.757))]\n", + ")\n", + "# beryllium hydride\n", + "molecule_BeH2 = Molecule(\n", + " atoms=[(\"Be\", (0.0, 0.0, 0.0)), (\"H\", (0, 0, 1.334)), (\"H\", (0, 0, -1.334))]\n", + ")\n", + "# carbon dioxide\n", + "molecule_CO2 = Molecule(\n", + " atoms=[(\"C\", (0.0, 0.0, 0.0)), (\"O\", (0, 0, 1.1693)), (\"O\", (0, 0, -1.1693))]\n", + ")\n", + "# ethyne, acetylene\n", + "molecule_C2H2 = Molecule(\n", + " atoms=[\n", + " (\"C\", (0, 0, -0.5977)),\n", + " (\"C\", (0, 0, 0.5977)),\n", + " (\"H\", (0, 0, -1.6692)),\n", + " (\"H\", (0, 0, 1.6692)),\n", + " ]\n", + ")\n", + "# chloroform\n", + "molecule_CH3Cl = Molecule(\n", + " atoms=[\n", + " (\"C\", (0, 0, -1.1401)),\n", + " (\"Cl\", (0, 0, 0.6645)),\n", + " (\"H\", (0, 1.0343, -1.4855)),\n", + " (\"H\", (0.8957, -0.5171, -1.4855)),\n", + " (\"H\", (-0.8957, -0.5171, -1.4855)),\n", + " ]\n", + ")\n", + "# ethylene\n", + "molecule_C2H4 = Molecule(\n", + " atoms=[\n", + " (\"C\", (0, 0, 0.6673)),\n", + " (\"C\", (0, 0, -0.6673)),\n", + " (\"H\", (0, 0.9239, 1.2411)),\n", + " (\"H\", (0, -0.9239, 1.2411)),\n", + " (\"H\", (0, -0.9239, -1.2411)),\n", + " (\"H\", (0, 0.9239, -1.2411)),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "9e37fada-9ecc-4a24-bf2c-0994e9c14149", + "metadata": { + "id": "9e37fada-9ecc-4a24-bf2c-0994e9c14149", + "tags": [] + }, + "outputs": [], + "source": [ + "# define your molecule\n", + "# molecule = molecule_H2\n", + "# molecule = molecule_O2\n", + "# molecule = molecule_LiH\n", + "\n", + "molecule = molecule_BeH2\n", + "\n", + "# molecule = molecule_H2O\n", + "\n", + "# molecule = molecule_CO2\n", + "# The exponentiation constraints are not satisfiable.\n", + "# Minimal max_depth is 36476.\n", + "# molecule = molecule_CH3Cl\n", + "# The exponentiation constraints are not satisfiable.\n", + "# Minimal max_depth is 57965.\n", + "# molecule = molecule_C2H2\n", + "# The exponentiation constraints are not satisfiable.\n", + "# Minimal max_depth is 15115.\n", + "# molecule = molecule_C2H4\n", + "# The exponentiation constraints are not satisfiable.\n", + "# Minimal max_depth is 24471." + ] + }, + { + "cell_type": "markdown", + "id": "ClsUidSlHIsO", + "metadata": { + "id": "ClsUidSlHIsO" + }, + "source": [ + "# **Results for BeH2:**\n", + "\n", + "Your qubit solution is [{'phase': 0.46875}: 135341]\n", + "\n", + "The final results of the Energy (matrix's eigenvlues) is therefore:\n", + "\n", + "[-5.0500156710895965]\n", + "\n", + "exact result: -3.940331561325765\n", + "\n", + "The results including the error contributed from the resolution (number of qubits participating in the QPE) are: The resolution of result is 3.3666771140597356 the energy solution is between -8.416692785149332 and -1.683338557029861" + ] + }, + { + "cell_type": "markdown", + "id": "Cab7eyKPHSW8", + "metadata": { + "id": "Cab7eyKPHSW8" + }, + "source": [ + "# **Results for H2O:**\n", + "\n", + "Your qubit solution is\n", + "[{'phase': 0.453125}: 89076]\n", + "\n", + "The final results of the Energy (matrix's eigenvlues) is therefore:\n", + "\n", + "[-29.018825909142947]\n", + "\n", + "exact result: -23.54449724044351\n", + "\n", + "\n", + "The results including the error contributed from the resolution (number of qubits\n", + "participating in the QPE) are:\n", + "The resolution of result is 11.607530363657174\n", + "the energy solution is between -40.62635627280012 and -17.41129554548577\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "5d27e5df-e16e-44b2-b78a-187905577908", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5d27e5df-e16e-44b2-b78a-187905577908", + "outputId": "7bad3408-043c-4a50-beb7-a0b2acfb6360", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your Hamiltonian is\n", + "-0.702 * IIIIIII\n", + "-0.230 * ZIZZZIZ\n", + "-0.022 * IIIIIZX\n", + "+0.022 * ZIZZZZX\n", + "-0.251 * ZIIIZZI\n", + "-0.058 * ZIZZZXZ\n", + "+0.058 * IIZZIXZ\n", + "-0.857 * IIIZIII\n", + "-0.857 * IIZIIII\n", + "-0.495 * IIIIIIZ\n", + "-0.755 * IIIIIZI\n", + "-0.230 * ZZZZZII\n", + "-0.022 * ZXIIIII\n", + "+0.022 * IXZZZII\n", + "-0.251 * IIIIZII\n", + "+0.058 * YZZZYII\n", + "+0.058 * XZZZXII\n", + "-0.495 * IZIIIII\n", + "-0.755 * ZIIIIII\n", + "+0.062 * IIZZIZZ\n", + "+0.010 * IIIIIXI\n", + "-0.010 * ZIIIZXI\n", + "+0.172 * ZIZIZIZ\n", + "+0.172 * ZIIZZIZ\n", + "+0.159 * ZIZZZII\n", + "+0.093 * ZIZZZZZ\n", + "+0.012 * ZIIIZIX\n", + "-0.012 * IIZZIIX\n", + "+0.003 * ZIZZZYY\n", + "+0.020 * IIZZIXX\n", + "+0.017 * IIZZIYY\n", + "+0.017 * IIIIIYY\n", + "+0.020 * IIIIIXX\n", + "+0.003 * ZIIIZYY\n", + "+0.014 * IIIZIZX\n", + "-0.014 * ZIZIZZX\n", + "+0.014 * IIZIIZX\n", + "-0.014 * ZIIZZZX\n", + "+0.005 * IIIIIIX\n", + "-0.005 * ZIZZZIX\n", + "+0.202 * IZIIIIZ\n", + "+0.003 * ZZZZZZX\n", + "-0.003 * IZIIIZX\n", + "+0.041 * ZZIIXZZ\n", + "-0.041 * IIZZXZZ\n", + "-0.041 * ZZZZXII\n", + "+0.041 * IIIIXII\n", + "-0.011 * ZZZZXXI\n", + "+0.011 * IIIIXXI\n", + "-0.011 * IZIIYYZ\n", + "+0.011 * ZIZZYYZ\n", + "+0.012 * ZZIXIZZ\n", + "-0.012 * IIZXZZZ\n", + "-0.012 * IZZXZZI\n", + "+0.012 * ZIIXIZI\n", + "+0.012 * ZZXIIZZ\n", + "-0.012 * IIXZZZZ\n", + "-0.012 * IZXZZZI\n", + "+0.012 * ZIXIIZI\n", + "+0.003 * IXZZZIZ\n", + "-0.003 * ZXIIIIZ\n", + "+0.039 * ZXIIIZX\n", + "-0.039 * IXZZZZX\n", + "-0.011 * XIZZIZZ\n", + "+0.011 * XZIIZZZ\n", + "+0.011 * XIIIIII\n", + "-0.011 * XZZZZII\n", + "+0.014 * XIIIIXI\n", + "-0.014 * XZZZZXI\n", + "+0.014 * YIZZZYZ\n", + "-0.014 * YZIIIYZ\n", + "+0.103 * ZIZZIIZ\n", + "-0.012 * IIIIZZX\n", + "+0.012 * ZIZZIZX\n", + "+0.024 * IYIIYZZ\n", + "+0.024 * IXIIXZZ\n", + "-0.024 * IYZZYII\n", + "-0.024 * IXZZXII\n", + "-0.015 * IYZZYXI\n", + "-0.015 * IXZZXXI\n", + "+0.015 * ZYIIXYZ\n", + "-0.015 * ZXIIYYZ\n", + "-0.001 * XZIIXIZ\n", + "-0.001 * YZIIYIZ\n", + "-0.018 * YZZZYZX\n", + "-0.018 * XZZZXZX\n", + "-0.018 * XZIIXZX\n", + "-0.018 * YZIIYZX\n", + "-0.012 * IYIYIZZ\n", + "-0.012 * IXIXIZZ\n", + "+0.012 * ZYZYZZI\n", + "+0.012 * ZXZXZZI\n", + "-0.012 * IYYIIZZ\n", + "-0.012 * IXXIIZZ\n", + "+0.012 * ZYYZZZI\n", + "+0.012 * ZXXZZZI\n", + "+0.198 * ZZZZZIZ\n", + "-0.036 * YYZZIZZ\n", + "-0.036 * XXZZIZZ\n", + "+0.036 * YYIIIII\n", + "+0.036 * XXIIIII\n", + "+0.014 * YYIIIXI\n", + "+0.014 * XXIIIXI\n", + "-0.014 * XYZZZYZ\n", + "+0.014 * YXZZZYZ\n", + "+0.107 * IIZZZIZ\n", + "-0.009 * ZIIIIZX\n", + "+0.009 * IIZZZZX\n", + "+0.174 * ZIIZZZI\n", + "+0.174 * ZIZIZZI\n", + "+0.081 * ZIIIZZZ\n", + "+0.182 * ZIIIZII\n", + "+0.026 * ZIZIZXZ\n", + "-0.026 * IIZIIXZ\n", + "+0.026 * ZIIZZXZ\n", + "-0.026 * IIIZIXZ\n", + "+0.017 * ZIZZZXI\n", + "-0.017 * IIZZIXI\n", + "+0.103 * IZZZIZI\n", + "-0.001 * IZIIIXZ\n", + "+0.001 * ZZIIZXZ\n", + "+0.024 * IZIIYZY\n", + "-0.024 * ZIZZYZY\n", + "+0.024 * ZZIIXIX\n", + "-0.024 * IIZZXIX\n", + "-0.012 * IXIIZZI\n", + "+0.012 * ZXZZIZI\n", + "+0.018 * IXZZZXZ\n", + "-0.018 * ZXIIIXZ\n", + "-0.018 * ZXZZIXZ\n", + "+0.018 * IXIIZXZ\n", + "-0.015 * YIZZZZY\n", + "+0.015 * YZIIIZY\n", + "-0.015 * XIZZIIX\n", + "+0.015 * XZIIZIX\n", + "+0.231 * ZIIIIZI\n", + "-0.003 * ZIZZIXZ\n", + "+0.003 * IIZZZXZ\n", + "+0.004 * ZIIXXZI\n", + "+0.004 * ZIIYYZI\n", + "+0.004 * IIIYYII\n", + "+0.004 * IIIXXII\n", + "+0.004 * ZIXIXZI\n", + "+0.004 * ZIYIYZI\n", + "+0.004 * IIYIYII\n", + "+0.004 * IIXIXII\n", + "-0.021 * ZYIIXZY\n", + "+0.021 * ZXIIYZY\n", + "+0.021 * IYIIYIX\n", + "+0.021 * IXIIXIX\n", + "-0.003 * XZZZXZI\n", + "-0.003 * YZZZYZI\n", + "+0.041 * XZIIXXZ\n", + "+0.041 * YZIIYXZ\n", + "+0.003 * XZZXZZI\n", + "+0.003 * YZZYZZI\n", + "+0.003 * YZZYIII\n", + "+0.003 * XZZXIII\n", + "+0.003 * XZXZZZI\n", + "+0.003 * YZYZZZI\n", + "+0.003 * YZYZIII\n", + "+0.003 * XZXZIII\n", + "+0.102 * ZZIIZZI\n", + "-0.007 * ZZZZZXZ\n", + "+0.007 * IZZZIXZ\n", + "+0.024 * XYZZZZY\n", + "-0.024 * YXZZZZY\n", + "-0.024 * YYZZIIX\n", + "-0.024 * XXZZIIX\n", + "+0.223 * IIIIZZI\n", + "+0.389 * IIZZIII\n", + "+0.171 * IIIZIIZ\n", + "+0.191 * IIIZIZI\n", + "+0.172 * ZZZIZII\n", + "-0.012 * ZZIYIIY\n", + "+0.012 * IIZYZIY\n", + "-0.012 * ZZIXIIX\n", + "+0.012 * IIZXZIX\n", + "+0.014 * ZXIZIII\n", + "-0.014 * IXZIZII\n", + "+0.174 * IIIZZII\n", + "-0.003 * IIZXYYZ\n", + "+0.003 * IIZYXYZ\n", + "+0.003 * IIZYYXZ\n", + "+0.003 * IIZXXXZ\n", + "-0.026 * YZZIYII\n", + "-0.026 * XZZIXII\n", + "+0.012 * IIXXIII\n", + "+0.012 * IIYYIII\n", + "-0.013 * IYIXIIY\n", + "+0.013 * IXIYIIY\n", + "+0.013 * IYIYIIX\n", + "+0.013 * IXIXIIX\n", + "-0.004 * YZIXIYZ\n", + "+0.004 * XZIYIYZ\n", + "+0.004 * YZIYIXZ\n", + "+0.004 * XZIXIXZ\n", + "+0.171 * IZIZIII\n", + "+0.191 * ZIIZIII\n", + "+0.171 * IIZIIIZ\n", + "+0.191 * IIZIIZI\n", + "+0.172 * ZZIZZII\n", + "-0.012 * ZZYIIIY\n", + "+0.012 * IIYZZIY\n", + "-0.012 * ZZXIIIX\n", + "+0.012 * IIXZZIX\n", + "+0.014 * ZXZIIII\n", + "-0.014 * IXIZZII\n", + "+0.174 * IIZIZII\n", + "-0.003 * IIXZYYZ\n", + "+0.003 * IIYZXYZ\n", + "+0.003 * IIYZYXZ\n", + "+0.003 * IIXZXXZ\n", + "-0.026 * YZIZYII\n", + "-0.026 * XZIZXII\n", + "-0.013 * IYXIIIY\n", + "+0.013 * IXYIIIY\n", + "+0.013 * IYYIIIX\n", + "+0.013 * IXXIIIX\n", + "-0.004 * YZXIIYZ\n", + "+0.004 * XZYIIYZ\n", + "+0.004 * YZYIIXZ\n", + "+0.004 * XZXIIXZ\n", + "+0.171 * IZZIIII\n", + "+0.191 * ZIZIIII\n", + "+0.074 * IIIIIZZ\n", + "-0.036 * ZZZZXYY\n", + "+0.036 * IIIIXYY\n", + "-0.036 * ZZZZXXX\n", + "+0.036 * IIIIXXX\n", + "+0.014 * XIIIIYY\n", + "-0.014 * XZZZZYY\n", + "+0.014 * XIIIIXX\n", + "-0.014 * XZZZZXX\n", + "+0.102 * IIIIZIZ\n", + "-0.024 * IYZZYYY\n", + "-0.024 * IXZZXYY\n", + "-0.024 * IYZZYXX\n", + "-0.024 * IXZZXXX\n", + "+0.007 * YZZZYIZ\n", + "+0.007 * XZZZXIZ\n", + "+0.035 * YYIIIYY\n", + "+0.035 * XXIIIYY\n", + "+0.035 * YYIIIXX\n", + "+0.035 * XXIIIXX\n", + "+0.109 * ZIIIIIZ\n", + "+0.107 * ZZZZZZI\n", + "-0.009 * ZXIIIZI\n", + "+0.009 * IXZZZZI\n", + "+0.109 * IZIIIZI\n", + "+0.062 * ZZZZIII\n", + "+0.010 * XIIIXII\n", + "+0.010 * YIIIYII\n", + "+0.093 * IZZZZII\n", + "+0.012 * ZXIIZII\n", + "-0.012 * IXZZIII\n", + "+0.003 * XYZZYII\n", + "+0.020 * XXZZXII\n", + "+0.017 * YYZZXII\n", + "+0.017 * YYIIXII\n", + "+0.020 * XXIIXII\n", + "+0.003 * XYIIYII\n", + "+0.005 * IXIIIII\n", + "-0.005 * ZXZZZII\n", + "+0.081 * IZIIZII\n", + "-0.017 * YIZZYII\n", + "-0.017 * XIZZXII\n", + "+0.074 * ZZIIIII\n" + ] + } + ], + "source": [ + "# define your molecule problem\n", + "\n", + "gs_problem = MoleculeProblem(\n", + " molecule=molecule,\n", + " basis=\"sto3g\",\n", + " mapping=\"jordan_wigner\", #'bravyi_kitaev'\n", + " z2_symmetries=True,\n", + " freeze_core=True,\n", + ")\n", + "\n", + "operator = gs_problem.generate_hamiltonian()\n", + "gs_problem = gs_problem.update_problem(operator.num_qubits)\n", + "print(\"Your Hamiltonian is\", operator.show(), sep=\"\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "7a0b57c6-a057-41cb-8163-cc91d559bbdd", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7a0b57c6-a057-41cb-8163-cc91d559bbdd", + "outputId": "1460479e-94e8-4c11-baa9-d0b96c9916b7", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your Pauli list is\n", + "[('IIIIIII', (-0.7022930768258921+0j)), ('ZIZZZIZ', (-0.23019060454699553+0j)), ('IIIIIZX', (-0.022105135983230773+0j)), ('ZIZZZZX', (0.022105135983230773+0j)), ('ZIIIZZI', (-0.2508359055835329+0j)), ('ZIZZZXZ', (-0.05762054716987136+0j)), ('IIZZIXZ', (0.05762054716987136+0j)), ('IIIZIII', (-0.8572771753840491+0j)), ('IIZIIII', (-0.8572771753840495+0j)), ('IIIIIIZ', (-0.4953913605926791+0j)), ('IIIIIZI', (-0.755422115779769+0j)), ('ZZZZZII', (-0.2301906045469956+0j)), ('ZXIIIII', (-0.022105135983230766+0j)), ('IXZZZII', (0.022105135983230766+0j)), ('IIIIZII', (-0.25083590558353275+0j)), ('YZZZYII', (0.05762054716987136+0j)), ('XZZZXII', (0.05762054716987136+0j)), ('IZIIIII', (-0.49539136059267913+0j)), ('ZIIIIII', (-0.755422115779769+0j)), ('IIZZIZZ', (0.06177536902294072+0j)), ('IIIIIXI', (0.009628629697052186+0j)), ('ZIIIZXI', (-0.009628629697052186+0j)), ('ZIZIZIZ', (0.17213123525686325+0j)), ('ZIIZZIZ', (0.1721312352568633+0j)), ('ZIZZZII', (0.15942306177427767+0j)), ('ZIZZZZZ', (0.09279153113235836+0j)), ('ZIIIZIX', (0.011782782608242606+0j)), ('IIZZIIX', (-0.011782782608242606+0j)), ('ZIZZZYY', (0.002973281387454196+0j)), ('IIZZIXX', (0.020388829108894987+0j)), ('IIZZIYY', (0.017415547721440768+0j)), ('IIIIIYY', (0.017415547721440768+0j)), ('IIIIIXX', (0.020388829108894987+0j)), ('ZIIIZYY', (0.002973281387454196+0j)), ('IIIZIZX', (0.014419981611826721+0j)), ('ZIZIZZX', (-0.014419981611826721+0j)), ('IIZIIZX', (0.014419981611826716+0j)), ('ZIIZZZX', (-0.014419981611826716+0j)), ('IIIIIIX', (0.0048161379430657495+0j)), ('ZIZZZIX', (-0.0048161379430657495+0j)), ('IZIIIIZ', (0.2024043809018113+0j)), ('ZZZZZZX', (0.002565939742358108+0j)), ('IZIIIZX', (-0.002565939742358108+0j)), ('ZZIIXZZ', (0.04108938500992236+0j)), ('IIZZXZZ', (-0.04108938500992236+0j)), ('ZZZZXII', (-0.04108938500992236+0j)), ('IIIIXII', (0.04108938500992236+0j)), ('ZZZZXXI', (-0.011051936749184687+0j)), ('IIIIXXI', (0.011051936749184687+0j)), ('IZIIYYZ', (-0.011051936749184687+0j)), ('ZIZZYYZ', (0.011051936749184687+0j)), ('ZZIXIZZ', (0.01234821063234334+0j)), ('IIZXZZZ', (-0.01234821063234334+0j)), ('IZZXZZI', (-0.01234821063234334+0j)), ('ZIIXIZI', (0.01234821063234334+0j)), ('ZZXIIZZ', (0.01234821063234334+0j)), ('IIXZZZZ', (-0.01234821063234334+0j)), ('IZXZZZI', (-0.01234821063234334+0j)), ('ZIXIIZI', (0.01234821063234334+0j)), ('IXZZZIZ', (0.002565939742358108+0j)), ('ZXIIIIZ', (-0.002565939742358108+0j)), ('ZXIIIZX', (0.03889565589184009+0j)), ('IXZZZZX', (-0.03889565589184009+0j)), ('XIZZIZZ', (-0.011051936749184687+0j)), ('XZIIZZZ', (0.011051936749184687+0j)), ('XIIIIII', (0.011051936749184687+0j)), ('XZZZZII', (-0.011051936749184687+0j)), ('XIIIIXI', (0.01414965096283118+0j)), ('XZZZZXI', (-0.01414965096283118+0j)), ('YIZZZYZ', (0.01414965096283118+0j)), ('YZIIIYZ', (-0.01414965096283118+0j)), ('ZIZZIIZ', (0.10286475403286306+0j)), ('IIIIZZX', (-0.011879666226520792+0j)), ('ZIZZIZX', (0.011879666226520792+0j)), ('IYIIYZZ', (0.023662448834763396+0j)), ('IXIIXZZ', (0.023662448834763396+0j)), ('IYZZYII', (-0.023662448834763396+0j)), ('IXZZXII', (-0.023662448834763396+0j)), ('IYZZYXI', (-0.015307708024581815+0j)), ('IXZZXXI', (-0.015307708024581815+0j)), ('ZYIIXYZ', (0.015307708024581815+0j)), ('ZXIIYYZ', (-0.015307708024581815+0j)), ('XZIIXIZ', (-0.0014233070521324988+0j)), ('YZIIYIZ', (-0.0014233070521324988+0j)), ('YZZZYZX', (-0.018280989412036014+0j)), ('XZZZXZX', (-0.018280989412036014+0j)), ('XZIIXZX', (-0.018280989412036014+0j)), ('YZIIYZX', (-0.018280989412036014+0j)), ('IYIYIZZ', (-0.01185327361540123+0j)), ('IXIXIZZ', (-0.01185327361540123+0j)), ('ZYZYZZI', (0.01185327361540123+0j)), ('ZXZXZZI', (0.01185327361540123+0j)), ('IYYIIZZ', (-0.011853273615401231+0j)), ('IXXIIZZ', (-0.011853273615401231+0j)), ('ZYYZZZI', (0.011853273615401231+0j)), ('ZXXZZZI', (0.011853273615401231+0j)), ('ZZZZZIZ', (0.19831871766611772+0j)), ('YYZZIZZ', (-0.03569653713347678+0j)), ('XXZZIZZ', (-0.03569653713347678+0j)), ('YYIIIII', (0.03569653713347678+0j)), ('XXIIIII', (0.03569653713347678+0j)), ('YYIIIXI', (0.013897967082179451+0j)), ('XXIIIXI', (0.013897967082179451+0j)), ('XYZZZYZ', (-0.013897967082179451+0j)), ('YXZZZYZ', (0.013897967082179451+0j)), ('IIZZZIZ', (0.10694118209518956+0j)), ('ZIIIIZX', (-0.009081829139113701+0j)), ('IIZZZZX', (0.009081829139113701+0j)), ('ZIIZZZI', (0.1744698035079177+0j)), ('ZIZIZZI', (0.1744698035079177+0j)), ('ZIIIZZZ', (0.08104582589502732+0j)), ('ZIIIZII', (0.1820000129718488+0j)), ('ZIZIZXZ', (0.02628674552520143+0j)), ('IIZIIXZ', (-0.02628674552520143+0j)), ('ZIIZZXZ', (0.026286745525201414+0j)), ('IIIZIXZ', (-0.026286745525201414+0j)), ('ZIZZZXI', (0.01726508183549788+0j)), ('IIZZIXI', (-0.01726508183549788+0j)), ('IZZZIZI', (0.10286475403286306+0j)), ('IZIIIXZ', (-0.0014233070521324988+0j)), ('ZZIIZXZ', (0.0014233070521324988+0j)), ('IZIIYZY', (0.023662448834763396+0j)), ('ZIZZYZY', (-0.023662448834763396+0j)), ('ZZIIXIX', (0.023662448834763396+0j)), ('IIZZXIX', (-0.023662448834763396+0j)), ('IXIIZZI', (-0.011879666226520792+0j)), ('ZXZZIZI', (0.011879666226520792+0j)), ('IXZZZXZ', (0.018280989412036014+0j)), ('ZXIIIXZ', (-0.018280989412036014+0j)), ('ZXZZIXZ', (-0.018280989412036014+0j)), ('IXIIZXZ', (0.018280989412036014+0j)), ('YIZZZZY', (-0.015307708024581815+0j)), ('YZIIIZY', (0.015307708024581815+0j)), ('XIZZIIX', (-0.015307708024581815+0j)), ('XZIIZIX', (0.015307708024581815+0j)), ('ZIIIIZI', (0.23075467521596427+0j)), ('ZIZZIXZ', (-0.0025513531024711268+0j)), ('IIZZZXZ', (0.0025513531024711268+0j)), ('ZIIXXZI', (0.0036560013958361025+0j)), ('ZIIYYZI', (0.0036560013958361025+0j)), ('IIIYYII', (0.0036560013958361025+0j)), ('IIIXXII', (0.0036560013958361025+0j)), ('ZIXIXZI', (0.0036560013958361025+0j)), ('ZIYIYZI', (0.0036560013958361025+0j)), ('IIYIYII', (0.0036560013958361025+0j)), ('IIXIXII', (0.0036560013958361025+0j)), ('ZYIIXZY', (-0.020873062000978788+0j)), ('ZXIIYZY', (0.020873062000978788+0j)), ('IYIIYIX', (0.020873062000978788+0j)), ('IXIIXIX', (0.020873062000978788+0j)), ('XZZZXZI', (-0.0025513531024711255+0j)), ('YZZZYZI', (-0.0025513531024711255+0j)), ('XZIIXXZ', (0.04125144772662377+0j)), ('YZIIYXZ', (0.04125144772662377+0j)), ('XZZXZZI', (0.0034405062273071014+0j)), ('YZZYZZI', (0.0034405062273071014+0j)), ('YZZYIII', (0.0034405062273071014+0j)), ('XZZXIII', (0.0034405062273071014+0j)), ('XZXZZZI', (0.0034405062273071014+0j)), ('YZYZZZI', (0.0034405062273071014+0j)), ('YZYZIII', (0.0034405062273071014+0j)), ('XZXZIII', (0.0034405062273071014+0j)), ('ZZIIZZI', (0.10191888789600612+0j)), ('ZZZZZXZ', (-0.006564129606561645+0j)), ('IZZZIXZ', (0.006564129606561645+0j)), ('XYZZZZY', (0.023829211442059527+0j)), ('YXZZZZY', (-0.023829211442059527+0j)), ('YYZZIIX', (-0.023829211442059527+0j)), ('XXZZIIX', (-0.023829211442059527+0j)), ('IIIIZZI', (0.22325146069847254+0j)), ('IIZZIII', (0.3892355930337427+0j)), ('IIIZIIZ', (0.17086285707799778+0j)), ('IIIZIZI', (0.19133630882633235+0j)), ('ZZZIZII', (0.17213123525686325+0j)), ('ZZIYIIY', (-0.01185327361540123+0j)), ('IIZYZIY', (0.01185327361540123+0j)), ('ZZIXIIX', (-0.01185327361540123+0j)), ('IIZXZIX', (0.01185327361540123+0j)), ('ZXIZIII', (0.014419981611826721+0j)), ('IXZIZII', (-0.014419981611826721+0j)), ('IIIZZII', (0.1744698035079177+0j)), ('IIZXYYZ', (-0.0034405062273071014+0j)), ('IIZYXYZ', (0.0034405062273071014+0j)), ('IIZYYXZ', (0.0034405062273071014+0j)), ('IIZXXXZ', (0.0034405062273071014+0j)), ('YZZIYII', (-0.02628674552520143+0j)), ('XZZIXII', (-0.02628674552520143+0j)), ('IIXXIII', (0.012124689610585541+0j)), ('IIYYIII', (0.012124689610585541+0j)), ('IYIXIIY', (-0.012722452161354637+0j)), ('IXIYIIY', (0.012722452161354637+0j)), ('IYIYIIX', (0.012722452161354637+0j)), ('IXIXIIX', (0.012722452161354637+0j)), ('YZIXIYZ', (-0.004138154161062577+0j)), ('XZIYIYZ', (0.004138154161062577+0j)), ('YZIYIXZ', (0.004138154161062577+0j)), ('XZIXIXZ', (0.004138154161062577+0j)), ('IZIZIII', (0.17086285707799778+0j)), ('ZIIZIII', (0.19133630882633235+0j)), ('IIZIIIZ', (0.17086285707799784+0j)), ('IIZIIZI', (0.19133630882633237+0j)), ('ZZIZZII', (0.1721312352568633+0j)), ('ZZYIIIY', (-0.011853273615401231+0j)), ('IIYZZIY', (0.011853273615401231+0j)), ('ZZXIIIX', (-0.011853273615401231+0j)), ('IIXZZIX', (0.011853273615401231+0j)), ('ZXZIIII', (0.014419981611826716+0j)), ('IXIZZII', (-0.014419981611826716+0j)), ('IIZIZII', (0.1744698035079177+0j)), ('IIXZYYZ', (-0.0034405062273071023+0j)), ('IIYZXYZ', (0.0034405062273071023+0j)), ('IIYZYXZ', (0.0034405062273071023+0j)), ('IIXZXXZ', (0.0034405062273071023+0j)), ('YZIZYII', (-0.026286745525201414+0j)), ('XZIZXII', (-0.026286745525201414+0j)), ('IYXIIIY', (-0.012722452161354645+0j)), ('IXYIIIY', (0.012722452161354645+0j)), ('IYYIIIX', (0.012722452161354645+0j)), ('IXXIIIX', (0.012722452161354645+0j)), ('YZXIIYZ', (-0.004138154161062578+0j)), ('XZYIIYZ', (0.004138154161062578+0j)), ('YZYIIXZ', (0.004138154161062578+0j)), ('XZXIIXZ', (0.004138154161062578+0j)), ('IZZIIII', (0.17086285707799784+0j)), ('ZIZIIII', (0.19133630882633237+0j)), ('IIIIIZZ', (0.07373286867690836+0j)), ('ZZZZXYY', (-0.03569653713347678+0j)), ('IIIIXYY', (0.03569653713347678+0j)), ('ZZZZXXX', (-0.03569653713347678+0j)), ('IIIIXXX', (0.03569653713347678+0j)), ('XIIIIYY', (0.013897967082179451+0j)), ('XZZZZYY', (-0.013897967082179451+0j)), ('XIIIIXX', (0.013897967082179451+0j)), ('XZZZZXX', (-0.013897967082179451+0j)), ('IIIIZIZ', (0.10191888789600612+0j)), ('IYZZYYY', (-0.023829211442059527+0j)), ('IXZZXYY', (-0.023829211442059527+0j)), ('IYZZYXX', (-0.023829211442059527+0j)), ('IXZZXXX', (-0.023829211442059527+0j)), ('YZZZYIZ', (0.006564129606561645+0j)), ('XZZZXIZ', (0.006564129606561645+0j)), ('YYIIIYY', (0.03516605240243114+0j)), ('XXIIIYY', (0.03516605240243114+0j)), ('YYIIIXX', (0.03516605240243114+0j)), ('XXIIIXX', (0.03516605240243114+0j)), ('ZIIIIIZ', (0.10889892107933949+0j)), ('ZZZZZZI', (0.10694118209518956+0j)), ('ZXIIIZI', (-0.009081829139113701+0j)), ('IXZZZZI', (0.009081829139113701+0j)), ('IZIIIZI', (0.10889892107933949+0j)), ('ZZZZIII', (0.06177536902294072+0j)), ('XIIIXII', (0.009628629697052186+0j)), ('YIIIYII', (0.009628629697052186+0j)), ('IZZZZII', (0.09279153113235836+0j)), ('ZXIIZII', (0.011782782608242606+0j)), ('IXZZIII', (-0.011782782608242606+0j)), ('XYZZYII', (0.002973281387454196+0j)), ('XXZZXII', (0.020388829108894987+0j)), ('YYZZXII', (0.017415547721440768+0j)), ('YYIIXII', (0.017415547721440768+0j)), ('XXIIXII', (0.020388829108894987+0j)), ('XYIIYII', (0.002973281387454196+0j)), ('IXIIIII', (0.0048161379430657495+0j)), ('ZXZZZII', (-0.0048161379430657495+0j)), ('IZIIZII', (0.08104582589502732+0j)), ('YIZZYII', (-0.01726508183549788+0j)), ('XIZZXII', (-0.01726508183549788+0j)), ('ZZIIIII', (0.07373286867690836+0j))]\n" + ] + } + ], + "source": [ + "pauli_ops = operator.pauli_list\n", + "N = operator.num_qubits\n", + "print(\"Your Pauli list is\", pauli_ops, sep=\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "685f4a01-caf3-4d0c-b9f3-4fc89bc5192a", + "metadata": { + "id": "685f4a01-caf3-4d0c-b9f3-4fc89bc5192a" + }, + "source": [ + "## 2. Preparing the Molecule for QPE" + ] + }, + { + "cell_type": "markdown", + "id": "1b1bafad-d35c-4504-9665-02b0ae86d52f", + "metadata": { + "id": "1b1bafad-d35c-4504-9665-02b0ae86d52f" + }, + "source": [ + "### 2.1 Chose the Algorithm's Precision\n", + "\n", + "For QPE algorithms, the precision is set by the number of qubits chosen $n$, such that the resolution is $1/{2^n}$. In case the matrix needs to be normlized, the resolution will be distorted. In case of normalization, that the span of results in the QPE is strached between the lowest and highest possible phase, thus the reslution will be mapped to $normalization-coefficient/{2^n} ~\\sim 1/{((\\lambda_{max}-\\lambda_{min})*2^n)}$.\n", + "\n", + "Here you can chose the precision in the parameter `n_qpe`, or by setting your desired resolution. If you chose your desired resolution and set the parameter `get_recommended_n` to be True, the number of qubits will be calculated for you accordingly.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "4e96164f-aa00-4723-9f59-b1c13ccb58d8", + "metadata": { + "id": "4e96164f-aa00-4723-9f59-b1c13ccb58d8", + "tags": [] + }, + "outputs": [], + "source": [ + "# `n_qpe`- The precision of the QPE (the number of qubits to be used in the QPE. Creates resolution of 1/2^n_qpe\n", + "n_qpe = 6" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "74aeea8b-1e16-408f-bc5f-c5888b552a6f", + "metadata": { + "id": "74aeea8b-1e16-408f-bc5f-c5888b552a6f", + "tags": [] + }, + "outputs": [], + "source": [ + "# recommanded n_qpe:\n", + "get_recommanded_n = False\n", + "\n", + "import math\n", + "\n", + "desired_resolution = 0.02\n", + "\n", + "\n", + "def get_nqpe(pauli_operator, desired_resolution):\n", + " N = pauli_operator.num_qubits\n", + " A = 0\n", + " for a, b in pauli_operator.pauli_list:\n", + " A = A + abs(b)\n", + " nqpe = math.log2(2 * N * A / desired_resolution)\n", + " return math.ceil(nqpe)\n", + "\n", + "\n", + "if get_recommanded_n:\n", + " n_qpe = get_nqpe(operator, desired_resolution)\n", + " print(\"number of qubits for QPE is\", n_qpe)" + ] + }, + { + "cell_type": "markdown", + "id": "fa3d1079-c12b-48db-8935-1ea059fdbce9", + "metadata": { + "id": "fa3d1079-c12b-48db-8935-1ea059fdbce9" + }, + "source": [ + "### 2.3 Normalize the Matrix\n", + "\n", + "As QPE obtains a phase in the form $e^{2\\pi i\\theta}$, there is meaning only for $\\theta \\in [0,2\\pi)$. Generally, our matrix M can have any eigenvalue, thus \\theta can have any value. In order to fix this discrepancy, the values of the matrix are stretched to be rescaled. We assume\n", + "$\\theta \\in [\\lambda_{min}, \\lambda_{max}]$\n", + "and use a normalization function in order to map those values into $[0, 1-1/{2^n}]$, where n is the number of qubits chosen for the QPE process in section 2.2.\n", + "\n", + "We perform the normalization procedure as following:\n", + "\n", + "a. We evaluate $\\lambda_{min},\\lambda_{max}$ (in the function ` normalization_params()` below). In order to do so we use rough estimation of the absolute max value that can take place by adding together all the pauli coefficients and multiplying by the matrix's dimensions. That will yield us a value $\\lambda$ (which is referred in the code as `normalization_coeff`) and we now assume that the domain is $\\theta \\in [-\\lambda, \\lambda]$.\n", + "In general, one can build a more accurate assessment, which will decrease the span of solutions and thus achieve a better resolution.\n", + "\n", + "b. We make sure only positive values are available by adding $\\lambda*I^n$ to the pauli list. Now our evaluated span is $[0, 2*\\lambda]$.\n", + "\n", + "c. We normlize our matrix by multiplying all of the pauli coefficients by $(1-1/2^n)/(2*\\lambda)$. Now the span of $\\theta$ is $[0, 1-1/2^n]$, as required for proper QPE process.\n", + "\n", + "The values of the matrix's eigenvalues should be now between $0$ to $1-(1/2^n)$. The QPE procedure will be performed on this new normalized matrix. After the phases are obtained, the original phases of the pre-normalized matrix will be gathered by performing opposite steps to this normalization procedure.\n", + "\n", + "* Note that in case your matrix's eigenvalues are naturally between the values $0$ to $1-(1/2^n)$, you may not want to normalize it, as the normalization procedure may enlarge the span, thus lowering the resolution of the agorithm. In that case, you may skip those lines or change the value `normalize` to False." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "70d8b16f-5f50-4272-9b7b-0ca7cad00b60", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "70d8b16f-5f50-4272-9b7b-0ca7cad00b60", + "outputId": "4c9491de-b9f5-4855-edac-2798e3def5ab", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[('IIIIIII', (0.48892810536438785+0j)), ('ZIZZZIZ', (-0.0010683317925043478+0j)), ('IIIIIZX', (-0.00010259158750198228+0j)), ('ZIZZZZX', (0.00010259158750198228+0j)), ('ZIIIZZI', (-0.0011641481769591397+0j)), ('ZIZZZXZ', (-0.0002674212640616372+0j)), ('IIZZIXZ', (0.0002674212640616372+0j)), ('IIIZIII', (-0.003978687415385474+0j)), ('IIZIIII', (-0.003978687415385476+0j)), ('IIIIIIZ', (-0.002299148313610232+0j)), ('IIIIIZI', (-0.0035059704744972017+0j)), ('ZZZZZII', (-0.0010683317925043482+0j)), ('ZXIIIII', (-0.00010259158750198224+0j)), ('IXZZZII', (0.00010259158750198224+0j)), ('IIIIZII', (-0.0011641481769591388+0j)), ('YZZZYII', (0.0002674212640616372+0j)), ('XZZZXII', (0.0002674212640616372+0j)), ('IZIIIII', (-0.002299148313610232+0j)), ('ZIIIIII', (-0.0035059704744972017+0j)), ('IIZZIZZ', (0.00028670410267514636+0j)), ('IIIIIXI', (4.468718974806055e-05+0j)), ('ZIIIZXI', (-4.468718974806055e-05+0j)), ('ZIZIZIZ', (0.0007988739221995865+0j)), ('ZIIZZIZ', (0.0007988739221995868+0j)), ('ZIZZZII', (0.0007398943396800268+0j)), ('ZIZZZZZ', (0.0004306524281429421+0j)), ('ZIIIZIX', (5.468477433874995e-05+0j)), ('IIZZIIX', (-5.468477433874995e-05+0j)), ('ZIZZZYY', (1.3799221043490736e-05+0j)), ('IIZZIXX', (9.462607907840828e-05+0j)), ('IIZZIYY', (8.082685803491742e-05+0j)), ('IIIIIYY', (8.082685803491742e-05+0j)), ('IIIIIXX', (9.462607907840828e-05+0j)), ('ZIIIZYY', (1.3799221043490736e-05+0j)), ('IIIZIZX', (6.69242119310627e-05+0j)), ('ZIZIZZX', (-6.69242119310627e-05+0j)), ('IIZIIZX', (6.692421193106269e-05+0j)), ('ZIIZZZX', (-6.692421193106269e-05+0j)), ('IIIIIIX', (2.2352055991986362e-05+0j)), ('ZIZZZIX', (-2.2352055991986362e-05+0j)), ('IZIIIIZ', (0.0009393738527474021+0j)), ('ZZZZZZX', (1.1908718037412015e-05+0j)), ('IZIIIZX', (-1.1908718037412015e-05+0j)), ('ZZIIXZZ', (0.00019069890548721174+0j)), ('IIZZXZZ', (-0.00019069890548721174+0j)), ('ZZZZXII', (-0.00019069890548721174+0j)), ('IIIIXII', (0.00019069890548721174+0j)), ('ZZZZXXI', (-5.129286410771216e-05+0j)), ('IIIIXXI', (5.129286410771216e-05+0j)), ('IZIIYYZ', (-5.129286410771216e-05+0j)), ('ZIZZYYZ', (5.129286410771216e-05+0j)), ('ZZIXIZZ', (5.730896803991555e-05+0j)), ('IIZXZZZ', (-5.730896803991555e-05+0j)), ('IZZXZZI', (-5.730896803991555e-05+0j)), ('ZIIXIZI', (5.730896803991555e-05+0j)), ('ZZXIIZZ', (5.730896803991555e-05+0j)), ('IIXZZZZ', (-5.730896803991555e-05+0j)), ('IZXZZZI', (-5.730896803991555e-05+0j)), ('ZIXIIZI', (5.730896803991555e-05+0j)), ('IXZZZIZ', (1.1908718037412015e-05+0j)), ('ZXIIIIZ', (-1.1908718037412015e-05+0j)), ('ZXIIIZX', (0.00018051764476372577+0j)), ('IXZZZZX', (-0.00018051764476372577+0j)), ('XIZZIZZ', (-5.129286410771216e-05+0j)), ('XZIIZZZ', (5.129286410771216e-05+0j)), ('XIIIIII', (5.129286410771216e-05+0j)), ('XZZZZII', (-5.129286410771216e-05+0j)), ('XIIIIXI', (6.566958719353869e-05+0j)), ('XZZZZXI', (-6.566958719353869e-05+0j)), ('YIZZZYZ', (6.566958719353869e-05+0j)), ('YZIIIYZ', (-6.566958719353869e-05+0j)), ('ZIZZIIZ', (0.000477403008162358+0j)), ('IIIIZZX', (-5.513441844904338e-05+0j)), ('ZIZZIZX', (5.513441844904338e-05+0j)), ('IYIIYZZ', (0.00010981919278779331+0j)), ('IXIIXZZ', (0.00010981919278779331+0j)), ('IYZZYII', (-0.00010981919278779331+0j)), ('IXZZXII', (-0.00010981919278779331+0j)), ('IYZZYXI', (-7.104421653185207e-05+0j)), ('IXZZXXI', (-7.104421653185207e-05+0j)), ('ZYIIXYZ', (7.104421653185207e-05+0j)), ('ZXIIYYZ', (-7.104421653185207e-05+0j)), ('XZIIXIZ', (-6.605674359651609e-06+0j)), ('YZIIYIZ', (-6.605674359651609e-06+0j)), ('YZZZYZX', (-8.484343757534281e-05+0j)), ('XZZZXZX', (-8.484343757534281e-05+0j)), ('XZIIXZX', (-8.484343757534281e-05+0j)), ('YZIIYZX', (-8.484343757534281e-05+0j)), ('IYIYIZZ', (-5.5011928369130166e-05+0j)), ('IXIXIZZ', (-5.5011928369130166e-05+0j)), ('ZYZYZZI', (5.5011928369130166e-05+0j)), ('ZXZXZZI', (5.5011928369130166e-05+0j)), ('IYYIIZZ', (-5.501192836913017e-05+0j)), ('IXXIIZZ', (-5.501192836913017e-05+0j)), ('ZYYZZZI', (5.501192836913017e-05+0j)), ('ZXXZZZI', (5.501192836913017e-05+0j)), ('ZZZZZIZ', (0.0009204119844437524+0j)), ('YYZZIZZ', (-0.0001656702956102602+0j)), ('XXZZIZZ', (-0.0001656702956102602+0j)), ('YYIIIII', (0.0001656702956102602+0j)), ('XXIIIII', (0.0001656702956102602+0j)), ('YYIIIXI', (6.450150350093854e-05+0j)), ('XXIIIXI', (6.450150350093854e-05+0j)), ('XYZZZYZ', (-6.450150350093854e-05+0j)), ('YXZZZYZ', (6.450150350093854e-05+0j)), ('IIZZZIZ', (0.0004963220153364809+0j)), ('ZIIIIZX', (-4.214944750895218e-05+0j)), ('IIZZZZX', (4.214944750895218e-05+0j)), ('ZIIZZZI', (0.0008097273921596634+0j)), ('ZIZIZZI', (0.0008097273921596634+0j)), ('ZIIIZZZ', (0.0003761397326525242+0j)), ('ZIIIZII', (0.0008446756568395641+0j)), ('ZIZIZXZ', (0.00012199874978090469+0j)), ('IIZIIXZ', (-0.00012199874978090469+0j)), ('ZIIZZXZ', (0.0001219987497809046+0j)), ('IIIZIXZ', (-0.0001219987497809046+0j)), ('ZIZZZXI', (8.012853461743276e-05+0j)), ('IIZZIXI', (-8.012853461743276e-05+0j)), ('IZZZIZI', (0.000477403008162358+0j)), ('IZIIIXZ', (-6.605674359651609e-06+0j)), ('ZZIIZXZ', (6.605674359651609e-06+0j)), ('IZIIYZY', (0.00010981919278779331+0j)), ('ZIZZYZY', (-0.00010981919278779331+0j)), ('ZZIIXIX', (0.00010981919278779331+0j)), ('IIZZXIX', (-0.00010981919278779331+0j)), ('IXIIZZI', (-5.513441844904338e-05+0j)), ('ZXZZIZI', (5.513441844904338e-05+0j)), ('IXZZZXZ', (8.484343757534281e-05+0j)), ('ZXIIIXZ', (-8.484343757534281e-05+0j)), ('ZXZZIXZ', (-8.484343757534281e-05+0j)), ('IXIIZXZ', (8.484343757534281e-05+0j)), ('YIZZZZY', (-7.104421653185207e-05+0j)), ('YZIIIZY', (7.104421653185207e-05+0j)), ('XIZZIIX', (-7.104421653185207e-05+0j)), ('XZIIZIX', (7.104421653185207e-05+0j)), ('ZIIIIZI', (0.0010709496866189421+0j)), ('ZIZZIXZ', (-1.1841020351975455e-05+0j)), ('IIZZZXZ', (1.1841020351975455e-05+0j)), ('ZIIXXZI', (1.6967775606213202e-05+0j)), ('ZIIYYZI', (1.6967775606213202e-05+0j)), ('IIIYYII', (1.6967775606213202e-05+0j)), ('IIIXXII', (1.6967775606213202e-05+0j)), ('ZIXIXZI', (1.6967775606213202e-05+0j)), ('ZIYIYZI', (1.6967775606213202e-05+0j)), ('IIYIYII', (1.6967775606213202e-05+0j)), ('IIXIXII', (1.6967775606213202e-05+0j)), ('ZYIIXZY', (-9.68734401060554e-05+0j)), ('ZXIIYZY', (9.68734401060554e-05+0j)), ('IYIIYIX', (9.68734401060554e-05+0j)), ('IXIIXIX', (9.68734401060554e-05+0j)), ('XZZZXZI', (-1.184102035197545e-05+0j)), ('YZZZYZI', (-1.184102035197545e-05+0j)), ('XZIIXXZ', (0.00019145105066260875+0j)), ('YZIIYXZ', (0.00019145105066260875+0j)), ('XZZXZZI', (1.5967646430117258e-05+0j)), ('YZZYZZI', (1.5967646430117258e-05+0j)), ('YZZYIII', (1.5967646430117258e-05+0j)), ('XZZXIII', (1.5967646430117258e-05+0j)), ('XZXZZZI', (1.5967646430117258e-05+0j)), ('YZYZZZI', (1.5967646430117258e-05+0j)), ('YZYZIII', (1.5967646430117258e-05+0j)), ('XZXZIII', (1.5967646430117258e-05+0j)), ('ZZIIZZI', (0.0004730131727585797+0j)), ('ZZZZZXZ', (-3.0464615889121402e-05+0j)), ('IZZZIXZ', (3.0464615889121402e-05+0j)), ('XYZZZZY', (0.00011059315050655418+0j)), ('YXZZZZY', (-0.00011059315050655418+0j)), ('YYZZIIX', (-0.00011059315050655418+0j)), ('XXZZIIX', (-0.00011059315050655418+0j)), ('IIIIZZI', (0.0010361267075021726+0j)), ('IIZZIII', (0.001806471465812303+0j)), ('IIIZIIZ', (0.0007929872843150064+0j)), ('IIIZIZI', (0.0008880061033849397+0j)), ('ZZZIZII', (0.0007988739221995865+0j)), ('ZZIYIIY', (-5.5011928369130166e-05+0j)), ('IIZYZIY', (5.5011928369130166e-05+0j)), ('ZZIXIIX', (-5.5011928369130166e-05+0j)), ('IIZXZIX', (5.5011928369130166e-05+0j)), ('ZXIZIII', (6.69242119310627e-05+0j)), ('IXZIZII', (-6.69242119310627e-05+0j)), ('IIIZZII', (0.0008097273921596634+0j)), ('IIZXYYZ', (-1.5967646430117258e-05+0j)), ('IIZYXYZ', (1.5967646430117258e-05+0j)), ('IIZYYXZ', (1.5967646430117258e-05+0j)), ('IIZXXXZ', (1.5967646430117258e-05+0j)), ('YZZIYII', (-0.00012199874978090469+0j)), ('XZZIXII', (-0.00012199874978090469+0j)), ('IIXXIII', (5.6271590279399006e-05+0j)), ('IIYYIII', (5.6271590279399006e-05+0j)), ('IYIXIIY', (-5.904585093444126e-05+0j)), ('IXIYIIY', (5.904585093444126e-05+0j)), ('IYIYIIX', (5.904585093444126e-05+0j)), ('IXIXIIX', (5.904585093444126e-05+0j)), ('YZIXIYZ', (-1.9205482609715886e-05+0j)), ('XZIYIYZ', (1.9205482609715886e-05+0j)), ('YZIYIXZ', (1.9205482609715886e-05+0j)), ('XZIXIXZ', (1.9205482609715886e-05+0j)), ('IZIZIII', (0.0007929872843150064+0j)), ('ZIIZIII', (0.0008880061033849397+0j)), ('IIZIIIZ', (0.0007929872843150067+0j)), ('IIZIIZI', (0.0008880061033849398+0j)), ('ZZIZZII', (0.0007988739221995868+0j)), ('ZZYIIIY', (-5.501192836913017e-05+0j)), ('IIYZZIY', (5.501192836913017e-05+0j)), ('ZZXIIIX', (-5.501192836913017e-05+0j)), ('IIXZZIX', (5.501192836913017e-05+0j)), ('ZXZIIII', (6.692421193106269e-05+0j)), ('IXIZZII', (-6.692421193106269e-05+0j)), ('IIZIZII', (0.0008097273921596634+0j)), ('IIXZYYZ', (-1.596764643011726e-05+0j)), ('IIYZXYZ', (1.596764643011726e-05+0j)), ('IIYZYXZ', (1.596764643011726e-05+0j)), ('IIXZXXZ', (1.596764643011726e-05+0j)), ('YZIZYII', (-0.0001219987497809046+0j)), ('XZIZXII', (-0.0001219987497809046+0j)), ('IYXIIIY', (-5.90458509344413e-05+0j)), ('IXYIIIY', (5.90458509344413e-05+0j)), ('IYYIIIX', (5.90458509344413e-05+0j)), ('IXXIIIX', (5.90458509344413e-05+0j)), ('YZXIIYZ', (-1.920548260971589e-05+0j)), ('XZYIIYZ', (1.920548260971589e-05+0j)), ('YZYIIXZ', (1.920548260971589e-05+0j)), ('XZXIIXZ', (1.920548260971589e-05+0j)), ('IZZIIII', (0.0007929872843150067+0j)), ('ZIZIIII', (0.0008880061033849398+0j)), ('IIIIIZZ', (0.00034219975187565625+0j)), ('ZZZZXYY', (-0.0001656702956102602+0j)), ('IIIIXYY', (0.0001656702956102602+0j)), ('ZZZZXXX', (-0.0001656702956102602+0j)), ('IIIIXXX', (0.0001656702956102602+0j)), ('XIIIIYY', (6.450150350093854e-05+0j)), ('XZZZZYY', (-6.450150350093854e-05+0j)), ('XIIIIXX', (6.450150350093854e-05+0j)), ('XZZZZXX', (-6.450150350093854e-05+0j)), ('IIIIZIZ', (0.0004730131727585797+0j)), ('IYZZYYY', (-0.00011059315050655418+0j)), ('IXZZXYY', (-0.00011059315050655418+0j)), ('IYZZYXX', (-0.00011059315050655418+0j)), ('IXZZXXX', (-0.00011059315050655418+0j)), ('YZZZYIZ', (3.0464615889121402e-05+0j)), ('XZZZXIZ', (3.0464615889121402e-05+0j)), ('YYIIIYY', (0.00016320827634266465+0j)), ('XXIIIYY', (0.00016320827634266465+0j)), ('YYIIIXX', (0.00016320827634266465+0j)), ('XXIIIXX', (0.00016320827634266465+0j)), ('ZIIIIIZ', (0.0005054080282183209+0j)), ('ZZZZZZI', (0.0004963220153364809+0j)), ('ZXIIIZI', (-4.214944750895218e-05+0j)), ('IXZZZZI', (4.214944750895218e-05+0j)), ('IZIIIZI', (0.0005054080282183209+0j)), ('ZZZZIII', (0.00028670410267514636+0j)), ('XIIIXII', (4.468718974806055e-05+0j)), ('YIIIYII', (4.468718974806055e-05+0j)), ('IZZZZII', (0.0004306524281429421+0j)), ('ZXIIZII', (5.468477433874995e-05+0j)), ('IXZZIII', (-5.468477433874995e-05+0j)), ('XYZZYII', (1.3799221043490736e-05+0j)), ('XXZZXII', (9.462607907840828e-05+0j)), ('YYZZXII', (8.082685803491742e-05+0j)), ('YYIIXII', (8.082685803491742e-05+0j)), ('XXIIXII', (9.462607907840828e-05+0j)), ('XYIIYII', (1.3799221043490736e-05+0j)), ('IXIIIII', (2.2352055991986362e-05+0j)), ('ZXZZZII', (-2.2352055991986362e-05+0j)), ('IZIIZII', (0.0003761397326525242+0j)), ('YIZZYII', (-8.012853461743276e-05+0j)), ('XIZZXII', (-8.012853461743276e-05+0j)), ('ZZIIIII', (0.00034219975187565625+0j))]\n" + ] + } + ], + "source": [ + "from typing import cast\n", + "\n", + "from classiq import Pauli, PauliTerm\n", + "\n", + "# normalizing the operator\n", + "## we need to create a matrix such that its normalized version will have eigenvalues of [0,1/2^k] when k is the resolution of the QPE\n", + "normalize = True\n", + "\n", + "\n", + "def normalization_params(pauli_list, N):\n", + " A = 0\n", + " for a, b in pauli_list:\n", + " A = A + abs(b)\n", + " return N * A\n", + "\n", + "\n", + "def normalize_hamiltonian(pauli_list, normalization_coeff, k):\n", + " new_pauli_list = []\n", + " for a, b in pauli_list:\n", + " if a == \"I\" * N:\n", + " new_pauli_list.append(\n", + " (\n", + " a,\n", + " (b + normalization_coeff)\n", + " * (1 - 1 / (2**k))\n", + " / (2 * normalization_coeff),\n", + " )\n", + " )\n", + " else:\n", + " new_pauli_list.append((a, b * (1 - 1 / (2**k)) / (2 * normalization_coeff)))\n", + " return new_pauli_list\n", + "\n", + "\n", + "pauli_list = pauli_ops\n", + "if normalize:\n", + " normalization_coeff = normalization_params(pauli_ops, N)\n", + " new_pauli_list = normalize_hamiltonian(pauli_ops, normalization_coeff, n_qpe)\n", + " pauli_ops = new_pauli_list\n", + " print(pauli_ops)" + ] + }, + { + "cell_type": "markdown", + "id": "21e4de42-3417-46d4-b981-664bb0683dc4", + "metadata": { + "id": "21e4de42-3417-46d4-b981-664bb0683dc4" + }, + "source": [ + "Convert the objects to qmod:" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "e340b469-5566-4bd5-bb5d-3107ebc790e0", + "metadata": { + "id": "e340b469-5566-4bd5-bb5d-3107ebc790e0", + "tags": [] + }, + "outputs": [], + "source": [ + "CHAR_TO_STUCT_DICT = {\"I\": Pauli.I, \"X\": Pauli.X, \"Y\": Pauli.Y, \"Z\": Pauli.Z}\n", + "\n", + "\n", + "def pauli_str_to_enums(pauli):\n", + " return [CHAR_TO_STUCT_DICT[s] for s in pauli]\n", + "\n", + "\n", + "def pauli_list_to_hamiltonian(pauli_list):\n", + " return [\n", + " PauliTerm(\n", + " pauli=pauli_str_to_enums(pauli), coefficient=cast(complex, coeff).real\n", + " )\n", + " for pauli, coeff in pauli_list\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "id": "62d2e51d-d532-4c26-86dd-a5b9b40d009e", + "metadata": { + "id": "62d2e51d-d532-4c26-86dd-a5b9b40d009e" + }, + "source": [ + "## 3. Creating the Quantum Circuit\n", + "\n", + "We will now create a quantum circuit of the QPE algorithm using the Classiq platform. The user is able to fill in their constraints and preferences as desired." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "fd4ee616-2a11-46ba-adc0-ed5171d7dd7d", + "metadata": { + "id": "fd4ee616-2a11-46ba-adc0-ed5171d7dd7d", + "tags": [] + }, + "outputs": [], + "source": [ + "constraints = Constraints()\n", + "preferences = Preferences(timeout_seconds=600)" + ] + }, + { + "cell_type": "markdown", + "id": "43c249a1-9db3-4164-bec1-f345670d4cd1", + "metadata": { + "id": "43c249a1-9db3-4164-bec1-f345670d4cd1" + }, + "source": [ + "### 3.1. Create the phase estimation model" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "b05c5ced-e02a-4b56-acc5-c62de3564239", + "metadata": { + "id": "b05c5ced-e02a-4b56-acc5-c62de3564239", + "tags": [] + }, + "outputs": [], + "source": [ + "from classiq import molecule_problem_to_qmod\n", + "from classiq.qmod import (\n", + " CInt,\n", + " Output,\n", + " QArray,\n", + " QBit,\n", + " QCallable,\n", + " QNum,\n", + " allocate,\n", + " allocate_num,\n", + " control,\n", + " invert,\n", + " qfunc,\n", + " repeat,\n", + ")\n", + "from classiq.qmod.builtins import (\n", + " H,\n", + " apply_to_all,\n", + " exponentiation_with_depth_constraint,\n", + " molecule_hartree_fock,\n", + " qft,\n", + ")\n", + "from classiq.qmod.symbolic import log, pi\n", + "\n", + "# this constant will be multipled be a linear factor for each qbit of the qpe, so the\n", + "# depth will scale linear with the power of each unitary, on the expense of approximating the\n", + "# exponentiation function\n", + "exp_max_depth = 2200\n", + "\n", + "\n", + "# define a Quantum Phase Estimation function that allows specifying each controlled\n", + "# power unitary directly\n", + "@qfunc\n", + "def my_flexible_qpe(\n", + " unitary_with_power: QCallable[CInt],\n", + " phase: QArray[QBit],\n", + ") -> None:\n", + " apply_to_all(H, phase)\n", + "\n", + " repeat(\n", + " count=phase.len,\n", + " iteration=lambda index: control(\n", + " ctrl=phase[index],\n", + " operand=lambda: unitary_with_power(2**index),\n", + " ),\n", + " )\n", + " invert(lambda: qft(phase))\n", + "\n", + "\n", + "@qfunc\n", + "def main(reg: Output[QArray[QBit]], phase: Output[QNum]):\n", + " allocate_num(num_qubits=n_qpe, is_signed=False, fraction_digits=n_qpe, out=phase)\n", + " allocate(N, reg)\n", + "\n", + " # The state chosen for the initial state is HF, as usually it has good overlap with the with the eigenstate of minimal energy.\n", + " molecule_hartree_fock(molecule_problem_to_qmod(gs_problem), reg)\n", + "\n", + " # # Hereby we send the pauli list created for the molecule for creating phase estimation circuit.\n", + " my_flexible_qpe(\n", + " lambda power: exponentiation_with_depth_constraint(\n", + " pauli_list_to_hamiltonian(pauli_ops),\n", + " evolution_coefficient=-2 * np.pi * power,\n", + " max_depth=exp_max_depth * ((2**0.5) ** log(power, 2)),\n", + " qbv=reg,\n", + " ),\n", + " phase,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "467eca03-8a66-43d8-b2af-6d86b21e36d5", + "metadata": { + "id": "467eca03-8a66-43d8-b2af-6d86b21e36d5", + "tags": [] + }, + "source": [ + "## 3.2. Synthesizing the Circuit\n", + "\n", + "Hereby we syntesize the circuit and show it using the analyzer." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "10eaa569-de42-41b4-b615-c04bdc850ecf", + "metadata": { + "id": "10eaa569-de42-41b4-b615-c04bdc850ecf", + "tags": [] + }, + "outputs": [], + "source": [ + "from classiq import create_model\n", + "from classiq.execution import ExecutionPreferences\n", + "\n", + "num_shots = 200000\n", + "\n", + "qmod = create_model(\n", + " main,\n", + " constraints=constraints,\n", + " preferences=preferences,\n", + " execution_preferences=ExecutionPreferences(num_shots=num_shots),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "a7aae67f-1750-43be-9446-74fa0565058a", + "metadata": { + "id": "a7aae67f-1750-43be-9446-74fa0565058a" + }, + "outputs": [], + "source": [ + "# from classiq import write_qmod\n", + "\n", + "# write_qmod(qmod, name=\"qpe_for_molecules\") # optional" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "8d434afe-5cbc-4a56-a48c-e657090c348a", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8d434afe-5cbc-4a56-a48c-e657090c348a", + "outputId": "660ea141-5ece-4b9f-ca7b-68e2abdea824", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://platform.classiq.io/circuit/99f0cfde-38f4-4b77-958b-6991194539a5?version=0.42.1\n" + ] + } + ], + "source": [ + "from classiq import show, synthesize\n", + "\n", + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "id": "7483f266-af0f-4d08-aa96-317b4044df58", + "metadata": { + "id": "7483f266-af0f-4d08-aa96-317b4044df58" + }, + "source": [ + "# 4. Measurment and Analysis\n" + ] + }, + { + "cell_type": "markdown", + "id": "e5bf0b3c-839f-43de-9da1-cba55ceba995", + "metadata": { + "id": "e5bf0b3c-839f-43de-9da1-cba55ceba995" + }, + "source": [ + "### 4.1. Circuit Execution\n", + "\n", + "The circuit is now sent to execution on a default simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "bc063bfc-de4b-4181-82b1-f805f86baa2e", + "metadata": { + "id": "bc063bfc-de4b-4181-82b1-f805f86baa2e", + "tags": [] + }, + "outputs": [], + "source": [ + "from classiq import execute\n", + "\n", + "results = execute(qprog).result()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "05e682bd-0f1a-4e10-ba0b-e0bf3378fecd", + "metadata": { + "id": "05e682bd-0f1a-4e10-ba0b-e0bf3378fecd", + "tags": [] + }, + "outputs": [], + "source": [ + "from classiq.execution import ExecutionDetails\n", + "\n", + "results = results[0].value" + ] + }, + { + "cell_type": "markdown", + "id": "8611351f-1b14-4969-878d-6f022cdfce2a", + "metadata": { + "id": "8611351f-1b14-4969-878d-6f022cdfce2a" + }, + "source": [ + "### 4.2. Presenting the Result's Count" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "9c0ee98c-3ffa-4f1d-9cb2-4fada19b08b4", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9c0ee98c-3ffa-4f1d-9cb2-4fada19b08b4", + "outputId": "dbdec0d4-3bef-487c-ce25-5761628ee8ab", + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'phase': 0.46875}: 135118,\n", + " {'phase': 0.484375}: 36276,\n", + " {'phase': 0.453125}: 8424,\n", + " {'phase': 0.5}: 5425,\n", + " {'phase': 0.4375}: 2817,\n", + " {'phase': 0.515625}: 2133,\n", + " {'phase': 0.421875}: 1332,\n", + " {'phase': 0.53125}: 1130,\n", + " {'phase': 0.40625}: 859,\n", + " {'phase': 0.546875}: 694]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results.parsed_counts_of_outputs(\"phase\")[:10]" + ] + }, + { + "cell_type": "markdown", + "id": "41009d2c-4276-409b-b9f4-8dee8103f208", + "metadata": { + "id": "41009d2c-4276-409b-b9f4-8dee8103f208" + }, + "source": [ + "### 4.3. Chosing the Most Probable Solution\n", + "\n", + "Hereby the user will choose the number of eigenvalues they wish to extract from the poll of results. The\n", + "value `number_of_solutions` will determine how many results out of `qpe_results` will be analyzed.\n", + "The `parsed_counts` property is already sorted.\n", + "\n", + "We get the result in the `phase` variable already encoded as fixed point variable in the range [0,1]." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "ba022acc-738c-4685-a7ff-70ea2c400bfd", + "metadata": { + "id": "ba022acc-738c-4685-a7ff-70ea2c400bfd" + }, + "outputs": [], + "source": [ + "number_of_solutions = 1 # to be set" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "4a54cb17-8c0a-4b00-a3a3-6e276fa92b53", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4a54cb17-8c0a-4b00-a3a3-6e276fa92b53", + "outputId": "52406be4-77d6-4bc1-e6f5-891113990de4", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your qubit solution is\n", + "[{'phase': 0.46875}: 135118]\n" + ] + } + ], + "source": [ + "solutions = results.parsed_counts_of_outputs(\"phase\")[:number_of_solutions]\n", + "print(\"Your qubit solution is\", solutions, sep=\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "2f784e6f-d7ed-4cc9-81dd-f6b952d0dc01", + "metadata": { + "id": "2f784e6f-d7ed-4cc9-81dd-f6b952d0dc01" + }, + "source": [ + "### 4.4. Translating into Energy value (Phase)" + ] + }, + { + "cell_type": "markdown", + "id": "d83d16de-2450-4c7a-8093-26bf13d4dce4", + "metadata": { + "id": "d83d16de-2450-4c7a-8093-26bf13d4dce4" + }, + "source": [ + "Map the phase back into the original values, i.e. renormalized into it's original span." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "836084e1-a20d-4a55-93cc-91a40c1d2f53", + "metadata": { + "id": "836084e1-a20d-4a55-93cc-91a40c1d2f53" + }, + "outputs": [], + "source": [ + "def post_process_phase(phase):\n", + " return (\n", + " (phase * 2 * normalization_coeff) / (1 - (1 / 2**n_qpe))\n", + " ) - normalization_coeff" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "a5bdb723-b015-4e80-98ea-985901c6c8d7", + "metadata": { + "id": "a5bdb723-b015-4e80-98ea-985901c6c8d7", + "tags": [] + }, + "outputs": [], + "source": [ + "# renormalize into the \"real\" solution -\n", + "if normalize:\n", + " solution = [post_process_phase(value.state[\"phase\"]) for value in solutions]\n", + "else:\n", + " solution = phase" + ] + }, + { + "cell_type": "markdown", + "id": "6c963b82-26a7-4251-bae0-32e66c57fa1d", + "metadata": { + "id": "6c963b82-26a7-4251-bae0-32e66c57fa1d" + }, + "source": [ + "The final results of the Energy (matrix's eigenvlues) is therefore:" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "43e8ec8f-2be9-403d-8ae9-9380fb2b08c9", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "43e8ec8f-2be9-403d-8ae9-9380fb2b08c9", + "outputId": "57fe6127-9b33-4cc5-ffcc-a121004cf862", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-5.050015671089611]\n" + ] + } + ], + "source": [ + "print(solution)" + ] + }, + { + "cell_type": "markdown", + "id": "7565aa1f-b8ba-4617-a2ef-79317261dfe7", + "metadata": { + "id": "7565aa1f-b8ba-4617-a2ef-79317261dfe7" + }, + "source": [ + "And the results including the error contributed from the resolution (number of qubits participating in the QPE) are:" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "79f1c1ba-61fd-438e-a3d5-7606ea95e70f", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "79f1c1ba-61fd-438e-a3d5-7606ea95e70f", + "outputId": "d75f1d8a-8af0-48c8-a552-a37bf9fbf641", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the resolution of result is 3.3666771140597387\n", + "the eneregy solution is beteen -8.41669278514935 and -1.683338557029872\n" + ] + } + ], + "source": [ + "if normalize:\n", + " energy_resolution = (\n", + " (1 / (2**n_qpe)) * 2 * normalization_coeff / (1 - (1 / 2**n_qpe))\n", + " )\n", + "else:\n", + " energy_resolution = 1 / (2**n_qpe)\n", + "\n", + "print(\"the resolution of result is\", energy_resolution)\n", + "\n", + "for sol in solution:\n", + " print(\n", + " \"the eneregy solution is beteen\",\n", + " sol - energy_resolution,\n", + " \"and\",\n", + " sol + energy_resolution,\n", + " )\n", + "\n", + " ###if zero or exceed the normalization range need to add conditions" + ] + }, + { + "cell_type": "markdown", + "id": "d570c6b0-bd32-40d1-9ebb-c1ee7c8663ad", + "metadata": { + "id": "d570c6b0-bd32-40d1-9ebb-c1ee7c8663ad" + }, + "source": [ + "### 4.4. Find Exact Solution for Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "bd9e84a5-d131-4835-bade-13ba01035b44", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bd9e84a5-d131-4835-bade-13ba01035b44", + "outputId": "7cfc9892-b918-4447-806d-f13493e84053", + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exact result: -3.940331561325752\n" + ] + } + ], + "source": [ + "mat = operator.to_matrix()\n", + "w, v = np.linalg.eig(mat)\n", + "print(\"exact result:\", np.real(min(w)))" + ] + }, + { + "cell_type": "markdown", + "id": "703c6ae7-5174-433f-ad9f-78f9864b1914", + "metadata": { + "id": "703c6ae7-5174-433f-ad9f-78f9864b1914" + }, + "source": [ + "### 4.4. Find the Solution's Histogram" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "dfc5f725-495b-45d1-9c67-a1daf80a1454", + "metadata": { + "id": "dfc5f725-495b-45d1-9c67-a1daf80a1454", + "tags": [] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "energy_vec = []\n", + "energy_prob = []\n", + "\n", + "for value, counts in results.parsed_counts_of_outputs(\"phase\"):\n", + " temp = value[1][\"phase\"]\n", + " if normalize:\n", + " temp2 = (\n", + " temp * 2 * normalization_coeff / (1 - (1 / 2**n_qpe))\n", + " ) - normalization_coeff\n", + " else:\n", + " temp2 = temp\n", + " energy_vec.append(temp2)\n", + " energy_prob.append(counts[1] / num_shots)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "993c5b3b-7a05-44f1-9c4e-6651cd50f4cb", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "993c5b3b-7a05-44f1-9c4e-6651cd50f4cb", + "outputId": "640fb07e-7b78-45ad-958a-c447af80f9be", + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(energy_vec, energy_prob, \".\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9797b512-d41f-47c1-8c0f-4134f0500b80", + "metadata": { + "id": "9797b512-d41f-47c1-8c0f-4134f0500b80" + }, + "source": [ + "## References\n", + "\n", + "[1]: [Michael A. Nielsen and Isaac L. Chuang. 2011. Quantum Computation and Quantum Information: 10th Anniversary Edition, Cambridge University Press, New York, NY, USA.\n", + "](http://mmrc.amss.cas.cn/tlb/201702/W020170224608149940643.pdf)\n" + ] + }, + { + "cell_type": "markdown", + "id": "ttDDvHfPDI4y", + "metadata": { + "id": "ttDDvHfPDI4y" + }, + "source": [ + "# **Results for BeH2:**\n", + "\n", + "Your qubit solution is [{'phase': 0.46875}: 135341]\n", + "\n", + "The final results of the Energy (matrix's eigenvlues) is therefore:\n", + "\n", + "[-5.0500156710895965]\n", + "\n", + "exact result: -3.940331561325765\n", + "\n", + "The results including the error contributed from the resolution (number of qubits participating in the QPE) are: The resolution of result is 3.3666771140597356 the energy solution is between -8.416692785149332 and -1.683338557029861" + ] + }, + { + "cell_type": "markdown", + "id": "JvBCdhv08YSu", + "metadata": { + "id": "JvBCdhv08YSu" + }, + "source": [ + "# **Results for H2O:**\n", + "\n", + "Your qubit solution is\n", + "[{'phase': 0.453125}: 89076]\n", + "\n", + "The final results of the Energy (matrix's eigenvlues) is therefore:\n", + "\n", + "[-29.018825909142947]\n", + "\n", + "exact result: -23.54449724044351\n", + "\n", + "\n", + "The results including the error contributed from the resolution (number of qubits\n", + "participating in the QPE) are:\n", + "The resolution of result is 11.607530363657174\n", + "the energy solution is between -40.62635627280012 and -17.41129554548577\n", + "\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/community/QClass_2024/Submissions/HW4/Priyabrata_Bag_HW4.ipynb b/community/QClass_2024/Submissions/HW4/Priyabrata_Bag_HW4.ipynb index 77dd92a0..6a235878 100644 --- a/community/QClass_2024/Submissions/HW4/Priyabrata_Bag_HW4.ipynb +++ b/community/QClass_2024/Submissions/HW4/Priyabrata_Bag_HW4.ipynb @@ -1,429 +1,1686 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "8d7703dc-4560-4c42-b641-c95dc1958032", - "metadata": { - "id": "8d7703dc-4560-4c42-b641-c95dc1958032" - }, - "source": [ - "# Quantum Software Development Journey:\n", - "# From Theory to Application with Classiq" - ] - }, - { - "cell_type": "markdown", - "id": "d1af5c13-129a-4e5d-8f40-ad400d35b764", - "metadata": { - "id": "d1af5c13-129a-4e5d-8f40-ad400d35b764" - }, - "source": [ - "## Final Assignment - Overview\n", - "\n", - "In this homework assignment, you have the opportunity to implement something meaningful, be creative, and practice your new skills and knowledge! You can apply your knowledge from the course and contribute to the Classiq community. Details are provided below.\n", - "\n", - "**Successful contributions will have the opportunity to earn SWAG credits and potentially more advanced certificates.**\n", - "\n", - "## The Project\n", - "\n", - "### Goal\n", - "The main goal is to be creative, collaborate with each other and with the community, and to apply your knowledge to bridge the gap between theory and application! Focus on the last two weeks of the course, using this assignment to solidify and expand your knowledge and skills.\n", - "\n", - "### Optional Projects\n", - "You may choose a project from the following list, or come up with your own idea. Just please make sure to consult with us before you start!\n", - "\n", - "- **Domain of Expertise**:\n", - " - Use your background in neural networks, chemistry, biology, or any other field to implement something new. We are here to support you!\n", - " - Example: An advanced application of VQE for a more complex molecule.\n", - " - Implementation of different QNN or QAE architectures.\n", - " - Combine your domain of expertise with the power of Classiq!\n", - "\n", - "- **QNN for XOR Problem**:\n", - " - Classiq has an available dataset for training PQC to imitate the XOR gate, similar to how we trained a U-gate to act as a NOT gate. Design a QNN to solve the XOR problem. Read more on the dataset [here](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/qml/qnn/datasets/#datasetxor).\n", - "\n", - "- **QNN as VQE**:\n", - " - Like VQE, QNNs with well-suited loss functions and data can be used to find minima of a system. Can you solve one of the problems from week 3 (in class or HW3) by implementing it with QNN?\n", - " - Review the materials from weeks 3 and 4 and tackle this problem!\n", - " - If needed, you may create synthetic data.\n", - " - Do you have another example to show how QNN can generalize VQE? Show us!\n", - "\n", - "- **Noise Reduction Using Quantum Auto-Encoders**:\n", - " - Quantum Auto-Encoders can be used to reduce noise!\n", - " - Create code that generates a quantum state, adds random noise to it, and tries to reconstruct it using a Quantum Auto-Encoder.\n", - " - If needed, you may create synthetic data.\n", - "\n", - "- **Contribute to Quantum Algorithm Zoo**:\n", - " - Implement one of the algorithms in the [Quantum Algorithm Zoo](https://quantumalgorithmzoo.org/) that has not been implemented yet using Classiq.\n", - " - By doing so, you will have the opportunity to contribute to one of the main resources on quantum algorithms! (your Implementation will be linked to their website!)\n", - "\n", - "- **New Algorithm Implementation**:\n", - " - Choose a research paper (you may consult us) and try to implement it using Classiq's SDK.\n", - "\n", - "### Note\n", - "\n", - "- For those who choose a more extensive project, you will have a discussion with me or another Classiq member to fine-tune your project's purpose and set a deadline. This collaborative approach ensures your project aligns with course objectives and maximizes your learning experience.\n", - "- **You are allowed to work in teams of up to 3 members!**\n", - "\n", - "### Deadline & Submission\n", - "\n", - "- **Important Dates**:\n", - " - **Assignment Release:** 29.5.2024\n", - " - **Submission Deadline:** 10.6.2024 (7 A.M GMT+3)\n", - "- Consult with us before submitting your project, and we will direct you to the right place in the [Classiq Library](https://github.com/Classiq/classiq-library).\n", - "- You might get an extension to the deadline based on your specific project and progress.\n", - "\n", - "## Conclusion\n", - "\n", - "Choose the project that best aligns with your interests and career goals. This project provides a valuable opportunity to deepen your understanding of QML and quantum computing in general, while contributing to the Classiq community.\n", - "\n", - "If you have any questions or need further clarification, feel free to reach out.\n", - "\n", - "**Happy coding!**\n" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# VQE for a more Complex Molecule:\n", - "### Hamiltonian of the Water (H₂O) Molecule" - ], - "metadata": { - "id": "HojnZ_UpJrDs" - }, - "id": "HojnZ_UpJrDs" - }, - { - "cell_type": "markdown", - "source": [ - "\\begin{align*}\n", - "\\hat{H} =& - 73.13873 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I) + 0.22757 (Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.04375 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.04375 (X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", - "&+ 0.17420 (I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I) + 0.16757 (Z\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.15961 (I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I) + 0.11952 (Z\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.18067 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I) + 0.13402 (Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I)\\\\\n", - "&+ 0.22757 (I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I) + 0.19393 (Z\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.03079 (Y\\otimes I\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.03079 (X\\otimes I\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", - "&+ 0.01387 (Y\\otimes X\\otimes X\\otimes Y\\otimes I\\otimes I\\otimes I\\otimes I) - 0.01387 (Y\\otimes Y\\otimes X\\otimes X\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.01387 (X\\otimes X\\otimes Y\\otimes Y\\otimes I\\otimes I\\otimes I\\otimes I) + 0.01387 (X\\otimes Y\\otimes Y\\otimes X\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.04375 (I\\otimes Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.03079 (Z\\otimes Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I)\\\\\n", - "&- 0.04375 (I\\otimes X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I) - 0.03079 (Z\\otimes X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", - "&+ 0.01783 (Y\\otimes X\\otimes I\\otimes I\\otimes X\\otimes Y\\otimes I\\otimes I) - 0.01783 (Y\\otimes Y\\otimes I\\otimes I\\otimes X\\otimes X\\otimes I\\otimes I)\\\\\n", - "&- 0.01783 (X\\otimes X\\otimes I\\otimes I\\otimes Y\\otimes Y\\otimes I\\otimes I) + 0.01783 (X\\otimes Y\\otimes I\\otimes I\\otimes Y\\otimes X\\otimes I\\otimes I)\\\\\n", - "&+ 0.01737 (Y\\otimes X\\otimes I\\otimes I\\otimes I\\otimes I\\otimes X\\otimes Y) - 0.01737 (Y\\otimes Y\\otimes I\\otimes I\\otimes I\\otimes I\\otimes X\\otimes X)\\\\\n", - "&- 0.01737 (X\\otimes X\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Y\\otimes Y) + 0.01737 (X\\otimes Y\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Y\\otimes X)\\\\\n", - "&- 0.03010 (Y\\otimes Z\\otimes I\\otimes Z\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.03010 (X\\otimes Z\\otimes I\\otimes Z\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", - "&+ 0.17420 (I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I) + 0.18144 (Z\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.02981 (Y\\otimes Z\\otimes Z\\otimes I\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.02981 (X\\otimes Z\\otimes Z\\otimes I\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.00029 (Y\\otimes Z\\otimes Y\\otimes Y\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.00029 (Y\\otimes Z\\otimes Y\\otimes X\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", - "&- 0.00029 (X\\otimes Z\\otimes X\\otimes Y\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.00029 (X\\otimes Z\\otimes X\\otimes X\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", - "&- 0.02510 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes Z\\otimes I) - 0.02510 (X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes Z\\otimes I)\\\\\n", - "&- 0.15961 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I) + 0.13735 (Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I)\\\\\n", - "&- 0.01131 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes Z\\otimes I\\otimes I) - 0.01131 (X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes Z\\otimes I\\otimes I)\\\\\n", - "&- 0.01456 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes X\\otimes Y) + 0.01456 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes X\\otimes X)\\\\\n", - "&+ 0.01456 (X\\otimes Z\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes Y\\otimes Y) - 0.01456 (X\\otimes Z\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes Y\\otimes X)\\\\\n", - "&- 0.18067 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z) + 0.15138 (Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z)\\\\\n", - "&- 0.01054 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I\\otimes Z) - 0.01054 (X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I\\otimes Z)\\\\\n", - "&+ 0.16757 (I\\otimes Z\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I) + 0.11952 (I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I)\\\\\n", - "&+ 0.13402 (I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z) + 0.18144 (I\\otimes Z\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.02981 (I\\otimes Y\\otimes I\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.02981 (I\\otimes X\\otimes I\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", - "&- 0.00029 (I\\otimes Y\\otimes X\\otimes X\\otimes Y\\otimes I\\otimes I\\otimes I) + 0.00029 (I\\otimes Y\\otimes Y\\otimes X\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", - "&+ 0.00029 (I\\otimes X\\otimes X\\otimes Y\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.00029 (I\\otimes X\\otimes Y\\otimes Y\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", - "&- 0.03010 (I\\otimes Y\\otimes Z\\otimes I\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.03010 (I\\otimes X\\otimes Z\\otimes I\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", - "&+ 0.13735 (I\\otimes Z\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I) - 0.01131 (I\\otimes Y\\otimes Z\\otimes Z\\otimes I\\otimes Y\\otimes I\\otimes I)\\\\\n", - "&- 0.01131 (I\\otimes X\\otimes Z\\otimes Z\\otimes I\\otimes X\\otimes I\\otimes I) + 0.01456 (I\\otimes Y\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes X\\otimes Y)\\\\\n", - "&+ 0.01456 (I\\otimes Y\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes Y\\otimes Y) + 0.01456 (I\\otimes X\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes X\\otimes X)\\\\\n", - "&+ 0.01456 (I\\otimes X\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes Y\\otimes X) - 0.02510 (I\\otimes Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes Z)\\\\\n", - "&- 0.02510 (I\\otimes X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes Z) + 0.15138 (I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I)\\\\\n", - "&- 0.01054 (I\\otimes Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes Z\\otimes I) - 0.01054 (I\\otimes X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes Z\\otimes I)\\\\\n", - "&+ 0.13767 (I\\otimes I\\otimes Z\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I) + 0.14973 (I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I)\\\\\n", - "&+ 0.22004 (I\\otimes I\\otimes Z\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I) + 0.00956 (I\\otimes I\\otimes Y\\otimes X\\otimes X\\otimes Y\\otimes I\\otimes I)\\\\\n", - "&- 0.00956 (I\\otimes I\\otimes Y\\otimes Y\\otimes X\\otimes X\\otimes I\\otimes I) - 0.00956 (I\\otimes I\\otimes X\\otimes X\\otimes Y\\otimes Y\\otimes I\\otimes I)\\\\\n", - "&+ 0.00956 (I\\otimes I\\otimes X\\otimes Y\\otimes Y\\otimes X\\otimes I\\otimes I) + 0.00609 (I\\otimes I\\otimes Y\\otimes X\\otimes I\\otimes I\\otimes X\\otimes Y)\\\\\n", - "&- 0.00609 (I\\otimes I\\otimes Y\\otimes Y\\otimes I\\otimes I\\otimes X\\otimes X) - 0.00609 (I\\otimes I\\otimes X\\otimes X\\otimes I\\otimes I\\otimes Y\\otimes Y)\\\\\n", - "&+ 0.00609 (I\\otimes I\\otimes X\\otimes Y\\otimes I\\otimes I\\otimes Y\\otimes X) + 0.14723 (I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I)\\\\\n", - "&+ 0.15582 (I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z) + 0.13767 (I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes Z\\otimes I\\otimes I)\\\\\n", - "&+ 0.14973 (I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes Z) + 0.14723 (I\\otimes I\\otimes I\\otimes Z\\otimes Z\\otimes I\\otimes I\\otimes I)\\\\\n", - "&+ 0.15582 (I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes Z\\otimes I) + 0.11270 (I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes Z\\otimes I)\\\\\n", - "&+ 0.14926 (I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes Z\\otimes I\\otimes I) + 0.02869 (I\\otimes I\\otimes I\\otimes I\\otimes Y\\otimes X\\otimes X\\otimes Y)\\\\\n", - "&- 0.02869 (I\\otimes I\\otimes I\\otimes I\\otimes Y\\otimes Y\\otimes X\\otimes X) - 0.02869 (I\\otimes I\\otimes I\\otimes I\\otimes X\\otimes X\\otimes Y\\otimes Y)\\\\\n", - "&+ 0.02869 (I\\otimes I\\otimes I\\otimes I\\otimes X\\otimes Y\\otimes Y\\otimes X) + 0.14139 (I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes Z)\\\\\n", - "&+ 0.11270 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes Z) + 0.14139 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes Z\\otimes I)\\\\\n", - "&+ 0.15436 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes Z)\n", - "\\end{align*}" - ], - "metadata": { - "id": "sgBR_fcRKAqq" - }, - "id": "sgBR_fcRKAqq" - }, - { - "cell_type": "code", - "source": [ - "# !pip install -U classiq" - ], - "metadata": { - "id": "bkgCA-XNLBaq" - }, - "id": "bkgCA-XNLBaq", - "execution_count": 1, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# import classiq\n", - "# classiq.authenticate()" - ], - "metadata": { - "id": "jfBwcuM2LdS0" - }, - "id": "jfBwcuM2LdS0", - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "e4b9b85d-f164-4c1b-aca3-e24e9a0427f8", - "metadata": { - "id": "e4b9b85d-f164-4c1b-aca3-e24e9a0427f8" - }, - "outputs": [], - "source": [ - "from typing import List\n", - "from classiq import *\n", - "\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm],\n", - " [PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=-73.13873),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.22757),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.04375),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.04375),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.17420),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.16757),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.15961),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.11952),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I], coefficient=-0.18067),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.13402),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.22757),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.19393),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.03079),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.03079),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.X, Pauli.X, Pauli.Y, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.01387),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Y, Pauli.X, Pauli.X, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.01387),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.X, Pauli.Y, Pauli.Y, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.01387),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Y, Pauli.Y, Pauli.X, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.01387),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I], coefficient=-0.04375),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I], coefficient=-0.03079),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.I], coefficient=-0.04375),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.I], coefficient=-0.03079),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.X, Pauli.I, Pauli.I, Pauli.X, Pauli.Y, Pauli.I, Pauli.I], coefficient=0.01783),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Y, Pauli.I, Pauli.I, Pauli.X, Pauli.X, Pauli.I, Pauli.I], coefficient=-0.01783),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.X, Pauli.I, Pauli.I, Pauli.Y, Pauli.Y, Pauli.I, Pauli.I], coefficient=-0.01783),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Y, Pauli.I, Pauli.I, Pauli.Y, Pauli.X, Pauli.I, Pauli.I], coefficient=0.01783),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.X, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.X, Pauli.Y], coefficient=0.01737),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Y, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.X, Pauli.X], coefficient=-0.01737),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.X, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Y, Pauli.Y], coefficient=-0.01737),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Y, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Y, Pauli.X], coefficient=0.01737),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.I, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.03010),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.I, Pauli.Z, Pauli.X, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.03010),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.17420),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.18144),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.Z, Pauli.I, Pauli.Y, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.02981),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.Z, Pauli.I, Pauli.X, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.02981),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.Y, Pauli.Y, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I], coefficient=-0.00029),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.Y, Pauli.X, Pauli.Z, Pauli.X, Pauli.I, Pauli.I], coefficient=-0.00029),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.Y, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I], coefficient=-0.00029),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X, Pauli.Z, Pauli.X, Pauli.I, Pauli.I], coefficient=-0.00029),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=-0.02510),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.Z, Pauli.I], coefficient=-0.02510),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I], coefficient=-0.15961),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I], coefficient=0.13735),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.Z, Pauli.I, Pauli.I], coefficient=-0.01131),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.Z, Pauli.I, Pauli.I], coefficient=-0.01131),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.X, Pauli.Y], coefficient=-0.01456),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.X, Pauli.X], coefficient=0.01456),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.Y, Pauli.Y], coefficient=0.01456),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.Y, Pauli.X], coefficient=-0.01456),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z], coefficient=-0.18067),\n", - " PauliTerm(pauli=[Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z], coefficient=0.15138),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I, Pauli.Z], coefficient=-0.01054),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.I, Pauli.Z], coefficient=-0.01054),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.16757),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I], coefficient=0.11952),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z], coefficient=0.13402),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.18144),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.I, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I], coefficient=-0.02981),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.I, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.I], coefficient=-0.02981),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.X, Pauli.X, Pauli.Y, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.00029),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.Y, Pauli.X, Pauli.X, Pauli.I, Pauli.I, Pauli.I], coefficient=0.00029),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.X, Pauli.Y, Pauli.Y, Pauli.I, Pauli.I, Pauli.I], coefficient=0.00029),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.Y, Pauli.Y, Pauli.X, Pauli.I, Pauli.I, Pauli.I], coefficient=-0.00029),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.Z, Pauli.I, Pauli.Z, Pauli.Y, Pauli.I, Pauli.I], coefficient=-0.03010),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.Z, Pauli.I, Pauli.Z, Pauli.X, Pauli.I, Pauli.I], coefficient=-0.03010),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I], coefficient=0.13735),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.Z, Pauli.Z, Pauli.I, Pauli.Y, Pauli.I, Pauli.I], coefficient=-0.01131),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.Z, Pauli.Z, Pauli.I, Pauli.X, Pauli.I, Pauli.I], coefficient=-0.01131),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.X, Pauli.Y], coefficient=0.01456),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.Y, Pauli.Y], coefficient=0.01456),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.X, Pauli.X], coefficient=0.01456),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.Y, Pauli.X], coefficient=0.01456),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.I, Pauli.Z], coefficient=-0.02510),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.I, Pauli.Z], coefficient=-0.02510),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.15138),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.Y, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.Y, Pauli.Z, Pauli.I], coefficient=-0.01054),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.X, Pauli.Z, Pauli.Z, Pauli.Z, Pauli.X, Pauli.Z, Pauli.I], coefficient=-0.01054),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I], coefficient=0.13767),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.14973),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Z, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I], coefficient=0.22004),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Y, Pauli.X, Pauli.X, Pauli.Y, Pauli.I, Pauli.I], coefficient=0.00956),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Y, Pauli.Y, Pauli.X, Pauli.X, Pauli.I, Pauli.I], coefficient=-0.00956),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.X, Pauli.X, Pauli.Y, Pauli.Y, Pauli.I, Pauli.I], coefficient=-0.00956),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.X, Pauli.Y, Pauli.Y, Pauli.X, Pauli.I, Pauli.I], coefficient=0.00956),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Y, Pauli.X, Pauli.I, Pauli.I, Pauli.X, Pauli.Y], coefficient=0.00609),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Y, Pauli.Y, Pauli.I, Pauli.I, Pauli.X, Pauli.X], coefficient=-0.00609),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.X, Pauli.X, Pauli.I, Pauli.I, Pauli.Y, Pauli.Y], coefficient=-0.00609),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.X, Pauli.Y, Pauli.I, Pauli.I, Pauli.Y, Pauli.X], coefficient=0.00609),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I], coefficient=0.14723),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z], coefficient=0.15582),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.Z, Pauli.I, Pauli.I], coefficient=0.13767),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.I, Pauli.Z], coefficient=0.14973),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.Z, Pauli.I, Pauli.I, Pauli.I], coefficient=0.14723),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.15582),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.11270),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.Z, Pauli.I, Pauli.I], coefficient=0.14926),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Y, Pauli.X, Pauli.X, Pauli.Y], coefficient=0.02869),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Y, Pauli.Y, Pauli.X, Pauli.X], coefficient=-0.02869),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.X, Pauli.X, Pauli.Y, Pauli.Y], coefficient=-0.02869),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.X, Pauli.Y, Pauli.Y, Pauli.X], coefficient=0.02869),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.I, Pauli.Z], coefficient=0.14139),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.I, Pauli.Z], coefficient=0.11270),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.Z, Pauli.I], coefficient=0.14139),\n", - " PauliTerm(pauli=[Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.I, Pauli.Z, Pauli.Z], coefficient=0.15436)])" - ] - }, - { - "cell_type": "code", - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 6]) -> None:\n", - " allocate(8, q)\n", - " # U(angles[0], angles[1], angles[2], 0, q[0])\n", - " # U(angles[3], angles[4], angles[5], 0, q[1])\n", - " # U(angles[6], angles[7], angles[8], 0, q[2])\n", - " # U(angles[9], angles[10], angles[11], 0, q[3])\n", - " # U(angles[12], angles[13], angles[14], 0, q[4])\n", - " # U(angles[15], angles[16], angles[17], 0, q[5])\n", - " # U(angles[18], angles[19], angles[20], 0, q[6])\n", - " # U(angles[21], angles[22], angles[23], 0, q[7])\n", - " repeat(q.len, lambda i: U(angles[0], angles[1], angles[2], 0, q[i]))\n", - " repeat(q.len-1, lambda i: repeat(q.len-i-1, lambda j: CX(q[i], q[i+j+1])))\n", - " repeat(q.len, lambda i: U(angles[3], angles[4], angles[5], 0, q[i]))\n", - " # repeat(q.len-1, lambda i: repeat(q.len-i-1, lambda j: CX(q[i], q[i+j+1])))\n", - " # repeat(q.len, lambda i: U(angles[6], angles[7], angles[8], 0, q[i]))\n", - "\n", - "\n", - "@cfunc\n", - "def cmain() -> None:\n", - " res = vqe(\n", - " HAMILTONIAN,\n", - " False,\n", - " [],\n", - " optimizer=Optimizer.COBYLA,\n", - " max_iteration=5000,\n", - " tolerance=0.001,\n", - " step_size=0,\n", - " skip_compute_variance=False,\n", - " alpha_cvar=1.0,\n", - " )\n", - " save({\"result\": res})\n", - "\n", - "qmod = create_model(main, classical_execution_function=cmain)\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ], - "metadata": { - "id": "pm3NUPq7K7Xd" - }, - "id": "pm3NUPq7K7Xd", - "execution_count": 4, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "execution = execute(qprog)\n", - "res = execution.result()\n", - "# execution.open_in_ide()\n", - "vqe_result = res[0].value" - ], - "metadata": { - "id": "sTTUaPmKLW5O" - }, - "id": "sTTUaPmKLW5O", - "execution_count": 5, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "print(f\"Optimal energy: {vqe_result.energy}\")\n", - "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", - "print(f\"Eigenstate: {vqe_result.eigenstate}\")" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "y2LsEoJQL6KS", - "outputId": "f97511b4-26f0-4032-f737-0338a207238e" - }, - "id": "y2LsEoJQL6KS", - "execution_count": 6, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Optimal energy: -74.28639479492185\n", - "Optimal parameters: {'angles_0': -1.622441216459358, 'angles_1': 6.273309048672006, 'angles_2': 2.393676433518781, 'angles_3': -1.5671779543739635, 'angles_4': 1.8858586567955338, 'angles_5': -0.026747140832290826}\n", - "Eigenstate: {'10101001': (0.02209708691207961+0j), '10001010': (0.02209708691207961+0j), '10100010': (0.02209708691207961+0j), '10101000': (0.02209708691207961+0j), '10101101': (0.02209708691207961+0j), '10110101': (0.02209708691207961+0j), '10100101': (0.03125+0j), '10101011': (0.038273277230987154+0j), '10101010': (0.9973108373270593+0j)}\n" - ] - } - ] + "cells": [ + { + "cell_type": "markdown", + "id": "8d7703dc-4560-4c42-b641-c95dc1958032", + "metadata": { + "id": "8d7703dc-4560-4c42-b641-c95dc1958032" + }, + "source": [ + "# Quantum Software Development Journey:\n", + "# From Theory to Application with Classiq" + ] + }, + { + "cell_type": "markdown", + "id": "d1af5c13-129a-4e5d-8f40-ad400d35b764", + "metadata": { + "id": "d1af5c13-129a-4e5d-8f40-ad400d35b764" + }, + "source": [ + "## Final Assignment - Overview\n", + "\n", + "In this homework assignment, you have the opportunity to implement something meaningful, be creative, and practice your new skills and knowledge! You can apply your knowledge from the course and contribute to the Classiq community. Details are provided below.\n", + "\n", + "**Successful contributions will have the opportunity to earn SWAG credits and potentially more advanced certificates.**\n", + "\n", + "## The Project\n", + "\n", + "### Goal\n", + "The main goal is to be creative, collaborate with each other and with the community, and to apply your knowledge to bridge the gap between theory and application! Focus on the last two weeks of the course, using this assignment to solidify and expand your knowledge and skills.\n", + "\n", + "### Optional Projects\n", + "You may choose a project from the following list, or come up with your own idea. Just please make sure to consult with us before you start!\n", + "\n", + "- **Domain of Expertise**:\n", + " - Use your background in neural networks, chemistry, biology, or any other field to implement something new. We are here to support you!\n", + " - Example: An advanced application of VQE for a more complex molecule.\n", + " - Implementation of different QNN or QAE architectures.\n", + " - Combine your domain of expertise with the power of Classiq!\n", + "\n", + "- **QNN for XOR Problem**:\n", + " - Classiq has an available dataset for training PQC to imitate the XOR gate, similar to how we trained a U-gate to act as a NOT gate. Design a QNN to solve the XOR problem. Read more on the dataset [here](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/qml/qnn/datasets/#datasetxor).\n", + "\n", + "- **QNN as VQE**:\n", + " - Like VQE, QNNs with well-suited loss functions and data can be used to find minima of a system. Can you solve one of the problems from week 3 (in class or HW3) by implementing it with QNN?\n", + " - Review the materials from weeks 3 and 4 and tackle this problem!\n", + " - If needed, you may create synthetic data.\n", + " - Do you have another example to show how QNN can generalize VQE? Show us!\n", + "\n", + "- **Noise Reduction Using Quantum Auto-Encoders**:\n", + " - Quantum Auto-Encoders can be used to reduce noise!\n", + " - Create code that generates a quantum state, adds random noise to it, and tries to reconstruct it using a Quantum Auto-Encoder.\n", + " - If needed, you may create synthetic data.\n", + "\n", + "- **Contribute to Quantum Algorithm Zoo**:\n", + " - Implement one of the algorithms in the [Quantum Algorithm Zoo](https://quantumalgorithmzoo.org/) that has not been implemented yet using Classiq.\n", + " - By doing so, you will have the opportunity to contribute to one of the main resources on quantum algorithms! (your Implementation will be linked to their website!)\n", + "\n", + "- **New Algorithm Implementation**:\n", + " - Choose a research paper (you may consult us) and try to implement it using Classiq's SDK.\n", + "\n", + "### Note\n", + "\n", + "- For those who choose a more extensive project, you will have a discussion with me or another Classiq member to fine-tune your project's purpose and set a deadline. This collaborative approach ensures your project aligns with course objectives and maximizes your learning experience.\n", + "- **You are allowed to work in teams of up to 3 members!**\n", + "\n", + "### Deadline & Submission\n", + "\n", + "- **Important Dates**:\n", + " - **Assignment Release:** 29.5.2024\n", + " - **Submission Deadline:** 10.6.2024 (7 A.M GMT+3)\n", + "- Consult with us before submitting your project, and we will direct you to the right place in the [Classiq Library](https://github.com/Classiq/classiq-library).\n", + "- You might get an extension to the deadline based on your specific project and progress.\n", + "\n", + "## Conclusion\n", + "\n", + "Choose the project that best aligns with your interests and career goals. This project provides a valuable opportunity to deepen your understanding of QML and quantum computing in general, while contributing to the Classiq community.\n", + "\n", + "If you have any questions or need further clarification, feel free to reach out.\n", + "\n", + "**Happy coding!**\n" + ] + }, + { + "cell_type": "markdown", + "id": "HojnZ_UpJrDs", + "metadata": { + "id": "HojnZ_UpJrDs" + }, + "source": [ + "# VQE for a more Complex Molecule:\n", + "### Hamiltonian of the Water (H₂O) Molecule" + ] + }, + { + "cell_type": "markdown", + "id": "sgBR_fcRKAqq", + "metadata": { + "id": "sgBR_fcRKAqq" + }, + "source": [ + "\\begin{align*}\n", + "\\hat{H} =& - 73.13873 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I) + 0.22757 (Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.04375 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.04375 (X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", + "&+ 0.17420 (I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I) + 0.16757 (Z\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.15961 (I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I) + 0.11952 (Z\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.18067 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I) + 0.13402 (Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I)\\\\\n", + "&+ 0.22757 (I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I) + 0.19393 (Z\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.03079 (Y\\otimes I\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.03079 (X\\otimes I\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", + "&+ 0.01387 (Y\\otimes X\\otimes X\\otimes Y\\otimes I\\otimes I\\otimes I\\otimes I) - 0.01387 (Y\\otimes Y\\otimes X\\otimes X\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.01387 (X\\otimes X\\otimes Y\\otimes Y\\otimes I\\otimes I\\otimes I\\otimes I) + 0.01387 (X\\otimes Y\\otimes Y\\otimes X\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.04375 (I\\otimes Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.03079 (Z\\otimes Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I)\\\\\n", + "&- 0.04375 (I\\otimes X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I) - 0.03079 (Z\\otimes X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", + "&+ 0.01783 (Y\\otimes X\\otimes I\\otimes I\\otimes X\\otimes Y\\otimes I\\otimes I) - 0.01783 (Y\\otimes Y\\otimes I\\otimes I\\otimes X\\otimes X\\otimes I\\otimes I)\\\\\n", + "&- 0.01783 (X\\otimes X\\otimes I\\otimes I\\otimes Y\\otimes Y\\otimes I\\otimes I) + 0.01783 (X\\otimes Y\\otimes I\\otimes I\\otimes Y\\otimes X\\otimes I\\otimes I)\\\\\n", + "&+ 0.01737 (Y\\otimes X\\otimes I\\otimes I\\otimes I\\otimes I\\otimes X\\otimes Y) - 0.01737 (Y\\otimes Y\\otimes I\\otimes I\\otimes I\\otimes I\\otimes X\\otimes X)\\\\\n", + "&- 0.01737 (X\\otimes X\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Y\\otimes Y) + 0.01737 (X\\otimes Y\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Y\\otimes X)\\\\\n", + "&- 0.03010 (Y\\otimes Z\\otimes I\\otimes Z\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.03010 (X\\otimes Z\\otimes I\\otimes Z\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", + "&+ 0.17420 (I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I) + 0.18144 (Z\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.02981 (Y\\otimes Z\\otimes Z\\otimes I\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.02981 (X\\otimes Z\\otimes Z\\otimes I\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.00029 (Y\\otimes Z\\otimes Y\\otimes Y\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.00029 (Y\\otimes Z\\otimes Y\\otimes X\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", + "&- 0.00029 (X\\otimes Z\\otimes X\\otimes Y\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.00029 (X\\otimes Z\\otimes X\\otimes X\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", + "&- 0.02510 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes Z\\otimes I) - 0.02510 (X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes Z\\otimes I)\\\\\n", + "&- 0.15961 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I) + 0.13735 (Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I)\\\\\n", + "&- 0.01131 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes Z\\otimes I\\otimes I) - 0.01131 (X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes Z\\otimes I\\otimes I)\\\\\n", + "&- 0.01456 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes X\\otimes Y) + 0.01456 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes X\\otimes X)\\\\\n", + "&+ 0.01456 (X\\otimes Z\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes Y\\otimes Y) - 0.01456 (X\\otimes Z\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes Y\\otimes X)\\\\\n", + "&- 0.18067 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z) + 0.15138 (Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z)\\\\\n", + "&- 0.01054 (Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I\\otimes Z) - 0.01054 (X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I\\otimes Z)\\\\\n", + "&+ 0.16757 (I\\otimes Z\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I) + 0.11952 (I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I)\\\\\n", + "&+ 0.13402 (I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z) + 0.18144 (I\\otimes Z\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.02981 (I\\otimes Y\\otimes I\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.02981 (I\\otimes X\\otimes I\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", + "&- 0.00029 (I\\otimes Y\\otimes X\\otimes X\\otimes Y\\otimes I\\otimes I\\otimes I) + 0.00029 (I\\otimes Y\\otimes Y\\otimes X\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", + "&+ 0.00029 (I\\otimes X\\otimes X\\otimes Y\\otimes Y\\otimes I\\otimes I\\otimes I) - 0.00029 (I\\otimes X\\otimes Y\\otimes Y\\otimes X\\otimes I\\otimes I\\otimes I)\\\\\n", + "&- 0.03010 (I\\otimes Y\\otimes Z\\otimes I\\otimes Z\\otimes Y\\otimes I\\otimes I) - 0.03010 (I\\otimes X\\otimes Z\\otimes I\\otimes Z\\otimes X\\otimes I\\otimes I)\\\\\n", + "&+ 0.13735 (I\\otimes Z\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I) - 0.01131 (I\\otimes Y\\otimes Z\\otimes Z\\otimes I\\otimes Y\\otimes I\\otimes I)\\\\\n", + "&- 0.01131 (I\\otimes X\\otimes Z\\otimes Z\\otimes I\\otimes X\\otimes I\\otimes I) + 0.01456 (I\\otimes Y\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes X\\otimes Y)\\\\\n", + "&+ 0.01456 (I\\otimes Y\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes Y\\otimes Y) + 0.01456 (I\\otimes X\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes X\\otimes X)\\\\\n", + "&+ 0.01456 (I\\otimes X\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes Y\\otimes X) - 0.02510 (I\\otimes Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes I\\otimes Z)\\\\\n", + "&- 0.02510 (I\\otimes X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes I\\otimes Z) + 0.15138 (I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I)\\\\\n", + "&- 0.01054 (I\\otimes Y\\otimes Z\\otimes Z\\otimes Z\\otimes Y\\otimes Z\\otimes I) - 0.01054 (I\\otimes X\\otimes Z\\otimes Z\\otimes Z\\otimes X\\otimes Z\\otimes I)\\\\\n", + "&+ 0.13767 (I\\otimes I\\otimes Z\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I) + 0.14973 (I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I)\\\\\n", + "&+ 0.22004 (I\\otimes I\\otimes Z\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I) + 0.00956 (I\\otimes I\\otimes Y\\otimes X\\otimes X\\otimes Y\\otimes I\\otimes I)\\\\\n", + "&- 0.00956 (I\\otimes I\\otimes Y\\otimes Y\\otimes X\\otimes X\\otimes I\\otimes I) - 0.00956 (I\\otimes I\\otimes X\\otimes X\\otimes Y\\otimes Y\\otimes I\\otimes I)\\\\\n", + "&+ 0.00956 (I\\otimes I\\otimes X\\otimes Y\\otimes Y\\otimes X\\otimes I\\otimes I) + 0.00609 (I\\otimes I\\otimes Y\\otimes X\\otimes I\\otimes I\\otimes X\\otimes Y)\\\\\n", + "&- 0.00609 (I\\otimes I\\otimes Y\\otimes Y\\otimes I\\otimes I\\otimes X\\otimes X) - 0.00609 (I\\otimes I\\otimes X\\otimes X\\otimes I\\otimes I\\otimes Y\\otimes Y)\\\\\n", + "&+ 0.00609 (I\\otimes I\\otimes X\\otimes Y\\otimes I\\otimes I\\otimes Y\\otimes X) + 0.14723 (I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I)\\\\\n", + "&+ 0.15582 (I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z) + 0.13767 (I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes Z\\otimes I\\otimes I)\\\\\n", + "&+ 0.14973 (I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes I\\otimes Z) + 0.14723 (I\\otimes I\\otimes I\\otimes Z\\otimes Z\\otimes I\\otimes I\\otimes I)\\\\\n", + "&+ 0.15582 (I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes Z\\otimes I) + 0.11270 (I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes Z\\otimes I)\\\\\n", + "&+ 0.14926 (I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes Z\\otimes I\\otimes I) + 0.02869 (I\\otimes I\\otimes I\\otimes I\\otimes Y\\otimes X\\otimes X\\otimes Y)\\\\\n", + "&- 0.02869 (I\\otimes I\\otimes I\\otimes I\\otimes Y\\otimes Y\\otimes X\\otimes X) - 0.02869 (I\\otimes I\\otimes I\\otimes I\\otimes X\\otimes X\\otimes Y\\otimes Y)\\\\\n", + "&+ 0.02869 (I\\otimes I\\otimes I\\otimes I\\otimes X\\otimes Y\\otimes Y\\otimes X) + 0.14139 (I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes I\\otimes Z)\\\\\n", + "&+ 0.11270 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes I\\otimes Z) + 0.14139 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes Z\\otimes I)\\\\\n", + "&+ 0.15436 (I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes I\\otimes Z\\otimes Z)\n", + "\\end{align*}" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "bkgCA-XNLBaq", + "metadata": { + "id": "bkgCA-XNLBaq" + }, + "outputs": [], + "source": [ + "# !pip install -U classiq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "jfBwcuM2LdS0", + "metadata": { + "id": "jfBwcuM2LdS0" + }, + "outputs": [], + "source": [ + "# import classiq\n", + "# classiq.authenticate()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e4b9b85d-f164-4c1b-aca3-e24e9a0427f8", + "metadata": { + "id": "e4b9b85d-f164-4c1b-aca3-e24e9a0427f8" + }, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from classiq import *\n", + "\n", + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-73.13873,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.22757,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.04375,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.04375,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.17420,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.16757,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.15961,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.11952,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.18067,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.13402,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.22757,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.19393,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.03079,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.03079,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.01387,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01387,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01387,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.01387,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.04375,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.03079,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.04375,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.03079,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.01783,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01783,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01783,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.01783,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=0.01737,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=-0.01737,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=-0.01737,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=0.01737,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.03010,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.03010,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.17420,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.18144,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.02981,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.02981,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.00029,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.00029,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.00029,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.00029,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.02510,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.02510,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.15961,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.13735,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01131,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01131,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=-0.01456,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=0.01456,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=0.01456,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=-0.01456,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=-0.18067,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=0.15138,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=-0.01054,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=-0.01054,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.16757,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.11952,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=0.13402,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.18144,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.02981,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.02981,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.00029,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.00029,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.00029,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.00029,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.03010,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.03010,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.13735,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01131,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01131,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=0.01456,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=0.01456,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=0.01456,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=0.01456,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=-0.02510,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=-0.02510,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.15138,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Y,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01054,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.X,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.01054,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.13767,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.14973,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.22004,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.00956,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.00956,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=-0.00956,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.00956,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=0.00609,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=-0.00609,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=-0.00609,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=0.00609,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.14723,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=0.15582,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.13767,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=0.14973,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.14723,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.15582,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.11270,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.14926,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=0.02869,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=-0.02869,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " ],\n", + " coefficient=-0.02869,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.X,\n", + " Pauli.Y,\n", + " Pauli.Y,\n", + " Pauli.X,\n", + " ],\n", + " coefficient=0.02869,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=0.14139,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=0.11270,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " Pauli.I,\n", + " ],\n", + " coefficient=0.14139,\n", + " ),\n", + " PauliTerm(\n", + " pauli=[\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.I,\n", + " Pauli.Z,\n", + " Pauli.Z,\n", + " ],\n", + " coefficient=0.15436,\n", + " ),\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "pm3NUPq7K7Xd", + "metadata": { + "id": "pm3NUPq7K7Xd" + }, + "outputs": [], + "source": [ + "@qfunc\n", + "def main(q: Output[QArray[QBit]], angles: CArray[CReal, 6]) -> None:\n", + " allocate(8, q)\n", + " # U(angles[0], angles[1], angles[2], 0, q[0])\n", + " # U(angles[3], angles[4], angles[5], 0, q[1])\n", + " # U(angles[6], angles[7], angles[8], 0, q[2])\n", + " # U(angles[9], angles[10], angles[11], 0, q[3])\n", + " # U(angles[12], angles[13], angles[14], 0, q[4])\n", + " # U(angles[15], angles[16], angles[17], 0, q[5])\n", + " # U(angles[18], angles[19], angles[20], 0, q[6])\n", + " # U(angles[21], angles[22], angles[23], 0, q[7])\n", + " repeat(q.len, lambda i: U(angles[0], angles[1], angles[2], 0, q[i]))\n", + " repeat(q.len - 1, lambda i: repeat(q.len - i - 1, lambda j: CX(q[i], q[i + j + 1])))\n", + " repeat(q.len, lambda i: U(angles[3], angles[4], angles[5], 0, q[i]))\n", + " # repeat(q.len-1, lambda i: repeat(q.len-i-1, lambda j: CX(q[i], q[i+j+1])))\n", + " # repeat(q.len, lambda i: U(angles[6], angles[7], angles[8], 0, q[i]))\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " res = vqe(\n", + " HAMILTONIAN,\n", + " False,\n", + " [],\n", + " optimizer=Optimizer.COBYLA,\n", + " max_iteration=5000,\n", + " tolerance=0.001,\n", + " step_size=0,\n", + " skip_compute_variance=False,\n", + " alpha_cvar=1.0,\n", + " )\n", + " save({\"result\": res})\n", + "\n", + "\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "sTTUaPmKLW5O", + "metadata": { + "id": "sTTUaPmKLW5O" + }, + "outputs": [], + "source": [ + "execution = execute(qprog)\n", + "res = execution.result()\n", + "# execution.open_in_ide()\n", + "vqe_result = res[0].value" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "y2LsEoJQL6KS", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "y2LsEoJQL6KS", + "outputId": "f97511b4-26f0-4032-f737-0338a207238e" + }, + "outputs": [ { - "cell_type": "code", - "source": [], - "metadata": { - "id": "Wc7QKyY6MDvu" - }, - "id": "Wc7QKyY6MDvu", - "execution_count": 6, - "outputs": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.8" - }, - "colab": { - "provenance": [] + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal energy: -74.0387620605469\n", + "Optimal parameters: {'angles_0': -1.6244327148424826, 'angles_1': 0.0029992440706366028, 'angles_2': -3.0176878190240437, 'angles_3': 4.742160511370476, 'angles_4': -0.027681125858615045, 'angles_5': -3.186328011179737}\n", + "Eigenstate: {'00010101': (0.02209708691207961+0j), '00101010': (0.02209708691207961+0j), '10101010': (0.03125+0j), '01011010': (0.03125+0j), '01010100': (0.02209708691207961+0j), '01010111': (0.038273277230987154+0j), '01000101': (0.02209708691207961+0j), '01011101': (0.02209708691207961+0j), '11010101': (0.02209708691207961+0j), '01001010': (0.03125+0j), '01010001': (0.04419417382415922+0j), '01010101': (0.9953505192895616+0j)}\n" + ] } + ], + "source": [ + "print(f\"Optimal energy: {vqe_result.energy}\")\n", + "print(f\"Optimal parameters: {vqe_result.optimal_parameters}\")\n", + "print(f\"Eigenstate: {vqe_result.eigenstate}\")" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/community/QClass_2024/Submissions/HW4/Yasir_Mansour_HW4_molecule_eigensolver.ipynb b/community/QClass_2024/Submissions/HW4/Yasir_Mansour_HW4_molecule_eigensolver.ipynb index 090647d7..d3bb4ef5 100644 --- a/community/QClass_2024/Submissions/HW4/Yasir_Mansour_HW4_molecule_eigensolver.ipynb +++ b/community/QClass_2024/Submissions/HW4/Yasir_Mansour_HW4_molecule_eigensolver.ipynb @@ -1,16 +1,5 @@ { "cells": [ - { - "cell_type": "markdown", - "id": "726d2386", - "metadata": { - "colab_type": "text", - "id": "view-in-github" - }, - "source": [ - "\"Open" - ] - }, { "cell_type": "markdown", "id": "4fbae0f9", @@ -34,7 +23,7 @@ "id": "TWGNYMkUKh6C" }, "source": [ - "` **RESULTS**\n", + "**RESULTS**\n", "\n", "Comparison of different molecules in terms of width and depth. The more atoms in a molecule, the more qubits/circuit depth are necessary. System overload when more than 3 atoms.\n", "\n", @@ -76,7 +65,7 @@ "id": "Br0-chtAKv6D" }, "source": [ - "##**co2**\n", + "## **co2**\n", "\n", "hw-eff ansatz: width 24/depth 175\n", "\n", @@ -100,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "C3SemPUxJw4V", "metadata": { "colab": { @@ -111,12 +100,12 @@ }, "outputs": [], "source": [ - "!pip install classiq" + "# !pip install classiq" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "zjvfmLnXJ1Kk", "metadata": { "id": "zjvfmLnXJ1Kk" @@ -128,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "LHrqCSj2J5PC", "metadata": { "colab": { @@ -139,13 +128,13 @@ }, "outputs": [], "source": [ - "import classiq\n", - "classiq.authenticate()" + "# import classiq\n", + "# classiq.authenticate()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "c6bbe65f-1e6a-475c-a43f-cb4cc04bbdfa", "metadata": { "id": "c6bbe65f-1e6a-475c-a43f-cb4cc04bbdfa", @@ -188,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "VN6XdfYfLApS", "metadata": { "id": "VN6XdfYfLApS", @@ -196,40 +185,60 @@ }, "outputs": [], "source": [ - "#hydrogen\n", + "# hydrogen\n", "molecule_H2 = Molecule(atoms=[(\"H\", (0.0, 0.0, 0)), (\"H\", (0.0, 0.0, 0.735))])\n", "\n", - "#oxygen\n", + "# oxygen\n", "molecule_O2 = Molecule(atoms=[(\"O\", (0.0, 0.0, 0)), (\"O\", (0.0, 0.0, 1.16))])\n", "\n", - "#lithium hydride\n", + "# lithium hydride\n", "molecule_LiH = Molecule(atoms=[(\"H\", (0.0, 0.0, 0.0)), (\"Li\", (0.0, 0.0, 1.596))])\n", "\n", - "#water\n", + "# water\n", "molecule_H2O = Molecule(\n", " atoms=[(\"O\", (0.0, 0.0, 0.0)), (\"H\", (0, 0.586, 0.757)), (\"H\", (0, 0.586, -0.757))]\n", ")\n", - "#beryllium hydride\n", + "# beryllium hydride\n", "molecule_BeH2 = Molecule(\n", " atoms=[(\"Be\", (0.0, 0.0, 0.0)), (\"H\", (0, 0, 1.334)), (\"H\", (0, 0, -1.334))]\n", ")\n", - "#carbon dioxide\n", - "molecule_CO2 = Molecule(atoms=[(\"C\", (0.0, 0.0, 0.0)),\n", - " (\"O\", (0, 0, 1.1693)), (\"O\", (0, 0, -1.1693))])\n", + "# carbon dioxide\n", + "molecule_CO2 = Molecule(\n", + " atoms=[(\"C\", (0.0, 0.0, 0.0)), (\"O\", (0, 0, 1.1693)), (\"O\", (0, 0, -1.1693))]\n", + ")\n", "\n", - "#ethyne, acetylene\n", - "molecule_C2H2 = Molecule(atoms=[(\"C\", (0, 0, -0.5977)), (\"C\", (0, 0, 0.5977)),\n", - " (\"H\", (0, 0, -1.6692)), (\"H\", (0, 0, 1.6692))])\n", + "# ethyne, acetylene\n", + "molecule_C2H2 = Molecule(\n", + " atoms=[\n", + " (\"C\", (0, 0, -0.5977)),\n", + " (\"C\", (0, 0, 0.5977)),\n", + " (\"H\", (0, 0, -1.6692)),\n", + " (\"H\", (0, 0, 1.6692)),\n", + " ]\n", + ")\n", "\n", - "#chloroform\n", - "molecule_CH3Cl = Molecule(atoms=[(\"C\", (0, 0, -1.1401)), (\"Cl\", (0, 0, 0.6645)),\n", - " (\"H\", (0, 1.0343, -1.4855)),\n", - " (\"H\", (0.8957, -0.5171, -1.4855)), (\"H\", (-0.8957, -0.5171, -1.4855))])\n", + "# chloroform\n", + "molecule_CH3Cl = Molecule(\n", + " atoms=[\n", + " (\"C\", (0, 0, -1.1401)),\n", + " (\"Cl\", (0, 0, 0.6645)),\n", + " (\"H\", (0, 1.0343, -1.4855)),\n", + " (\"H\", (0.8957, -0.5171, -1.4855)),\n", + " (\"H\", (-0.8957, -0.5171, -1.4855)),\n", + " ]\n", + ")\n", "\n", - "#ethylene\n", - "molecule_C2H4 = Molecule(atoms=[(\"C\", (0, 0, 0.6673)), (\"C\", (0, 0, -0.6673)),\n", - " (\"H\", (0, 0.9239, 1.2411)), (\"H\", (0, -0.9239, 1.2411)),\n", - " (\"H\", (0, -0.9239, -1.2411)), (\"H\", (0, 0.9239, -1.2411))])\n" + "# ethylene\n", + "molecule_C2H4 = Molecule(\n", + " atoms=[\n", + " (\"C\", (0, 0, 0.6673)),\n", + " (\"C\", (0, 0, -0.6673)),\n", + " (\"H\", (0, 0.9239, 1.2411)),\n", + " (\"H\", (0, -0.9239, 1.2411)),\n", + " (\"H\", (0, -0.9239, -1.2411)),\n", + " (\"H\", (0, 0.9239, -1.2411)),\n", + " ]\n", + ")" ] }, { @@ -244,7 +253,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "2e77678f", "metadata": { "id": "2e77678f", @@ -276,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "2e0426d5", "metadata": { "colab": { @@ -287,7 +296,529 @@ "outputId": "205584a3-ca38-4d54-ca52-dbc3f88b8bbf", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your Hamiltonian is\n", + "-18.374 * IIIIIIII\n", + "+1.169 * ZIZIZIZZ\n", + "-0.061 * IIZIIZZX\n", + "+0.061 * ZIIIZZIX\n", + "+0.139 * IIIIIZXI\n", + "-0.139 * ZIZIZZXZ\n", + "+0.813 * ZIIIZZII\n", + "+0.192 * ZIZIZXZZ\n", + "-0.192 * IIZIIXZZ\n", + "+0.823 * IIIIIIIZ\n", + "-0.114 * IIZIIIYY\n", + "-0.114 * IIZIIIXX\n", + "+1.640 * IIZIIIII\n", + "+0.385 * IIIIIIZI\n", + "+0.377 * IIIIIZII\n", + "+1.169 * ZZZZZIII\n", + "-0.061 * ZZZXIIII\n", + "+0.061 * IIIXZIII\n", + "+0.139 * ZXIIIIII\n", + "-0.139 * IXZZZIII\n", + "+0.813 * IIIIZIII\n", + "-0.192 * YZZZYIII\n", + "-0.192 * XZZZXIII\n", + "+0.823 * IIIZIIII\n", + "-0.114 * IYZYIIII\n", + "-0.114 * IXZXIIII\n", + "+0.385 * IZIIIIII\n", + "+0.377 * ZIIIIIII\n", + "+0.125 * IIZIIZZZ\n", + "+0.024 * IIIIIXII\n", + "-0.024 * ZIIIZXII\n", + "+0.138 * ZIZIZIZI\n", + "+0.019 * ZIIIZIXX\n", + "+0.019 * ZIIIZIYY\n", + "+0.338 * ZIIIZIZZ\n", + "+0.128 * ZIZIZIIZ\n", + "+0.141 * ZIZIZZZZ\n", + "-0.003 * ZIZIZIZX\n", + "+0.003 * IIIIIIIX\n", + "+0.029 * ZIIIZIXI\n", + "-0.029 * IIZIIIXZ\n", + "-0.011 * ZIIIZYIY\n", + "-0.011 * IIIIIXIX\n", + "-0.000 * IIIIIYIY\n", + "-0.000 * IIZIIYZY\n", + "-0.011 * IIZIIXZX\n", + "-0.011 * ZIZIZYZY\n", + "+0.010 * ZIZIZYYZ\n", + "+0.016 * IIZIIXXZ\n", + "+0.005 * IIZIIYYZ\n", + "+0.005 * IIIIIYYI\n", + "+0.016 * IIIIIXXI\n", + "+0.010 * ZIIIZYYI\n", + "+0.030 * IIIIIZXZ\n", + "-0.030 * ZIZIZZXI\n", + "-0.023 * IIIIIZZX\n", + "+0.023 * ZIZIZZIX\n", + "-0.001 * IIZIIZIX\n", + "+0.001 * ZIIIZZZX\n", + "+0.001 * IIZIIIZX\n", + "-0.001 * ZIIIZIIX\n", + "+0.065 * IIZIIZXI\n", + "-0.065 * ZIIIZZXZ\n", + "+0.020 * IIIIIIXI\n", + "-0.020 * ZIZIZIXZ\n", + "+0.182 * IZIZIIZZ\n", + "+0.001 * ZZIZZZZX\n", + "-0.001 * IZZZIZIX\n", + "+0.036 * ZZZZZZXI\n", + "-0.036 * IZIZIZXZ\n", + "+0.036 * ZZIZXZZZ\n", + "-0.036 * IIZIXZZZ\n", + "-0.036 * ZZZZXIII\n", + "+0.036 * IIIIXIII\n", + "+0.010 * ZZZZXXII\n", + "-0.010 * IIIIXXII\n", + "+0.010 * IZIZYYZZ\n", + "-0.010 * ZIZIYYZZ\n", + "+0.001 * IZIXZIZZ\n", + "-0.001 * ZIZXIIZZ\n", + "+0.031 * ZZIXIZZX\n", + "-0.031 * IIZXZZZX\n", + "-0.031 * IZZXZZIX\n", + "+0.031 * ZIIXIZIX\n", + "+0.005 * ZZZXIZXI\n", + "-0.005 * IIIXZZXI\n", + "-0.005 * IZIXZZXZ\n", + "+0.005 * ZIZXIZXZ\n", + "+0.036 * ZZXIIZZI\n", + "-0.036 * IIXZZZZI\n", + "-0.036 * IZXIZZIZ\n", + "+0.036 * ZIXZIZIZ\n", + "+0.036 * IXZIZIZZ\n", + "-0.036 * ZXIZIIZZ\n", + "+0.005 * ZXZIIZZX\n", + "-0.005 * IXIZZZZX\n", + "-0.005 * IXIIZZIX\n", + "+0.005 * ZXZZIZIX\n", + "+0.025 * ZXIIIZXI\n", + "-0.025 * IXZZZZXI\n", + "-0.025 * IXZIZZXZ\n", + "+0.025 * ZXIZIZXZ\n", + "+0.010 * XIZIIZZZ\n", + "-0.010 * XZIZZZZZ\n", + "-0.010 * XIIIIIII\n", + "+0.010 * XZZZZIII\n", + "+0.015 * XIIIIXII\n", + "-0.015 * XZZZZXII\n", + "+0.015 * YIZIZYZZ\n", + "-0.015 * YZIZIYZZ\n", + "+0.161 * ZIZIIIZZ\n", + "+0.002 * IIZIZZZX\n", + "-0.002 * ZIIIIZIX\n", + "+0.019 * IIIIZZXI\n", + "-0.019 * ZIZIIZXZ\n", + "-0.005 * IIZYYZZZ\n", + "-0.005 * IIZXXZZZ\n", + "+0.005 * IIIYYIII\n", + "+0.005 * IIIXXIII\n", + "+0.009 * IIIYYXII\n", + "+0.009 * IIIXXXII\n", + "-0.009 * ZIZYXYZZ\n", + "+0.009 * ZIZXYYZZ\n", + "+0.010 * IYIZYZZZ\n", + "+0.010 * IXIZXZZZ\n", + "-0.010 * IYZZYIII\n", + "-0.010 * IXZZXIII\n", + "-0.009 * IYZZYXII\n", + "-0.009 * IXZZXXII\n", + "+0.009 * ZYIZXYZZ\n", + "-0.009 * ZXIZYYZZ\n", + "+0.035 * XZIZXIZZ\n", + "+0.035 * YZIZYIZZ\n", + "+0.019 * YZIZYZZX\n", + "+0.019 * XZIZXZZX\n", + "+0.019 * XZZZXZIX\n", + "+0.019 * YZZZYZIX\n", + "-0.019 * YZZZYZXI\n", + "-0.019 * XZZZXZXI\n", + "-0.019 * XZIZXZXZ\n", + "-0.019 * YZIZYZXZ\n", + "+0.169 * ZIZZZIZZ\n", + "-0.026 * IIZZIZZX\n", + "+0.026 * ZIIZZZIX\n", + "+0.022 * IIIZIZXI\n", + "-0.022 * ZIZZZZXZ\n", + "+0.012 * IIYYIZZI\n", + "+0.012 * IIXXIZZI\n", + "-0.012 * ZIYYZZIZ\n", + "-0.012 * ZIXXZZIZ\n", + "-0.024 * ZYIYZIZZ\n", + "-0.024 * ZXIXZIZZ\n", + "+0.008 * IYIYIZZX\n", + "+0.008 * IXIXIZZX\n", + "-0.008 * ZYZYZZIX\n", + "-0.008 * ZXZXZZIX\n", + "-0.015 * IYZYIZXI\n", + "-0.015 * IXZXIZXI\n", + "+0.015 * ZYIYZZXZ\n", + "+0.015 * ZXIXZZXZ\n", + "+0.019 * YZIYIZZZ\n", + "+0.019 * XZIXIZZZ\n", + "-0.019 * YZZYIIII\n", + "-0.019 * XZZXIIII\n", + "+0.004 * YZZYIXII\n", + "+0.004 * XZZXIXII\n", + "-0.004 * XZIYZYZZ\n", + "+0.004 * YZIXZYZZ\n", + "-0.015 * IYYIIZZI\n", + "-0.015 * IXXIIZZI\n", + "+0.015 * ZYYIZZIZ\n", + "+0.015 * ZXXIZZIZ\n", + "+0.154 * ZZZIZIZZ\n", + "+0.015 * IZZIIZZX\n", + "-0.015 * ZZIIZZIX\n", + "+0.024 * IZIIIZXI\n", + "-0.024 * ZZZIZZXZ\n", + "-0.025 * YYZIIZZZ\n", + "-0.025 * XXZIIZZZ\n", + "+0.025 * YYIIIIII\n", + "+0.025 * XXIIIIII\n", + "+0.002 * YYIIIXII\n", + "+0.002 * XXIIIXII\n", + "-0.002 * XYZIZYZZ\n", + "+0.002 * YXZIZYZZ\n", + "+0.156 * IIZIZIZZ\n", + "-0.003 * ZIZIIZZX\n", + "+0.003 * IIIIZZIX\n", + "+0.017 * ZIIIIZXI\n", + "-0.017 * IIZIZZXZ\n", + "+0.138 * ZIIIZZIZ\n", + "-0.018 * ZIZIZZYY\n", + "-0.018 * ZIZIZZXX\n", + "+0.307 * ZIZIZZII\n", + "+0.125 * ZIIIZZZI\n", + "+0.229 * ZIIIZIII\n", + "+0.039 * ZIZIZXZI\n", + "-0.039 * IIZIIXZI\n", + "+0.008 * ZIIIZXXX\n", + "+0.008 * ZIIIZXYY\n", + "+0.001 * ZIIIZYXY\n", + "+0.001 * IIIIIYYX\n", + "-0.008 * IIIIIXXX\n", + "-0.008 * IIIIIXYY\n", + "+0.089 * ZIIIZXZZ\n", + "-0.089 * IIIIIXZZ\n", + "+0.026 * ZIZIZXIZ\n", + "-0.026 * IIZIIXIZ\n", + "+0.161 * IZZZIZII\n", + "+0.035 * IZIZIXZZ\n", + "-0.035 * ZZIZZXZZ\n", + "-0.005 * IZZZYZIY\n", + "+0.005 * ZIIIYZIY\n", + "-0.005 * ZZZZXIIX\n", + "+0.005 * IIIIXIIX\n", + "+0.010 * IZIZYZYZ\n", + "-0.010 * ZIZIYZYZ\n", + "+0.010 * ZZIZXIXZ\n", + "-0.010 * IIZIXIXZ\n", + "+0.002 * IZZXZZII\n", + "-0.002 * ZIIXIZII\n", + "-0.019 * IZIXZXZZ\n", + "+0.019 * ZIZXIXZZ\n", + "+0.019 * ZZIXIXZZ\n", + "-0.019 * IIZXZXZZ\n", + "+0.019 * IXIIZZII\n", + "-0.019 * ZXZZIZII\n", + "+0.019 * IXZIZXZZ\n", + "-0.019 * ZXIZIXZZ\n", + "-0.019 * ZXZIIXZZ\n", + "+0.019 * IXIZZXZZ\n", + "+0.009 * YIIIZZIY\n", + "-0.009 * YZZZIZIY\n", + "+0.009 * XIIIIIIX\n", + "-0.009 * XZZZZIIX\n", + "-0.009 * YIZIZZYZ\n", + "+0.009 * YZIZIZYZ\n", + "-0.009 * XIZIIIXZ\n", + "+0.009 * XZIZZIXZ\n", + "+0.313 * ZIIIIZII\n", + "-0.001 * ZIZIIXZZ\n", + "+0.001 * IIZIZXZZ\n", + "-0.012 * ZIIYXZIY\n", + "+0.012 * ZIIXYZIY\n", + "+0.012 * IIIYYIIX\n", + "+0.012 * IIIXXIIX\n", + "+0.007 * ZIZYXZYZ\n", + "-0.007 * ZIZXYZYZ\n", + "-0.007 * IIZYYIXZ\n", + "-0.007 * IIZXXIXZ\n", + "+0.007 * ZIXZXZIZ\n", + "+0.007 * ZIYZYZIZ\n", + "+0.007 * IIYZYIIZ\n", + "+0.007 * IIXZXIIZ\n", + "+0.007 * ZYZZXZIY\n", + "-0.007 * ZXZZYZIY\n", + "-0.007 * IYZZYIIX\n", + "-0.007 * IXZZXIIX\n", + "-0.018 * ZYIZXZYZ\n", + "+0.018 * ZXIZYZYZ\n", + "+0.018 * IYIZYIXZ\n", + "+0.018 * IXIZXIXZ\n", + "-0.001 * XZZZXZII\n", + "-0.001 * YZZZYZII\n", + "+0.076 * XZIZXXZZ\n", + "+0.076 * YZIZYXZZ\n", + "+0.150 * ZIIZZZII\n", + "+0.040 * ZIZZZXZZ\n", + "-0.040 * IIZZIXZZ\n", + "-0.011 * ZYZYZZII\n", + "-0.011 * ZXZXZZII\n", + "-0.020 * ZYIYZXZZ\n", + "-0.020 * ZXIXZXZZ\n", + "+0.020 * IYIYIXZZ\n", + "+0.020 * IXIXIXZZ\n", + "-0.001 * XZZYZZIY\n", + "+0.001 * YZZXZZIY\n", + "+0.001 * YZZYIIIX\n", + "+0.001 * XZZXIIIX\n", + "-0.011 * XZIYZZYZ\n", + "+0.011 * YZIXZZYZ\n", + "+0.011 * YZIYIIXZ\n", + "+0.011 * XZIXIIXZ\n", + "+0.006 * XZXIZZIZ\n", + "+0.006 * YZYIZZIZ\n", + "+0.006 * YZYIIIIZ\n", + "+0.006 * XZXIIIIZ\n", + "+0.143 * ZZIIZZII\n", + "+0.009 * ZZZIZXZZ\n", + "-0.009 * IZZIIXZZ\n", + "-0.012 * XYIIZZIY\n", + "+0.012 * YXIIZZIY\n", + "+0.012 * YYIIIIIX\n", + "+0.012 * XXIIIIIX\n", + "+0.016 * XYZIZZYZ\n", + "-0.016 * YXZIZZYZ\n", + "-0.016 * YYZIIIXZ\n", + "-0.016 * XXZIIIXZ\n", + "+0.305 * IIIIZZII\n", + "+0.351 * IIZIIIIZ\n", + "+0.120 * IIIIIIZZ\n", + "+0.135 * IIIIIZIZ\n", + "-0.059 * IIIIIIYY\n", + "-0.059 * IIIIIIXX\n", + "-0.025 * IIZIIZYY\n", + "-0.025 * IIZIIZXX\n", + "+0.169 * ZZZZZIIZ\n", + "-0.024 * ZZIZZIYY\n", + "-0.024 * ZZIZZIXX\n", + "+0.019 * ZZIZXYZY\n", + "-0.019 * IIZIXYZY\n", + "+0.019 * ZZIZXXZX\n", + "-0.019 * IIZIXXZX\n", + "-0.026 * ZZZXIIIZ\n", + "+0.026 * IIIXZIIZ\n", + "+0.008 * ZZIXIIYY\n", + "-0.008 * IIZXZIYY\n", + "+0.008 * ZZIXIIXX\n", + "-0.008 * IIZXZIXX\n", + "+0.012 * ZZYIIIIY\n", + "-0.012 * IIYZZIIY\n", + "+0.012 * ZZXIIIIX\n", + "-0.012 * IIXZZIIX\n", + "+0.022 * ZXIIIIIZ\n", + "-0.022 * IXZZZIIZ\n", + "-0.015 * ZXZIIIYY\n", + "+0.015 * IXIZZIYY\n", + "-0.015 * ZXZIIIXX\n", + "+0.015 * IXIZZIXX\n", + "+0.004 * XIZIIYZY\n", + "-0.004 * XZIZZYZY\n", + "+0.004 * XIZIIXZX\n", + "-0.004 * XZIZZXZX\n", + "+0.150 * IIIIZIIZ\n", + "-0.011 * IIZIZIYY\n", + "-0.011 * IIZIZIXX\n", + "+0.001 * IIZYYYZY\n", + "+0.001 * IIZXXYZY\n", + "+0.001 * IIZYYXZX\n", + "+0.001 * IIZXXXZX\n", + "+0.011 * IYIZYYZY\n", + "+0.011 * IXIZXYZY\n", + "+0.011 * IYIZYXZX\n", + "+0.011 * IXIZXXZX\n", + "-0.040 * YZZZYIIZ\n", + "-0.040 * XZZZXIIZ\n", + "+0.020 * YZIZYIYY\n", + "+0.020 * XZIZXIYY\n", + "+0.020 * YZIZYIXX\n", + "+0.020 * XZIZXIXX\n", + "+0.196 * IIIZIIIZ\n", + "-0.030 * IIZZIIYY\n", + "-0.030 * IIZZIIXX\n", + "-0.014 * IIXYIIIY\n", + "+0.014 * IIYXIIIY\n", + "+0.014 * IIYYIIIX\n", + "+0.014 * IIXXIIIX\n", + "-0.030 * IYZYIIIZ\n", + "-0.030 * IXZXIIIZ\n", + "+0.017 * IYIYIIYY\n", + "+0.017 * IXIXIIYY\n", + "+0.017 * IYIYIIXX\n", + "+0.017 * IXIXIIXX\n", + "+0.017 * YZIYIYZY\n", + "+0.017 * XZIXIYZY\n", + "+0.017 * YZIYIXZX\n", + "+0.017 * XZIXIXZX\n", + "+0.000 * IYXIIIIY\n", + "-0.000 * IXYIIIIY\n", + "-0.000 * IYYIIIIX\n", + "-0.000 * IXXIIIIX\n", + "+0.137 * IZIIIIIZ\n", + "-0.011 * IZZIIIYY\n", + "-0.011 * IZZIIIXX\n", + "-0.014 * YYZIIYZY\n", + "-0.014 * XXZIIYZY\n", + "-0.014 * YYZIIXZX\n", + "-0.014 * XXZIIXZX\n", + "+0.152 * ZIIIIIIZ\n", + "-0.010 * ZIZIIIYY\n", + "-0.010 * ZIZIIIXX\n", + "+0.285 * IIZIIIZI\n", + "+0.306 * IIZIIZII\n", + "+0.338 * ZZIZZIII\n", + "-0.023 * ZZIXIIII\n", + "+0.023 * IIZXZIII\n", + "-0.015 * ZZYIIIYI\n", + "+0.015 * IIYZZIYI\n", + "-0.015 * ZZXIIIXI\n", + "+0.015 * IIXZZIXI\n", + "+0.065 * ZXZIIIII\n", + "-0.065 * IXIZZIII\n", + "+0.307 * IIZIZIII\n", + "-0.006 * IIXZYYZI\n", + "+0.006 * IIYZXYZI\n", + "+0.006 * IIYZYXZI\n", + "+0.006 * IIXZXXZI\n", + "-0.089 * YZIZYIII\n", + "-0.089 * XZIZXIII\n", + "+0.351 * IIZZIIII\n", + "+0.000 * IIXYIIYI\n", + "-0.000 * IIYXIIYI\n", + "-0.000 * IIYYIIXI\n", + "-0.000 * IIXXIIXI\n", + "-0.059 * IYIYIIII\n", + "-0.059 * IXIXIIII\n", + "-0.010 * IYXIIIYI\n", + "+0.010 * IXYIIIYI\n", + "+0.010 * IYYIIIXI\n", + "+0.010 * IXXIIIXI\n", + "-0.006 * YZXIIYZI\n", + "+0.006 * XZYIIYZI\n", + "+0.006 * YZYIIXZI\n", + "+0.006 * XZXIIXZI\n", + "+0.285 * IZZIIIII\n", + "+0.306 * ZIZIIIII\n", + "+0.113 * IIIIIZZI\n", + "+0.154 * ZZZZZIZI\n", + "-0.025 * ZZZZXYYI\n", + "+0.025 * IIIIXYYI\n", + "-0.025 * ZZZZXXXI\n", + "+0.025 * IIIIXXXI\n", + "+0.015 * ZZZXIIZI\n", + "-0.015 * IIIXZIZI\n", + "+0.024 * ZXIIIIZI\n", + "-0.024 * IXZZZIZI\n", + "+0.002 * XIIIIYYI\n", + "-0.002 * XZZZZYYI\n", + "+0.002 * XIIIIXXI\n", + "-0.002 * XZZZZXXI\n", + "+0.143 * IIIIZIZI\n", + "+0.012 * IIIYYYYI\n", + "+0.012 * IIIXXYYI\n", + "+0.012 * IIIYYXXI\n", + "+0.012 * IIIXXXXI\n", + "-0.016 * IYZZYYYI\n", + "-0.016 * IXZZXYYI\n", + "-0.016 * IYZZYXXI\n", + "-0.016 * IXZZXXXI\n", + "-0.009 * YZZZYIZI\n", + "-0.009 * XZZZXIZI\n", + "+0.137 * IIIZIIZI\n", + "-0.011 * IYZYIIZI\n", + "-0.011 * IXZXIIZI\n", + "-0.014 * YZZYIYYI\n", + "-0.014 * XZZXIYYI\n", + "-0.014 * YZZYIXXI\n", + "-0.014 * XZZXIXXI\n", + "+0.149 * IZIIIIZI\n", + "+0.029 * YYIIIYYI\n", + "+0.029 * XXIIIYYI\n", + "+0.029 * YYIIIXXI\n", + "+0.029 * XXIIIXXI\n", + "+0.142 * ZIIIIIZI\n", + "+0.156 * ZZZZZZII\n", + "-0.003 * ZZZXIZII\n", + "+0.003 * IIIXZZII\n", + "+0.017 * ZXIIIZII\n", + "-0.017 * IXZZZZII\n", + "+0.152 * IIIZIZII\n", + "-0.010 * IYZYIZII\n", + "-0.010 * IXZXIZII\n", + "+0.142 * IZIIIZII\n", + "+0.125 * ZZZZIIII\n", + "+0.024 * XIIIXIII\n", + "+0.024 * YIIIYIII\n", + "+0.138 * ZZZIZIII\n", + "+0.019 * ZXIXZIII\n", + "+0.019 * ZYIYZIII\n", + "+0.128 * ZIZZZIII\n", + "+0.141 * IZZZZIII\n", + "-0.003 * ZZZXZIII\n", + "+0.003 * IIIXIIII\n", + "+0.029 * ZXIIZIII\n", + "-0.029 * IXZZIIII\n", + "-0.011 * XIIYYIII\n", + "-0.011 * XIIXXIII\n", + "-0.000 * YIIYXIII\n", + "-0.000 * YZZYXIII\n", + "-0.011 * XZZXXIII\n", + "-0.011 * XZZYYIII\n", + "+0.010 * XYZZYIII\n", + "+0.016 * XXZZXIII\n", + "+0.005 * YYZZXIII\n", + "+0.005 * YYIIXIII\n", + "+0.016 * XXIIXIII\n", + "+0.010 * XYIIYIII\n", + "+0.030 * ZXIZIIII\n", + "-0.030 * IXZIZIII\n", + "-0.001 * ZIZXIIII\n", + "+0.001 * IZIXZIII\n", + "+0.001 * IZZXIIII\n", + "-0.001 * ZIIXZIII\n", + "+0.020 * IXIIIIII\n", + "-0.020 * ZXZZZIII\n", + "+0.138 * IIIZZIII\n", + "-0.018 * IYZYZIII\n", + "-0.018 * IXZXZIII\n", + "+0.125 * IZIIZIII\n", + "-0.039 * YZZIYIII\n", + "-0.039 * XZZIXIII\n", + "-0.008 * YXIXYIII\n", + "-0.008 * YYIYYIII\n", + "+0.001 * XXIYYIII\n", + "+0.001 * YYIXXIII\n", + "-0.008 * XXIXXIII\n", + "-0.008 * XYIYXIII\n", + "-0.026 * YIZZYIII\n", + "-0.026 * XIZZXIII\n", + "+0.120 * IZIZIIII\n", + "+0.135 * ZIIZIIII\n", + "-0.025 * ZYZYIIII\n", + "-0.025 * ZXZXIIII\n", + "+0.113 * ZZIIIIII\n" + ] + } + ], "source": [ "chemistry_problem = MoleculeProblem(\n", " molecule=molecule,\n", @@ -344,7 +875,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "90b20061-8dbd-4136-adba-28ddacb1f583", "metadata": { "id": "90b20061-8dbd-4136-adba-28ddacb1f583", @@ -361,8 +892,18 @@ "\n", "hwea_params = HEAParameters(\n", " num_qubits=12,\n", - " connectivity_map=[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8),\n", - " (8, 9), (9, 10)],\n", + " connectivity_map=[\n", + " (0, 1),\n", + " (1, 2),\n", + " (2, 3),\n", + " (3, 4),\n", + " (4, 5),\n", + " (5, 6),\n", + " (6, 7),\n", + " (7, 8),\n", + " (8, 9),\n", + " (9, 10),\n", + " ],\n", " reps=3,\n", " one_qubit_gates=[\"x\", \"ry\"],\n", " two_qubit_gates=[\"cx\"],\n", @@ -393,7 +934,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "f13599d2-e8e7-4165-aa26-8ae8d4bdafaa", "metadata": { "id": "f13599d2-e8e7-4165-aa26-8ae8d4bdafaa", @@ -401,14 +942,15 @@ }, "outputs": [], "source": [ - "from classiq import write_qmod\n", + "# optional:\n", "\n", - "write_qmod(qmod, name=\"molecule_eigensolver\")" + "# from classiq import write_qmod\n", + "# write_qmod(qmod, name=\"molecule_eigensolver\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "22cd12d1-2c87-400a-a983-b2f24e40fa45", "metadata": { "colab": { @@ -422,7 +964,7 @@ "outputs": [], "source": [ "qprog = synthesize(qmod)\n", - "show(qprog)" + "# show(qprog) # optional" ] }, { @@ -448,7 +990,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "1f520673", "metadata": { "colab": { @@ -459,7 +1001,15 @@ "outputId": "fd4a3467-c48b-483c-b156-0a0cde9e2189", "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "circuit depth: 1048\n" + ] + } + ], "source": [ "chemistry_problem = MoleculeProblem(\n", " molecule=molecule,\n", @@ -491,7 +1041,7 @@ ")\n", "\n", "qprog = synthesize(serialized_chemistry_model)\n", - "show(qprog)\n", + "# show(qprog) # optional\n", "\n", "circuit = QuantumProgram.from_qprog(qprog)\n", "print(f\"circuit depth: {circuit.transpiled_circuit.depth}\")" @@ -516,12 +1066,14 @@ "source": [ "## 3. Execute to Find Ground State\n", "\n", - "Once we've synthesized the model we can execute it." + "Once we've synthesized the model we can execute it. \n", + "\n", + "**Uncomment the remaining code lines to run the final part. It will take a few minutes.**" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "1a66d377", "metadata": { "colab": { @@ -534,8 +1086,8 @@ }, "outputs": [], "source": [ - "result = execute(qprog).result()\n", - "chemistry_result_dict = result[1].value" + "# result = execute(qprog).result()\n", + "# chemistry_result_dict = result[1].value" ] }, { @@ -560,7 +1112,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "437b3211", "metadata": { "colab": { @@ -573,12 +1125,12 @@ }, "outputs": [], "source": [ - "chemistry_result_dict[\"total_energy\"]" + "# chemistry_result_dict[\"total_energy\"]" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "9a537d3c", "metadata": { "colab": { @@ -590,7 +1142,7 @@ }, "outputs": [], "source": [ - "chemistry_result_dict[\"vqe_result\"][\"optimal_parameters\"]" + "# chemistry_result_dict[\"vqe_result\"][\"optimal_parameters\"]" ] }, { @@ -605,7 +1157,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "5c896576", "metadata": { "colab": { @@ -618,10 +1170,10 @@ }, "outputs": [], "source": [ - "mat = operator.to_matrix()\n", - "w, v = np.linalg.eig(mat)\n", - "print(\"exact result:\", np.real(min(w)))\n", - "print(\"vqe result:\", chemistry_result_dict[\"energy\"])" + "# mat = operator.to_matrix()\n", + "# w, v = np.linalg.eig(mat)\n", + "# print(\"exact result:\", np.real(min(w)))\n", + "# print(\"vqe result:\", chemistry_result_dict[\"energy\"])" ] }, { @@ -668,14 +1220,11 @@ "id": "bxRq_3-Jb4_0" }, "source": [ - "##**co2**\n", + "## **co2**\n", "\n", "hw-eff: width 24/depth 175\n", "\n", - "ucc: width 20/depth 19767, width 24/depth 16968\n", - "\n", - "Error number 90001 occurred. The resources needed to execute this request are insufficient.\n", - " This may be due to computational limitations, or high load on Classiq's servers." + "ucc: width 20/depth 19767, width 24/depth 16968" ] }, { @@ -697,7 +1246,7 @@ "provenance": [] }, "kernelspec": { - "display_name": "Python 3 [Default]", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, diff --git a/community/QClass_2024/Submissions/HW4/index.md b/community/QClass_2024/Submissions/HW4/index.md deleted file mode 100644 index d42278e1..00000000 --- a/community/QClass_2024/Submissions/HW4/index.md +++ /dev/null @@ -1,27 +0,0 @@ -:rocket: Final Assignment Alert! :rocket: - -Hey everyone! :tada: Get ready to apply your skills and creativity in our final assignment. Here are the main highlights: - -:sparkles: Goal: -- Be creative and collaborate with each other and the community. -- Apply your knowledge to bridge the gap between theory and application! - -:hammer_and_wrench: Project Options: -- Read in the thread! -- Feel free to suggest different projects. - -:gift: Rewards: -- Earn SWAG credits. -- Potentially more advanced certificates! (depending on the project results) -- Mentoring from a Classiq member for selected projects during the process, to enhance your learning! - -:date: Important Dates: -- Release: 29.5.2024 -- Submission Deadline: 10.6.2024 (7 A.M GMT+3) (might be flexible for this project solid deadline for HW1-3) - -:busts_in_silhouette: Teamwork: -- Work in teams of up to 3 members! - -For more details, check out the full assignment document. Reach out if you have any questions. - -Happy coding and good luck! :computer::star2: \ No newline at end of file diff --git a/community/basic_examples/entanglement/bell_state_of_2_qubits.qmod b/community/basic_examples/entanglement/bell_state_of_2_qubits.qmod index a3128a11..35df42c7 100644 --- a/community/basic_examples/entanglement/bell_state_of_2_qubits.qmod +++ b/community/basic_examples/entanglement/bell_state_of_2_qubits.qmod @@ -7,4 +7,3 @@ qfunc main(output registers: qbit[]) { allocate<2>(registers); my_bell_state(registers); } - diff --git a/community/basic_examples/entanglement/bell_state_of_2_qubits.synthesis_options.json b/community/basic_examples/entanglement/bell_state_of_2_qubits.synthesis_options.json index 9e26dfee..0967ef42 100644 --- a/community/basic_examples/entanglement/bell_state_of_2_qubits.synthesis_options.json +++ b/community/basic_examples/entanglement/bell_state_of_2_qubits.synthesis_options.json @@ -1 +1 @@ -{} \ No newline at end of file +{} diff --git a/community/basic_examples/entanglement/entanglement.ipynb b/community/basic_examples/entanglement/entanglement.ipynb index 47eb807b..332da381 100644 --- a/community/basic_examples/entanglement/entanglement.ipynb +++ b/community/basic_examples/entanglement/entanglement.ipynb @@ -31,11 +31,13 @@ " H(reg[0])\n", " CX(reg[0], reg[1])\n", "\n", + "\n", "@qfunc\n", "def main(registers: Output[QArray[QBit]]) -> None:\n", " allocate(2, registers)\n", " my_bell_state(registers)\n", "\n", + "\n", "model = create_model(main)\n", "write_qmod(model, \"bell_state_of_2_qubits\")\n", "\n", @@ -77,8 +79,8 @@ "If we measure both the qubits we will either get the state $|00\\rangle$ or the state $|11\\rangle$ with equal probability.\n", "\n", "It is described as:\n", - "- When Alice oberseve her state as $|0\\rangle$ then the state of Bob's qubit collapses to the state $|0\\rangle$\n", - "- When Alice oberseve her state as $|1\\rangle$ then the state of Bob's qubit collapses to the state $|1\\rangle$ \n", + "- When Alice observes her state as $|0\\rangle$ then the state of Bob's qubit collapses to the state $|0\\rangle$\n", + "- When Alice observes her state as $|1\\rangle$ then the state of Bob's qubit collapses to the state $|1\\rangle$ \n", "\n", "The resultant entangled state is designated as a bell pair state $|\\Phi^{+}\\rangle$\n", "$$|\\Phi^{+}\\rangle = \\frac{1}{\\sqrt{2}} \\left( |00\\rangle + |11\\rangle \\right)$$\n", diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod index afa2dbc1..7b0f0cb4 100644 --- a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod +++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod @@ -9,4 +9,3 @@ qfunc main(output ctrl: qbit[], output target: qbit) { allocate<1>(target); my_mcx(ctrl, target); } - diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json index eccba304..9b5bf99c 100644 --- a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json +++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json @@ -5,229 +5,64 @@ }, "preferences": { "custom_hardware_settings": { - "basis_gates": [ - "cx", - "u" - ], + "basis_gates": ["cx", "u"], "connectivity_map": [ - [ - 0, - 1 - ], - [ - 1, - 2 - ], - [ - 2, - 3 - ], - [ - 3, - 4 - ], - [ - 4, - 5 - ], - [ - 6, - 7 - ], - [ - 7, - 8 - ], - [ - 8, - 9 - ], - [ - 9, - 10 - ], - [ - 10, - 11 - ], - [ - 12, - 13 - ], - [ - 13, - 14 - ], - [ - 14, - 15 - ], - [ - 15, - 16 - ], - [ - 16, - 17 - ], - [ - 0, - 6 - ], - [ - 6, - 12 - ], - [ - 1, - 7 - ], - [ - 7, - 13 - ], - [ - 2, - 8 - ], - [ - 8, - 14 - ], - [ - 3, - 9 - ], - [ - 9, - 15 - ], - [ - 4, - 10 - ], - [ - 10, - 16 - ], - [ - 5, - 11 - ], - [ - 11, - 17 - ], - [ - 1, - 0 - ], - [ - 2, - 1 - ], - [ - 3, - 2 - ], - [ - 4, - 3 - ], - [ - 5, - 4 - ], - [ - 7, - 6 - ], - [ - 8, - 7 - ], - [ - 9, - 8 - ], - [ - 10, - 9 - ], - [ - 11, - 10 - ], - [ - 13, - 12 - ], - [ - 14, - 13 - ], - [ - 15, - 14 - ], - [ - 16, - 15 - ], - [ - 17, - 16 - ], - [ - 6, - 0 - ], - [ - 12, - 6 - ], - [ - 7, - 1 - ], - [ - 13, - 7 - ], - [ - 8, - 2 - ], - [ - 14, - 8 - ], - [ - 9, - 3 - ], - [ - 15, - 9 - ], - [ - 10, - 4 - ], - [ - 16, - 10 - ], - [ - 11, - 5 - ], - [ - 17, - 11 - ] + [0, 1], + [1, 2], + [2, 3], + [3, 4], + [4, 5], + [6, 7], + [7, 8], + [8, 9], + [9, 10], + [10, 11], + [12, 13], + [13, 14], + [14, 15], + [15, 16], + [16, 17], + [0, 6], + [6, 12], + [1, 7], + [7, 13], + [2, 8], + [8, 14], + [3, 9], + [9, 15], + [4, 10], + [10, 16], + [5, 11], + [11, 17], + [1, 0], + [2, 1], + [3, 2], + [4, 3], + [5, 4], + [7, 6], + [8, 7], + [9, 8], + [10, 9], + [11, 10], + [13, 12], + [14, 13], + [15, 14], + [16, 15], + [17, 16], + [6, 0], + [12, 6], + [7, 1], + [13, 7], + [8, 2], + [14, 8], + [9, 3], + [15, 9], + [10, 4], + [16, 10], + [11, 5], + [17, 11] ] }, "random_seed": -1 } -} \ No newline at end of file +} diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod index afa2dbc1..7b0f0cb4 100644 --- a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod +++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod @@ -9,4 +9,3 @@ qfunc main(output ctrl: qbit[], output target: qbit) { allocate<1>(target); my_mcx(ctrl, target); } - diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json index 54a8c00f..15bbf496 100644 --- a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json +++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json @@ -5,141 +5,42 @@ }, "preferences": { "custom_hardware_settings": { - "basis_gates": [ - "cx", - "u" - ], + "basis_gates": ["cx", "u"], "connectivity_map": [ - [ - 0, - 1 - ], - [ - 0, - 2 - ], - [ - 0, - 3 - ], - [ - 0, - 4 - ], - [ - 0, - 5 - ], - [ - 0, - 6 - ], - [ - 0, - 7 - ], - [ - 0, - 8 - ], - [ - 0, - 9 - ], - [ - 0, - 10 - ], - [ - 0, - 11 - ], - [ - 0, - 12 - ], - [ - 0, - 13 - ], - [ - 0, - 14 - ], - [ - 0, - 15 - ], - [ - 0, - 16 - ], - [ - 1, - 0 - ], - [ - 2, - 0 - ], - [ - 3, - 0 - ], - [ - 4, - 0 - ], - [ - 5, - 0 - ], - [ - 6, - 0 - ], - [ - 7, - 0 - ], - [ - 8, - 0 - ], - [ - 9, - 0 - ], - [ - 10, - 0 - ], - [ - 11, - 0 - ], - [ - 12, - 0 - ], - [ - 13, - 0 - ], - [ - 14, - 0 - ], - [ - 15, - 0 - ], - [ - 16, - 0 - ] + [0, 1], + [0, 2], + [0, 3], + [0, 4], + [0, 5], + [0, 6], + [0, 7], + [0, 8], + [0, 9], + [0, 10], + [0, 11], + [0, 12], + [0, 13], + [0, 14], + [0, 15], + [0, 16], + [1, 0], + [2, 0], + [3, 0], + [4, 0], + [5, 0], + [6, 0], + [7, 0], + [8, 0], + [9, 0], + [10, 0], + [11, 0], + [12, 0], + [13, 0], + [14, 0], + [15, 0], + [16, 0] ] }, "random_seed": -1 } -} \ No newline at end of file +} diff --git a/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb b/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb index 7618195a..8e2cac18 100644 --- a/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb +++ b/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb @@ -1,645 +1,691 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "S5a8KVmhRyCm" - }, - "source": [ - "# HW-aware Synthesis of MCX\n", - "\n", - "This tutorial consists of two parts,\n", - "1. How to create a 10-CONTROL MCX gate with Classiq\n", - "2. Classiq's Hardware-Aware Synthesis capability\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "AE1ksqSMC_MY" - }, - "source": [ - "## 1. How to create a 10-CONTROL MCX gate with Classiq" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CiCAjWxbC_Ma" - }, - "source": [ - "To create an MCX gate with 10 control qubits using Classiq, we will first define a quantum function called `my_mcx`, whose arguments are an array of qubits (of any size) to be used as control, and a single qubit argument to be used as the target." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "N55CY8rJo6nu" - }, - "outputs": [], - "source": [ - "#importing all the necessary libraries from classiq\n", - "\n", - "from math import pi\n", - "from classiq import *" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "8jxKs0RkpLqf" - }, - "outputs": [], - "source": [ - "# define MCX quantum function\n", - "@qfunc\n", - "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", - " control(ctrl, lambda: X(target))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "DxI88JO1C_Mh" - }, - "source": [ - "Then, to create an MCX gate with 10 control qubits we will create a quantum main function that will simply execute our `my_mcx` function with 10 qubits allocated to the control argument." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "NIxnhfOgpSSI" - }, - "outputs": [], - "source": [ - "# define the MCX parameters within the quantum 'main' function\n", - "@qfunc\n", - "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", - " allocate(10, ctrl)\n", - " allocate(1, target)\n", - " my_mcx(ctrl, target)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Iu8uortFC_Mi" - }, - "source": [ - "To build our model we will use the `create_model` function:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "iHVgE7SCpZBL" - }, - "outputs": [], - "source": [ - "# build a model\n", - "model = create_model(main)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CTi8GIBrC_Mk" - }, - "source": [ - "To constrain a circuit to only 20 qubits and optimize for circuit depth, we pass the max width and optimization parameter to a `Constraints` object and update our model" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "zbzL6MksC_Ml" - }, - "outputs": [], - "source": [ - "from classiq import write_qmod\n", - "\n", - "constraints = Constraints(\n", - " max_width=20, optimization_parameter=OptimizationParameter.DEPTH\n", - ")\n", - "model = set_constraints(model, constraints)\n", - "\n", - "write_qmod(model, \"mcx_10_ctrl_depth\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bpBmDJcBC_Mm" - }, - "source": [ - "We can now synthesize our model, create a quantum program and view it:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "OebNdwj-C_Mn", - "outputId": "d6b32f26-36b9-42a8-f8d0-629dbcd5598d" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/c51e64f0-fc0a-43a8-b484-2ddf7366c956?version=0.42.0\n" - ] - } - ], - "source": [ - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "HDdeZAmNC_Mo" - }, - "source": [ - "Additionally, To get the transpiled circuit from our qprog object and print its depth:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "4Ykj96NcC_Mp", - "outputId": "759f30d6-34e5-4e17-9e68-ec112c1ef074" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Synthesized MCX depth is 52\n" - ] - } - ], - "source": [ - "circuit = QuantumProgram.from_qprog(qprog)\n", - "print(f\"Synthesized MCX depth is {circuit.transpiled_circuit.depth}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rF_sE_vHC_Mq" - }, - "source": [ - "# 2. Classiq's Hardware-Aware Synthesis capability" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "74aCfp3IC_Mq" - }, - "source": [ - "In the above section we have seen how to create a MCX circuit, add constraints to it and optimize its depth in Classiq. In this section we will check the hardware-aware synthesis capability of Classiq. In this example we will implement and synthesize a simple MCX (Multiple Control-X) circuit with two different HW-aware configuration settings using Classiq's synthesis engine.\n", - "\n", - "The two different fictitious hardware created here demonstrates how to insert your own custom-designed machine. For comparison, we create two types of hardware with `cx, u` basis gates. The difference between them manifests in the connectivity map: one has grid connectivity while the other has star connectivity.\n", - "\n", - "The two fictitious hardware created are using two different simulators: Classiq's Simulator and IonQ's Simulator. We will compare the depth of the circuit and we will optimise the number of cnot gates as it is important in quantum computation because they cause more errors and are very expensive.\n" - ] - }, - { - "cell_type": "code", - "source": [ - "# define MCX quantum function\n", - "@qfunc\n", - "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", - " control(ctrl, lambda: X(target))" - ], - "metadata": { - "id": "kDz3GbcKEwwB" - }, - "execution_count": 10, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# define the MCX parameters within the quantum 'main' function\n", - "@qfunc\n", - "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", - " allocate(12, ctrl)\n", - " allocate(1, target)\n", - " my_mcx(ctrl, target)" - ], - "metadata": { - "id": "yOzokSMZEw78" - }, - "execution_count": 11, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# build a model\n", - "model = create_model(main)" - ], - "metadata": { - "id": "5bGo7UFBEw_V" - }, - "execution_count": 12, - "outputs": [] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "id": "NlxS3xSTC_Mr" - }, - "outputs": [], - "source": [ - "# define the hardware parameters\n", - "max_width = 18\n", - "\n", - "#Grid Connectivity\n", - "grid_connectivity = [\n", - " [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], # Row 1\n", - " [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], # Row 2\n", - " [12, 13], [13, 14], [14, 15], [15, 16], [16, 17], # Row 3\n", - " [0, 6], [6, 12], # Column 1\n", - " [1, 7], [7, 13], # Column 2\n", - " [2, 8], [8, 14], # Column 3\n", - " [3, 9], [9, 15], # Column 4\n", - " [4, 10], [10, 16], # Column 5\n", - " [5, 11], [11, 17] # Column 6\n", - "]\n", - "\n", - "#Star Connectivity\n", - "star_connectivity = [[0, i] for i in range(1, max_width-1)]" - ] - }, - { - "cell_type": "code", - "source": [ - "#Plotting Grid Connectivity\n", - "import matplotlib.pyplot as plt\n", - "import networkx as nx\n", - "\n", - "G = nx.Graph()\n", - "G.add_edges_from(grid_connectivity)\n", - "\n", - "# Define the positions of the nodes in a 3x6 grid\n", - "pos = {}\n", - "for i in range(3):\n", - " for j in range(6):\n", - " pos[i * 6 + j] = (j, -i) # (x, y) coordinates\n", - "\n", - "# Plot the graph\n", - "plt.figure(figsize=(10, 6))\n", - "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n", - "plt.title(\"3x6 Grid Connectivity Map\")\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 659 - }, - "id": "qVDIz-txBcRS", - "outputId": "62566d81-b841-4eb0-e4fa-046f1a6151bd" - }, - "execution_count": 14, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "#plotting Star Connectivity\n", - "import numpy as np\n", - "\n", - "G = nx.Graph()\n", - "G.add_edges_from(star_connectivity)\n", - "\n", - "# Define the positions of the nodes in a star configuration\n", - "pos = {}\n", - "pos[0] = (0, 0) # Central node\n", - "angle_step = 360 / (len(star_connectivity))\n", - "for i in range(1, 18):\n", - " angle = angle_step * (i - 1)\n", - " radians = np.deg2rad(angle)\n", - " pos[i] = (np.cos(radians), np.sin(radians))\n", - "\n", - "# Plot the graph\n", - "plt.figure(figsize=(10, 10))\n", - "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n", - "plt.title(\"Star Connectivity Map\")\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "0AEHYvxACpS7", - "outputId": "62c17d67-b8f0-403c-96ba-41bcc319619f" - }, - "execution_count": 15, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "#Grid Preferences\n", - "preferences_grid = Preferences(\n", - " custom_hardware_settings=CustomHardwareSettings(\n", - " basis_gates=[\"cx\", \"u\"],\n", - " connectivity_map=grid_connectivity,\n", - " ),\n", - " random_seed=-1,\n", - ")\n", - "\n", - "\n", - "#Star Preferences\n", - "preferences_star = Preferences(\n", - " custom_hardware_settings=CustomHardwareSettings(basis_gates=[\"cx\", \"u\"],\n", - " connectivity_map=star_connectivity,),\n", - " random_seed=-1,\n", - ")" - ], - "metadata": { - "id": "1ogjh7qTGJd3" - }, - "execution_count": 16, - "outputs": [] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "id": "_3KIstIjC_Ms" - }, - "outputs": [], - "source": [ - "# define synthesis engine constraints\n", - "constraints = Constraints(optimization_parameter=\"cx\", max_width=max_width)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "id": "wviSbVIqsavi" - }, - "outputs": [], - "source": [ - "# define models with different preferences\n", - "model = set_constraints(model, constraints)\n", - "model_grid = set_preferences(model, preferences_grid)\n", - "model_star = set_preferences(model, preferences_star)\n", - "\n", - "\n", - "# write models to files\n", - "write_qmod(model_grid, \"hardware_aware_mcx_grid\")\n", - "write_qmod(model_star, \"hardware_aware_mcx_star\")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "hWP-uuNmsf5g", - "outputId": "762decbc-3005-4419-bb7e-6e14571db2a3" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/4e728c67-0064-4699-87cd-e689b15937e7?version=0.42.0\n" - ] - } - ], - "source": [ - "qprog_grid= synthesize(model_grid)\n", - "show(qprog_grid)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "7-1tx3a3squr", - "outputId": "65034a5d-dd40-42e4-b045-88e2a9401c37" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Synthesized MCX cx-count for grid connectivity is 117\n", - "Opening: https://platform.classiq.io/circuit/4e728c67-0064-4699-87cd-e689b15937e7?version=0.42.0\n" - ] - } - ], - "source": [ - "circuit_grid = QuantumProgram.from_qprog(qprog_grid)\n", - "\n", - "print(f\"Synthesized MCX cx-count for grid connectivity is {circuit_grid.transpiled_circuit.count_ops['cx']}\")\n", - "circuit_grid.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cYcpNdbos3is", - "outputId": "fd1c4e8b-623a-425f-bebe-a39d7f051f7f" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Opening: https://platform.classiq.io/circuit/b94a1120-5b81-4a27-a949-b90e018518e0?version=0.42.0\n" - ] - } - ], - "source": [ - "qprog_star = synthesize(model_star)\n", - "show(qprog_star)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "FySbcicutSXk", - "outputId": "c1d536d1-67e4-4f99-95d1-60884614ed2d" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Synthesized MCX cx-count for star connectivity is 114\n", - "Opening: https://platform.classiq.io/circuit/b94a1120-5b81-4a27-a949-b90e018518e0?version=0.42.0\n" - ] - } - ], - "source": [ - "circuit_star = QuantumProgram.from_qprog(qprog_star)\n", - "\n", - "print(f\"Synthesized MCX cx-count for star connectivity is {circuit_star.transpiled_circuit.count_ops['cx']}\")\n", - "circuit_star.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "4p-TBa9ztebZ", - "outputId": "39293b2b-7081-4267-f3b5-005f37ee830b" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Synthesized Depth for grid connectivity is 82\n" - ] - } - ], - "source": [ - "print(f\"Synthesized Depth for grid connectivity is {circuit_grid.transpiled_circuit.depth}\")" + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "S5a8KVmhRyCm" + }, + "source": [ + "# HW-aware Synthesis of MCX\n", + "\n", + "This tutorial consists of two parts,\n", + "1. How to create a 10-CONTROL MCX gate with Classiq\n", + "2. Classiq's Hardware-Aware Synthesis capability\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AE1ksqSMC_MY" + }, + "source": [ + "## 1. How to create a 10-CONTROL MCX gate with Classiq" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CiCAjWxbC_Ma" + }, + "source": [ + "To create an MCX gate with 10 control qubits using Classiq, we will first define a quantum function called `my_mcx`, whose arguments are an array of qubits (of any size) to be used as control, and a single qubit argument to be used as the target." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N55CY8rJo6nu" + }, + "outputs": [], + "source": [ + "# importing all the necessary libraries from classiq\n", + "\n", + "from math import pi\n", + "\n", + "from classiq import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "8jxKs0RkpLqf" + }, + "outputs": [], + "source": [ + "# define MCX quantum function\n", + "\n", + "\n", + "@qfunc\n", + "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", + " control(ctrl, lambda: X(target))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DxI88JO1C_Mh" + }, + "source": [ + "Then, to create an MCX gate with 10 control qubits we will create a quantum main function that will simply execute our `my_mcx` function with 10 qubits allocated to the control argument." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "NIxnhfOgpSSI" + }, + "outputs": [], + "source": [ + "# define the MCX parameters within the quantum 'main' function\n", + "\n", + "\n", + "@qfunc\n", + "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", + " allocate(10, ctrl)\n", + " allocate(1, target)\n", + " my_mcx(ctrl, target)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Iu8uortFC_Mi" + }, + "source": [ + "To build our model we will use the `create_model` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "iHVgE7SCpZBL" + }, + "outputs": [], + "source": [ + "# build a model\n", + "model = create_model(main)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CTi8GIBrC_Mk" + }, + "source": [ + "To constrain a circuit to only 20 qubits and optimize for circuit depth, we pass the max width and optimization parameter to a `Constraints` object and update our model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "zbzL6MksC_Ml" + }, + "outputs": [], + "source": [ + "from classiq import write_qmod\n", + "\n", + "constraints = Constraints(\n", + " max_width=20, optimization_parameter=OptimizationParameter.DEPTH\n", + ")\n", + "model = set_constraints(model, constraints)\n", + "\n", + "write_qmod(model, \"mcx_10_ctrl_depth\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bpBmDJcBC_Mm" + }, + "source": [ + "We can now synthesize our model, create a quantum program and view it:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OebNdwj-C_Mn", + "outputId": "d6b32f26-36b9-42a8-f8d0-629dbcd5598d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: http://localhost:4200/circuit/0a38090c-f137-4276-893b-6f9a21f47668?version=0.0.0\n" + ] + } + ], + "source": [ + "qprog = synthesize(model)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HDdeZAmNC_Mo" + }, + "source": [ + "Additionally, To get the transpiled circuit from our qprog object and print its depth:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4Ykj96NcC_Mp", + "outputId": "759f30d6-34e5-4e17-9e68-ec112c1ef074" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Synthesized MCX depth is 52\n" + ] + } + ], + "source": [ + "circuit = QuantumProgram.from_qprog(qprog)\n", + "print(f\"Synthesized MCX depth is {circuit.transpiled_circuit.depth}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rF_sE_vHC_Mq" + }, + "source": [ + "# 2. Classiq's Hardware-Aware Synthesis capability" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "74aCfp3IC_Mq" + }, + "source": [ + "In the above section we have seen how to create a MCX circuit, add constraints to it and optimize its depth in Classiq. In this section we will check the hardware-aware synthesis capability of Classiq. In this example we will implement and synthesize a simple MCX (Multiple Control-X) circuit with two different HW-aware configuration settings using Classiq's synthesis engine.\n", + "\n", + "The two different fictitious hardware created here demonstrates how to insert your own custom-designed machine. For comparison, we create two types of hardware with `cx, u` basis gates. The difference between them manifests in the connectivity map: one has grid connectivity while the other has star connectivity.\n", + "\n", + "The two fictitious hardware created are using two different simulators: Classiq's Simulator and IonQ's Simulator. We will compare the depth of the circuit and we will optimise the number of cnot gates as it is important in quantum computation because they cause more errors and are very expensive.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "kDz3GbcKEwwB" + }, + "outputs": [], + "source": [ + "# define MCX quantum function\n", + "\n", + "\n", + "@qfunc\n", + "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", + " control(ctrl, lambda: X(target))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "yOzokSMZEw78" + }, + "outputs": [], + "source": [ + "# define the MCX parameters within the quantum 'main' function\n", + "\n", + "\n", + "@qfunc\n", + "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", + " allocate(12, ctrl)\n", + " allocate(1, target)\n", + " my_mcx(ctrl, target)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "5bGo7UFBEw_V" + }, + "outputs": [], + "source": [ + "# build a model\n", + "model = create_model(main)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "NlxS3xSTC_Mr" + }, + "outputs": [], + "source": [ + "# define the hardware parameters\n", + "max_width = 18\n", + "\n", + "# Grid Connectivity\n", + "grid_connectivity = [\n", + " [0, 1],\n", + " [1, 2],\n", + " [2, 3],\n", + " [3, 4],\n", + " [4, 5], # Row 1\n", + " [6, 7],\n", + " [7, 8],\n", + " [8, 9],\n", + " [9, 10],\n", + " [10, 11], # Row 2\n", + " [12, 13],\n", + " [13, 14],\n", + " [14, 15],\n", + " [15, 16],\n", + " [16, 17], # Row 3\n", + " [0, 6],\n", + " [6, 12], # Column 1\n", + " [1, 7],\n", + " [7, 13], # Column 2\n", + " [2, 8],\n", + " [8, 14], # Column 3\n", + " [3, 9],\n", + " [9, 15], # Column 4\n", + " [4, 10],\n", + " [10, 16], # Column 5\n", + " [5, 11],\n", + " [11, 17], # Column 6\n", + "]\n", + "\n", + "# Star Connectivity\n", + "star_connectivity = [[0, i] for i in range(1, max_width - 1)]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 659 + }, + "id": "qVDIz-txBcRS", + "outputId": "62566d81-b841-4eb0-e4fa-046f1a6151bd" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "EVxTVGqf1HIS", - "outputId": "53561623-3c04-4931-d8f3-b6d82c680be5" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Synthesized Depth for star connectivity is 191\n" - ] - } - ], - "source": [ - "print(f\"Synthesized Depth for star connectivity is {circuit_star.transpiled_circuit.depth}\")" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting Grid Connectivity\n", + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "\n", + "G = nx.Graph()\n", + "G.add_edges_from(grid_connectivity)\n", + "\n", + "# Define the positions of the nodes in a 3x6 grid\n", + "pos = {}\n", + "for i in range(3):\n", + " for j in range(6):\n", + " pos[i * 6 + j] = (j, -i) # (x, y) coordinates\n", + "\n", + "# Plot the graph\n", + "plt.figure(figsize=(10, 6))\n", + "nx.draw(\n", + " G,\n", + " pos,\n", + " with_labels=True,\n", + " node_size=500,\n", + " node_color=\"skyblue\",\n", + " font_size=16,\n", + " font_color=\"black\",\n", + " edge_color=\"gray\",\n", + ")\n", + "plt.title(\"3x6 Grid Connectivity Map\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "0AEHYvxACpS7", + "outputId": "62c17d67-b8f0-403c-96ba-41bcc319619f" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, - { - "cell_type": "markdown", - "source": [ - "**Conclusion:** Given the connectivity of the hardware and its preferences the engince optimizes the constraints of the model. In this case the constraits were `max_width` which is the maximum number of qubits it can use and the number of `cx gates`. Our main aim is to minimize the number of cx gates.\n", - "\n", - "With `Star Connectivity` the minimum number of cx gates required after transpiling the circuit is just 114 and depth of the circuit turned out to be 191.\n", - "\n", - "Whereas with `Grid Connectivity` the minimum number of cx gates required after transpiling the circuit is 117 and depth of the circuit is 82.\n", - "\n", - "Looking at the both the cases we can come to a conclusion that star connectivity is more favourable to synthesize and execute a `mcx circuit`.\n", - "\n" - ], - "metadata": { - "id": "b043xgbpHGEO" - } - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "0oDCHQ3Pczgt" - }, - "execution_count": null, - "outputs": [] + }, + "metadata": {}, + "output_type": "display_data" } - ], - "metadata": { + ], + "source": [ + "# plotting Star Connectivity\n", + "import numpy as np\n", + "\n", + "G = nx.Graph()\n", + "G.add_edges_from(star_connectivity)\n", + "\n", + "# Define the positions of the nodes in a star configuration\n", + "pos = {}\n", + "pos[0] = (0, 0) # Central node\n", + "angle_step = 360 / (len(star_connectivity))\n", + "for i in range(1, 18):\n", + " angle = angle_step * (i - 1)\n", + " radians = np.deg2rad(angle)\n", + " pos[i] = (np.cos(radians), np.sin(radians))\n", + "\n", + "# Plot the graph\n", + "plt.figure(figsize=(10, 10))\n", + "nx.draw(\n", + " G,\n", + " pos,\n", + " with_labels=True,\n", + " node_size=500,\n", + " node_color=\"skyblue\",\n", + " font_size=16,\n", + " font_color=\"black\",\n", + " edge_color=\"gray\",\n", + ")\n", + "plt.title(\"Star Connectivity Map\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "1ogjh7qTGJd3" + }, + "outputs": [], + "source": [ + "# Grid Preferences\n", + "preferences_grid = Preferences(\n", + " custom_hardware_settings=CustomHardwareSettings(\n", + " basis_gates=[\"cx\", \"u\"],\n", + " connectivity_map=grid_connectivity,\n", + " ),\n", + " random_seed=-1,\n", + ")\n", + "\n", + "\n", + "# Star Preferences\n", + "preferences_star = Preferences(\n", + " custom_hardware_settings=CustomHardwareSettings(\n", + " basis_gates=[\"cx\", \"u\"],\n", + " connectivity_map=star_connectivity,\n", + " ),\n", + " random_seed=-1,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "_3KIstIjC_Ms" + }, + "outputs": [], + "source": [ + "# define synthesis engine constraints\n", + "constraints = Constraints(optimization_parameter=\"cx\", max_width=max_width)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "wviSbVIqsavi" + }, + "outputs": [], + "source": [ + "# define models with different preferences\n", + "model = set_constraints(model, constraints)\n", + "model_grid = set_preferences(model, preferences_grid)\n", + "model_star = set_preferences(model, preferences_star)\n", + "\n", + "\n", + "# write models to files\n", + "write_qmod(model_grid, \"hardware_aware_mcx_grid\")\n", + "write_qmod(model_star, \"hardware_aware_mcx_star\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" + "base_uri": "https://localhost:8080/" + }, + "id": "hWP-uuNmsf5g", + "outputId": "762decbc-3005-4419-bb7e-6e14571db2a3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: http://localhost:4200/circuit/74f4c802-631d-4f39-b68b-3b95397e67bd?version=0.0.0\n" + ] + } + ], + "source": [ + "qprog_grid = synthesize(model_grid)\n", + "show(qprog_grid)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7-1tx3a3squr", + "outputId": "65034a5d-dd40-42e4-b045-88e2a9401c37" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Synthesized MCX cx-count for grid connectivity is 117\n", + "Opening: http://localhost:4200/circuit/74f4c802-631d-4f39-b68b-3b95397e67bd?version=0.0.0\n" + ] + } + ], + "source": [ + "circuit_grid = QuantumProgram.from_qprog(qprog_grid)\n", + "\n", + "print(\n", + " f\"Synthesized MCX cx-count for grid connectivity is {circuit_grid.transpiled_circuit.count_ops['cx']}\"\n", + ")\n", + "circuit_grid.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cYcpNdbos3is", + "outputId": "fd1c4e8b-623a-425f-bebe-a39d7f051f7f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: http://localhost:4200/circuit/d47721d8-f737-4e07-be84-ad204e5df08d?version=0.0.0\n" + ] + } + ], + "source": [ + "qprog_star = synthesize(model_star)\n", + "show(qprog_star)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FySbcicutSXk", + "outputId": "c1d536d1-67e4-4f99-95d1-60884614ed2d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Synthesized MCX cx-count for star connectivity is 114\n", + "Opening: http://localhost:4200/circuit/d47721d8-f737-4e07-be84-ad204e5df08d?version=0.0.0\n" + ] } + ], + "source": [ + "circuit_star = QuantumProgram.from_qprog(qprog_star)\n", + "\n", + "print(\n", + " f\"Synthesized MCX cx-count for star connectivity is {circuit_star.transpiled_circuit.count_ops['cx']}\"\n", + ")\n", + "circuit_star.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4p-TBa9ztebZ", + "outputId": "39293b2b-7081-4267-f3b5-005f37ee830b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Synthesized Depth for grid connectivity is 82\n" + ] + } + ], + "source": [ + "print(\n", + " f\"Synthesized Depth for grid connectivity is {circuit_grid.transpiled_circuit.depth}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EVxTVGqf1HIS", + "outputId": "53561623-3c04-4931-d8f3-b6d82c680be5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Synthesized Depth for star connectivity is 191\n" + ] + } + ], + "source": [ + "print(\n", + " f\"Synthesized Depth for star connectivity is {circuit_star.transpiled_circuit.depth}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b043xgbpHGEO" + }, + "source": [ + "**Conclusion:** Given the connectivity of the hardware and its preferences the engince optimizes the constraints of the model. In this case the constraits were `max_width` which is the maximum number of qubits it can use and the number of `cx gates`. Our main aim is to minimize the number of cx gates.\n", + "\n", + "With `Star Connectivity` the minimum number of cx gates required after transpiling the circuit is just 114 and depth of the circuit turned out to be 191.\n", + "\n", + "Whereas with `Grid Connectivity` the minimum number of cx gates required after transpiling the circuit is 117 and depth of the circuit is 82.\n", + "\n", + "Looking at the both the cases we can come to a conclusion that star connectivity is more favourable to synthesize and execute a `mcx circuit`.\n", + "\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 0 + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod index 293534ae..2b24a6a7 100644 --- a/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod +++ b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod @@ -9,4 +9,3 @@ qfunc main(output ctrl: qbit[], output target: qbit) { allocate<1>(target); my_mcx(ctrl, target); } - diff --git a/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json index 1c4b772e..e5062f9d 100644 --- a/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json +++ b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json @@ -3,4 +3,4 @@ "max_width": 20, "optimization_parameter": "depth" } -} \ No newline at end of file +} diff --git a/community/basic_examples/vqe/vqe.ipynb b/community/basic_examples/vqe/vqe.ipynb index 56771c63..3479c185 100644 --- a/community/basic_examples/vqe/vqe.ipynb +++ b/community/basic_examples/vqe/vqe.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -23,26 +23,27 @@ "\n", "from classiq import *\n", "\n", - "#Defining the Hamiltonian from the problem\n", - "HAMILTONIAN = QConstant(\"HAMILTONIAN\", List[PauliTerm], \n", - " [ \n", - " PauliTerm([Pauli.Z], 1),\n", - " PauliTerm([Pauli.X], 0.1)])\n", + "# Defining the Hamiltonian from the problem\n", + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\", List[PauliTerm], [PauliTerm([Pauli.Z], 1), PauliTerm([Pauli.X], 0.1)]\n", + ")\n", "\n", - "#Defining the Ansatz for the Problem\n", + "\n", + "# Defining the Ansatz for the Problem\n", "@qfunc\n", "def main(q: Output[QBit], angles: CArray[CReal, 1]) -> None:\n", " allocate(1, q)\n", - " RY(angles[0], q) \n", + " RY(angles[0], q)\n", + "\n", "\n", - "#Defining the Variational Quantum Eigensolver primitives with proper paramters\n", + "# Defining the Variational Quantum Eigensolver primitives with proper paramters\n", "@cfunc\n", "def cmain() -> None:\n", " res = vqe(\n", - " HAMILTONIAN, #Hamiltonian of the problem\n", - " False, #Maximize Parameter\n", + " HAMILTONIAN, # Hamiltonian of the problem\n", + " False, # Maximize Parameter\n", " [],\n", - " optimizer=Optimizer.COBYLA, # Classical Optimizer\n", + " optimizer=Optimizer.COBYLA, # Classical Optimizer\n", " max_iteration=1000,\n", " tolerance=0.001,\n", " step_size=0,\n", @@ -51,6 +52,7 @@ " )\n", " save({\"result\": res})\n", "\n", + "\n", "qmod = create_model(main, classical_execution_function=cmain)\n", "qprog = synthesize(qmod)\n", "write_qmod(qmod, name=\"vqe_primitives\")" @@ -65,14 +67,14 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/8758a1e5-bd68-4be4-896e-7fd4e98d9a95?version=0.42.0\n" + "Opening: https://platform.classiq.io/circuit/4b5a812b-24e6-4165-a09d-4dfcc2d9b523?version=0.42.0\n" ] } ], @@ -89,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -100,15 +102,15 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Minimal energy of the Hamiltonian -1.015625\n", - "Optimal parameters for the Ansatz {'angles_0': 3.2430102953668842}\n" + "Minimal energy of the Hamiltonian -1.01240234375\n", + "Optimal parameters for the Ansatz {'angles_0': 9.566986160448005}\n" ] } ], @@ -287,7 +289,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -301,9 +303,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.1" + "version": "3.11.8" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/community/basic_examples/vqe/vqe_primitives.qmod b/community/basic_examples/vqe/vqe_primitives.qmod index 9a094c96..3d669341 100644 --- a/community/basic_examples/vqe/vqe_primitives.qmod +++ b/community/basic_examples/vqe/vqe_primitives.qmod @@ -17,4 +17,4 @@ qfunc main(output q: qbit) { cscope ``` res = vqe(HAMILTONIAN, False, [], optimizer=Optimizer.COBYLA, max_iteration=1000, tolerance=0.001, step_size=0, skip_compute_variance=False, alpha_cvar=1.0) save({'result': res}) -``` \ No newline at end of file +``` diff --git a/community/basic_examples/vqe/vqe_primitives.synthesis_options.json b/community/basic_examples/vqe/vqe_primitives.synthesis_options.json index 9e26dfee..0967ef42 100644 --- a/community/basic_examples/vqe/vqe_primitives.synthesis_options.json +++ b/community/basic_examples/vqe/vqe_primitives.synthesis_options.json @@ -1 +1 @@ -{} \ No newline at end of file +{} diff --git a/functions/function_usage_examples/arithmetic/arithmetic_expression/arithmetic_expression_example.json b/functions/function_usage_examples/arithmetic/arithmetic_expression/arithmetic_expression_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/arithmetic_expression/arithmetic_expression_example.json rename to functions/function_usage_examples/arithmetic/arithmetic_expression/arithmetic_expression_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_2vars_example.json b/functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_2vars_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_2vars_example.json rename to functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_2vars_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_integer_example.json b/functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_integer_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_integer_example.json rename to functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_integer_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/bitwise_invert/bitwise_invert_example.json b/functions/function_usage_examples/arithmetic/bitwise_invert/bitwise_invert_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/bitwise_invert/bitwise_invert_example.json rename to functions/function_usage_examples/arithmetic/bitwise_invert/bitwise_invert_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_2vars_example.json b/functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_2vars_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_2vars_example.json rename to functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_2vars_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_integer_example.json b/functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_integer_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_integer_example.json rename to functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_integer_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_2vars_example.json b/functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_2vars_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_2vars_example.json rename to functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_2vars_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_integer_example.json b/functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_integer_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_integer_example.json rename to functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_integer_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/comparator/comparator_2vars_example.json b/functions/function_usage_examples/arithmetic/comparator/comparator_2vars_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/comparator/comparator_2vars_example.json rename to functions/function_usage_examples/arithmetic/comparator/comparator_2vars_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/comparator/comparator_integer_example.json b/functions/function_usage_examples/arithmetic/comparator/comparator_integer_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/comparator/comparator_integer_example.json rename to functions/function_usage_examples/arithmetic/comparator/comparator_integer_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/extremum/maximum_float_example.json b/functions/function_usage_examples/arithmetic/extremum/maximum_float_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/extremum/maximum_float_example.json rename to functions/function_usage_examples/arithmetic/extremum/maximum_float_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/extremum/minimum_2vars_example.json b/functions/function_usage_examples/arithmetic/extremum/minimum_2vars_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/extremum/minimum_2vars_example.json rename to functions/function_usage_examples/arithmetic/extremum/minimum_2vars_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/modulo/modulo_example.json b/functions/function_usage_examples/arithmetic/modulo/modulo_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/modulo/modulo_example.json rename to functions/function_usage_examples/arithmetic/modulo/modulo_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/multiplication/multiplication_2vars_example.json b/functions/function_usage_examples/arithmetic/multiplication/multiplication_2vars_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/multiplication/multiplication_2vars_example.json rename to functions/function_usage_examples/arithmetic/multiplication/multiplication_2vars_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/multiplication/multiplication_float_example.json b/functions/function_usage_examples/arithmetic/multiplication/multiplication_float_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/multiplication/multiplication_float_example.json rename to functions/function_usage_examples/arithmetic/multiplication/multiplication_float_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/negation/negation_example.json b/functions/function_usage_examples/arithmetic/negation/negation_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/negation/negation_example.json rename to functions/function_usage_examples/arithmetic/negation/negation_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/subtraction/subtraction_2vars_example.json b/functions/function_usage_examples/arithmetic/subtraction/subtraction_2vars_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/subtraction/subtraction_2vars_example.json rename to functions/function_usage_examples/arithmetic/subtraction/subtraction_2vars_example.metadata.json diff --git a/functions/function_usage_examples/arithmetic/subtraction/subtraction_float_example.json b/functions/function_usage_examples/arithmetic/subtraction/subtraction_float_example.metadata.json similarity index 100% rename from functions/function_usage_examples/arithmetic/subtraction/subtraction_float_example.json rename to functions/function_usage_examples/arithmetic/subtraction/subtraction_float_example.metadata.json diff --git a/functions/function_usage_examples/mcx/mcx_example.json b/functions/function_usage_examples/mcx/mcx_example.metadata.json similarity index 100% rename from functions/function_usage_examples/mcx/mcx_example.json rename to functions/function_usage_examples/mcx/mcx_example.metadata.json diff --git a/functions/open_library_definitions/grover_operator.qmod b/functions/open_library_definitions/grover_operator.qmod index 489de704..2fc6318c 100644 --- a/functions/open_library_definitions/grover_operator.qmod +++ b/functions/open_library_definitions/grover_operator.qmod @@ -1,7 +1,7 @@ qfunc grover_operator(packed_vars: qbit[]) { oracle(packed_vars); - grover_diffuser(packed_vars); U<0, 0, 0, pi>(packed_vars[0]); } diff --git a/functions/open_library_definitions/grover_search.qmod b/functions/open_library_definitions/grover_search.qmod index 3b9563bc..13284f92 100644 --- a/functions/open_library_definitions/grover_search.qmod +++ b/functions/open_library_definitions/grover_search.qmod @@ -1,10 +1,10 @@ qfunc grover_search(packed_vars: qbit[]) { hadamard_transform(packed_vars); power (reps) { - grover_operator(packed_vars); } } diff --git a/functions/open_library_definitions/qsvt_inversion.qmod b/functions/open_library_definitions/qsvt_inversion.qmod index da4481dd..1a3057a7 100644 --- a/functions/open_library_definitions/qsvt_inversion.qmod +++ b/functions/open_library_definitions/qsvt_inversion.qmod @@ -1,7 +1,7 @@ qfunc qsvt_inversion(qvar: qbit[], aux: qbit) { - qsvt(qvar, aux); } diff --git a/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.json b/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.json rename to functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.qmod b/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.qmod index 60daaedf..49dffa89 100644 --- a/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.qmod +++ b/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.qmod @@ -7,12 +7,12 @@ qfunc main(output x: qnum<2, False, 0>, output y: qnum<2, False, 0>) { allocate<4>(packed_vars); hadamard_transform(packed_vars); power (2) { - grover_operator(arg0); - }, lambda(arg0) { - hadamard_transform(arg0); + grover_operator(vars); + }, lambda(vars) { + hadamard_transform(vars); }>(packed_vars); } packed_vars -> {x, y}; diff --git a/functions/qmod_library_reference/classiq_open_library/hadamard_transform/hadamard_transform.json b/functions/qmod_library_reference/classiq_open_library/hadamard_transform/hadamard_transform.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/hadamard_transform/hadamard_transform.json rename to functions/qmod_library_reference/classiq_open_library/hadamard_transform/hadamard_transform.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations.json b/functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations.json rename to functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type1.json b/functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type1.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type1.json rename to functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type1.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type2.json b/functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type2.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type2.json rename to functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type2.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/qct_qst/qct_type2.json b/functions/qmod_library_reference/classiq_open_library/qct_qst/qct_type2.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/qct_qst/qct_type2.json rename to functions/qmod_library_reference/classiq_open_library/qct_qst/qct_type2.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/qct_qst/qst_type2.json b/functions/qmod_library_reference/classiq_open_library/qct_qst/qst_type2.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/qct_qst/qst_type2.json rename to functions/qmod_library_reference/classiq_open_library/qct_qst/qst_type2.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/qft/qft.json b/functions/qmod_library_reference/classiq_open_library/qft/qft.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/qft/qft.json rename to functions/qmod_library_reference/classiq_open_library/qft/qft.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/qpe/qpe.json b/functions/qmod_library_reference/classiq_open_library/qpe/qpe.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/qpe/qpe.json rename to functions/qmod_library_reference/classiq_open_library/qpe/qpe.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/qpe/qpe_flexible.json b/functions/qmod_library_reference/classiq_open_library/qpe/qpe_flexible.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/qpe/qpe_flexible.json rename to functions/qmod_library_reference/classiq_open_library/qpe/qpe_flexible.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.ipynb b/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.ipynb index ac0db60c..44484637 100644 --- a/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.ipynb +++ b/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.ipynb @@ -229,7 +229,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.0 + 0.57226496\u00b7x + 0.0\u00b7x\u00b2 - 0.5134161\u00b7x\u00b3 + 0.0\u00b7x\u2074 - 1.05884886\u00b7x\u2075\n" + "0.0 + 0.57226496·x + 0.0·x² - 0.5134161·x³ + 0.0·x⁴ - 1.05884886·x⁵\n" ] } ], @@ -276,9 +276,7 @@ "\n", "execution_preferences = ExecutionPreferences(\n", " num_shots=1,\n", - " backend_preferences=ClassiqBackendPreferences(\n", - " backend_name=\"aer_simulator_statevector\"\n", - " ),\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator_statevector\"),\n", ")\n", "\n", "constraints = Constraints(max_width=13)\n", @@ -327,7 +325,7 @@ "source": [ "## References\n", "\n", - "[1]: Andr\u00e1s Gily\u00e9n, Yuan Su, Guang Hao Low, and Nathan Wiebe. 2019. Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing (STOC 2019). Association for Computing Machinery, New York, NY, USA, 193\u2013204 https://doi.org/10.1145/3313276.3316366.\n", + "[1]: András Gilyén, Yuan Su, Guang Hao Low, and Nathan Wiebe. 2019. Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing (STOC 2019). Association for Computing Machinery, New York, NY, USA, 193–204 https://doi.org/10.1145/3313276.3316366.\n", "\n", "[2]: Stamatopoulos, Nikitas, and William J. Zeng. \"Derivative pricing using quantum signal processing.\" arXiv preprint arXiv:2307.14310 (2023).\n" ] diff --git a/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.json b/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.json rename to functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.qmod b/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.qmod index bc1e779f..fa1889b0 100644 --- a/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.qmod +++ b/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.qmod @@ -12,12 +12,12 @@ qfunc u_sqrt(a: qnum, ref: qnum, res: qbit) { qfunc qsvt_sqrt_polynomial(state: qnum, ref: qnum, ind: qbit, qsvt_aux: qbit) { full_reg: qbit[]; {ind, ref, state} -> full_reg; - qsvt(full_reg, qsvt_aux); full_reg -> {ind, ref, state}; } diff --git a/functions/qmod_library_reference/classiq_open_library/special_state_preparations/inplace_prepare_int.json b/functions/qmod_library_reference/classiq_open_library/special_state_preparations/inplace_prepare_int.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/special_state_preparations/inplace_prepare_int.json rename to functions/qmod_library_reference/classiq_open_library/special_state_preparations/inplace_prepare_int.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_bell_state.json b/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_bell_state.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_bell_state.json rename to functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_bell_state.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_exponential_state.json b/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_exponential_state.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_exponential_state.json rename to functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_exponential_state.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_ghz_state.json b/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_ghz_state.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_ghz_state.json rename to functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_ghz_state.metadata.json diff --git a/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_int.json b/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_int.metadata.json similarity index 100% rename from functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_int.json rename to functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_int.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.json b/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.json rename to functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/qdrift/qdrift.json b/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/qdrift/qdrift.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/qdrift/qdrift.json rename to functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/qdrift/qdrift.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/suzuki_trotter/suzuki_trotter.json b/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/suzuki_trotter/suzuki_trotter.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/suzuki_trotter/suzuki_trotter.json rename to functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/suzuki_trotter/suzuki_trotter.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.json b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.json rename to functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.json b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.json rename to functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state_and_amplitudes.ipynb b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state_and_amplitudes.ipynb index 892a5b9b..a8bb7eaf 100644 --- a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state_and_amplitudes.ipynb +++ b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state_and_amplitudes.ipynb @@ -109,8 +109,8 @@ "## Example 1: Loading Point Mass (PMF) Function\n", "\n", "This example generates a quantum program whose output state probabilities are an approximation to the PMF given.\n", - "That is, the probability of measuring the state $|000\u27e9$ is $0.05$, $|001\u27e9$ is $0.11$,...\n", - ", and the probability to measure $|111\u27e9$ is $0.06$." + "That is, the probability of measuring the state $|000⟩$ is $0.05$, $|001⟩$ is $0.11$,...\n", + ", and the probability to measure $|111⟩$ is $0.06$." ] }, { @@ -247,9 +247,7 @@ " prepare_amplitudes(amplitudes=amps.tolist(), bound=0, out=x)\n", "\n", "\n", - "backend_preferences = ClassiqBackendPreferences(\n", - " backend_name=\"aer_simulator_statevector\"\n", - ")\n", + "backend_preferences = ClassiqBackendPreferences(backend_name=\"simulator_statevector\")\n", "execution_preferences = ExecutionPreferences(\n", " num_shots=1, backend_preferences=backend_preferences\n", ")\n", diff --git a/functions/qmod_library_reference/qmod_core_library/standard_gates/CRX.json b/functions/qmod_library_reference/qmod_core_library/standard_gates/CRX.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/standard_gates/CRX.json rename to functions/qmod_library_reference/qmod_core_library/standard_gates/CRX.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/standard_gates/CX.json b/functions/qmod_library_reference/qmod_core_library/standard_gates/CX.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/standard_gates/CX.json rename to functions/qmod_library_reference/qmod_core_library/standard_gates/CX.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/standard_gates/PHASE.json b/functions/qmod_library_reference/qmod_core_library/standard_gates/PHASE.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/standard_gates/PHASE.json rename to functions/qmod_library_reference/qmod_core_library/standard_gates/PHASE.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/standard_gates/R.json b/functions/qmod_library_reference/qmod_core_library/standard_gates/R.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/standard_gates/R.json rename to functions/qmod_library_reference/qmod_core_library/standard_gates/R.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/standard_gates/RZ.json b/functions/qmod_library_reference/qmod_core_library/standard_gates/RZ.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/standard_gates/RZ.json rename to functions/qmod_library_reference/qmod_core_library/standard_gates/RZ.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/standard_gates/RZZ.json b/functions/qmod_library_reference/qmod_core_library/standard_gates/RZZ.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/standard_gates/RZZ.json rename to functions/qmod_library_reference/qmod_core_library/standard_gates/RZZ.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/standard_gates/SWAP.json b/functions/qmod_library_reference/qmod_core_library/standard_gates/SWAP.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/standard_gates/SWAP.json rename to functions/qmod_library_reference/qmod_core_library/standard_gates/SWAP.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/standard_gates/U.json b/functions/qmod_library_reference/qmod_core_library/standard_gates/U.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/standard_gates/U.json rename to functions/qmod_library_reference/qmod_core_library/standard_gates/U.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/standard_gates/X.json b/functions/qmod_library_reference/qmod_core_library/standard_gates/X.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/standard_gates/X.json rename to functions/qmod_library_reference/qmod_core_library/standard_gates/X.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/unitary/unitary.json b/functions/qmod_library_reference/qmod_core_library/unitary/unitary.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/unitary/unitary.json rename to functions/qmod_library_reference/qmod_core_library/unitary/unitary.metadata.json diff --git a/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.ipynb b/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.ipynb index b1ee0e8d..e241b41d 100644 --- a/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.ipynb +++ b/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.ipynb @@ -69,7 +69,6 @@ "metadata": {}, "outputs": [], "source": [ - "\n", "MU = MU_LOG_RET * dt\n", "CHOLESKY = np.linalg.cholesky(COV) * np.sqrt(dt)\n", "SCALING_FACTOR = 1 / CHOLESKY[0, 0]" @@ -150,8 +149,12 @@ "source": [ "from IPython.display import Markdown\n", "\n", - "if K >= max(S0*np.exp(np.dot(CHOLESKY,[grid_points[-1]]*2) + MU)):\n", - " display(Markdown(' K always greater than the maximum asset values. Stop the run, the payoff is 0'))" + "if K >= max(S0 * np.exp(np.dot(CHOLESKY, [grid_points[-1]] * 2) + MU)):\n", + " display(\n", + " Markdown(\n", + " \" K always greater than the maximum asset values. Stop the run, the payoff is 0\"\n", + " )\n", + " )" ] }, { @@ -179,10 +182,12 @@ "source": [ "FRAC_PLACES = 1\n", "\n", + "\n", "def round_factor(a):\n", " precision_factor = 2 ** (FRAC_PLACES)\n", " return np.floor(a * precision_factor) / precision_factor\n", "\n", + "\n", "def floor_factor(a):\n", " precision_factor = 2 ** (FRAC_PLACES)\n", " return np.floor(a * precision_factor) / precision_factor" @@ -232,7 +237,7 @@ "source": [ "from functools import reduce\n", "\n", - "from classiq import QNum, get_expression_numeric_attributes, qfunc, Output\n", + "from classiq import Output, QNum, get_expression_numeric_attributes, qfunc\n", "from classiq.qmod.symbolic import max as qmax\n", "\n", "a = STEP_X / SCALING_FACTOR\n", @@ -329,8 +334,20 @@ }, "outputs": [], "source": [ - "from classiq import QBit, Constraints, synthesize, create_model, allocate, inplace_prepare_state, within_apply, control, bind, show\n", - "from classiq.qmod.symbolic import sqrt, exp\n", + "from classiq import (\n", + " Constraints,\n", + " QBit,\n", + " allocate,\n", + " bind,\n", + " control,\n", + " create_model,\n", + " inplace_prepare_state,\n", + " show,\n", + " synthesize,\n", + " within_apply,\n", + ")\n", + "from classiq.qmod.symbolic import exp, sqrt\n", + "\n", "\n", "def get_payoff_expression(x, size, fraction_digits):\n", " payoff = sqrt(\n", @@ -345,6 +362,7 @@ " )\n", " return payoff\n", "\n", + "\n", "def get_payoff_expression_normalized(x: QNum, size, fraction_digits):\n", " x_max = 1 - 1 / (2**size)\n", " payoff_max = get_payoff_expression(x_max, size, fraction_digits)\n", @@ -444,7 +462,7 @@ }, "outputs": [], "source": [ - "from classiq import cfunc, Z\n", + "from classiq import Z, cfunc\n", "from classiq.qmod.builtins.classical_execution_primitives import iqae, save\n", "\n", "\n", @@ -452,6 +470,7 @@ "def qmci_oracle(ind: QBit):\n", " Z(ind)\n", "\n", + "\n", "@cfunc\n", "def cmain():\n", " iqae_res = iqae(epsilon=0.01, alpha=0.05)\n", @@ -465,7 +484,8 @@ "metadata": {}, "outputs": [], "source": [ - "from classiq import CInt, QCallable, grover_operator, power, QArray\n", + "from classiq import CInt, QArray, QCallable, grover_operator, power\n", + "\n", "\n", "@qfunc\n", "def grover_algorithm(\n", @@ -533,6 +553,7 @@ "from classiq import execute, write_qmod\n", "from classiq.execution import ExecutionPreferences\n", "\n", + "\n", "def synthesize_and_execute(post_process):\n", " constraints = Constraints(max_width=25)\n", " qmod = create_model(\n", @@ -581,10 +602,11 @@ "source": [ "import sympy\n", "\n", + "\n", "def parse_result_bruteforce(iqae_res):\n", " payoff_expression = f\"sqrt(max({S0[0]} * exp({STEP_X / SCALING_FACTOR * (2 ** (MAX_NUM_QUBITS - MAX_FRAC_PLACES))} * x + ({MU[0]+MIN_X*CHOLESKY[0].sum()})), {K}))\"\n", " payoff_func = sympy.lambdify(sympy.symbols(\"x\"), payoff_expression)\n", - " payoff_max = payoff_func(1 - 1 / (2**MAX_NUM_QUBITS)) \n", + " payoff_max = payoff_func(1 - 1 / (2**MAX_NUM_QUBITS))\n", "\n", " option_value = iqae_res.estimation * (payoff_max**2) - K\n", " confidence_interval = np.array(iqae_res.confidence_interval) * (payoff_max**2) - K\n", diff --git a/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.qmod b/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.qmod index 0b70cc22..388c7914 100644 --- a/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.qmod +++ b/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.qmod @@ -44,10 +44,10 @@ qfunc grover_algorithm(output ind_reg: qbit) { full_reg: qbit[]; allocate<5>(full_reg); - grover_algorithm(full_reg); state_reg: qbit[]; full_reg -> {state_reg, ind_reg}; @@ -56,4 +56,4 @@ qfunc main(output ind_reg: qbit) { cscope ``` iqae_res = iqae(epsilon=0.01, alpha=0.05) save({'iqae_res': iqae_res}) -``` \ No newline at end of file +``` diff --git a/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.synthesis_options.json b/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.synthesis_options.json index 3975d8b2..29a83131 100644 --- a/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.synthesis_options.json +++ b/research/rainbow_options_bruteforce_method/rainbow_options_bruteforce_method.synthesis_options.json @@ -2,4 +2,4 @@ "constraints": { "max_width": 25 } -} \ No newline at end of file +} diff --git a/research/rainbow_options_direct_method/rainbow_options_direct_method.qmod b/research/rainbow_options_direct_method/rainbow_options_direct_method.qmod index 94b1621b..66a02338 100644 --- a/research/rainbow_options_direct_method/rainbow_options_direct_method.qmod +++ b/research/rainbow_options_direct_method/rainbow_options_direct_method.qmod @@ -75,10 +75,10 @@ qfunc grover_algorithm(output ind_reg: qbit) { full_reg: qbit[]; allocate<10>(full_reg); - grover_algorithm(full_reg); state_reg: qbit[]; full_reg -> {state_reg, ind_reg}; diff --git a/research/rainbow_options_integration_method/rainbow_options_integration_method.qmod b/research/rainbow_options_integration_method/rainbow_options_integration_method.qmod index 4a3a0cce..a2cc2ef9 100644 --- a/research/rainbow_options_integration_method/rainbow_options_integration_method.qmod +++ b/research/rainbow_options_integration_method/rainbow_options_integration_method.qmod @@ -67,10 +67,10 @@ qfunc grover_algorithm(output ind_reg: qbit) { full_reg: qbit[]; allocate<10>(full_reg); - grover_algorithm(full_reg); state_reg: qbit[]; full_reg -> {state_reg, ind_reg}; diff --git a/tutorials/classiq_concepts/analyze/analyze.ipynb b/tutorials/classiq_concepts/analyze/analyze.ipynb index 5a2b316b..f43e257f 100644 --- a/tutorials/classiq_concepts/analyze/analyze.ipynb +++ b/tutorials/classiq_concepts/analyze/analyze.ipynb @@ -95,6 +95,9 @@ }, { "cell_type": "markdown", + "metadata": { + "collapsed": false + }, "source": [ "The high-level functional design approach of Classiq enables analyzing quantum circuits on different level of functionalities. You can view your circuit only on the functional building blocks level, e.g. `hadamard_transform` and `Arithmetic` in the example below, or you can zoom in to the actual gate-level implementations:\n", "
\n", @@ -106,10 +109,7 @@ " \n", "
\n", "This is especially helpful in large circuits.\n" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "markdown", @@ -135,24 +135,24 @@ }, { "cell_type": "markdown", + "metadata": { + "collapsed": false + }, "source": [ "On the other hand, **the transpiled circuit is the circuit that is sent for execution** which is further optimized by eliminating functional blocks that have no influence on the circuit like the two blocks that cancel each other. The transpiled circuit contains only the set of gates defined by the optimization preferences. It is possible to view the transpiled circuit by downloading the circuit `as Transpiled QASM` and uploading it to the visualization tool:\n", "
\n", " \n", "
" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "markdown", - "source": [ - "The Quantum program can be downloaded in various formats including QASM, JPEG, JSON, and LaTeX code. To do this, click the download button as illustrated in the preceding image" - ], "metadata": { "collapsed": false - } + }, + "source": [ + "The Quantum program can be downloaded in various formats including QASM, JPEG, JSON, and LaTeX code. To do this, click the download button as illustrated in the preceding image" + ] }, { "cell_type": "markdown", @@ -179,6 +179,29 @@ "source": [ "After analyzing the quantum circuit one would usually want to either adapt the model or to execute the circuit on a simulator or on real hardware. Continue to Execute chapter to understand how to do that.\n" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Verify Your Understanding - Recommended Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Open the above example in the IDE and from the Quantum Program tab, export the circuit as a LaTeX file. View it in a LaTeX Editor (it is recommended to use [Overleaf](https://www.overleaf.com/) - a free, easy to use online LaTeX editor)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "write_qmod(create_model(main), \"analyze\")" + ] } ], "metadata": { diff --git a/tutorials/classiq_concepts/analyze/analyze.metadata.json b/tutorials/classiq_concepts/analyze/analyze.metadata.json new file mode 100644 index 00000000..90dcb3cc --- /dev/null +++ b/tutorials/classiq_concepts/analyze/analyze.metadata.json @@ -0,0 +1,7 @@ +{ + "friendly_name": "Analyze - Classiq Visualization Tool", + "description": "Demonstration of the Classiq visualization tool", + "problem_domain_tags": [], + "qmod_type": ["function"], + "level": ["basic", "demos"] +} diff --git a/tutorials/classiq_concepts/analyze/analyze.qmod b/tutorials/classiq_concepts/analyze/analyze.qmod new file mode 100644 index 00000000..2f4f6848 --- /dev/null +++ b/tutorials/classiq_concepts/analyze/analyze.qmod @@ -0,0 +1,5 @@ +qfunc main(output x: qnum, output y: qnum) { + allocate<4>(x); + hadamard_transform(x); + y = (x ** 2) + 1; +} diff --git a/tutorials/classiq_concepts/analyze/analyze.synthesis_options.json b/tutorials/classiq_concepts/analyze/analyze.synthesis_options.json new file mode 100644 index 00000000..0967ef42 --- /dev/null +++ b/tutorials/classiq_concepts/analyze/analyze.synthesis_options.json @@ -0,0 +1 @@ +{} diff --git a/tutorials/classiq_concepts/design/classical_variables_and_operations/classical_variables_and_operations.json b/tutorials/classiq_concepts/design/classical_variables_and_operations/classical_variables_and_operations.metadata.json similarity index 100% rename from tutorials/classiq_concepts/design/classical_variables_and_operations/classical_variables_and_operations.json rename to tutorials/classiq_concepts/design/classical_variables_and_operations/classical_variables_and_operations.metadata.json diff --git a/tutorials/classiq_concepts/design/design/design.ipynb b/tutorials/classiq_concepts/design/design/design.ipynb index 7dd7558b..487e66c2 100644 --- a/tutorials/classiq_concepts/design/design/design.ipynb +++ b/tutorials/classiq_concepts/design/design/design.ipynb @@ -11,11 +11,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The first step in quantum software development is designing your software, your algorithm. Classiq features a unique high-level modeling language called Qmod, that naturally captures the core concepts of quantum algorithm design. There are two ways to design in Qmod:\n", + "The first step in quantum software development is to design your software and your algorithm. Classiq features a unique high-level modeling language called Qmod that naturally captures the core concepts of quantum algorithm design. There are two ways to design in Qmod:\n", "* Directly, via the Classiq IDE using the Qmod native syntax\n", - "* With Classiq Python SDK package, that gives access to the Qmod language via Python\n", + "* With the Classiq Python SDK package, which gives access to the Qmod language via Python\n", "\n", - "Once you finished designing your algorithm you send it to the Classiq synthesis engine (compiler) to create a concrete quantum circuit implementation - a quantum program." + "Once you finish designing your algorithm, you send it to the Classiq synthesis engine (compiler) to create a concrete quantum circuit implementation - a quantum program." ] }, { @@ -29,9 +29,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's get started and understand Qmod through a concrete example. \n", + "First, understand Qmod through an example. \n", "\n", - "Our task is to design a quantum algorithm that computes the arithemtic operation $y=x^2+1$ coherently, for a quantum variable $|x\\rangle$ that is a superpostion of all the numbers between $0$ and $7$:\n", + "The task is to design a quantum algorithm that coherently computes the arithmetic operation $y=x^2+1$, for a quantum variable $|x\\rangle$ that is a superposition of all the numbers between $0$ and $7$:\n", "$\\begin{equation}\n", "|x\\rangle = \\frac{1}{\\sqrt{8}}(|0\\rangle+|1\\rangle+\\dots +|7\\rangle.\n", "\\end{equation}$\n", @@ -47,7 +47,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Sounds complicated? The following code in Qmod with a few lines creates the desired algorithm with Classiq:" + "This may sound complicated, but the following few lines of code in Qmod create the desired algorithm with Classiq:" ] }, { @@ -78,7 +78,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "and the desired quantum program can be synthesized and viewed:" + "Synthesize and view the quantum program:" ] }, { @@ -128,43 +128,43 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The above code is a quantum model written in Qmod. A model is composed of quantum functions with at least one quantum function called `main`. In Python, quantum functions are defined using regular Python functions decorated with `@qfunc`, and in the native Qmod syntax they are defined with the `qfunc` keyword. \n", + "The above code is a quantum model written in Qmod. A model is composed of quantum functions with at least one quantum function called `main`. Define quantum functions in Python using regular Python functions decorated with `@qfunc`, and in the native Qmod syntax define them with the `qfunc` keyword. \n", "\n", - "Quantum functions manipulate quantum objects which are represented using quantum variables. Every variable needs to be declared and initialized before it is used. \n", + "Quantum functions manipulate quantum objects that are represented using quantum variables. Declare and initialize each variable before it is used. \n", "\n", - "The following explains these principles:" + "The following points explain the principles:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "**1) There must be a `qfunc` decorator in Python or keyword in the native syntax**\n", + "**1) Include a `qfunc` decorator in Python or keyword in the native syntax**\n", "\n", - "We can see the `qfunc` decorator (`@qfunc`) in the Python implementation, and the corresponding keyword in the native implementation. This in Qmod that we are dealing with quantum functions that manipulate quantum objects. \n", + "You can see the `qfunc` decorator (`@qfunc`) in the Python implementation and the corresponding keyword in the native implementation. This indicates to Qmod that we are dealing with quantum functions that manipulate quantum objects. \n", "\n", - "**2) There must be a `main` function**\n", + "**2) Include a `main` function**\n", "\n", - "Every quantum algorithm written in Qmod must have a `main` function. From this `main` function the quantum program is created using the `synthesize(create_model(main))` command in Python, or just by pressing the Synthesis button in the IDE.\n", + "Every quantum algorithm written in Qmod must have a `main` function. From this `main` function, create the quantum program using the `synthesize(create_model(main))` command in Python or by clicking Synthesis in the IDE.\n", "\n", - "**3) The arguments of the `main` function must be declared as `output`s**\n", + "**3) Declare the arguments of the `main` function as `output`s**\n", "\n", - "In the above example, there are two arguments of the `main` function: `x` and `y`, both are quantum variables. The type of both them is `QNum`(`qnum` in the native syntax) which stands for a quantum number (see [Quantum Variables](./quantum_variables.ipynb)). In addition to the type, the variables of the `main` function must be declared as `output` which indicates these quantum variables are not initialized outside the scope of the function.\n", + "In the above example, the two arguments of the `main` function—`x` and `y`—are both quantum variables. Their type is `QNum`(`qnum` in the native syntax), which announces a quantum number (see [Quantum Variables](./quantum_variables.ipynb)). In addition to the type, declare the variables of the `main` function as `output`, indicating that these quantum variables are not initialized outside the scope of the function.\n", "
\n", " Types of Quantum Variables \n", - "In Qmod there are 3 types of quantum variables:\n", + "Qmod has these types of quantum variables:\n", "\n", - "1. `QBit` (`qbit`)\n", - "2. `QArray[QBit]` (`qbit[]`)\n", - "3. `QNum` (`qnum`)\n", + "* `QBit` (`qbit`)\n", + "* `QArray[QBit]` (`qbit[]`)\n", + "* `QNum` (`qnum`)\n", "
\n", "\n", "\n", - "**4) Every quantum variable needs to be declared before it is used**\n", + "**4) Declare each quantum variable before using it**\n", "\n", - "Here we declare the the variables `x` and `y` as arguments of the `main` function, but we could also declare variables in the scope of a function (see [Quantum Variables](./quantum_variables.ipynb)).\n", + "You can declare the variables `x` and `y` as arguments of the `main` function or in the scope of a function (see [Quantum Variables](./quantum_variables.ipynb)).\n", "
\n", - " Declaration within a Scope of a Function \n", + " Declaration Within the Scope of a Function \n", "You can declare a quantum variable within the scope of a function with \n", "\n", "=== Python\n", @@ -175,22 +175,22 @@ "\n", "
\n", "\n", - "**5) Every quantum variable needs to be initialized**\n", + "**5) Initialize each quantum variable**\n", "\n", - "After a quantum variable is declared it needs to be initialized. There are several ways to initialize quantum variables, and in the above example we can see two ways:\n", + "After declaring a quantum variable, initialize it using one of several ways. Two are shown in the example above:\n", "\n", "* `x` is initialized with the `allocate` operation.\n", "* `y` i initialized with the `|=` (`=` in native) numeric assignment.\n", "\n", "
\n", " Types of Initializations \n", - "There are a few ways to initialize a quantum variable:\n", + "Ways to initialize a quantum variable:\n", "\n", - "1. With `allocate` or `allocate_num` \n", - "2. With `prepare_int`, `prepare_state` or `prepare_amplitudes`\n", - "3. As the result of a numeric operation, like in the example above\n", - "4. With the `bind` operation (`->` in native)\n", - "5. With any function that declares its quantum variable argument as `output`\n", + "* With `allocate` or `allocate_num` \n", + "* With `prepare_int`, `prepare_state`, or `prepare_amplitudes`\n", + "* As the result of a numeric operation, as in the example above\n", + "* With the `bind` operation (`->` in native)\n", + "* With any function that declares its quantum variable argument as `output`\n", "\n", "
" ] @@ -200,12 +200,26 @@ "metadata": {}, "source": [ "## Next Steps\n", - "Now that you are familiar with the foundations of Qmod, you can continue to understand it in a bit more detail, with:\n", + "Now that you are familiar with the foundations of Qmod, you can continue with\n", "* Quantum Variables and Functions\n", "* Quantum Operations\n", "* Classical Control Flow" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Verify Your Understanding - Recommended Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Write within the IDE with the native Qmod syntax a quantum algorithm that coherently calculates $y=2x+4z+2$ where $x$ and $z$ are quantum numbers represented with 5 qubits each, and they are initialized in a superposition of all possible values." + ] + }, { "cell_type": "code", "execution_count": 3, @@ -241,7 +255,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" }, "vscode": { "interpreter": { diff --git a/tutorials/classiq_concepts/design/design/design.json b/tutorials/classiq_concepts/design/design/design.metadata.json similarity index 100% rename from tutorials/classiq_concepts/design/design/design.json rename to tutorials/classiq_concepts/design/design/design.metadata.json diff --git a/tutorials/classiq_concepts/design/quantum_operations/quantum_operations.json b/tutorials/classiq_concepts/design/quantum_operations/quantum_operations.metadata.json similarity index 100% rename from tutorials/classiq_concepts/design/quantum_operations/quantum_operations.json rename to tutorials/classiq_concepts/design/quantum_operations/quantum_operations.metadata.json diff --git a/tutorials/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.ipynb b/tutorials/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.ipynb index 6e62e018..403b663d 100644 --- a/tutorials/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.ipynb +++ b/tutorials/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.ipynb @@ -11,27 +11,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In Qmod there are three types of quantum objects which are represented by quantum variables:\n", - "1. **Qubit** (quantum bit) \n", + "In Qmod these types of quantum objects are represented by quantum variables:\n", + "* **Qubit** (quantum bit) \n", "\n", " * Written as `QBit` in the Python SDK\n", " * Written as `qbit` in the native syntax\n", "\n", - "2. **Qubit Array** \n", + "* **Qubit Array** \n", "\n", - " A sequence of qubits, should be thought of as a quantum register with definite number of qubits.\n", + " A sequence of qubits, considered as a quantum register with a definite number of qubits.\n", " \n", " * Written as `QArray` in the Python SDK\n", " * Written as `qbit[]` in the native syntax\n", " \n", - "3. **Quantum Number** \n", + "* **Quantum Number** \n", "\n", - " A qubit array (quantum register) that represents numbers. The numbers can be positive and negative integers, and it can be fixed point numbers (e.g. $-5.25$). The quantum number object has a definite number of qubits (as every qubit array), and it has 2 properties for its numeric representation: if the number is signed or not (only positive or it represents negative numbers as well) and how many fractional digits it has (where is the decimal point).\n", + " A qubit array (quantum register) that represents numbers. The numbers can be positive and negative integers, and can be fixed point (e.g., $-5.25$). The quantum number object has a definite number of qubits (as does every qubit array), and it has two properties for its numeric representation: if the number is signed or not (only positive or it represents negative numbers as well) and how many fractional digits it has (where is the decimal point).\n", "\n", " * Written as `QNum` in the Python SDK\n", " * Written as `qnum` in the native syntax\n", "\n", - "As explained in the [Design page](../design/design.ipynb), every quantum variable needs to be declared and initialized before it is used." + "As explained in the [Design page](../design.ipynb), you must declare and then initialize each quantum variable." ] }, { @@ -45,27 +45,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's get started and understand these quantum variables through a concrete example.\n", + "First, understand these quantum variables through a concrete example.\n", "\n", - "Our task is to design a quantum algorithm that flips the most significant bit (MSB) of a quantum number and to verify this.\n", + "The task is to design a quantum algorithm that flips the most significant bit (MSB) of a quantum number and then verify the new number.\n", "\n", "
\n", " What is the MSB? \n", "\n", - "In a binary representation, every number can be represented by a bit string (a sequence of 0's and 1's). For example, the number $6$ can be represented by the bit string $110$. How come? In order to understand it we move bit by bit and sum up the multiplication of the bit value times $2$ to the power of the bit position.\n", + "In a binary representation, every number can be represented by a bit string (a sequence of zeros and ones). For example, the number $6$ can be represented by the bit string $110$. How? To understand it better, move one bit at a time and sum up the multiplication of the bit value times $2$ to the power of the bit position.\n", "\n", - "We start with the right most bit called the least significant bit (LSB) since its position is the 0th position and sum $0\\times 2^0 =0$ plus $1\\times 2^1=2$ for the middle bit plus $1\\times 2^2=4$ for the left most bit - the most significant bit (MSB) since its contribution to the sum is the most significant.\n", + "Start with the rightmost bit, called the least significant bit (LSB) since its position is the 0th position. Sum $0\\times 2^0 =0$ plus $1\\times 2^1=2$ for the middle bit plus $1\\times 2^2=4$ for the leftmost bit—the most significant bit (MSB) since its contribution to the sum is the most significant.\n", "\n", "
\n", "\n", - "How to approach that? We will have a function called `flip_msb` that will receive a Qubit Array, and we will flip its MSB. This function will be called from the `main` function with some Quantum Number, and then we will verify we receive the correct number using a Qubit indicator.\n" + "This is how to handle it. Use the `flip_msb` function that receives a qubit array and flips its MSB. Call this function from the `main` function with some quantum number, and then verify the number using a qubit indicator.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The `flip_msb` function receives a `QArray` variable named `reg` (shortcut for register), and it flips its MSB using the `X` gate. This gate operates on the qubit at the last position of the Qubit Array `reg` where the counting starts from $0$. One can see the property `len` of the register `reg` is used as part of the function." + "The `flip_msb` function receives a `QArray` variable named `reg` (shortcut for register), and it flips its MSB using the `X` gate. This gate operates on the qubit at the last position of the qubit array `reg` where the counting starts from $0$. The property `len` of the register `reg` is used as part of the function." ] }, { @@ -93,18 +93,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "An important thing to note is that the variable `reg` is not initialized within the scope of the function `flip_msb`. This can be seen by the lack of the `output` declaration in the scope of the function, and it means that `reg` is initialized before it is called in the function. \n", + "Note that the variable `reg` is not initialized within the scope of the function `flip_msb`. This can be seen by the lack of the `output` declaration in the scope of the function, and it means that `reg` is initialized before it is called in the function. \n", "\n", "Now to the `main` function. \n", "\n", - "We have only one variable as an argument for the function which is the indicator if we manage to flip the MSB or not. This is a Qubit variable named `indicator`. \n", + "There is only one variable as an argument for the function, which is the indicator, regardless of whether the MSB successfully flips. This is a qubit variable named `indicator`. \n", "\n", - "Within the function itself we declare and initialize a Quantum Number named `x` with $4$ qubits. A general initialziation with `allocate` initializes the Quantum Number to the state $|0\\rangle = |0000\\rangle$ (this is true for Qubits and Qubit Arrays as well). The function `flip_msb` acts on the Quantum Number `x` in order to flip its MSB and to create the state $|1000\\rangle = |8\\rangle$.\n", + "Within the function itself, declare and initialize a quantum number named `x` with $4$ qubits. A general initialization with `allocate` initializes the quantum number to the state $|0\\rangle = |0000\\rangle$. (This is true for both qubits and qubit arrays). The function `flip_msb` acts on the quantum number `x`, flipping its MSB and creating the state $|1000\\rangle = |8\\rangle$.\n", "\n", "
\n", " NOTE \n", "\n", - "As we don't declare if the Quantum Number is signed or not, or how many fractional digits it has, it is just initialized with no fractional digits and is not signed (see [`allocate_num`](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/quantum-types/) for initializing a Quantum Number with these options). \n", + "There is no need to declare if the quantum number is signed nor the number of its fractional digits. It is initialized with no fractional digits and is not signed (see [`allocate_num`](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/quantum-types/) for initializing a quantum number with these options). \n", "\n", "
" ] @@ -140,7 +140,7 @@ "metadata": {}, "source": [ "\n", - "Finally, we initialize the `indicator` qubit with the numeric assignment of the expression $x==8$. That is, if indeed we manage to flip the MSB of `x` and to transform it to the state `|8\\rangle` then the state od the qubit `indicator` will be equal $|1\\rangle$ otherwise it will equal $|0\\rangle (i.e. indicating if we manage to complete the `flip_msb` operation or not)." + "Finally, initialize the `indicator` qubit with the numeric assignment of the expression $x==8$. That is, if you flip the MSB of `x` and transform it to the state `|8\\rangle`, then the state of the qubit `indicator` equals $|1\\rangle$; otherwise, it equals $|0\\rangle (i.e., indicating if the `flip_msb` operation succeeded)." ] }, { @@ -148,8 +148,8 @@ "metadata": {}, "source": [ "
\n", - " `flip_msb` receives a Quantum Number or a Quantum Array? \n", - "One might notice that the function `flip_msb` is called with a Quantum Number `x` from the `main` function, whilst it is declared with a quantum array named `reg`. This demonstrates that quantum numbers can be cast to quantum arrays if they have the same number of qubits. In `main` we are intrested in the manupulation of an arithmetic quantum object - a quantum number, whilst in the function `flip_msb` we are just interested in treating the quantum number as a qubit array, without its numeric description, and to apply a specific gate on one of its qubits.\n", + " Does `flip_msb` receive a quantum number or a quantum array? \n", + "Note that the function `flip_msb` is called with the quantum number `x` from the `main` function, whilst it is declared with a quantum array named `reg`. This demonstrates that quantum numbers can be cast to quantum arrays if they have the same number of qubits. In `main` you want to manipulate an arithmetic quantum object—a quantum number—whilst in the function `flip_msb` you just want to treat the quantum number as a qubit array, without its numeric description, and to apply a specific gate on one of its qubits.\n", "
" ] }, @@ -157,7 +157,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "That's it! Now we want to check if indeed we managed to flip the MSB. The desired quantum program can be synthesized and viewed:" + "That's it! Now, to check if the MSB flipped successfully, synthesize and view the quantum program:" ] }, { @@ -200,7 +200,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And then the quantum program can be executed to receive the results:" + "Execute the quantum program to receive the results:" ] }, { @@ -244,7 +244,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And indeed we managed to flip the MSB as indicated by the `indicator` variable." + "You did flip the MSB as indicated by the `indicator` variable." ] }, { @@ -260,11 +260,25 @@ "source": [ "The following summarizes the main takeaways from the example in terms of quantum variables and functions:\n", "\n", - "* There are 3 types of quantum objects in Qmod: a qubit, a qubit array, and a quantum number. Objects can be cast from one to another (as `x` being cast from quantum number in the `main` function to qubit array in the `flip_msb` function)\n", - "* Quantum objects are represented by quantum variables. Each variable needs to be declared and initialized before it is used. The initialization can be done in several ways, here we see two options: with the `allocate` function (the initialization of `x`) or with a numeric assignment (the initializaiton of `indicator`).\n", + "* Types of quantum objects in Qmod: qubit, qubit array, and quantum number. Objects can be cast from one to another (as `x` is cast from the quantum number in the `main` function to a qubit array with the `flip_msb` function).\n", + "* Quantum objects are represented by quantum variables. Each variable needs to be declared and initialized before it is used. The initialization can be done in several ways, and here are two options: with the `allocate` function (the initialization of `x`) or with a numeric assignment (the initialization of `indicator`).\n", "* Quantum variables that are arguments of a function can be declared with the `Output` modifier and initialized within the scope of a function (like `indicator` in the `main` function). Without the `Output` modifier they must be initialized outside the scope of the function (like `reg` in the `flip_msb`) function.\n", - "* Quantum variables can be declared and initialized within a function (like `x` in the `main` function)\n", - "* The quantum program is always generated from the `main` function, even when further quantum functions are used. The execution results of the quantum program are interperted only for the arguments of the `main` function (like for `indicator` in the above example)\n" + "* Quantum variables can be declared and initialized within a function (like `x` in the `main` function).\n", + "* The quantum program is always generated from the `main` function, even when further quantum functions are used. The execution results of the quantum program are interpreted only for the arguments of the `main` function (like `indicator` in the above example).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Verify Your Understanding - Recommended Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create another quantum function `flip_lsb` that flips the least significant bit." ] }, { @@ -302,7 +316,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" }, "vscode": { "interpreter": { diff --git a/tutorials/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.json b/tutorials/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.metadata.json similarity index 100% rename from tutorials/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.json rename to tutorials/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.metadata.json diff --git a/tutorials/classiq_concepts/execute/execute.ipynb b/tutorials/classiq_concepts/execute/execute.ipynb index 6caf9f16..2e28f7ce 100644 --- a/tutorials/classiq_concepts/execute/execute.ipynb +++ b/tutorials/classiq_concepts/execute/execute.ipynb @@ -489,6 +489,20 @@ "All the above should enable one to analyze the results and post-process them in Python as needed." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Verify Your Understanding - Recommended Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Adapt the code such that the quantum number $x$ is allocated with 8 qubits. Then, execute the algorithm with 5096 shots and post process the results from your Python SDK. Plot a graph of all the measured values of $x$ and $y$ with the corresponding axes (make sure you receive the graph of $y=x^2+1$)." + ] + }, { "cell_type": "code", "execution_count": 13, @@ -522,7 +536,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" }, "vscode": { "interpreter": { diff --git a/tutorials/classiq_concepts/execute/execute.json b/tutorials/classiq_concepts/execute/execute.metadata.json similarity index 100% rename from tutorials/classiq_concepts/execute/execute.json rename to tutorials/classiq_concepts/execute/execute.metadata.json diff --git a/tutorials/classiq_concepts/optimize/optimize.ipynb b/tutorials/classiq_concepts/optimize/optimize.ipynb index 72ce7843..729edff4 100644 --- a/tutorials/classiq_concepts/optimize/optimize.ipynb +++ b/tutorials/classiq_concepts/optimize/optimize.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the previous chapter we focused on how to design quantum algorithms with the Qmod language. Once a quantum algorithm is designed, it can be compiled into a quantum circuit implementation that can be executed on quantum computers or simulators. This is done by the Classiq synthesis engine. In this chapter we cover how to use and utilize the Classiq synthesis engine in the IDE and the Python SDK through concrete examples." + "The previous section focused on how to design quantum algorithms with the Qmod language. Once you have designed a quantum algorithm, the Classiq synthesis engine compiles it into a quantum circuit ready for implementation on quantum computers or simulators. This section covers how to use the Classiq synthesis engine in the IDE and the Python SDK through concrete examples." ] }, { @@ -25,23 +25,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In most cases, a specific quantum model can be compiled to many, sometime infinite number of quantum circuits that might differ in their properties. Some will have more qubits with smaller circuit depth, some will have all the qubits connected to each other whilst other will not, and some will have a fewer number of 2-qubit gates than others. \n", + "In most cases, a specific quantum model can be compiled to many or sometimes an infinite number of quantum circuits that might differ in their properties. Some may have more qubits with smaller circuit depth, some may have all the qubits connected to each other whilst others do not, and some may have fewer 2-qubit gates than others. \n", "\n", - "The Classiq synthesis engine receives the quantum model as an input, together with the constraints and preferences of the desired quantum program, and outputs a quantum program implementation of the quantum model that satisfies the constraints and preferences.\n", + "The Classiq synthesis engine receives the quantum model as input together with the constraints and preferences of the desired quantum program, and outputs a quantum program implementation of the quantum model that satisfies the constraints and preferences.\n", "\n", - "Some of the current available constraints options for the Synthesis engine are:\n", + "Some of the available constraint options for the synthesis engine:\n", "* Optimization parameter - either to optimize for circuit width or circuit depth;\n", "* Maximal gate count - maximum allowed number of a specific 1- or 2-qubit gate;\n", "* Maximal circuit width or circuit depth.\n", "\n", - "And some of the available preferences:\n", + "Some of the available preferences:\n", "* Compiling the quantum circuit for a specific quantum processor;\n", "* The desired connectivity map of the quantum circuit;\n", - "* The output format of the quantum circuit, e.g. `QASM` or `QIR`.\n", + "* The output format of the quantum circuit, e.g., `QASM` or `QIR`.\n", "\n", - "A full list of possible [constraints](https://docs.classiq.io/latest/classiq_101/classiq_concepts/optimize/) and [preferences](https://docs.classiq.io/latest/reference-manual/platform/synthesis/constraints/) is available in the reference manual. \n", + "See a full list of [constraints](https://docs.classiq.io/latest/classiq_101/classiq_concepts/optimize/) and [preferences](https://docs.classiq.io/latest/reference-manual/platform/synthesis/constraints/) in the reference manual. \n", "\n", - "In the following we cover how to apply constraints and preferences through a concrete example." + "This section covers how to apply constraints and preferences through an actual example." ] }, { @@ -55,7 +55,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's go back to the example covered in the 'Design - The Qmod language' tutorial, where the task is to create a quantum algorithm that calculates in a superposition the arithmetic expression $y=x^2+1$. \n", + "The task covered in the 'Design - The Qmod Language' tutorial is to create a quantum algorithm that calculates the arithmetic expression $y=x^2+1$ in a superposition. \n", "\n", "The following model written in Qmod implements the desired task:" ] @@ -88,7 +88,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Which one can always directly synthesize without any constraints or preferences:" + "You can always directly synthesize it without any constraints or preferences:" ] }, { @@ -120,7 +120,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "But in the following we cover how to do apply constraints and preferences. We first cover how to apply these in the IDE and then in the Python SDK." + "Now, apply constraints and preferences; first in the IDE, and then in the Python SDK." ] }, { @@ -134,7 +134,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the IDE, once your model is completed, you can directly synthesize your algorithm with the default constraints and preferences by pressing the `Synthesize` button:\n", + "In the IDE, once your model is complete, you can directly synthesize your algorithm with the default constraints and preferences by clicking `Synthesize`:\n", "\n", "\n", "
\n", @@ -146,13 +146,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "However, if you do want to apply some constraints and preferences, this can be done easily by adapting the parameters on the right-hand side of the screen and then synthesizing your model:\n", + "To apply constraints and preferences, adapt the parameters on the right of the window and then synthesize your model:\n", "\n", "
\n", " \n", "
\n", "\n", - "All the constraints and preferences that are available in the IDE can also be configured in the Python SDK as we cover next." + "Below, see how to configure the constraints and preferences in the Python SDK." ] }, { @@ -166,7 +166,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The synthesis engine receives an underlying Qmod representation of the quantum model that is constructed in the Python SDK using the `create_model` function:" + "The synthesis engine receives an underlying Qmod representation of the quantum model that you construct in the Python SDK using the `create_model` function:" ] }, { @@ -189,9 +189,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This `quantum_model` can be directly synthesized with the command `synthesize(quantum_model)` to return the quantum program implementation. However, if we want to apply some constraints and preferences we need to adapt the `quantum_model` representation.\n", + "You can synthesize this `quantum_model` directly with the command `synthesize(quantum_model)` to return the quantum program implementation. However, to apply constraints and preferences, first adapt the `quantum_model` representation.\n", "\n", - "First, assume that we want to receive a circuit implementation with minimal number of qubits and with maximal circuit depth of $500$. So we can apply these as constraints to our `quantum_model`:" + "Create a circuit with the minimum number of qubits and a maximum circuit depth of $500$ by applying these constraints to the `quantum_model`:" ] }, { @@ -216,7 +216,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Then the `quantum_model` can be then synthesized as usual:" + "Synthesize the `quantum_model` as usual:" ] }, { @@ -239,7 +239,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And the parameters of the circuit implementation can be extracted:" + "Extract the parameters of the circuit implementation:" ] }, { @@ -273,15 +273,15 @@ "metadata": {}, "source": [ "
\n", - " Compilation vs. Transpilation \n", - "The synthesis engine is a compiler that compiles a high-level functional model to one specific circuit out of many possible implementations. A transpiler on the other hand, transforms one circuit implementation to another one. Its use can be to change from a circuit representation with a given basis gate set to another one, or to further optimize a given circuit implementation with basic optimization procedures like cancellation of two identical Hermitian gates applied consequently. \n", + " Compilation versus Transpilation \n", + "The synthesis engine is a compiler that compiles a high-level functional model to one specific circuit out of many possible implementations. A transpiler, on the other hand, transforms one circuit implementation to another. Its use can be to change from a circuit representation with a given basis gate set to another one, or to further optimize a given circuit implementation with basic optimization procedures such as cancellation of two identical Hermitian gates applied consequently. \n", "
\n", "\n", - "It is **highly recommended** to complete the following exercise in order to experience by yourself for the first time how the same quantum algorithm can be compiled into two different circuit implementation that can substantially differ from each other.\n", + "It is **highly recommended** that you complete the following exercise yourself, to experience for the first time how the one quantum algorithm can be compiled into two different circuit implementations that can substantially differ from one other.\n", "\n", "
\n", " Recommended Exercise \n", - "Modify the constraints above such that you optimize the circuit for minimal circuit depth using maximum 25 qubits. What are the circuit depth and width you receive? Are they different than the above example? Try to analyze the two quantum circuits using `show(quantum_program)` and figure our which functional building block is implemented differently. \n", + "Modify the constraints above to optimize the circuit for minimum circuit depth using maximum 25 qubits. What circuit depth and width do you receive? Are they different than shown above? Analyze the two quantum circuits using `show(quantum_program)` and determine which functional building block is implemented differently. \n", "
\n", "\n" ] @@ -290,7 +290,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Assume now that we want to execute the above quantum model on the IBM quantum processor `ibm_brisbane`. It is recommended to pass this information to the synthesis engine so the quantum program will be most adequate for the desired quantum computer. This is done by adding the following preference and re-synthesizing `quantum_model`:" + "For the purpose of the exercise, assume that you will execute the quantum model on the `ibm_brisbane` IBM quantum processor. Pass this information to the synthesis engine so the quantum program is built appropriately. Do it by adding this preference and resynthesizing `quantum_model`:" ] }, { @@ -320,10 +320,35 @@ "source": [ "
\n", " Optional Exercise \n", - "Extract the circuit depth and width of the above quantum program. How do these differ from the previous values? Try to think why they differ in such a way. It is good to know that the `IBM Brisbane` device as specific limited connectivity between its qubits, so there might be a certain overhead in applying some 2-qubit gates...\n", + "Extract the circuit depth and width of the above quantum program. How do they differ from the previous values? Consider why they differ in such a way. (It is helpful to know that the `IBM Brisbane` device has specific limited connectivity between its qubits, so there might be a certain overhead in applying some 2-qubit gates.)\n", "
\n", "\n", - "So now you have a quantum program that implements the quantum model that calculates $y=x^2+1$ in a superposition, that is optimized for a specific real quantum computer. It only remains to follow the next chapters and to see how to actually run it on that computer with Classiq. But first we want to deep dive to the Analysis capabilities of Classiq." + "So now you have a quantum program that implements the quantum model that calculates $y=x^2+1$ in a superposition, optimized for a specific real quantum computer. The following sections show how to actually run it on that computer with Classiq. But first, dive deeply into the Classiq analysis capabilities." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Verify Your Understanding - Recommended Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Synthesize 3 different implementations of an MCX (multi-control-x) with 5 control qubits and 1 target qubit (you should use the control quantum operation for implementing an MCX, follow [this](https://docs.classiq.io/latest/explore/functions/function_usage_examples/mcx/mcx_example/) tutorial that can be open in the IDE). One implementation should be optimized for minimized depth, the other for minimized width, and the third somewhere in between (choose yourself what is the maximal width / depth you apply). \n", + "\n", + "Export the 3 implementations as LaTeX files on the hierarchy level that demonstrates the differences between the implementations. Aggregate the implementations in 1 file and export it as a PDF and explain the key differences (it is recommended to use [Overleaf](https://www.overleaf.com/) - a free, easy to use online LaTeX editor)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Advanced Exercise\n", + "\n", + "Synthesize 5 different implementations of an MCX with 20 control qubits and 1 target qubit. Compare the circuit width and circuit depth required for each implementation." ] }, { @@ -359,7 +384,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" }, "vscode": { "interpreter": { diff --git a/tutorials/classiq_concepts/optimize/optimize.json b/tutorials/classiq_concepts/optimize/optimize.metadata.json similarity index 100% rename from tutorials/classiq_concepts/optimize/optimize.json rename to tutorials/classiq_concepts/optimize/optimize.metadata.json diff --git a/tutorials/classiq_concepts/repeat/repeat.json b/tutorials/classiq_concepts/repeat/repeat.metadata.json similarity index 100% rename from tutorials/classiq_concepts/repeat/repeat.json rename to tutorials/classiq_concepts/repeat/repeat.metadata.json diff --git a/tutorials/discrete_quantum_walk/quantum_walk_circle.json b/tutorials/discrete_quantum_walk/quantum_walk_circle.metadata.json similarity index 100% rename from tutorials/discrete_quantum_walk/quantum_walk_circle.json rename to tutorials/discrete_quantum_walk/quantum_walk_circle.metadata.json diff --git a/tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.json b/tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.metadata.json similarity index 100% rename from tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.json rename to tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.metadata.json diff --git a/tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod b/tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod index 9937b876..6e3491a2 100644 --- a/tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod +++ b/tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod @@ -25,8 +25,8 @@ qfunc main(output x: qnum) { allocate<1>(coin); H(coin); S(coin); - discrete_quantum_walk(output x: qbit[]) { allocate<4>(x); coin: qbit[]; prepare_state<[0.25, 0.25, 0.25, 0.25], 0.0>(coin); - discrete_quantum_walk(arg0); - }>(arg0); + discrete_quantum_walk(coin); + }>(coin); }, [lambda() { moving_one_hamming_dist<0>(x); }, lambda() { diff --git a/tutorials/exponentiation/exponentiation.json b/tutorials/exponentiation/exponentiation.metadata.json similarity index 100% rename from tutorials/exponentiation/exponentiation.json rename to tutorials/exponentiation/exponentiation.metadata.json diff --git a/tutorials/exponentiation/exponentiation_minimize_error.json b/tutorials/exponentiation/exponentiation_minimize_error.metadata.json similarity index 100% rename from tutorials/exponentiation/exponentiation_minimize_error.json rename to tutorials/exponentiation/exponentiation_minimize_error.metadata.json diff --git a/tutorials/getting_started/part5_grover.ipynb b/tutorials/getting_started/part5_grover.ipynb index 0ff21547..54433872 100644 --- a/tutorials/getting_started/part5_grover.ipynb +++ b/tutorials/getting_started/part5_grover.ipynb @@ -273,7 +273,7 @@ "### 6. Execute the ciruit\n", "\n", "1. When the circuit opens in the IDE, press \"Execute\". \n", - "2. Pick the AER simulator from the \"Classiq\" provider.\n", + "2. Pick the \"simulator\" from the \"Classiq\" provider.\n", "3. Execute the job.\n", "4. Validate the results.\n", "
\n", diff --git a/tutorials/hardware_aware_mcx/hardware_aware_mcx_all_to_all.json b/tutorials/hardware_aware_mcx/hardware_aware_mcx_all_to_all.metadata.json similarity index 100% rename from tutorials/hardware_aware_mcx/hardware_aware_mcx_all_to_all.json rename to tutorials/hardware_aware_mcx/hardware_aware_mcx_all_to_all.metadata.json diff --git a/tutorials/hardware_aware_mcx/hardware_aware_mcx_linear.json b/tutorials/hardware_aware_mcx/hardware_aware_mcx_linear.metadata.json similarity index 100% rename from tutorials/hardware_aware_mcx/hardware_aware_mcx_linear.json rename to tutorials/hardware_aware_mcx/hardware_aware_mcx_linear.metadata.json diff --git a/tutorials/hello_many_worlds/hello_many_worlds.ipynb b/tutorials/hello_many_worlds/hello_many_worlds.ipynb index 0ff7b90b..4f6a4572 100644 --- a/tutorials/hello_many_worlds/hello_many_worlds.ipynb +++ b/tutorials/hello_many_worlds/hello_many_worlds.ipynb @@ -11,13 +11,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "With Classiq (as perhaps in quantum) there are many parallel worlds one can work with. These refer to the IDE - Python SDK interfaces. In the following we run the same 'Hello World' example in different flows of the steps design-optimize-analyze-execute between the IDE and the Python SDK:\n", + "With Classiq (as, perhaps, with quantum computing) there are many parallel worlds in which to work; specifically, the IDE and Python SDK interfaces. The 'Hello World' example below runs in different flows of the design-optimize-analyze-execute steps between the IDE and the Python SDK:\n", "\n", "1. [All in IDE](#all-in-ide)\n", "2. [Design (SDK) - Optimize (SDK) - Analyze (IDE) - Execute (SDK)](#design-sdk---optimize-sdk---analyze-ide---execute-sdk)\n", "3. [Design (SDK) - Optimize (SDK) - Analyze (IDE) - Execute (IDE)](#design-sdk---optimize-sdk---analyze-ide---execute-ide)\n", "\n", - "The 'Hello World' example calculates in a superposition the simple arithmetic operation $y=x^2+1$ - an example that is covered in depth in the Classiq 101." + "The 'Hello World' example calculates the simple arithmetic operation $y=x^2+1$ in a superposition. This example is covered in depth in Classiq 101." ] }, { @@ -31,7 +31,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Copy and paste the following code in the `Model` tab in the IDE, then press `Synthesize` as the GIF belows shows:\n", + "Copy and paste the following code in the `Model` tab in the IDE, then click `Synthesize` as shown in the GIF:\n", "```\n", "qfunc main(output x: qnum, output y:qnum){\n", " allocate<4>(x);\n", @@ -54,7 +54,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Check that you receive 2 blocks in the quantum circuit: `hadamard_transform` and `Arithmetic`, then press `Execute`:" + "Check that you receive two blocks in the quantum circuit: `hadamard_transform` and `Arithmetic`, then click `Execute`:" ] }, { @@ -70,7 +70,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the `Execution` tab, choose the simulator under the Classiq provider (and make sure that other options are unmarked). Change the job name to be 'hello world' and press `Run`:" + "In the `Execution` tab, under the Classiq provider, choose the simulator (and make sure that other options are not selected). Change the job name to 'hello world' and click `Run`:" ] }, { @@ -86,7 +86,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the `Jobs` tab check the results by hovering over the histogram bars and verifying you receive 16 bars, and each bar encapsulates the correct relation between $x$ and $y$, i.e. $y=x^2+1$:" + "In the `Jobs` tab, check the results by hovering over the histogram bars and verifying you receive 16 bars. Each bar encapsulates the correct relation between $x$ and $y$; i.e., $y=x^2+1$:" ] }, { @@ -102,7 +102,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "That's it! You just completed designing, optimizing, running ans executing your first quantum algorithm with the Classiq IDE!" + "That's it! You just completed designing, optimizing, analyzing, and executing your first quantum algorithm with the Classiq IDE." ] }, { @@ -147,7 +147,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Then run the following in order to optimize your algorithm from the Python SDK:" + "Optimize your algorithm by running this code from the Python SDK:" ] }, { @@ -170,7 +170,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Analyze your quantum circuit in the IDE by running the following code in Python and opening the popped up link:" + "Analyze your quantum circuit in the IDE by running this code in Python and opening the pop-up link:" ] }, { @@ -210,7 +210,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Finally, execute your code from the Python SDK by running the following code:" + "Execute your code in the Python SDK by running this:" ] }, { @@ -245,7 +245,7 @@ "source": [ "Check that you receive 16 pairs of `{'x': , 'y': }` and that the values indeed follow the connection $y=x^2+1$. \n", "\n", - "That's it! You just completed your first quantum algorithm from the Python SDK!" + "That's it! You just completed your first quantum algorithm in the Python SDK." ] }, { @@ -259,9 +259,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now let's run the same example in a mixed flow of the previous two:\n", + "Now, run the same example using a mixed flow of the previous two:\n", "\n", - "Design your hello world quantum algorithm by running the following code in your favorite Python SDK environment (after installing Classiq):" + "Design your hello world quantum algorithm by running this code in your favorite Python SDK environment (after installing Classiq):" ] }, { @@ -292,7 +292,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Then run the following in order to optimize your algorithm from the Python SDK:" + "Optimize your algorithm by running this code in the Python SDK:" ] }, { @@ -315,7 +315,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Analyze your quantum circuit in the IDE by running the following code in Python and opening the popped up link:" + "Analyze your quantum circuit in the IDE by running this code in Python and opening the pop-up link:" ] }, { @@ -355,7 +355,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Check that you receive 2 blocks in the quantum circuit: `hadamard_transform` and `Arithmetic`, then press `Execute`:" + "Check that you receive two blocks in the quantum circuit: `hadamard_transform` and `Arithmetic`, then click `Execute`:" ] }, { @@ -371,7 +371,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the `Execution` tab, choose the simulator under the Classiq provider (and make sure that other options are unmarked). Change the job name to be 'hello world' and press `Run`:" + "In the `Execution` tab, under the Classiq provider, choose the simulator (and make sure that other options are not selected). Change the job name to 'hello world' and click `Run`:" ] }, { @@ -387,7 +387,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the `Jobs` tab check the results by hovering over the histogram bars and verifying you receive 16 bars, and each bar encapsulates the correct relation between $x$ and $y$, i.e. $y=x^2+1$:" + "In the `Jobs` tab, check the results by hovering over the histogram bars and verifying you receive 16 bars. Each bar encapsulates the correct relation between $x$ and $y$; i.e., $y=x^2+1$:" ] }, { @@ -403,9 +403,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "That's it! You just completed the hello world example in a mixed flow of IDE and Python SDK!\n", + "That's it! You just completed the hello world example in a mixed flow of IDE and Python SDK.\n", "\n", - "You are ready to continue to the Classiq 101, enjoy!" + "You are ready to continue with Classiq 101. Enjoy!" ] }, { diff --git a/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.ipynb b/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.ipynb index 87fdc578..14b9d904 100644 --- a/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.ipynb +++ b/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.ipynb @@ -13,47 +13,51 @@ "id": "3f25ec81", "metadata": {}, "source": [ - "Quantum computing is based on the principles of quantum mechanics, which includes an important feature: unitarity. The operations we are able to execute in a quantum circuit are unitary. Would this mean that problems requiring non-unitary operations are out of hand for quantum computers? This is the task solved by the Linear Combination of Unitaries (LCU) algorithm [[1](#childs_paper), [2](#childs_notes)]. Lets dive in more details about what can be done with this algorithm.\n", + "Quantum computing is based on the principles of quantum mechanics, which includes an important feature: unitarity. The operations that evolve quantum states on quantum computers are unitary. Would this mean that problems requiring non-unitary operations are out of hand for quantum computers? This is the task solved by the Linear Combination of Unitaries (LCU) algorithm [[1](#childs_paper), [2](#childs_notes)]. \n", "\n", - "Given a non-unitary matrix $A$ that can be decomposed into\n", + "Given a non-unitary matrix $A$ that can be decomposed into a sum of unitary matrices as follows:\n", "\n", "\\begin{equation}\n", " A = \\sum_{i=0}^{2^n-1} \\alpha_i U_i,\n", "\\end{equation}\n", "\n", - "where $\\alpha_i$ are real, positive coefficients and $U_i$ are unitary matrices. The LCU algorithm can execute the action of $A$, up to a normalization factor, in a subspace of a bigger quantum circuit.\n", + "where $\\alpha_i$ are real, positive coefficients and $U_i$ are unitary matrices, the LCU algorithm applies the action of $A$, up to a normalization factor, on a desired quantum state. \n", "\n", - "The way LCU do this is by using auxiliary (control) qubits to project the operation given by $A$, up to normalization. The first step of the LCU is to prepare the state on the auxiliary qubits using the function PREPARE:\n", + "It does so by embedding the matrix $A$ in a bigger unitary. The first step of the LCU is to prepare the following state on an auxiliary quantum register according to the coefficients $\\alpha_i$ using the function PREPARE:\n", "\n", "\\begin{equation}\n", " |\\psi_0\\rangle = PREPARE|0\\rangle = \\sum_i \\sqrt{\\frac{\\alpha_i}{\\lambda}}|i\\rangle,\n", "\\end{equation}\n", "\n", - "where $\\lambda = \\sum_i |\\alpha_i|$ is a normalization factor. After that, the control qubits are entangled with the target qubits with the SELECT operation:\n", + "where $\\lambda = \\sum_i |\\alpha_i|$ is a normalization factor. This quantum register with the prepared state is used as a controller for the next step. Then, according to the controller quantum register, the following state is being prepared:\n", "\n", "\\begin{equation}\n", " SELECT|i\\rangle|\\psi\\rangle = |i\\rangle U_i |\\psi\\rangle,\n", "\\end{equation}\n", "\n", - "where $|\\psi\\rangle$ is a general quantum state. The final step is to have the PREPARE operation reversed. This way, the quantum circuit has the following effect on the qubits:\n", + "where $|\\psi\\rangle$ is the desired quantum state the matrix $A$ should be applied on. The final step is to have the PREPARE operation inversed such that the following desired state is created: \n", "\n", "\\begin{equation}\n", " LCU|0\\rangle|\\psi\\rangle = PREPARE^{-1}\\, SELECT\\, PREPARE |0\\rangle|\\psi\\rangle = V |0\\rangle |\\psi\\rangle,\n", "\\end{equation}\n", "\n", - "where V can be represented as\n", + "where $V$ can be represented as\n", "\n", "\n", "$$V = \\begin{bmatrix}A & \\cdot \\\\ \\cdot & \\cdot \\end{bmatrix}.$$\n", "\n", "\n", - "This is called the Block Encoding of the matrix A. This way, if we project the control qubits in the $|0\\rangle$ state, we would obtain\n", + "This is called the Block Encoding of the matrix A. By projecting the controller quantum register on the $|0\\rangle$ state the desired outcome is obtained:\n", "\n", "\\begin{equation}\n", " \\left(|0\\rangle\\langle0|\\otimes I\\right)LCU|0\\rangle|\\phi\\rangle = |0\\rangle\\frac{A}{\\lambda}|\\psi\\rangle.\n", "\\end{equation}\n", "\n", - "Therefore, the action of the sequence of operations over the target qubit will be the non-unitary operation $A$, up to a normalization factor. A more detailed mathematical description of the circuit can be seen below and in [[1](#childs_paper)]. It is also important to notice that the projection onto the $|0\\rangle$ state depends on a success probability, detailed in [[1]](https://arxiv.org/abs/1202.5822). Overall, the general circuit of the LCU would look like this:" + "Therefore, the action of the sequence of operations over the target qubit will be the non-unitary operation $A$, up to a normalization factor. \n", + "\n", + "Detailed mathematical description of the algorithm can be seen [below](#mathematical-description) and in refernce [[1](#childs_paper)]. It is also important to notice that the projection onto the $|0\\rangle$ state depends on a success probability, detailed in [[1]](https://arxiv.org/abs/1202.5822).\n", + "\n", + "Overall, a scheme of the algorithm looks like:" ] }, { @@ -61,7 +65,9 @@ "id": "24bce818", "metadata": {}, "source": [ - "![LCU_circuit](https://docs.classiq.io/resources/LCU_Circuit.png)" + "
\n", + " \n", + "
" ] }, { @@ -78,8 +84,8 @@ "metadata": {}, "source": [ "Now that we know how the LCU algorithm works, it's time to implement it on Classiq. For that, we will be using two important functions:\n", - "* [Within-Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/ )\n", - "* [Prepare state](https://docs.classiq.io/latest/tutorials/tutorials/prepare-state/prepare-state/?h=prepare_state)\n", + "* [Within-Apply](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/within-apply/)\n", + "* [Prepare state](https://docs.classiq.io/latest/reference-manual/platform/qmod/library-reference/core-library-functions/prepare_state_and_amplitudes/prepare_state_and_amplitudes/)\n", "\n", "\n", "\n", @@ -94,7 +100,7 @@ "\n", "
\n", "\n", - "The Prepare state function realizes the initial state preparation step of a quantum algorithm, given a bound for the error and the probabilities of the quantum states. Using [this tutorial](https://docs.classiq.io/latest/tutorials/tutorials/prepare-state/prepare-state/?h=prepare_state), one can play with this function." + "The Prepare state function realizes the initial state preparation step of a quantum algorithm, given a bound for the error and the probabilities of the quantum states. Using [this tutorial](https://docs.classiq.io/latest/reference-manual/platform/qmod/library-reference/core-library-functions/prepare_state_and_amplitudes/prepare_state_and_amplitudes/), one can play with this function." ] }, { @@ -116,33 +122,26 @@ "id": "c01e0f46", "metadata": {}, "source": [ - "Now that the operations are identified, we just need to build them and then use the Within-Apply function. The SELECT operation can be build using the [control](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/quantum-operators/) statement, and the [QFT function](https://docs.classiq.io/latest/tutorials/functions/function-usage-examples/qft/qft/):" + "Now that the operations are identified, we just need to build them and then use the Within-Apply function. The SELECT operation can be build using the [control](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/control/) statement, and the [QFT function](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qft/qft/):" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "id": "58e277dd", "metadata": {}, "outputs": [], "source": [ "from classiq import *\n", + "\n", + "\n", "@qfunc\n", "def lcu_controllers(controller: QNum, psi: QNum):\n", - " control(\n", - " ctrl= controller==0,\n", - " operand= lambda: apply_to_all(IDENTITY,psi)\n", - " )\n", + " control(ctrl=controller == 0, operand=lambda: apply_to_all(IDENTITY, psi))\n", "\n", - " control(\n", - " ctrl= controller==1,\n", - " operand= lambda: qft(psi)\n", - " )\n", + " control(ctrl=controller == 1, operand=lambda: qft(psi))\n", "\n", - " control(\n", - " ctrl=controller==2,\n", - " operand= lambda: invert(lambda: qft(psi))\n", - " )" + " control(ctrl=controller == 2, operand=lambda: invert(lambda: qft(psi)))" ] }, { @@ -173,25 +172,31 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "id": "82854a21", "metadata": {}, "outputs": [], "source": [ "@qfunc\n", "def main(controller: Output[QNum], psi: Output[QNum]):\n", - " #Defining the error bound and probability distribution\n", + "\n", + " # Defining the error bound and probability distribution\n", " error_bound = 0.01\n", - " controller_probabilities= [0.5,0.25,0.25,0]\n", - " #Allocating the target and control qubits, respectively\n", - " allocate(2,psi)\n", + " controller_probabilities = [0.5, 0.25, 0.25, 0]\n", + "\n", + " # Allocating the target and control qubits, respectively\n", + " allocate(2, psi)\n", + " allocate(2, controller)\n", "\n", - " allocate(2,controller)\n", - " #Executing the Within-Apply function, the SELECT function is defined by lcu_controllers and the PREPARE function is defined by the inplace_prepare_state function.\n", + " # Executing the Within-Apply function, the SELECT function is defined by lcu_controllers and the PREPARE function is defined by the inplace_prepare_state function.\n", " within_apply(\n", - " compute=lambda: inplace_prepare_state(probabilities=controller_probabilities,bound=error_bound,target=controller),\n", - " action= lambda:lcu_controllers(controller,psi)\n", - " )\n", + " compute=lambda: inplace_prepare_state(\n", + " probabilities=controller_probabilities, bound=error_bound, target=controller\n", + " ),\n", + " action=lambda: lcu_controllers(controller, psi),\n", + " )\n", + "\n", + "\n", "quantum_model = create_model(main)\n", "quantum_program = synthesize(quantum_model)" ] @@ -297,36 +302,35 @@ ], "source": [ "from classiq import *\n", + "\n", + "\n", "@qfunc\n", "def lcu_controllers(controller: QNum, psi: QNum):\n", - " control(\n", - " ctrl= controller==0,\n", - " operand= lambda: apply_to_all(IDENTITY,psi)\n", - " )\n", + " control(ctrl=controller == 0, operand=lambda: apply_to_all(IDENTITY, psi))\n", + "\n", + " control(ctrl=controller == 1, operand=lambda: qft(psi))\n", + "\n", + " control(ctrl=controller == 2, operand=lambda: invert(lambda: qft(psi)))\n", "\n", - " control(\n", - " ctrl= controller==1,\n", - " operand= lambda: qft(psi)\n", - " )\n", "\n", - " control(\n", - " ctrl=controller==2,\n", - " operand= lambda: invert(lambda: qft(psi))\n", - " )\n", "@qfunc\n", "def main(controller: Output[QNum], psi: Output[QNum]):\n", - " #Defining the error bound and probability distribution\n", + " # Defining the error bound and probability distribution\n", " error_bound = 0.01\n", - " controller_probabilities= [0.5,0.25,0.25,0]\n", - " #Allocating the target and control qubits, respectively\n", - " allocate(2,psi)\n", + " controller_probabilities = [0.5, 0.25, 0.25, 0]\n", + " # Allocating the target and control qubits, respectively\n", + " allocate(2, psi)\n", "\n", - " allocate(2,controller)\n", - " #Executing the Within-Apply function, the SELECT function is defined by lcu_controllers and the PREPARE function is defined by the inplace_prepare_state function.\n", + " allocate(2, controller)\n", + " # Executing the Within-Apply function, the SELECT function is defined by lcu_controllers and the PREPARE function is defined by the inplace_prepare_state function.\n", " within_apply(\n", - " compute=lambda: inplace_prepare_state(probabilities=controller_probabilities,bound=error_bound,target=controller),\n", - " action= lambda:lcu_controllers(controller,psi)\n", - " )\n", + " compute=lambda: inplace_prepare_state(\n", + " probabilities=controller_probabilities, bound=error_bound, target=controller\n", + " ),\n", + " action=lambda: lcu_controllers(controller, psi),\n", + " )\n", + "\n", + "\n", "quantum_model = create_model(main)\n", "quantum_program = synthesize(quantum_model)\n", "\n", @@ -348,16 +352,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "5937706e", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "write_qmod(quantum_model, \"linear_combination_of_unitaries\")" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.11.7 ('classiq')", "language": "python", "name": "python3" }, @@ -371,7 +377,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.11.7" + }, + "vscode": { + "interpreter": { + "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" + } } }, "nbformat": 4, diff --git a/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.json b/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.json new file mode 100644 index 00000000..d2b374de --- /dev/null +++ b/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.json @@ -0,0 +1,7 @@ +{ + "friendly_name": "LCU - Linear Combination of Unitaries", + "description": "Demonstration of the LCU algorithm for a specific example", + "problem_domain_tags": [], + "qmod_type": ["algorithm"], + "level": ["basic", "demos"] +} diff --git a/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.qmod b/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.qmod new file mode 100644 index 00000000..0584981d --- /dev/null +++ b/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.qmod @@ -0,0 +1,23 @@ +qfunc lcu_controllers(controller: qnum, psi: qnum) { + control (controller == 0) { + apply_to_all(psi); + } + control (controller == 1) { + qft(psi); + } + control (controller == 2) { + invert { + qft(psi); + } + } +} + +qfunc main(output controller: qnum, output psi: qnum) { + allocate<2>(psi); + allocate<2>(controller); + within { + inplace_prepare_state<[0.5, 0.25, 0.25, 0], 0.01>(controller); + } apply { + lcu_controllers(controller, psi); + } +} diff --git a/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.synthesis_options.json b/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.synthesis_options.json new file mode 100644 index 00000000..0967ef42 --- /dev/null +++ b/tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.synthesis_options.json @@ -0,0 +1 @@ +{} diff --git a/tutorials/mcx/mcx_14_ctrl_cx.json b/tutorials/mcx/mcx_14_ctrl_cx.metadata.json similarity index 100% rename from tutorials/mcx/mcx_14_ctrl_cx.json rename to tutorials/mcx/mcx_14_ctrl_cx.metadata.json diff --git a/tutorials/mcx/mcx_14_ctrl_depth.json b/tutorials/mcx/mcx_14_ctrl_depth.metadata.json similarity index 100% rename from tutorials/mcx/mcx_14_ctrl_depth.json rename to tutorials/mcx/mcx_14_ctrl_depth.metadata.json diff --git a/tutorials/mcx/mcx_14_ctrl_hardware.json b/tutorials/mcx/mcx_14_ctrl_hardware.metadata.json similarity index 100% rename from tutorials/mcx/mcx_14_ctrl_hardware.json rename to tutorials/mcx/mcx_14_ctrl_hardware.metadata.json diff --git a/tutorials/mcx/mcx_50_ctrl.json b/tutorials/mcx/mcx_50_ctrl.metadata.json similarity index 100% rename from tutorials/mcx/mcx_50_ctrl.json rename to tutorials/mcx/mcx_50_ctrl.metadata.json diff --git a/tutorials/phase_kickback/phase_kickback.ipynb b/tutorials/phase_kickback/phase_kickback.ipynb index 19eb5c6d..c7530925 100644 --- a/tutorials/phase_kickback/phase_kickback.ipynb +++ b/tutorials/phase_kickback/phase_kickback.ipynb @@ -11,27 +11,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Phase kickback [[1](#childs),[2](#LinLin),[3](#Wolf)] is an important and highly used primitive in quantum computing, and it deals with kicking the result of a function to the phase of a quantum state so it can be smartly manipulated with constructive and destructive interferences in order to achieve the desired result. Every quantum algortihm can be decomposed into 3 steps: 1)Encoding the data; 2) Manipulating the data; and 3) Extracting the result. The phase kickback primitive is a key step in the manipulaiton of the data that enables the extraction of the result. See the [Deutch-Jozsa](https://github.com/Classiq/classiq-library/blob/main/algorithms/deutsch_jozsa/deutsch_jozsa.ipynb) and [Simon's](https://github.com/Classiq/classiq-library/blob/main/algorithms/simon/simon.ipynb) algortihms for concrete examples of the applications of it.\n", + "Phase kickback [[1](#childs),[2](#LinLin),[3](#Wolf)] is an important and highly used primitive in quantum computing. It deals with kicking the result of a function to the phase of a quantum state so it can be smartly manipulated with constructive and destructive interferences to achieve the desired result. Every quantum algortihm can be decomposed into these steps: 1) Encoding the data; 2) Manipulating the data; and 3) Extracting the result. The phase kickback primitive is a key step in the manipulation of the data that enables extracting the result. See the [Deutsch-Jozsa](https://github.com/Classiq/classiq-library/blob/main/algorithms/deutsch_jozsa/deutsch_jozsa.ipynb) and [Simon's](https://github.com/Classiq/classiq-library/blob/main/algorithms/simon/simon.ipynb) algorithms for concrete examples.\n", "\n", - "The standard way [[4](#NielsenChuang)] of applying a classical function $f:\\{0,1\\}^n \\rightarrow \\{0,1\\}$ on quantum states is with the oracle model: \n", + "The standard way [[4](#NielsenChuang)] to apply a classical function $f:\\{0,1\\}^n \\rightarrow \\{0,1\\}$ on quantum states is with the oracle model: \n", "$\\begin{equation}\n", "O_f (|x \\rangle_n|y \\rangle_1) = |x \\rangle_n|y \\oplus f(x) \\rangle_1\n", "\\end{equation}$\n", - "with $|x \\rangle$ and $|y \\rangle$ being the argument and target quantum states respectively, and $\\oplus$ being affition modolu $2$, or the XOR operation. The phase kickback primitive takes the oracle $O_f$ as an input, and performs the follwoing operation:\n", + "with $|x \\rangle$ and $|y \\rangle$ as the argument and target quantum states, respectively, and $\\oplus$ as the addition modolu $2$ or the XOR operation. The phase kickback primitive takes the oracle $O_f$ as input, and performs this operation:\n", "$\\begin{equation}\n", "|x \\rangle\\rightarrow (-1)^{f(x)}|x \\rangle\n", "\\end{equation}$\n", - "This can obviously be applied on a superposition of states such that:\n", + "This can be applied on a superposition of state:\n", "$\\begin{equation}\n", "\\sum_{i=0}^{2^n-1}\\alpha_i|x_i \\rangle\\rightarrow (-1)^{f(x_i)}\\alpha_i|x_i \\rangle\n", "\\end{equation}$\n", - "with $\\alpha_i$ being the amplitude of the $|x_i \\rangle$ state.\n", + "with $\\alpha_i$ as the amplitude of the $|x_i \\rangle$ state.\n", "\n", - "How this is happening? It's quite simple actually (hence the beuty of it), all needed is to apply the oracle $O_f$ on the state target quantum state $|- \\rangle=\\frac{1}{\\sqrt{2}}|0 \\rangle-\\frac{1}{\\sqrt{2}}|1 \\rangle$ such that:\n", + "How does this happen? Its beauty lies in its simplicity: applying the oracle $O_f$ to the state target quantum state $|- \\rangle=\\frac{1}{\\sqrt{2}}|0 \\rangle-\\frac{1}{\\sqrt{2}}|1 \\rangle$:\n", "$\\begin{equation}\n", "O_f|x \\rangle |- \\rangle = (-1)^{f(x)}|x \\rangle |- \\rangle\n", "\\end{equation}$\n", - "and then effectively the desired transformation $|x \\rangle\\rightarrow (-1)^{f(x)}|x \\rangle$ is achieved. " + "then effectively achieving the desired transformation $|x \\rangle\\rightarrow (-1)^{f(x)}|x \\rangle$. " ] }, { @@ -47,7 +47,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's see how this actually works! (Go to the [Mathemtaical Description](#mathematical-description) for full mathematical description)" + "See full details in the [mathematical description](#mathematical-description)." ] }, { @@ -55,12 +55,12 @@ "metadata": {}, "source": [ "**Classiq Concepts**\n", - "* [Within-Apply](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/within-apply/ )\n", - "* [In-Place XOR](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/numeric-assignment/ )\n", + "* [within-apply](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/within-apply/ )\n", + "* [in-place XOR](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/numeric-assignment/ )\n", "\n", "**Related Algorithms**\n", - "* [Deutch-Jozsa Algorithm](https://github.com/Classiq/classiq-library/blob/main/algorithms/deutsch_jozsa/deutsch_jozsa.ipynb)\n", - "* [Simon's Algorithm](https://github.com/Classiq/classiq-library/blob/main/algorithms/simon/simon.ipynb)" + "* [Deutsch-Jozsa algorithm](https://github.com/Classiq/classiq-library/blob/main/algorithms/deutsch_jozsa/deutsch_jozsa.ipynb)\n", + "* [Simon's algorithm](https://github.com/Classiq/classiq-library/blob/main/algorithms/simon/simon.ipynb)" ] }, { @@ -70,13 +70,13 @@ "
\n", " NOTE \n", "\n", - "Sometimes another trick is refered as phase kickback ([video 1](https://www.youtube.com/watch?v=iLcQ-X6QzvU), [video 2](https://www.youtube.com/watch?v=455pmYaZXKw)). This is when applying a unitary $U$ with eigensystem $U| phi \\rangle=e^{i\\phi}|phi\\rangle$ which is controlled by a qubit in the $| + \\rangle=\\frac{1}{\\sqrt{2}}|0\\rangle+\\frac{1}{\\sqrt{2}}|1\\rangle$, the phase of the eigenvalue of $U$ is kicked-back to a relative phase in the controlled qubit:\n", + "Another trick is phase kickback ([video 1](https://www.youtube.com/watch?v=iLcQ-X6QzvU), [video 2](https://www.youtube.com/watch?v=455pmYaZXKw)). A unitary $U$ is applied to an eigensystem $U| phi \\rangle=e^{i\\phi}|phi\\rangle$ which is controlled by a qubit in the $| + \\rangle=\\frac{1}{\\sqrt{2}}|0\\rangle+\\frac{1}{\\sqrt{2}}|1\\rangle$, and the phase of the eigenvalue of $U$ is kicked back to a relative phase in the controlled qubit:\n", "$\\begin{equation}\n", "CU| + \\rangle| \\phi \\rangle=\\frac{1}{\\sqrt2}(|0\\rangle| \\phi \\rangle + e^{i\\phi}|1\\rangle| \\phi \\rangle) = \\frac{1}{\\sqrt{2}}(|0\\rangle+e^{i\\phi}|1\\rangle)| \\phi \\rangle\n", "\\end{equation}$\n", "\n", - "This is a good trick to know as well, but it is not what is commonly referred to Phase Kickback in the literature [[1](#childs),[2](#LinLin),[3](#Wolf)]\n", - "
" + "This useful trick is not the same as the Phase Kickback described in the literature [[1](#childs),[2](#LinLin),[3](#Wolf)]\n", + "." ] }, { @@ -90,14 +90,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In Classiq as in any proper devleoping platform, it is recomended to think and design your code on the functional level in terms of functions. The above figure directs us to what functional building blocks we need to have so now we will implement them one function at a time and then connect them." + "When using the Classiq system (as for any development platform), it is recommended to design your code at the functional level in terms of functions. The above figure indicates which functional building blocks you need, so you can now implement them, one function at a time, and then connect them." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "First we start with the **Prepare** $| - \\rangle$ building block implemented with the `prepare_minus` function. It is implemented by sequentially apllying the `X` (NOT) gate that transforms $|0\\rangle$ into $X|0\\rangle=|1\\rangle$, and then applying the Hadmard `H` gate that takes the $|1\\rangle$ state into the desired $H|1\\rangle=| - \\rangle$ state:" + "Start with the **Prepare** $| - \\rangle$ building block using the `prepare_minus` function. It is implemented by sequentially applying the `X` (NOT) gate that transforms $|0\\rangle$ into $X|0\\rangle=|1\\rangle$, and then applying the Hadamard `H` gate that takes the $|1\\rangle$ state into the desired $H|1\\rangle=| - \\rangle$ state:" ] }, { @@ -136,7 +136,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Then we need to define the oracle function that implements $O_f| x \\rangle| target \\rangle=| x \\rangle |target \\oplus f(x)\\rangle$. We will implement it for the function $f(x)= (x==0)$, such that the output is $1$ only if the input $x$ equals $0$. That is \n", + "Now, define the oracle function that implements $O_f| x \\rangle| target \\rangle=| x \\rangle |target \\oplus f(x)\\rangle$ for the function $f(x)= (x==0)$, such that the output is $1$ only if the input $x$ equals $0$.\n", "$\\begin{equation}\n", "O_f(| x \\rangle| target \\rangle) = | x \\rangle |target \\oplus (x==0)\\rangle\n", "\\end{equation}$" @@ -155,7 +155,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "With Classiq the XOR operation ($\\oplus$) is impleneted intuitively with `^=` :" + "With Classiq, the XOR operation ($\\oplus$) is implemented intuitively with `^=` :" ] }, { @@ -183,7 +183,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we want to combine the two building blocks for preforming the phase kickback. Notice that the we not interested in the $| - \\rangle$ state and its only purpose is for the implementation of $| x \\rangle\\rightarrow (-1)^{f(x)}| x \\rangle$. For such cases (that are common in quantum computing) the QMOD language offers the `Within-Apply` ([read more](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/within-apply/ ) ) statment. Everything we want only for the use of another specific function we apply in the `Within`, and we use it for the specific thing we are interested at in the `Apply`" + "Combine the two building blocks for performing the phase kickback. You are not interested in the $| - \\rangle$ state as its only purpose is to implement $| x \\rangle\\rightarrow (-1)^{f(x)}| x \\rangle$. For such cases (that are common in quantum computing), the Qmod language offers the `within-apply` ([read more](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/within-apply/ ) ) statement. Apply everything intended for use by another specific function in the `within`, and use it for the specific thing in the `apply`" ] }, { @@ -227,7 +227,7 @@ "\n", "Note! \n", "\n", - "In the native QMOD syntax in the IDE the following would look like:\n", + "This is how the native Qmod syntax in the IDE looks:\n", "\n", "```\n", "qfunc oracle_phase_kickback(x:qnum){\n", @@ -235,7 +235,7 @@ " within{prepare_minus(target);} apply{oracle_function(x,target);}\n", "}\n", "```\n", - "which is a bit more intuitive.\n", + "which is more intuitive.\n", "" ] }, @@ -243,7 +243,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we are ready to apply our `oracle_phase_kickback` function. Because we are dealing with quantum algortihms we want to utilize the power of quantum parallelism so we will apply the `oracle_phase_kickback` on a superposition of numbers. Creating a superposition is commonly done with the Hadamrd transform in quantum computing, which is just applying the Hadamrd gate `H` on all the qubits, and it's application on the $|0\\rangle$ state is:\n", + "Now you can use the `oracle_phase_kickback` function. To utilize the power of quantum parallelism, apply the `oracle_phase_kickback` on a superposition of numbers. Creating a superposition is commonly done with the Hadamard transform in quantum computing, which means applying the Hadamard gate `H` on all the qubits. Its application on the $|0\\rangle$ state:\n", "$\\begin{equation}\n", "H^{\\otimes n}|0\\rangle_n = \\frac{1}{\\sqrt{2^n}}\\sum_{i=0}^{2^n-1}| i \\rangle_n\n", "\\end{equation}$" @@ -263,11 +263,11 @@ "metadata": {}, "source": [ "\n", - "Therefore our phase kickback primitive is construct of\n", + "Therefore, the phase kickback primitive is constructed of this:\n", "\n", - "1. Initializing the `qnum` type with $4$ qubits using the `allocate` function such that $| x \\rangle=|0\\rangle$\n", - "2. Applying the Hadamrd transform on it using the `hadamard_transform` function such that $| x \\rangle = \\frac{1}{\\sqrt{2^n}}\\sum_{i=0}^{2^n-1}| i \\rangle_n$\n", - "3. Applying the Phase Kickback primitive with the `oracle_phase_kickback` function such that $| x \\rangle = \\frac{1}{\\sqrt{2^n}}\\sum_{i=0}^{2^n-1}(-1)^{i==0}| i \\rangle_n$" + "1. Initializing the `qnum` type with $4$ qubits using the `allocate` function such that $| x \\rangle=|0\\rangle$.\n", + "2. Applying the Hadamard transform using the `hadamard_transform` function such that $| x \\rangle = \\frac{1}{\\sqrt{2^n}}\\sum_{i=0}^{2^n-1}| i \\rangle_n$.\n", + "3. Applying the phase kickback primitive with the `oracle_phase_kickback` function such that $| x \\rangle = \\frac{1}{\\sqrt{2^n}}\\sum_{i=0}^{2^n-1}(-1)^{i==0}| i \\rangle_n$." ] }, { @@ -319,11 +319,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now let's varify that our quantum program actually does what we expect it to do. Remember - we expect to receive a $(-)$ phase only for the state $|0\\rangle$, that is:\n", + "Verify that the quantum program actually operates as expected; receiving a $(-)$ phase only for the state $|0\\rangle$, that is:\n", "$\\begin{equation}\n", "| x \\rangle = \\frac{1}{\\sqrt{2^4}}(|1\\rangle+| 2 \\rangle+\\dots +| 15 \\rangle-|0\\rangle)\n", "\\end{equation}$\n", - "In order to check this we will use the built-in Classiq state vector simulator from the IDE:" + "To check, use the built-in Classiq state vector simulator from the IDE:" ] }, { @@ -339,10 +339,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And indeed we see that only for the zero state we receive the $(-)$ phase as expected! That's really cool isn't it?\n", - "Note that in the result we see bit strings of 5 bits rather than just 4 - this includes the `target` qubit measurment that always result 0.\n", + "Indeed, see that you receive the $(-)$ phase only for the zero state, as expected.\n", + "The result shows bit strings of five bits rather than just four. This includes the `target` qubit measurement that always results in 0.\n", "\n", - "To see how this phase kickback is actually implemented in practice see the Deutch-Josza example and Simon's example (TODO links)" + "To see how this phase kickback is actually implemented in practice see the [Deutsch-Josza example](https://github.com/Classiq/classiq-library/blob/main/algorithms/deutsch_jozsa/deutsch_jozsa.ipynb) and [Simon's example](https://github.com/Classiq/classiq-library/blob/main/algorithms/simon/simon.ipynb)." ] }, { @@ -356,35 +356,35 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Our starting point is the defintion \n", + "The starting point is the definition \n", "$\\begin{equation}\n", "O_f (| x \\rangle_n| y \\rangle_1) = | x \\rangle_n|y \\oplus f(x)\\rangle_1\n", "\\end{equation}$\n", "for $f:\\{0,1\\}^n \\rightarrow \\{0,1\\}$.\n", "\n", - "Applying $O_f$ on $| x \\rangle| - \\rangle$ results:\n", + "Applying $O_f$ on $| x \\rangle| - \\rangle$ results in this:\n", "$\\begin{equation}\n", "O_f (| x \\rangle| - \\rangle) = \\frac{1}{\\sqrt{2}}(| x \\rangle |0 \\oplus f(x)\\rangle - | x \\rangle |1 \\oplus f(x)\\rangle)\n", "\\end{equation}$\n", "\n", "The expression $0 \\oplus f(x)$ equals $f(x)$ because $0\\oplus0=0$ and $0\\oplus1=1$.\n", "\n", - "The expression $1\\oplus f(x)$ equals $\\overline{f(x)}$ i.e. `NOT` $f(x)$ since $1\\oplus1=0$ and $1\\oplus0=1$.\n", + "The expression $1\\oplus f(x)$ equals $\\overline{f(x)}$; i.e., `NOT` $f(x)$ since $1\\oplus1=0$ and $1\\oplus0=1$.\n", "\n", "Therefore:\n", "\n", "$\\begin{equation}\n", - "O_f (| x \\rangle| - \\rangle) = | x \\rangle\\frac{1}{\\sqrt{2}}(|f(x)\\rangle - |\\overline{f(x)}\\rangle)\n", + "O_f (| x \\rangle| - \\rangle) = | x \\rangle\\frac{1}{\\sqrt{2}}(|f(x)\\rangle - |\\overline{f(x)}\\rangle).\n", "\\end{equation}$\n", "\n", "If $f(x)=0$ the target state is $\\frac{1}{\\sqrt{2}}(|0\\rangle - |1\\rangle) = | - \\rangle = (-1)^{f(x)}| - \\rangle$.\n", "\n", - "If $f(x)=1$ the target state is $\\frac{1}{\\sqrt{2}}(|1\\rangle - |0\\rangle) = -| - \\rangle = = (-1)^{f(x)}| - \\rangle$.\n", + "If $f(x)=1$ the target state is $\\frac{1}{\\sqrt{2}}(|1\\rangle - |0\\rangle) = -| - \\rangle = (-1)^{f(x)}| - \\rangle$.\n", "\n", "Therefore:\n", "\n", "$\\begin{equation}\n", - "O_f (| x \\rangle| - \\rangle) = (-1)^{f(x)}| x \\rangle| - \\rangle\n", + "O_f (| x \\rangle| - \\rangle) = (-1)^{f(x)}| x \\rangle| - \\rangle.\n", "\\end{equation}$\n", "\n" ] @@ -393,7 +393,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## All Code Together" + "## All the Code Together" ] }, { @@ -516,7 +516,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Refernces " + "## References " ] }, { diff --git a/tutorials/phase_kickback/phase_kickback.json b/tutorials/phase_kickback/phase_kickback.metadata.json similarity index 100% rename from tutorials/phase_kickback/phase_kickback.json rename to tutorials/phase_kickback/phase_kickback.metadata.json diff --git a/tutorials/prepare_state/prepare_state.json b/tutorials/prepare_state/prepare_state.metadata.json similarity index 100% rename from tutorials/prepare_state/prepare_state.json rename to tutorials/prepare_state/prepare_state.metadata.json diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.json b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.metadata.json similarity index 100% rename from tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.json rename to tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.metadata.json diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.qmod b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.qmod index c90b9c72..b6ccd2f0 100644 --- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.qmod +++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.qmod @@ -5,4 +5,3 @@ qfunc main(output z: qnum) { prepare_int<1>(y); z = (((2 * x) + y) + max(3 * y, 2)) > 4; } - diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.synthesis_options.json b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.synthesis_options.json index b90a8354..d9217744 100644 --- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.synthesis_options.json +++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.synthesis_options.json @@ -6,4 +6,4 @@ "preferences": { "random_seed": 424788457 } -} \ No newline at end of file +} diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.json b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.metadata.json similarity index 100% rename from tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.json rename to tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.metadata.json diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.qmod b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.qmod index c90b9c72..b6ccd2f0 100644 --- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.qmod +++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.qmod @@ -5,4 +5,3 @@ qfunc main(output z: qnum) { prepare_int<1>(y); z = (((2 * x) + y) + max(3 * y, 2)) > 4; } - diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.synthesis_options.json b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.synthesis_options.json index 63d39997..d0862a5e 100644 --- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.synthesis_options.json +++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.synthesis_options.json @@ -6,4 +6,4 @@ "preferences": { "random_seed": 424788457 } -} \ No newline at end of file +} diff --git a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb index d6c1eccf..3b2a7451 100644 --- a/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb +++ b/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb @@ -26,19 +26,21 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 2, "id": "674d1423-6ac5-4f6b-8328-7073a72c0a28", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:00:16.789628Z", - "iopub.status.busy": "2024-05-07T14:00:16.788315Z", - "iopub.status.idle": "2024-05-07T14:00:19.713422Z", - "shell.execute_reply": "2024-05-07T14:00:19.712748Z" - } - }, + "metadata": {}, "outputs": [], "source": [ - "from classiq import Output, QBit, QNum, prepare_int, create_model, qfunc, synthesize, execute\n", + "from classiq import (\n", + " Output,\n", + " QBit,\n", + " QNum,\n", + " create_model,\n", + " execute,\n", + " prepare_int,\n", + " qfunc,\n", + " synthesize,\n", + ")\n", "from classiq.qmod.symbolic import max\n", "\n", "\n", @@ -74,22 +76,15 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "id": "ba0e933a-9878-4ce2-b5af-2e4c65638f60", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:00:19.716687Z", - "iopub.status.busy": "2024-05-07T14:00:19.715919Z", - "iopub.status.idle": "2024-05-07T14:00:26.267367Z", - "shell.execute_reply": "2024-05-07T14:00:26.266648Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/737ef5dd-eba0-49f5-9a61-25814ca2f523?version=0.42.0\n", + "Opening: http://localhost:4200/circuit/9ffbb18e-8a8e-480b-9091-713d83e03db4?version=0.0.0\n", "The result of the arithmetic calculation: [{'z': 1.0}: 2048]\n" ] } @@ -116,7 +111,7 @@ "job = execute(qprog)\n", "result = job.result()\n", "parsed_counts = result[0].value.parsed_counts\n", - "print(\"The result of the arithmetic calculation: \",parsed_counts)\n", + "print(\"The result of the arithmetic calculation: \", parsed_counts)\n", "\n", "\n", "write_qmod(qmod, \"arithmetic_demo_9_qubits\")" @@ -132,22 +127,15 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "id": "77d24a43-5114-46a0-8309-33af8fdc75fb", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:00:26.272358Z", - "iopub.status.busy": "2024-05-07T14:00:26.271131Z", - "iopub.status.idle": "2024-05-07T14:00:33.694219Z", - "shell.execute_reply": "2024-05-07T14:00:33.693482Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/00705127-ab37-41d3-b8a6-71939bf39146?version=0.42.0\n", + "Opening: http://localhost:4200/circuit/9cfdfb42-91dd-4ccb-a9cd-126ad43d404c?version=0.0.0\n", "The result of the arithmetic calculation: [{'z': 1.0}: 2048]\n" ] } @@ -162,7 +150,7 @@ "job = execute(qprog)\n", "result = job.result()\n", "parsed_counts = result[0].value.parsed_counts\n", - "print(\"The result of the arithmetic calculation: \",parsed_counts)\n", + "print(\"The result of the arithmetic calculation: \", parsed_counts)\n", "\n", "\n", "write_qmod(qmod, \"arithmetic_demo_12_qubits\")" @@ -189,20 +177,28 @@ " \n", " Allocated values:\n", " \n", - " $$x = 2\\\\ y = 1$$\n", + " $$x = 2, \\,\\,\\, y = 1$$\n", " \n", " \n", " Expression Calculation:\n", "\n", - " $$2 \\cdot x + y = 2 \\cdot 2 + 1 = 4 + 1 = 5 \\\\ 3 \\cdot y = 3 \\cdot 1 = 3 \\\\ \\max(3 \\cdot y, 2) = \\max(3, 2) = 3$$\n", + " $$2 \\cdot x + y = 2 \\cdot 2 + 1 = 4 + 1 = 5 \\,\\,\\, 3 \\cdot y = 3 \\cdot 1 = 3 \\,\\,\\, \\max(3 \\cdot y, 2) = \\max(3, 2) = 3$$\n", " \n", " Therefore:\n", " \n", " $$2 \\cdot x + y + \\max(3 \\cdot y, 2) = 5 + 3 = 8$$\n", " \n", " As $$8 > 4 \\implies \\text{True}$$\n", - " Z is assigned the value True : $Z \\implies 1$" + " z is assigned the value True : $z \\implies 1$" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6115ec77-8405-42e2-b0d3-a00b163deb63", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -221,7 +217,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.1" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/tutorials/technology_demonstrations/discrete_quantum_walk_circle/discrete_quantum_walk_circle.ipynb b/tutorials/technology_demonstrations/discrete_quantum_walk_circle/discrete_quantum_walk_circle.ipynb new file mode 100644 index 00000000..51b2260d --- /dev/null +++ b/tutorials/technology_demonstrations/discrete_quantum_walk_circle/discrete_quantum_walk_circle.ipynb @@ -0,0 +1,808 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6d913177-eafe-488f-a2fc-8ccedf0f4be1", + "metadata": {}, + "source": [ + "# Discrete Quantum Walk on a Circle" + ] + }, + { + "cell_type": "markdown", + "id": "af0afde2-d59c-4186-a34f-142a5265f095", + "metadata": {}, + "source": [ + "This notebook demonstrates the capabilities of the synthesis engine for a walk operator on a circle. The walk operator acts on two quantum variables: a coin qubit and a position quantum number. The core part of the walk operator is the increment quantum function, which is implemented here via a series of multi-controlled X operation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b877ca03-2aad-4ae2-86b8-bc136a7ab38d", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "from classiq import *" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0d686f49-3780-46d3-962a-f689469ffbcf", + "metadata": {}, + "outputs": [], + "source": [ + "transpilation_options = {\"classiq\": \"custom\", \"qiskit\": 3}\n", + "NUM_QUBITS_MIN = 5\n", + "NUM_QUBITS_MAX = 12" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "49791668-1241-4781-8edc-124269a1f4bf", + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def my_mcx(x: QNum, y: QBit):\n", + " control(x == 2**x.size - 1, lambda: X(y))\n", + "\n", + "\n", + "@qfunc\n", + "def increment(x: QArray[QBit]):\n", + " repeat(x.len - 1, lambda i: my_mcx(x[0 : x.len - 1 - i], x[x.len - 1 - i]))\n", + " X(x[0])\n", + "\n", + "\n", + "@qfunc\n", + "def single_step_walk(\n", + " x: QNum, # position\n", + "):\n", + " coin = QNum(\"coin\")\n", + " allocate(1, coin)\n", + " H(coin)\n", + " control(coin == 0, lambda: increment(x)),\n", + " control(coin == 1, lambda: invert(lambda: increment(x)))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "10c1fca5-0b5a-4c0a-ae6e-29bbc9d6841d", + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import CustomHardwareSettings, Preferences\n", + "\n", + "preferences = Preferences(\n", + " custom_hardware_settings=CustomHardwareSettings(basis_gates=[\"cx\", \"u\"]),\n", + " transpilation_option=transpilation_options[\"classiq\"],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fa293f48-1aff-4467-a825-40989b359aa8", + "metadata": {}, + "source": [ + "## Synthesizing with two Different Optimization Scenarios " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e626a11c-40b6-4f53-ae44-541b7841a9fb", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from classiq import (\n", + " Constraints,\n", + " OptimizationParameter,\n", + " QuantumProgram,\n", + " set_constraints,\n", + " set_preferences,\n", + " synthesize,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2f121566-d943-463c-a0e4-6a2141a3d009", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 ======\n", + "time: 3.6095149517059326\n", + "time 2.083699941635132\n", + "6 ======\n", + "time: 4.189702272415161\n", + "time 2.097536087036133\n", + "7 ======\n", + "time: 7.209691762924194\n", + "time 3.0989890098571777\n", + "8 ======\n", + "time: 10.247850179672241\n", + "time 4.106258869171143\n", + "9 ======\n", + "time: 20.30021905899048\n", + "time 5.183635234832764\n", + "10 ======\n", + "time: 44.32120895385742\n", + "time 7.1332621574401855\n", + "11 ======\n", + "time: 77.35208916664124\n", + "time 9.147570848464966\n" + ] + } + ], + "source": [ + "classiq_depths_opt_width = []\n", + "classiq_cx_counts_opt_width = []\n", + "classiq_widths_opt_width = []\n", + "classiq_times_opt_width = []\n", + "\n", + "classiq_cx_counts_opt_cx = []\n", + "classiq_depths_opt_cx = []\n", + "classiq_widths_opt_cx = []\n", + "classiq_times_opt_cx = []\n", + "\n", + "\n", + "for num_qubits in range(NUM_QUBITS_MIN, NUM_QUBITS_MAX):\n", + "\n", + " print(num_qubits, \"======\")\n", + " start_time = time.time()\n", + "\n", + " @qfunc\n", + " def main(x: Output[QNum]):\n", + " allocate_num(num_qubits, False, 0, x)\n", + " single_step_walk(x)\n", + "\n", + " qmod = create_model(main)\n", + " qprog = synthesize(qmod)\n", + "\n", + " # width optimization\n", + " constraints = Constraints(\n", + " optimization_parameter=OptimizationParameter.WIDTH,\n", + " )\n", + " qmod = set_constraints(qmod, constraints=constraints)\n", + " qmod = set_preferences(qmod, preferences=preferences)\n", + " quantum_program = synthesize(qmod)\n", + " end_time = time.time() - start_time\n", + " circuit = QuantumProgram.from_qprog(quantum_program)\n", + " classiq_widths_opt_width.append(circuit.data.width)\n", + " classiq_depths_opt_width.append(circuit.transpiled_circuit.depth)\n", + " classiq_cx_counts_opt_width.append(circuit.transpiled_circuit.count_ops[\"cx\"])\n", + " classiq_times_opt_width.append(end_time)\n", + " print(\"time:\", end_time)\n", + " # CX Optimization with a Constrained Width\n", + " constraints = Constraints(\n", + " optimization_parameter=\"cx\",\n", + " max_width=2 * num_qubits, # setting some bound\n", + " )\n", + " qmod = set_constraints(qmod, constraints=constraints)\n", + " qmod = set_preferences(qmod, preferences=preferences)\n", + " start_time = time.time()\n", + " quantum_program = synthesize(qmod)\n", + " end_time = time.time() - start_time\n", + " circuit = QuantumProgram.from_qprog(quantum_program)\n", + " classiq_widths_opt_cx.append(circuit.data.width)\n", + " classiq_depths_opt_cx.append(circuit.transpiled_circuit.depth)\n", + " classiq_cx_counts_opt_cx.append(circuit.transpiled_circuit.count_ops[\"cx\"])\n", + " classiq_times_opt_cx.append(end_time)\n", + " print(\"time\", end_time)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bbfc20ad-e02e-41d7-8f58-699d46556e6a", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "classiq depths: [419, 749, 1195, 1773, 2499, 3389, 4099]\n", + "classiq cx_counts: [274, 514, 850, 1298, 1874, 2594, 3194]\n", + "classiq widths: [6, 7, 8, 9, 10, 11, 13]\n", + "[3.6095149517059326, 4.189702272415161, 7.209691762924194, 10.247850179672241, 20.30021905899048, 44.32120895385742, 77.35208916664124]\n", + "classiq depths: [193, 245, 335, 419, 509, 602, 704]\n", + "classiq cx_counts: [120, 152, 200, 260, 352, 436, 552]\n", + "classiq widths: [8, 9, 11, 12, 14, 15, 17]\n", + "[2.083699941635132, 2.097536087036133, 3.0989890098571777, 4.106258869171143, 5.183635234832764, 7.1332621574401855, 9.147570848464966]\n" + ] + } + ], + "source": [ + "print(\"classiq depths:\", classiq_depths_opt_width)\n", + "print(\"classiq cx_counts:\", classiq_cx_counts_opt_width)\n", + "print(\"classiq widths:\", classiq_widths_opt_width)\n", + "print(classiq_times_opt_width)\n", + "\n", + "print(\"classiq depths:\", classiq_depths_opt_cx)\n", + "print(\"classiq cx_counts:\", classiq_cx_counts_opt_cx)\n", + "print(\"classiq widths:\", classiq_widths_opt_cx)\n", + "print(classiq_times_opt_cx)" + ] + }, + { + "cell_type": "markdown", + "id": "8762fb46-9f6c-481b-9894-2b8adb415c3e", + "metadata": {}, + "source": [ + "## Comparing to Qiskit Implementation\n", + "\n", + "The qiskit data was generated using qiskit version 1.0.0. To run the qiskit code uncomment the commented cells below." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c224f0cd-471e-4431-9f19-b61b6296ca8b", + "metadata": {}, + "outputs": [], + "source": [ + "qiskit_cx_counts = [900, 2376, 5388, 11472, 23700, 48216]\n", + "qiskit_depths = [1645, 4222, 9485, 20122, 41509, 84398]\n", + "qiskit_widths = [6, 7, 8, 9, 10, 11]\n", + "qiskit_times = [\n", + " 0.43783092498779297,\n", + " 3.743027925491333,\n", + " 17.858744144439697,\n", + " 73.1058611869812,\n", + " 293.51222825050354,\n", + " 1222.052798986435,\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2615c5af-eb5b-48bf-b3f5-ca184de4bac4", + "metadata": {}, + "outputs": [], + "source": [ + "# from qiskit import QuantumCircuit, QuantumRegister, transpile\n", + "\n", + "# def get_incerement_circuit(num_qubits):\n", + "\n", + "# incerement_circuit= QuantumCircuit(num_qubits)\n", + "# for j in range(num_qubits - 1):\n", + "# incerement_circuit.mcx([k for k in range(num_qubits - 1-j)], num_qubits-1-j)\n", + "# incerement_circuit.x(0)\n", + "\n", + "# return incerement_circuit\n", + "\n", + "# # building the q_walk_step, the first qubit is the coin\n", + "# qiskit_cx_counts = []\n", + "# qiskit_depths = []\n", + "# qiskit_widths = []\n", + "# qiskit_times = []\n", + "\n", + "\n", + "# for num_qubits in range(NUM_QUBITS_MIN,NUM_QUBITS_MAX):\n", + "\n", + "# start_time = time.time()\n", + "# q_walk_step = QuantumCircuit(num_qubits+1)\n", + "# q_walk_step.h(0)\n", + "# q_walk_step.append(get_incerement_circuit(num_qubits).control(1, ctrl_state=1),\n", + "# [k for k in range(num_qubits+1)])\n", + "# q_walk_step.append(get_incerement_circuit(num_qubits).inverse().control(1, ctrl_state=0),\n", + "# [k for k in range(num_qubits+1)])\n", + "# transpiled_cir = transpile(\n", + "# q_walk_step,\n", + "# basis_gates=[\"u\", \"cx\"],\n", + "# optimization_level=transpilation_options[\"qiskit\"],\n", + "# )\n", + "# print(time.time()-start_time, \", \",num_qubits)\n", + "# print(transpiled_cir.depth())\n", + "# qiskit_depths.append(transpiled_cir.depth())\n", + "# qiskit_cx_counts.append(transpiled_cir.count_ops()[\"cx\"])\n", + "# qiskit_widths.append(transpiled_cir.width())\n", + "# qiskit_times.append(time.time()-start_time)\n", + "\n", + "\n", + "# print(qiskit_cx_counts)\n", + "# print(qiskit_depths)\n", + "# print(qiskit_widths)\n", + "# print(qiskit_times)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c209edb9-4c2c-4c58-b8e3-761d39a961f0", + "metadata": {}, + "outputs": [], + "source": [ + "num_qubits_classiq = range(NUM_QUBITS_MIN, NUM_QUBITS_MAX)\n", + "num_qubits_qiskit = num_qubits_classiq[0 : len(qiskit_cx_counts)]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "7657cf6b-26cd-486b-ac67-483f019b91ce", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "classiq_color = \"#119DA4\"\n", + "classiq_color_1 = \"#F43764\"\n", + "qiskit_color = \"#bb8bff\"\n", + "plt.rcParams[\"font.family\"] = \"serif\"\n", + "plt.rc(\"savefig\", dpi=300)\n", + "plt.rcParams[\"axes.linewidth\"] = 1\n", + "plt.rcParams[\"xtick.major.size\"] = 5\n", + "plt.rcParams[\"xtick.minor.size\"] = 5\n", + "plt.rcParams[\"ytick.major.size\"] = 5\n", + "plt.rcParams[\"ytick.minor.size\"] = 5\n", + "\n", + "(qiskit1,) = plt.semilogy(\n", + " num_qubits_qiskit,\n", + " qiskit_cx_counts,\n", + " \"-s\",\n", + " label=\"qiskit\",\n", + " markerfacecolor=qiskit_color,\n", + " markeredgecolor=\"k\",\n", + " markersize=6,\n", + " markeredgewidth=1.5,\n", + " color=qiskit_color,\n", + ")\n", + "\n", + "(classiq1,) = plt.semilogy(\n", + " num_qubits_classiq,\n", + " classiq_cx_counts_opt_width,\n", + " \"-D\",\n", + " label=\"classiq width opt.\",\n", + " markerfacecolor=classiq_color,\n", + " markeredgecolor=\"k\",\n", + " markersize=6.5,\n", + " markeredgewidth=1.5,\n", + " color=classiq_color,\n", + ")\n", + "\n", + "(classiq2,) = plt.semilogy(\n", + " num_qubits_classiq,\n", + " classiq_cx_counts_opt_cx,\n", + " \"-o\",\n", + " label=\"classiq cx opt.\",\n", + " markerfacecolor=classiq_color_1,\n", + " markeredgecolor=\"k\",\n", + " markersize=7,\n", + " markeredgewidth=1.5,\n", + " linewidth=1.5,\n", + " color=classiq_color_1,\n", + ")\n", + "\n", + "\n", + "first_legend = plt.legend(\n", + " handles=[qiskit1, classiq1, classiq2], fontsize=16, loc=\"upper left\"\n", + ")\n", + "\n", + "\n", + "plt.ylabel(\"CX-counts\", fontsize=16)\n", + "plt.xlabel(r\"$\\log_2$(Circle size)\", fontsize=16)\n", + "plt.yticks(fontsize=16)\n", + "plt.xticks(fontsize=16)\n", + "plt.axis(ymin=0.7e2, ymax=4e5, xmin=4, xmax=12)\n", + "\n", + "\n", + "for x, y, num_qubits in zip(\n", + " num_qubits_classiq, classiq_cx_counts_opt_width, classiq_widths_opt_width\n", + "):\n", + " plt.text(x * 0.94, y * 1.25, str(num_qubits), fontsize=16, color=classiq_color)\n", + "\n", + "for x, y, num_qubits in zip(\n", + " num_qubits_classiq,\n", + " classiq_cx_counts_opt_cx,\n", + " classiq_widths_opt_cx,\n", + "):\n", + " plt.text(x * 0.96, y * 1.25, str(num_qubits), fontsize=16, color=classiq_color_1)\n", + "for x, y, num_qubits in zip(num_qubits_qiskit, qiskit_cx_counts, qiskit_widths):\n", + " plt.text(x * 0.96, y * 1.2, str(num_qubits), fontsize=16, color=qiskit_color)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "3cadd644-9c60-4577-b766-21bc4728a8e8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "classiq_color = \"#119DA4\"\n", + "classiq_color_1 = \"#F43764\"\n", + "qiskit_color = \"#bb8bff\"\n", + "plt.rcParams[\"font.family\"] = \"serif\"\n", + "plt.rc(\"savefig\", dpi=300)\n", + "plt.rcParams[\"axes.linewidth\"] = 1\n", + "plt.rcParams[\"xtick.major.size\"] = 5\n", + "plt.rcParams[\"xtick.minor.size\"] = 5\n", + "plt.rcParams[\"ytick.major.size\"] = 5\n", + "plt.rcParams[\"ytick.minor.size\"] = 5\n", + "\n", + "(qiskit1,) = plt.semilogy(\n", + " num_qubits_qiskit,\n", + " qiskit_times,\n", + " \"-s\",\n", + " label=\"qiskit\",\n", + " markerfacecolor=qiskit_color,\n", + " markeredgecolor=\"k\",\n", + " markersize=6,\n", + " markeredgewidth=1.5,\n", + " color=qiskit_color,\n", + ")\n", + "\n", + "(classiq1,) = plt.semilogy(\n", + " num_qubits_classiq,\n", + " classiq_times_opt_width,\n", + " \"-D\",\n", + " label=\"classiq width opt.\",\n", + " markerfacecolor=classiq_color,\n", + " markeredgecolor=\"k\",\n", + " markersize=6.5,\n", + " markeredgewidth=1.5,\n", + " color=classiq_color,\n", + ")\n", + "\n", + "(classiq2,) = plt.semilogy(\n", + " num_qubits_classiq,\n", + " classiq_times_opt_cx,\n", + " \"-o\",\n", + " label=\"classiq cx opt.\",\n", + " markerfacecolor=classiq_color_1,\n", + " markeredgecolor=\"k\",\n", + " markersize=7,\n", + " markeredgewidth=1.5,\n", + " linewidth=1.5,\n", + " color=classiq_color_1,\n", + ")\n", + "\n", + "first_legend = plt.legend(\n", + " handles=[qiskit1, classiq1, classiq2], fontsize=16, loc=\"upper left\"\n", + ")\n", + "\n", + "\n", + "plt.ylabel(\"Generation time\", fontsize=16)\n", + "plt.xlabel(r\"$\\log_2$(Circle size)\", fontsize=16)\n", + "plt.yticks(fontsize=16)\n", + "plt.xticks(fontsize=16)\n", + "plt.axis(ymin=2e-1, ymax=2.5e4, xmin=4, xmax=12)\n", + "\n", + "\n", + "for x, y, num_qubits in zip(\n", + " num_qubits_classiq, classiq_times_opt_width, classiq_widths_opt_width\n", + "):\n", + " plt.text(x * 0.98, y * 1.4, str(num_qubits), fontsize=16, color=classiq_color)\n", + "\n", + "for x, y, num_qubits in zip(\n", + " num_qubits_classiq,\n", + " classiq_times_opt_cx,\n", + " classiq_widths_opt_cx,\n", + "):\n", + " plt.text(x * 0.96, y * 0.5, str(num_qubits), fontsize=16, color=classiq_color_1)\n", + "for x, y, num_qubits in zip(num_qubits_qiskit, qiskit_times, qiskit_widths):\n", + " plt.text(x * 0.94, y * 1.2, str(num_qubits), fontsize=16, color=qiskit_color)" + ] + }, + { + "cell_type": "markdown", + "id": "dbd2a879-61e3-48cb-8f42-4122bac5002e", + "metadata": {}, + "source": [ + "## Synthesizing large-scale examples\n", + "\n", + "We have extended the above model to larger and larger circle sizes. The results are saved in a `csv` file." + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "87c9a685-fa6c-47bf-8b96-6e2491a27c9b", + "metadata": {}, + "outputs": [], + "source": [ + "ind_for_plot = [0, 5, 10, 12, 14] + [k for k in range(15, 23)]" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "159ba8f0-eff7-4881-9624-28ef0b09262a", + "metadata": {}, + "outputs": [], + "source": [ + "import pathlib\n", + "\n", + "from pandas import *\n", + "\n", + "path = (\n", + " pathlib.Path(__file__).parent.resolve()\n", + " if \"__file__\" in locals()\n", + " else pathlib.Path(\".\")\n", + ")\n", + "input_file = path / \"results.csv\"\n", + "\n", + "# reading CSV file\n", + "data = read_csv(input_file) # this data is with cx optimization and max_width=100\n", + "\n", + "# converting column data to list\n", + "num_qubits_cx_opt = [data[\"log2_circle_size_cx_opt\"].tolist()[k] for k in ind_for_plot]\n", + "cx_cx_opt = [data[\"cx_cx_opt\"].tolist()[k] for k in ind_for_plot]\n", + "time_cx_opt = [data[\"time_cx_opt\"].tolist()[k] for k in ind_for_plot]\n", + "width_cx_opt = [data[\"width_cx_opt\"].tolist()[k] for k in ind_for_plot]\n", + "\n", + "# converting column data to list\n", + "num_qubits_width_opt = [\n", + " data[\"log2_circle_size_width_opt\"].tolist()[k] for k in ind_for_plot\n", + "]\n", + "cx_width_opt = [data[\"cx_width_opt\"].tolist()[k] for k in ind_for_plot]\n", + "time_width_opt = [data[\"time_width_opt\"].tolist()[k] for k in ind_for_plot]\n", + "width_width_opt = [data[\"width_width_opt\"].tolist()[k] for k in ind_for_plot]" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "5148b583-03bc-4be4-b112-e37097befbee", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "classiq_color = \"#119DA4\"\n", + "classiq_color_1 = \"#F43764\"\n", + "qiskit_color = \"#bb8bff\"\n", + "plt.rcParams[\"font.family\"] = \"serif\"\n", + "plt.rc(\"savefig\", dpi=300)\n", + "plt.rcParams[\"axes.linewidth\"] = 1\n", + "plt.rcParams[\"xtick.major.size\"] = 5\n", + "plt.rcParams[\"xtick.minor.size\"] = 5\n", + "plt.rcParams[\"ytick.major.size\"] = 5\n", + "plt.rcParams[\"ytick.minor.size\"] = 5\n", + "plt.figure(figsize=(8, 5))\n", + "\n", + "(qiskit1,) = plt.semilogy(\n", + " num_qubits_qiskit,\n", + " qiskit_cx_counts,\n", + " \"-s\",\n", + " label=\"qiskit\",\n", + " markerfacecolor=qiskit_color,\n", + " markeredgecolor=\"k\",\n", + " markersize=6,\n", + " markeredgewidth=1.5,\n", + " color=qiskit_color,\n", + ")\n", + "\n", + "(classiq1,) = plt.semilogy(\n", + " num_qubits_width_opt,\n", + " cx_width_opt,\n", + " \"-D\",\n", + " label=\"classiq width optimization\",\n", + " markerfacecolor=classiq_color,\n", + " markeredgecolor=\"k\",\n", + " markersize=6.5,\n", + " markeredgewidth=1.5,\n", + " color=classiq_color,\n", + ")\n", + "\n", + "(classiq2,) = plt.semilogy(\n", + " num_qubits_cx_opt,\n", + " cx_cx_opt,\n", + " \"-o\",\n", + " label=\"classiq cx optimization\",\n", + " markerfacecolor=classiq_color_1,\n", + " markeredgecolor=\"k\",\n", + " markersize=7,\n", + " markeredgewidth=1.5,\n", + " linewidth=1.5,\n", + " color=classiq_color_1,\n", + ")\n", + "\n", + "\n", + "first_legend = plt.legend(\n", + " handles=[qiskit1, classiq1, classiq2], fontsize=16, loc=\"lower right\"\n", + ")\n", + "\n", + "\n", + "plt.ylabel(\"CX-counts\", fontsize=16)\n", + "plt.xlabel(r\"$\\log_2$(Circle size)\", fontsize=16)\n", + "plt.yticks(fontsize=16)\n", + "plt.xticks(fontsize=16)\n", + "plt.axis(ymin=0.5e2, ymax=1e6, xmin=3, xmax=63)\n", + "# plt.xticks(num_qubits_opt_cx_max_width)\n", + "\n", + "\n", + "for x, y, num_qubits in zip(num_qubits_width_opt, cx_width_opt, width_width_opt):\n", + " plt.text(x * 1.01, y * 0.6, str(num_qubits), fontsize=15, color=classiq_color)\n", + "\n", + "for x, y, num_qubits in zip(\n", + " num_qubits_cx_opt,\n", + " cx_cx_opt,\n", + " width_cx_opt,\n", + "):\n", + " plt.text(x * 0.99, y * 0.45, str(num_qubits), fontsize=15, color=classiq_color_1)\n", + "for x, y, num_qubits in zip(num_qubits_qiskit, qiskit_cx_counts, qiskit_widths):\n", + " plt.text(x * 0.77, y * 1.2, str(num_qubits), fontsize=15, color=qiskit_color)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "4a8e71ba-b16f-4cf8-8f86-66841c9212fe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "classiq_color = \"#119DA4\"\n", + "classiq_color_1 = \"#F43764\"\n", + "qiskit_color = \"#bb8bff\"\n", + "plt.rcParams[\"font.family\"] = \"serif\"\n", + "plt.rc(\"savefig\", dpi=300)\n", + "plt.rcParams[\"axes.linewidth\"] = 1\n", + "plt.rcParams[\"xtick.major.size\"] = 5\n", + "plt.rcParams[\"xtick.minor.size\"] = 5\n", + "plt.rcParams[\"ytick.major.size\"] = 5\n", + "plt.rcParams[\"ytick.minor.size\"] = 5\n", + "plt.figure(figsize=(8, 5))\n", + "\n", + "\n", + "(qiskit1,) = plt.semilogy(\n", + " num_qubits_qiskit,\n", + " qiskit_times,\n", + " \"-s\",\n", + " label=\"qiskit\",\n", + " markerfacecolor=qiskit_color,\n", + " markeredgecolor=\"k\",\n", + " markersize=6,\n", + " markeredgewidth=1.5,\n", + " color=qiskit_color,\n", + ")\n", + "\n", + "(classiq1,) = plt.semilogy(\n", + " num_qubits_width_opt,\n", + " time_width_opt,\n", + " \"-D\",\n", + " label=\"classiq width optimization\",\n", + " markerfacecolor=classiq_color,\n", + " markeredgecolor=\"k\",\n", + " markersize=6.5,\n", + " markeredgewidth=1.5,\n", + " color=classiq_color,\n", + ")\n", + "\n", + "(classiq2,) = plt.semilogy(\n", + " num_qubits_cx_opt,\n", + " time_cx_opt,\n", + " \"-o\",\n", + " label=\"classiq cx optimization\",\n", + " markerfacecolor=classiq_color_1,\n", + " markeredgecolor=\"k\",\n", + " markersize=7,\n", + " markeredgewidth=1.5,\n", + " linewidth=1.5,\n", + " color=classiq_color_1,\n", + ")\n", + "\n", + "\n", + "first_legend = plt.legend(\n", + " handles=[qiskit1, classiq1, classiq2], fontsize=16, loc=\"lower right\"\n", + ")\n", + "\n", + "\n", + "plt.ylabel(\"Generation time [sec]\", fontsize=16)\n", + "plt.xlabel(r\"$\\log_2$(Circle size)\", fontsize=16)\n", + "plt.yticks(fontsize=16)\n", + "plt.xticks(fontsize=16)\n", + "plt.axis(ymin=0.2, ymax=8e3, xmin=3, xmax=63)\n", + "\n", + "\n", + "for x, y, num_qubits in zip(num_qubits_width_opt, time_width_opt, width_width_opt):\n", + " if num_qubits < 19:\n", + " plt.text(x * 0.8, y * 1.3, str(num_qubits), fontsize=15, color=classiq_color)\n", + " else:\n", + " plt.text(x * 0.95, y * 1.3, str(num_qubits), fontsize=15, color=classiq_color)\n", + "\n", + "for x, y, num_qubits in zip(\n", + " num_qubits_cx_opt,\n", + " time_cx_opt,\n", + " width_cx_opt,\n", + "):\n", + " plt.text(x * 1.0, y * 0.45, str(num_qubits), fontsize=15, color=classiq_color_1)\n", + "for x, y, num_qubits in zip(num_qubits_qiskit, qiskit_times, qiskit_widths):\n", + " plt.text(x * 0.72, y * 1.2, str(num_qubits), fontsize=15, color=qiskit_color)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88a73b4a-8782-4fc3-bf17-3d370279493f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/technology_demonstrations/discrete_quantum_walk_circle/results.csv b/tutorials/technology_demonstrations/discrete_quantum_walk_circle/results.csv new file mode 100644 index 00000000..7ba8252a --- /dev/null +++ b/tutorials/technology_demonstrations/discrete_quantum_walk_circle/results.csv @@ -0,0 +1,24 @@ +log2_circle_size_cx_opt,width_cx_opt,cx_cx_opt,time_cx_opt,,,,log2_circle_size_width_opt,width_width_opt,cx_width_opt,time_width_opt +5,8,120,1.030050755,,,,5,6,274,1.033107281 +6,9,152,1.549682856,,,,6,7,514,1.756486177 +7,11,200,2.408565044,,,,7,8,850,3.424333096 +8,12,260,3.318053246,,,,8,9,1298,7.059669018 +9,14,352,4.49042511,,,,9,10,1874,14.62335777 +10,15,436,6.236928225,,,,10,11,2594,30.57669568 +11,17,552,8.21525979,,,,11,13,3194,38.52312279 +12,18,632,10.4258492,,,,12,14,3914,121.3552897 +13,20,776,12.93056488,,,,13,15,5066,132.0802917 +14,21,836,16.34218383,,,,14,16,6378,138.0895779 +15,23,1004,19.96978807,,,,15,17,7850,144.433075 +16,24,1064,24.08605409,,,,16,18,9482,152.0853841 +17,26,1256,28.71955085,,,,17,19,11274,156.839324 +18,27,1312,33.7100358,,,,18,20,13418,167.8838196 +20,30,1588,45.90775609,,,,20,22,18762,191.7707002 +24,36,2564,81.53534484,,,,24,26,33674,277.2610381 +28,42,3668,136.5639482,,,,28,30,54026,390.1246259 +30,45,4324,167.5976551,,,,30,32,66122,426.9000242 +35,53,6088,298.3051138,,,,33,35,86666,498.2558219 +40,60,7704,475.1393759,,,,40,42,156554,819.1415811 +45,68,9984,715.2307372,,,,45,47,227594,1239.267411 +50,75,12092,1111.412863,,,,50,52,316170,1803.668634 +60,90,17148,1932.942601,,,,60,62,542090,3107.010131 diff --git a/tutorials/whats_classiq/whats_classiq.ipynb b/tutorials/whats_classiq/whats_classiq.ipynb new file mode 100644 index 00000000..ebb54993 --- /dev/null +++ b/tutorials/whats_classiq/whats_classiq.ipynb @@ -0,0 +1,276 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What's Classiq?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Your entry-point for creating & running quantum programs.\n", + "\n", + "Classiq allows you to [design](#design), [optimize](#optimization), [analyze](#analysis), and [execute](#execution) any quantum program. The platform is suited for quantum experts allowing flexible design and deep optimization of quantum programs. It is also a great way to learn quantum computing, with a [Library](https://github.com/Classiq/classiq-library) of algorithms and applications, and intuitive visualization.\n", + "\n", + "Classiq has two interfaces:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1.Web-based IDE at [platform.classiq.io](https://platform.classiq.io)\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2.Python SDK\n", + "\n", + "Quick installation via the command line:\n", + "\n", + "```bash\n", + "pip install classiq\n", + "```\n", + "\n", + "And authentication within Python:\n", + "\n", + "```Python\n", + "import classiq\n", + "classiq.authenticate()\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can transition directly between the two interfaces at any stage of the development. This allows you to do (almost) everything in the IDE or (almost) everything in the SDK, and combine and interchange between the two.\n", + "\n", + "Here is a high-level breakdown of the steps:\n", + "\n", + "1. [**Design**](#design) - write your quantum algorithm using Classiq's QMOD language. Qmod is built for describing quantum programs without pre determining the implementation details. It is intuitive and powerful.\n", + "2. [**Optimize**](#optimization) - Send your algorithm to Classiq's synthesis engine (compiler) that comes up with the optimal quantum program for your algorithm, according to the constraints and preferences you apply.\n", + "3. [**Analyze**](#analysis) the quantum program with the Classiq's visualizer tool in order to view the circuit level implementation of your algorithm.\n", + "4. [**Execute**](#execution) it on Classiq's simulators or on any quantum computer and simulators available via the cloud.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Design\n", + "\n", + "As developers, we are interested in the functionality of the quantum program. Classiq's Qmod language is designed to allow a full description of the program functionality, without determinting the implemtation details. This allows for a more flexible and powerful description of the quantum program, and later enables optimizing the program implementaion (see [optimization](#optimization))\n", + "\n", + "Classiq introduces a native quantum programming language, `Qmod`, that naturally captures the core concepts of quantum algorithms. There are two ways to design in `Qmod`:\n", + "\n", + "- Directly, via the Classiq IDE using the Qmod native syntax\n", + "\n", + "\n", + "\n", + "- With the Classiq Python SDK package that gives access to the Qmod language via Python" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Deutsch-Jozsa Algorithm\n", + "from classiq import *\n", + "\n", + "\n", + "@qfunc\n", + "def constant_function(x: QNum, res: QBit):\n", + " res ^= x < (2**x.size)\n", + "\n", + "\n", + "@qfunc\n", + "def prepare_minus(out: Output[QBit]):\n", + " allocate(1, out)\n", + " X(out)\n", + " H(out)\n", + "\n", + "\n", + "@qfunc\n", + "def apply_oracle(x: QNum):\n", + " aux = QBit(\"aux\")\n", + " within_apply(\n", + " compute=lambda: prepare_minus(aux), action=lambda: constant_function(x, aux)\n", + " )\n", + "\n", + "\n", + "@qfunc\n", + "def main(x: Output[QNum]):\n", + " allocate(4, x)\n", + " hadamard_transform(x)\n", + " apply_oracle(x)\n", + " hadamard_transform(x)\n", + "\n", + "\n", + "quantum_model = create_model(main)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimization\n", + "\n", + "Describing the program functionality without specifing the implementation is the only way forward. Most quantum algorithms and functional building blocks can be implemented in many ways, and a full program can be implemeted in countless possibilities. Some circuits have more auxiliary qubits that result in shorter circuit depth, others have a minimal number of qubits but longer circuits, some have all the qubits connected to each other, and others have limited connectivity. Implementation decisions are interconnected and must be managed globally.\n", + "\n", + "As developers, you want optimal implementation for your algorithms according to your definitions. The Classiq synthesis engine enables exactly this. You design your algorithm in Qmod and then you synthesize (compile) it with your constraints and preferences. Classiq's technology will output the best solution available." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "quantum_program = synthesize(quantum_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis\n", + "\n", + "Once a quantum program is created, no doubt you would like to analyze the result. Your questions could take different forms and levels of hierarchies.\n", + "\n", + "- Are the blocks connected in the right way?\n", + "- Are the auxiliary qubits reused as desired?\n", + "- What is the gate level implementation?\n", + "\n", + " The Classiq visualization tool allows explore these questions and is enabled by the high-level functional design of the quantum algorithm. You can access the tool directly in the IDE using the Quantum Program tab, or in the Python SDK using the `show(quantum_program)` command:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://platform.classiq.io/circuit/d8b09e26-17eb-4a4f-9bba-1390df4a8026?version=0.42.1\n" + ] + } + ], + "source": [ + "show(quantum_program)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Execution\n", + "\n", + "The final step of the quantum algorithm flow is running it to receive the results and then post-process them. There are two possibilities for quantum computing execution nowadays: on real quantum computers (QPU's) and on simulators (classical computers that simulate small quantum computers). With Classiq you can access both!\n", + "Several simulators are available for free with Classiq, and there is straightforward access to the majority of quantum processors and simulators available via the cloud through all major cloud providers such as IBM Quantum, Amazon Braket, and Azure Quantum.\n", + "You can send for execution directly in the IDE or via the SDK. In both cases, you can access all your jobs in the IDE Jobs tab." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ExecutionJob(id='ac0c5cd7-e0a2-4a36-891f-7121ad3b5a44')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "execute(quantum_program)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Getting Started\n", + "\n", + "- Continue on to [Classiq 101](./classiq_101/index.md)!\n", + "- A comprehensive [Library](https://github.com/Classiq/classiq-library) of examples, built with Classiq.\n", + "- Become part of the vibrant Classiq community by joining the [Classiq Community Slack](https://short.classiq.io/join-slack)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "write_qmod(quantum_model, \"whats_classiq\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.11.7 ('classiq_devolpment')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "e992e515f6583afc67b46eeabcda0f30363069fab8b382c7517b274ba7a59477" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/whats_classiq/whats_classiq.metadata.json b/tutorials/whats_classiq/whats_classiq.metadata.json new file mode 100644 index 00000000..e0233900 --- /dev/null +++ b/tutorials/whats_classiq/whats_classiq.metadata.json @@ -0,0 +1,7 @@ +{ + "friendly_name": "What's Classiq", + "description": "An Example of What is Classiq", + "problem_domain_tags": [], + "qmod_type": ["function"], + "level": ["basic", "demos"] +} diff --git a/tutorials/whats_classiq/whats_classiq.qmod b/tutorials/whats_classiq/whats_classiq.qmod new file mode 100644 index 00000000..1837939a --- /dev/null +++ b/tutorials/whats_classiq/whats_classiq.qmod @@ -0,0 +1,25 @@ +qfunc prepare_minus(output out: qbit) { + allocate<1>(out); + X(out); + H(out); +} + +qfunc constant_function(x: qnum, res: qbit) { + res ^= x < (2 ** x.size); +} + +qfunc apply_oracle(x: qnum) { + aux: qbit; + within { + prepare_minus(aux); + } apply { + constant_function(x, aux); + } +} + +qfunc main(output x: qnum) { + allocate<4>(x); + hadamard_transform(x); + apply_oracle(x); + hadamard_transform(x); +} diff --git a/tutorials/whats_classiq/whats_classiq.synthesis_options.json b/tutorials/whats_classiq/whats_classiq.synthesis_options.json new file mode 100644 index 00000000..0967ef42 --- /dev/null +++ b/tutorials/whats_classiq/whats_classiq.synthesis_options.json @@ -0,0 +1 @@ +{} diff --git a/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_1.ipynb b/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_1.ipynb index ac0da829..a3e1d1c1 100644 --- a/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_1.ipynb +++ b/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_1.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# The Qmod Workshop - Introduction\n", + "# The Qmod Workshop - Part 1: Introduction\n", "\n", "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", "\n", @@ -24,7 +24,7 @@ "\n", "Make sure you have a Python version of 3.8 through 3.11 installed. Unfortunately, Classiq is not yet supported with Python 3.12.\n", "\n", - "Install Classiq\u2019s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/reference-manual/platform/synthesis/getting-started/).\n", + "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/reference-manual/platform/synthesis/getting-started/).\n", "\n", "### Python Qmod Exercises - General Instructions\n", "\n", @@ -305,7 +305,7 @@ "\n", "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq\u2019s IDE in both cases.\n", + "3. Compare the gate count via the Classiq’s IDE in both cases.\n", "\n", "Note - the signature of function `unitary` is:" ] @@ -799,7 +799,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.11.7 ('classiq')", "language": "python", "name": "python3" }, @@ -813,7 +813,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" + }, + "vscode": { + "interpreter": { + "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" + } } }, "nbformat": 4, diff --git a/community/QClass_2024/Submissions/HW2/Jose_Alejandro_Garcia_Gonzalez_HW2_QClass2024.ipynb b/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_2.ipynb similarity index 68% rename from community/QClass_2024/Submissions/HW2/Jose_Alejandro_Garcia_Gonzalez_HW2_QClass2024.ipynb rename to tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_2.ipynb index d033044c..ff714511 100644 --- a/community/QClass_2024/Submissions/HW2/Jose_Alejandro_Garcia_Gonzalez_HW2_QClass2024.ipynb +++ b/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_2.ipynb @@ -9,15 +9,6 @@ "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." ] }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -26,18 +17,23 @@ "\n", "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", "\n", - "See also [Classical Types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/classical-types/#structs).\n", + "See also [Classical Types](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/classical-types/#structs).\n", "\n", "The builtin struct type `PauliTerm` is defined as follows:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "@struct\n", + "from dataclasses import dataclass\n", + "\n", + "from classiq import *\n", + "\n", + "\n", + "@dataclass\n", "class PauliTerm:\n", " pauli: CArray[Pauli]\n", " coefficient: CReal" @@ -58,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -77,19 +73,30 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" + "Allocate q and invoke the suzuki_trotter quantum function to complete this exercise:\n", + "\n", + "
\n", + " HINT\n", + " suzuki_trotter(
\n", + "  ...,
\n", + "  evolution_coefficient=3,
\n", + "  repetitions=4,
\n", + "  order=2,
\n", + "  qbv=q,
\n", + " )\n", + "
" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/55b5f10c-e720-4fe1-a8e4-7b6a578daacb?version=0.41.0\n" + "Opening: https://platform.classiq.io/circuit/1bb9845d-ce2f-40ff-b47b-b0e1dcc53137?version=0.42.1\n" ] } ], @@ -100,17 +107,6 @@ "@qfunc\n", "def main(q: Output[QArray[QBit]]) -> None:\n", " allocate(4, q)\n", - " suzuki_trotter(\n", - " [\n", - " PauliTerm(pauli=[Pauli.X, Pauli.Z, Pauli.X, Pauli.X], coefficient=0.5),\n", - " PauliTerm(pauli=[Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], coefficient=0.25),\n", - " PauliTerm(pauli=[Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], coefficient=0.3)\n", - " ],\n", - " evolution_coefficient=3,\n", - " repetitions=4,\n", - " order=2,\n", - " qbv=q,\n", - " )\n", "\n", "\n", "qmod = create_model(main)\n", @@ -127,8 +123,8 @@ "#### Exercise 7a\n", "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/quantum-types/#syntax).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/)\n", + "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/quantum-types/#syntax).\n", + "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/numeric-assignment/).\n", "\n", "Create the following quantum programs:\n", "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", @@ -142,146 +138,68 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/cb946f5f-e9ee-4438-becb-16e975c37705?version=0.41.0\n" - ] - } - ], + "outputs": [], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - "\n", - " res |= x + y\n", - "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", "show(qprog)" ] }, { - "cell_type": "code", - "execution_count": 4, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/c46f34d4-8a17-4a44-be45-4e0029b58287?version=0.41.0\n" - ] - } - ], "source": [ - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", + "#### Exercise 7b\n", + "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", "\n", - " res |= x * y\n", + "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" + "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", + " The declaration of the `prepare_state` function is:\n", + " " ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/9d3d77fd-6cbc-4f82-a7aa-d0388fc46765?version=0.41.0\n" - ] - } - ], + "outputs": [], "source": [ - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " prepare_int(2,x)\n", - " prepare_int(7,y)\n", - " prepare_int(1,z)\n", - "\n", - " res |= x * y -z\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" + "@qfunc(external=True)\n", + "def prepare_state(\n", + " probabilities: CArray[CReal],\n", + " bound: CReal,\n", + " out: Output[QArray[QBit]],\n", + ") -> None:\n", + " pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", + "
HintSet the bound to 0 in your code
\n", "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", + " \n", "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/56dc413c-5d6d-4c88-bc43-3264f5586a9b?version=0.41.0\n" - ] - } - ], + "outputs": [], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum('x')\n", - " y = QNum('y')\n", - " \n", - " prepare_state(probabilities=[0.5,0,0.5,0], bound=0, out=x)\n", - " prepare_state(probabilities=[0,0.25,0.25,0.25,0,0,0.25,0], bound=0, out=y)\n", - " \n", - " res|=x+y\n", - "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", "show(qprog)" @@ -296,7 +214,7 @@ "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", "\n", - "See also [Within Apply](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/within-apply/).\n", + "See also [Within Apply](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/within-apply/).\n", "\n", "#### Exercise 8a\n", "\n", @@ -319,46 +237,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "@qfunc\n", - "def two_sum(x: QNum, y:QNum, res: Output[QNum]):\n", - " res |= x + y" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/4eaeaa8c-b09c-42be-b22f-bae19c70a79c?version=0.41.0\n" - ] - } - ], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " tmp = QNum(\"tmp\")\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - "\n", - " within_apply(compute= lambda: two_sum(x,y,tmp),\n", - " action= lambda: two_sum(tmp,z,res))\n", - "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", "show(qprog)" @@ -374,7 +260,7 @@ "To understand the motivation, we will create another arithmetic circuit.\n", "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/user-guide/platform/synthesis/constraints/).\n", + "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/reference-manual/platform/synthesis/constraints/).\n", "\n", "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", "\n", @@ -388,14 +274,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/38f6ea92-94c2-472b-a201-f212b27fc174?version=0.41.0\n" + "Opening: https://platform.classiq.io/circuit/c2147d5f-03da-46f9-abb9-9f224cf494b5?version=0.42.1\n" ] } ], @@ -404,50 +290,11 @@ "\n", "# Your code here:\n", "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " w = QNum(\"w\")\n", - " tmp = QNum(\"tmp\")\n", - " aux = QNum(\"aux\")\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - " prepare_int(4,w)\n", - "\n", - " within_apply(compute= lambda: two_sum(x,y,tmp),\n", - " action= lambda: two_sum(tmp,z,aux))\n", - "\n", - " two_sum(aux,w,res)\n", - "\n", "qmod = create_model(main)\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", "qprog = synthesize(qmod)\n", "show(qprog)" ] }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'res': 14.0}\n" - ] - } - ], - "source": [ - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "for sampled_state in parsed_counts: print(sampled_state.state)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -462,37 +309,15 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/03a039ad-4fd8-4e63-b6a1-176853a3c1e2?version=0.41.0\n" - ] - } - ], + "outputs": [], "source": [ "from classiq import *\n", "\n", "# Your code here:\n", "\n", - "@qfunc\n", - "def main(res: Output[QNum]):\n", - " x = QNum(\"x\")\n", - " y = QNum(\"y\")\n", - " z = QNum(\"z\")\n", - " w = QNum(\"w\")\n", - " prepare_int(3,x)\n", - " prepare_int(5,y)\n", - " prepare_int(2,z)\n", - " prepare_int(4,w)\n", - "\n", - " res |= x + y + z + w\n", - "\n", "qmod = create_model(main)\n", - "qmod = set_constraints(qmod,Constraints(optimization_parameter='width'))\n", "qprog = synthesize(qmod)\n", "show(qprog)" ] @@ -507,7 +332,7 @@ "\n", "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", "\n", - "See also [Numeric assignment](https://docs.classiq.io/latest/user-guide/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", + "See also [Numeric assignment](https://docs.classiq.io/latest/reference-manual/platform/qmod/language-reference/statements/numeric-assignment/#semantics).\n", "\n", "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", "\n", @@ -522,31 +347,28 @@ "\n", "Notes:\n", "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" + "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n", + "\n", + "\n", + "
\n", + " Hint\n", + " dup_msb(x, label)
\n", + " control(label, ...) # 0.5 <= x < 1.0
\n", + " X(label)
\n", + " control(label, ...) # 0.0 <= x < 0.5
\n", + "
\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/48c90466-85ee-43e2-a3d0-af881d387b26?version=0.41.0\n" - ] - } - ], + "outputs": [], "source": [ - "\n", "from classiq import *\n", "\n", "\n", - "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", - " res ^= a * x + b\n", - "\n", - "\n", "@qfunc\n", "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", " CX(qba[qba.len - 1], msb)\n", @@ -560,11 +382,7 @@ "\n", " label = QArray(\"label\")\n", " allocate(1, label)\n", - "\n", - " dup_msb(x, label)\n", - " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", - " X(label)\n", - " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5\n", + " # Your code here:\n", "\n", "\n", "qmod = create_model(main)\n", @@ -572,33 +390,6 @@ "show(qprog)" ] }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'x': 0.375, 'res': 1.75}\n", - "{'x': 0.875, 'res': 1.375}\n", - "{'x': 0.0, 'res': 1.0}\n", - "{'x': 0.25, 'res': 1.5}\n", - "{'x': 0.75, 'res': 1.25}\n", - "{'x': 0.125, 'res': 1.25}\n", - "{'x': 0.625, 'res': 1.125}\n", - "{'x': 0.5, 'res': 1.0}\n" - ] - } - ], - "source": [ - "job = execute(qprog)\n", - "results = job.result()\n", - "parsed_counts = results[0].value.parsed_counts\n", - "for sampled_state in parsed_counts: print(sampled_state.state)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -611,14 +402,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/5da59760-3885-464e-9a92-758afc1042e8?version=0.41.0\n" + "Opening: https://platform.classiq.io/circuit/ac3ae5f1-7af8-46d6-ac00-aead9e95ecbd?version=0.42.1\n" ] } ], @@ -626,25 +417,18 @@ "from classiq import *\n", "\n", "\n", - "\n", - "from classiq import *\n", - "from math import pi\n", - "\n", - "\n", "@qfunc\n", "def main(res: Output[QArray[QBit]]) -> None:\n", " x: QArray[QBit] = QArray(\"x\")\n", " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", + " ...\n", " lsb = QBit(\"lsb\")\n", " msb = QNum(\"msb\", 2, False, 0)\n", " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 1, lambda: RY(pi / 3, lsb)) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", + " ...\n", " bind([lsb, msb], res)\n", "\n", + "\n", "model = create_model(main)\n", "qprog = synthesize(model)\n", "show(qprog)" @@ -679,57 +463,14 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/049103a2-7920-4a88-8ac7-3d4199be67e9?version=0.41.0\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(msb == 2, lambda: RY(pi / 3, lsb)) # msb==2 <==> bit1 bit2 == 10 (binary of decimal 2)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from classiq import *\n", "from classiq.qmod.symbolic import sqrt\n", "\n", - "prob_list= [\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " -sqrt(3) / 16,\n", - " 1 / 8 + sqrt(3) / 16,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " 1 / 8,\n", - " ]\n", + "\n", "@qfunc\n", "def pre_prepared_state(q: QArray[QBit]) -> None:\n", " prepare_state(\n", @@ -751,11 +492,282 @@ "\n", "# Your code here:" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solutions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 6" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution to exercise 6:\n", + "\n", + "\n", + "from classiq import *\n", + "\n", + "\n", + "@qfunc\n", + "def main(q: Output[QArray[QBit]]) -> None:\n", + " allocate(4, q)\n", + " suzuki_trotter(\n", + " [\n", + " PauliTerm([Pauli.X, Pauli.Z, Pauli.X, Pauli.X], 0.5),\n", + " PauliTerm([Pauli.Y, Pauli.I, Pauli.Z, Pauli.I], 0.25),\n", + " PauliTerm([Pauli.X, Pauli.I, Pauli.Z, Pauli.Y], 0.3),\n", + " ],\n", + " evolution_coefficient=3,\n", + " repetitions=4,\n", + " order=2,\n", + " qbv=q,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 7" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution to exercise 7a:\n", + "\n", + "\n", + "from classiq import *\n", + "\n", + "\n", + "@qfunc\n", + "def main(res: Output[QNum]) -> None:\n", + " x = QNum(\"x\")\n", + " y = QNum(\"y\")\n", + " z = QNum(\"z\")\n", + " prepare_int(2, x)\n", + " prepare_int(7, y)\n", + " prepare_int(1, z)\n", + " res |= x + y\n", + " # res |= x * y\n", + " # res |= x * y - z" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution to exercise 7b:\n", + "\n", + "\n", + "from classiq import *\n", + "\n", + "\n", + "@qfunc\n", + "def main(res: Output[QNum]) -> None:\n", + " x = QNum(\"x\")\n", + " y = QNum(\"y\")\n", + " prepare_state([0.5, 0, 0.5, 0.0], 0.0, x)\n", + " prepare_state([0, 0.25, 0.25, 0.25, 0.0, 0.0, 0.25, 0.0], 0.0, y)\n", + " res |= x + y\n", + "\n", + "\n", + "model = create_model(main)\n", + "qprog = synthesize(model)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution to exercise 8:\n", + "\n", + "\n", + "from classiq import *\n", + "\n", + "\n", + "@qfunc\n", + "def my_add(x: QNum, y: QNum, res: Output[QNum]) -> None:\n", + " res |= x + y\n", + "\n", + "\n", + "@qfunc\n", + "def main(res: Output[QNum]) -> None:\n", + " x = QNum(\"x\")\n", + " y = QNum(\"y\")\n", + " z = QNum(\"z\")\n", + " prepare_int(3, x)\n", + " prepare_int(5, y)\n", + " prepare_int(2, z)\n", + "\n", + " temp = QNum(\"temp\")\n", + " within_apply(\n", + " compute=lambda: my_add(x, y, temp), action=lambda: my_add(temp, z, res)\n", + " )\n", + "\n", + "\n", + "model = create_model(main)\n", + "qprog = synthesize(model)\n", + "show(qprog)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution to the advanced part of exercise 8:\n", + "\n", + "\n", + "from classiq import *\n", + "\n", + "\n", + "@qfunc\n", + "def my_add(x: QNum, y: QNum, res: Output[QNum]) -> None:\n", + " res |= x + y\n", + "\n", + "\n", + "@qfunc\n", + "def main(res: Output[QNum]) -> None:\n", + " x = QNum(\"x\")\n", + " y = QNum(\"y\")\n", + " z = QNum(\"z\")\n", + " w = QNum(\"w\")\n", + " prepare_int(3, x)\n", + " prepare_int(5, y)\n", + " prepare_int(2, z)\n", + " prepare_int(4, w)\n", + "\n", + " temp_xy = QNum(\"temp_xy\")\n", + " xyz = QNum(\"xyz\")\n", + " within_apply(\n", + " compute=lambda: my_add(x, y, temp_xy), action=lambda: my_add(temp_xy, z, xyz)\n", + " )\n", + " res |= xyz + w\n", + "\n", + "\n", + "model = create_model(main)\n", + "model = set_constraints(\n", + " model, Constraints(optimization_parameter=OptimizationParameter.WIDTH)\n", + ")\n", + "qprog = synthesize(model)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 9" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution to exercise 9:\n", + "\n", + "\n", + "from classiq import *\n", + "\n", + "\n", + "def linear_func(a: float, b: float, x: QNum, res: QNum) -> None:\n", + " res ^= a * x + b\n", + "\n", + "\n", + "@qfunc\n", + "def dup_msb(qba: QArray[QBit], msb: QBit) -> None:\n", + " CX(qba[qba.len - 1], msb)\n", + "\n", + "\n", + "@qfunc\n", + "def main(x: Output[QNum[3, False, 3]], res: Output[QNum[5, False, 3]]) -> None:\n", + " allocate(5, res)\n", + " allocate(3, x)\n", + " hadamard_transform(x)\n", + "\n", + " label = QArray(\"label\")\n", + " allocate(1, label)\n", + "\n", + " dup_msb(x, label)\n", + " control(label, lambda: linear_func(1.0, 0.5, x, res)) # 0.5 <= x < 1.0\n", + " X(label)\n", + " control(label, lambda: linear_func(2.0, 1.0, x, res)) # 0.0 <= x < 0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution to exercise 10:\n", + "\n", + "\n", + "from classiq import *\n", + "from classiq.qmod.symbolic import pi\n", + "\n", + "\n", + "@qfunc\n", + "def main(res: Output[QArray[QBit]]) -> None:\n", + " x: QArray[QBit] = QArray(\"x\")\n", + " allocate(3, x)\n", + " hadamard_transform(x)\n", + "\n", + " lsb = QBit(\"lsb\")\n", + " msb = QNum(\"msb\", 2, False, 0)\n", + " bind(x, [lsb, msb])\n", + "\n", + " control(msb == 1, lambda: RY(pi / 3, lsb))\n", + "\n", + " bind([lsb, msb], res)\n", + "\n", + "\n", + "model = create_model(main)\n", + "qprog = synthesize(model)\n", + "show(qprog)" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.11.7 ('classiq_devolpment')", "language": "python", "name": "python3" }, @@ -769,9 +781,14 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.7" + }, + "vscode": { + "interpreter": { + "hash": "e992e515f6583afc67b46eeabcda0f30363069fab8b382c7517b274ba7a59477" + } } }, "nbformat": 4, - "nbformat_minor": 4 + "nbformat_minor": 0 } diff --git a/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_3.ipynb b/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_3.ipynb new file mode 100644 index 00000000..273b6d1f --- /dev/null +++ b/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_3.ipynb @@ -0,0 +1,634 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The Qmod Workshop - Part 3: Execution Flows\n", + "\n", + "This is the third part of the Qmod workshop, covering exercises 11 and 12. Make sure to go through Part 1 and 2 before continuing with this notebook." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 11 - Execution with Parameters\n", + "\n", + "In this exercise, we will modify the manually created state preparation function from the previous exercise to accept a rotation angle as a parameter.\n", + "\n", + "1. Start by modifying the signature of the main function to be as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import *\n", + "from classiq.qmod.symbolic import pi\n", + "\n", + "\n", + "@qfunc\n", + "def main(rotation_angle: CReal, res: Output[QArray[QBit]]) -> None:\n", + " allocate(1, res)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Pass the rotation angle as a parameter to the controlled RY instead of using `pi/3` directly.\n", + "3. Define the following quantum constant, which will serve as the list of execution parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "angle_vals = QConstant(\"angle_vals\", List[float], [pi / 3, pi / 2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Create a cmain function that for each rotation angle, it calls the sample function and saves the result.\n", + "5. Execute the circuit and make sure the results are as expected (statistics from two runs should appear. What happens for `pi/2`?).\n", + "6. **Bonus**: try to add other values to the list and observe the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import *\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " # Your code here:\n", + " pass\n", + "\n", + "\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 12 - VQE\n", + "\n", + "The Variational Quantum Eigensolver is an algorithm that finds the minimal eigenvalue of a matrix by executing a parametric circuit (also referred to as an ansatz), estimating the expected value of the matrix for the state the circuit creates (from the distribution received by the execution), and using a classical optimizer to select the next set of parameters for the circuit, until reaching convergence (or exceeding a set amount of maximum iterations).\n", + "\n", + "The estimation of the expectation value is done on Pauli based matrices, so any matrix we want to perform this operation on, need to be decomposed into a sum of Pauli terms.\n", + "\n", + "In this exercise, we will create a simple VQE algorithm that estimates the minimal eigenvalue of a 2x2 matrix.\n", + "Fill in the gaps in the following snippet to find the minimal eigenvalue and it corresponding eigenstate for\n", + "\n", + "`[[1, -1], [-1, 0]] = 1/2*I + 1/2*Z - X`\n", + "\n", + "
Hint for HamiltonianHAMILTONIAN = QConstant(...)
\n", + "
Hint for cmain\n", + "res = vqe(
\n", + "  hamiltonian=...,
\n", + "  maximize=...,
\n", + "  initial_point=[],
\n", + "  optimizer=Optimizer.COBYLA,
\n", + "  max_iteration=1000,
\n", + "  tolerance=0.001,
\n", + "  step_size=0,
\n", + "  skip_compute_variance=False,
\n", + "  alpha_cvar=1.0,
\n", + " )
\n", + " save({\"result\": res})
\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from classiq import *\n", + "\n", + "# Your code here:\n", + "\n", + "\n", + "@qfunc\n", + "def main(q: Output[QBit], angles: CArray[CReal, 3]) -> None:\n", + " allocate(1, q)\n", + " U(angles[0], angles[1], angles[2], 0, q)\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " # Your code here\n", + " pass\n", + "\n", + "\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "res = execute(qprog)\n", + "\n", + "# TODO: Upon completion uncomment the code below\n", + "# vqe_result = res.result()[0].value\n", + "# print(vqe_result.energy, vqe_result.optimal_parameters, vqe_result.eigenstate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note:\n", + "The U gate is a general rotation matrix on a single qubit, so the given model creates an ansatz that spans all of the space for a single qubit, and thus gives us a full search space for this specific problem." + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Bonus: Exercise 13 - Quantum Counting with Iterative Quantum Amplitude Estimation\n", + "\n", + "Quantum Counting algorithm is an algorithm for efficiently estimating the number of valid solutions to a search problem, based on the amplitude estimation algorithm. It demonstrates a quadratic improvement in regard to a classical algorithm with black-box oracle access to the function $f$.\n", + "\n", + "More precisely, the counting problem is, given a boolean function $f :\\{0, 1\\}^n\\rightarrow\\{0,1\\}$, estimate the number of inputs $x$ to $f$ such that $f(x)=1$.\n", + "\n", + "Let's demonstrate how to estimate the Counting problem using a specific variant of the Amplitude Estimation algorithm - the Iterative Quantum Amplitude Estimation (IQAE).\n", + "\n", + "The IQAE does not rely on the [Quantum Phase Estimation](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb) algorithm, but purely on applications of the [grover operator](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.ipynb):\n", + "$$\n", + "Q\\equiv - A S_0 A^{\\dagger} S_{\\psi_1},\n", + "$$\n", + "Hence reducing the required amount of qubits and gates of the circuit, at the expense of additional multiplicative factor poly-logarithmic in the error $\\epsilon$.\n", + "\n", + "For that we need a state preparation with an indicator qubit point the valid solution among the states:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "from classiq import QArray, QBit, QNum, bind, hadamard_transform, qfunc\n", + "\n", + "A_SIZE = 2\n", + "B_SIZE = 2\n", + "DOMAIN_SIZE = A_SIZE + B_SIZE\n", + "\n", + "\n", + "@qfunc\n", + "def arith_equation(a: QNum, b: QNum, res: QBit):\n", + " res ^= a + b <= 2\n", + "\n", + "\n", + "@qfunc\n", + "def iqae_state_preparation(a: QNum, b: QNum, res: QBit):\n", + " reg = QArray(\"reg\")\n", + " bind([a, b, res], reg)\n", + " hadamard_transform(reg[0:DOMAIN_SIZE])\n", + " bind(reg, [a, b, res])\n", + " arith_equation(a, b, res)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Then, the quantum circuit that is needed to the iterative QAE scheme, which needs to apply powers of the grover operator:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "from classiq import CInt, QCallable, grover_operator, power\n", + "\n", + "\n", + "@qfunc\n", + "def my_iqae_algorithm(\n", + " k: CInt,\n", + " oracle_operand: QCallable[QArray[QBit]],\n", + " sp_operand: QCallable[QArray[QBit]],\n", + " x: QArray[QBit],\n", + "):\n", + " sp_operand(x)\n", + " power(k, lambda: grover_operator(oracle_operand, sp_operand, x))" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Now, after we already know how to attach execution parameters, let's build a parametric main, and a cmain assigning values to the parameters, in order to actually run hybrid execution algorithm.\n", + "So the parametric main should get as an input a parameter named `k`:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "from classiq import Output, Z, allocate\n", + "\n", + "\n", + "@qfunc\n", + "def main(\n", + " k: CInt,\n", + " ind_reg: Output[QBit],\n", + ") -> None:\n", + " full_reg = QArray(\"full_reg\")\n", + " allocate(DOMAIN_SIZE + 1, full_reg)\n", + " my_iqae_algorithm(\n", + " k=k,\n", + " oracle_operand=lambda x: Z(x[x.len - 1]),\n", + " sp_operand=lambda x: iqae_state_preparation(\n", + " x[0:A_SIZE], x[A_SIZE : x.len - 1], x[x.len - 1]\n", + " ),\n", + " x=full_reg,\n", + " )\n", + " state_reg = QArray(\"state_reg\", length=DOMAIN_SIZE)\n", + " bind(full_reg, [state_reg, ind_reg])" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "And the `cmain` will attach the relevant `k`, behind the scenes, all you need is:\n", + "* Call `iqae` in `cmain`, with the required `epsilon=1 / ((2**DOMAIN_SIZE_QCONST) * 2)` and `alpha=0.01`.\n", + "* Save its result into a variable named `iqae_res` using `save`.\n", + "\n", + "Fill in the `cmain`:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "from classiq import QConstant, bind, cfunc, iqae, save\n", + "\n", + "DOMAIN_SIZE_QCONST = QConstant(\"DOMAIN_SIZE_QCONST\", int, DOMAIN_SIZE)\n", + "\n", + "\n", + "@cfunc\n", + "def cmain():\n", + " # your code\n", + " pass" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Now let's run it and examine how many results apply the condition `a+b<=2` (there should be 6 of them: (a,b)=(0,0),(0,1),(1,0),(1,1),(2,0),(0,2))." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "from classiq import Constraints, create_model, show, synthesize\n", + "\n", + "constraints = Constraints(optimization_parameter=\"width\")\n", + "qmod_iqae = create_model(\n", + " entry_point=main,\n", + " constraints=constraints,\n", + " classical_execution_function=cmain,\n", + ")\n", + "\n", + "qprog_iqae = synthesize(qmod_iqae)\n", + "show(qprog_iqae)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "**Uncomment this cell and run it after completing the `cmain` function**." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# from classiq import execute\n", + "\n", + "# res = execute(qprog_iqae).result()\n", + "\n", + "# iqae_res = res[0].value\n", + "# print(\n", + "# f\"IQAE result: {iqae_res.estimation}, confidence interval: {iqae_res.confidence_interval}\"\n", + "# )\n", + "\n", + "# print(\n", + "# f\"Number of solutions: {(2**DOMAIN_SIZE) * iqae_res.estimation}, accuracy: \"\n", + "# f\"{(2**DOMAIN_SIZE)*(iqae_res.confidence_interval[1]-iqae_res.confidence_interval[0])}\"\n", + "# )" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solutions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 11" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution to exercise 11:\n", + "\n", + "\n", + "from typing import List\n", + "\n", + "from classiq import *\n", + "from classiq.qmod.symbolic import pi\n", + "\n", + "\n", + "@qfunc\n", + "def main(rotation_angle: CReal, res: Output[QArray[QBit]]) -> None:\n", + " x: QArray[QBit] = QArray(\"x\")\n", + " allocate(3, x)\n", + " hadamard_transform(x)\n", + "\n", + " ls_bit = QBit(\"ls_bit\")\n", + " ms_bits = QNum(\"ms_bits\", 2, False, 0)\n", + " bind(x, [ls_bit, ms_bits])\n", + "\n", + " control(ms_bits == 1, lambda: RY(rotation_angle, ls_bit))\n", + "\n", + " bind([ls_bit, ms_bits], res)\n", + "\n", + "\n", + "angle_vals = QConstant(\"angle_vals\", List[float], [pi / 3, pi / 2])\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + "\n", + " result = sample({\"rotation_angle\": pi / 3})\n", + " save({\"result\": result})\n", + " result = sample({\"rotation_angle\": pi / 2})\n", + " save({\"result\": result})\n", + "\n", + "\n", + "model = create_model(main, classical_execution_function=cmain)\n", + "qprog = synthesize(model)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 12" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Solution to exercise 12:\n", + "\n", + "\n", + "from typing import List\n", + "\n", + "from classiq import *\n", + "\n", + "HAMILTONIAN = QConstant(\n", + " \"HAMILTONIAN\",\n", + " List[PauliTerm],\n", + " [PauliTerm([Pauli.I], 0.5), PauliTerm([Pauli.Z], 0.5), PauliTerm([Pauli.X], -1.0)],\n", + ")\n", + "\n", + "\n", + "@qfunc\n", + "def main(q: Output[QBit], angles: CArray[CReal, 3]) -> None:\n", + " allocate(1, q)\n", + " U(angles[0], angles[1], angles[2], 0, q)\n", + "\n", + "\n", + "@cfunc\n", + "def cmain() -> None:\n", + " res = vqe(\n", + " HAMILTONIAN,\n", + " False,\n", + " [],\n", + " optimizer=Optimizer.COBYLA,\n", + " max_iteration=1000,\n", + " tolerance=0.001,\n", + " step_size=0,\n", + " skip_compute_variance=False,\n", + " alpha_cvar=1.0,\n", + " )\n", + " save({\"result\": res})\n", + "\n", + "\n", + "qmod = create_model(main, classical_execution_function=cmain)\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "res = execute(qprog)\n", + "vqe_result = res.result()[0].value\n", + "print(vqe_result.energy, vqe_result.optimal_parameters, vqe_result.eigenstate)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Exercise 13\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "from classiq import QArray, QBit, QCallable, QNum, bind, hadamard_transform, qfunc\n", + "\n", + "A_SIZE = 2\n", + "B_SIZE = 2\n", + "DOMAIN_SIZE = A_SIZE + B_SIZE\n", + "\n", + "\n", + "@qfunc\n", + "def arith_equation(a: QNum, b: QNum, res: QBit):\n", + " res ^= a + b <= 2\n", + "\n", + "\n", + "@qfunc\n", + "def iqae_state_preparation(a: QNum, b: QNum, res: QBit):\n", + " reg = QArray(\"reg\")\n", + " bind([a, b, res], reg)\n", + " hadamard_transform(reg[0:DOMAIN_SIZE])\n", + " bind(reg, [a, b, res])\n", + " arith_equation(a, b, res)\n", + "\n", + "\n", + "from classiq import CInt, grover_operator, power\n", + "\n", + "\n", + "@qfunc\n", + "def my_iqae_algorithm(\n", + " k: CInt,\n", + " oracle_operand: QCallable[QArray[QBit]],\n", + " sp_operand: QCallable[QArray[QBit]],\n", + " x: QArray[QBit],\n", + "):\n", + " sp_operand(x)\n", + " power(k, lambda: grover_operator(oracle_operand, sp_operand, x))\n", + "\n", + "\n", + "from classiq import Output, Z, allocate\n", + "\n", + "\n", + "@qfunc\n", + "def main(\n", + " k: CInt,\n", + " ind_reg: Output[QBit],\n", + ") -> None:\n", + " full_reg = QArray(\"full_reg\")\n", + " allocate(DOMAIN_SIZE + 1, full_reg)\n", + " my_iqae_algorithm(\n", + " k=k,\n", + " oracle_operand=lambda x: Z(x[x.len - 1]),\n", + " sp_operand=lambda x: iqae_state_preparation(\n", + " x[0:A_SIZE], x[A_SIZE : x.len - 1], x[x.len - 1]\n", + " ),\n", + " x=full_reg,\n", + " )\n", + " state_reg = QArray(\"state_reg\", length=DOMAIN_SIZE)\n", + " bind(full_reg, [state_reg, ind_reg])\n", + "\n", + "\n", + "from classiq import QConstant, bind, cfunc, iqae, save\n", + "\n", + "DOMAIN_SIZE_QCONST = QConstant(\"DOMAIN_SIZE_QCONST\", int, DOMAIN_SIZE)\n", + "\n", + "\n", + "@cfunc\n", + "def cmain():\n", + " iqae_res = iqae(epsilon=1 / ((2**DOMAIN_SIZE_QCONST) * 2), alpha=0.01)\n", + " save({\"iqae_res\": iqae_res})\n", + "\n", + "\n", + "from classiq import Constraints, create_model, show, synthesize\n", + "\n", + "constraints = Constraints(optimization_parameter=\"width\")\n", + "qmod_iqae = create_model(\n", + " main,\n", + " constraints=constraints,\n", + " classical_execution_function=cmain,\n", + ")\n", + "\n", + "qprog_iqae = synthesize(qmod_iqae)\n", + "show(qprog_iqae)\n", + "\n", + "from classiq import execute\n", + "\n", + "res = execute(qprog_iqae).result()\n", + "\n", + "iqae_res = res[0].value\n", + "print(\n", + " f\"IQAE result: {iqae_res.estimation}, confidence interval: {iqae_res.confidence_interval}\"\n", + ")\n", + "print(\n", + " f\"Number of solutions: {(2**DOMAIN_SIZE) * iqae_res.estimation}, accuracy: \"\n", + " f\"{(2**DOMAIN_SIZE)*(iqae_res.confidence_interval[1]-iqae_res.confidence_interval[0])}\"\n", + ")\n", + "for i, iteration in enumerate(iqae_res.iterations_data):\n", + " print(\n", + " f\"iteration_id: {i}, num grover iterations: {iteration.grover_iterations}, counts: {iteration.sample_results.counts}\"\n", + " )" + ], + "metadata": { + "collapsed": false + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/tutorials/workshops/grover_workshop/grover_workshop.json b/tutorials/workshops/grover_workshop/grover_workshop.metadata.json similarity index 100% rename from tutorials/workshops/grover_workshop/grover_workshop.json rename to tutorials/workshops/grover_workshop/grover_workshop.metadata.json diff --git a/tutorials/workshops/grover_workshop/grover_workshop.qmod b/tutorials/workshops/grover_workshop/grover_workshop.qmod index c52eff85..33ea3364 100644 --- a/tutorials/workshops/grover_workshop/grover_workshop.qmod +++ b/tutorials/workshops/grover_workshop/grover_workshop.qmod @@ -1,6 +1,6 @@ qfunc create_initial_state(reg: qbit[]) { - apply_to_all(reg); } diff --git a/tutorials/workshops/hhl_workshop/hhl_workshop.ipynb b/tutorials/workshops/hhl_workshop/hhl_workshop.ipynb index 80fc6f22..e0faea39 100644 --- a/tutorials/workshops/hhl_workshop/hhl_workshop.ipynb +++ b/tutorials/workshops/hhl_workshop/hhl_workshop.ipynb @@ -199,9 +199,7 @@ "# TODO update the qmod to have aer_simulator_statevector as backend, with one shot\n", "\n", "# Solution start\n", - "backend_preferences = ClassiqBackendPreferences(\n", - " backend_name=\"aer_simulator_statevector\"\n", - ")\n", + "backend_preferences = ClassiqBackendPreferences(backend_name=\"simulator_statevector\")\n", "qmod_b_load = set_execution_preferences(\n", " qmod_b_load,\n", " execution_preferences=ExecutionPreferences(\n", @@ -501,9 +499,7 @@ "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", "from classiq.synthesis import set_execution_preferences\n", "\n", - "backend_preferences = ClassiqBackendPreferences(\n", - " backend_name=\"aer_simulator_statevector\"\n", - ")\n", + "backend_preferences = ClassiqBackendPreferences(backend_name=\"simulator_statevector\")\n", "\n", "qmod_hhl = create_model(\n", " entry_point=main,\n",