diff --git a/applications/telecom/radio_access_network/radio_access_network_posisioning_antennas.metadata.json b/applications/telecom/radio_access_network/radio_access_network_posisioning_antennas.metadata.json new file mode 100644 index 000000000..6b64e49b0 --- /dev/null +++ b/applications/telecom/radio_access_network/radio_access_network_posisioning_antennas.metadata.json @@ -0,0 +1,7 @@ +{ + "friendly_name": "radio access network positioning antennas", + "description": "radio access network - positioning antennas", + "problem_domain_tags": [], + "qmod_type": [], + "level": [] +} diff --git a/applications/telecom/radio_access_network/radio_access_network_positioning_antennas.ipynb b/applications/telecom/radio_access_network/radio_access_network_positioning_antennas.ipynb new file mode 100644 index 000000000..82928ea89 --- /dev/null +++ b/applications/telecom/radio_access_network/radio_access_network_positioning_antennas.ipynb @@ -0,0 +1,508 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0", + "metadata": {}, + "source": [ + "# Radio Access Network" + ] + }, + { + "cell_type": "markdown", + "id": "1", + "metadata": {}, + "source": [ + "Radio Access Network (RAN) is an important part of network communication systems, responsible for connecting used devices such as smartphones and radio machines to a wireless network. \n", + "\n", + "Optimizing the Radio Access Network involves various tasks that make it challenging to optimize a network efficiently. These tasks include resource allocation, locating transmission devices, such as antennas, to enhance coverage according to the overall consumption. Ideally, the optimization of a RAN will maximize the resource utilization of the network, save operational costs to the owner of the network.\n", + "\n", + "In this case of RAN, the solution is the positions of the set of antennas we have in a region that that has consumers spread in various locations. Finding good positions of antennas with a limited number of antennas is very complex to optimize and find a good solution in polynomial time." + ] + }, + { + "cell_type": "markdown", + "id": "2", + "metadata": {}, + "source": [ + "## 1. Define problem classically with pyomo\n", + "\n", + " - We have a limited number of antennas defined by $N$.\n", + " - We have a set of potential locations: $\\{1,2,3,...,M\\}$, where $M>N$\n", + " - We limit certain locations with an overlap, not to use 2 antennas.\n", + "\n", + "### Mathematical definition\n", + "\n", + "Each location is a binary variable $x_{i}$ that is 1 if we put antenna there and 0 if we don't put in that location. Each location is charachterized with certain consumption $c_{i}$. \n", + "\n", + "Mathematically, it is translated into objective function which aims to maximized its coverage:\n", + "\n", + "$$\n", + "\\max_{x} \\sum_{i} c_{i}x_{i}\n", + "$$\n", + "\n", + "Now, we add the constraints, such as the number of antennas:\n", + "\n", + "$$\n", + "\\sum_{i} x_{i} \\leq N\n", + "$$\n", + "\n", + "We can also add a constraint that prevent an ovelap between antennas. All sets of neighboring antenna sites $\\{n_{0},n_{1},...,n_{k}\\}$ will have only 1 anntenna on the ground:\n", + "\n", + "$$\n", + "\\sum_{i}^{k} x_{n_{i}} == 1\n", + "$$\n", + "\n", + "### Defining Pyomo model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3", + "metadata": {}, + "outputs": [], + "source": [ + "# Import relevant packages\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", + "\n", + "# potenital locations\n", + "M = 13\n", + "# number of antennas\n", + "N = 7\n", + "\n", + "# consumption coefficient\n", + "c_vec = np.random.rand(1, M)[0]\n", + "\n", + "neighbors1 = [1, 3, 4]\n", + "neighbors2 = [0, 5]\n", + "neighbors3 = [6, 9]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4", + "metadata": {}, + "outputs": [], + "source": [ + "model = pyo.ConcreteModel()\n", + "\n", + "# define the variables\n", + "model.x = pyo.Var(range(M), domain=pyo.Binary)\n", + "\n", + "x_variables = np.array(list(model.x.values()))\n", + "\n", + "# constriants\n", + "model.num_antennas = pyo.Constraint(expr=sum(x_variables[i] for i in range(M)) <= N)\n", + "\n", + "model.neigh1 = pyo.Constraint(expr=sum(x_variables[i] for i in neighbors1) == 1)\n", + "model.neigh2 = pyo.Constraint(expr=sum(x_variables[i] for i in neighbors2) == 1)\n", + "model.neigh3 = pyo.Constraint(expr=sum(x_variables[i] for i in neighbors3) == 1)\n", + "\n", + "model.obj = pyo.Objective(expr=x_variables @ c_vec, sense=pyo.maximize)" + ] + }, + { + "cell_type": "markdown", + "id": "5", + "metadata": {}, + "source": [ + "### Define QAOA parameters and synthesize" + ] + }, + { + "cell_type": "markdown", + "id": "6", + "metadata": {}, + "source": [ + "In order to solve the Pyomo model defined above, we use the Classiq combinatorial optimization engine. For the quantum part of the QAOA algorithm (`QAOAConfig`) - define the number of repetitions (`num_layers`) and the `penalty_energy` to get results that satisfy your constraints. Be careful! large enrgy also can bring you away from the optimized solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7", + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import *\n", + "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", + "\n", + "qaoa_config = QAOAConfig(num_layers=4, penalty_energy=3.0)" + ] + }, + { + "cell_type": "markdown", + "id": "8", + "metadata": {}, + "source": [ + "For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (max_iteration)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9", + "metadata": {}, + "outputs": [], + "source": [ + "optimizer_config = OptimizerConfig(max_iteration=60, alpha_cvar=1.0)" + ] + }, + { + "cell_type": "markdown", + "id": "10", + "metadata": {}, + "source": [ + "Lastly, we load the model, based on the problem and algorithm parameters, which we can use to solve the problem:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "11", + "metadata": {}, + "outputs": [], + "source": [ + "qmod = construct_combinatorial_optimization_model(\n", + " pyo_model=model,\n", + " qaoa_config=qaoa_config,\n", + " optimizer_config=optimizer_config,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "12", + "metadata": {}, + "source": [ + "We also set the quantum backend we want to execute on:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "13", + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import set_execution_preferences\n", + "from classiq.execution import ClassiqBackendPreferences, ExecutionPreferences\n", + "\n", + "backend_preferences = ExecutionPreferences(\n", + " num_shots=3000,\n", + " # backend_preferences=ClassiqBackendPreferences(backend_name=\"aer_simulator\")\n", + ")\n", + "\n", + "qmod = set_execution_preferences(qmod, backend_preferences)" + ] + }, + { + "cell_type": "markdown", + "id": "14", + "metadata": {}, + "source": [ + "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "15", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Exception in callback Task.__step()\n", + "handle: \n", + "Traceback (most recent call last):\n", + " File \"/Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/asyncio/events.py\", line 84, in _run\n", + " self._context.run(self._callback, *self._args)\n", + "RuntimeError: cannot enter context: <_contextvars.Context object at 0x1082b9340> is already entered\n", + "Exception in callback Task.__step()\n", + "handle: \n", + "Traceback (most recent call last):\n", + " File \"/Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/asyncio/events.py\", line 84, in _run\n", + " self._context.run(self._callback, *self._args)\n", + "RuntimeError: cannot enter context: <_contextvars.Context object at 0x1082b9340> is already entered\n", + "Exception in callback Task.__step()\n", + "handle: \n", + "Traceback (most recent call last):\n", + " File \"/Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/asyncio/events.py\", line 84, in _run\n", + " self._context.run(self._callback, *self._args)\n", + "RuntimeError: cannot enter context: <_contextvars.Context object at 0x1082b9340> is already entered\n", + "Exception in callback Task.__step()\n", + "handle: \n", + "Traceback (most recent call last):\n", + " File \"/Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/asyncio/events.py\", line 84, in _run\n", + " self._context.run(self._callback, *self._args)\n", + "RuntimeError: cannot enter context: <_contextvars.Context object at 0x1082b9340> is already entered\n", + "Exception in callback Task.__step()\n", + "handle: \n", + "Traceback (most recent call last):\n", + " File \"/Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/asyncio/events.py\", line 84, in _run\n", + " self._context.run(self._callback, *self._args)\n", + "RuntimeError: cannot enter context: <_contextvars.Context object at 0x1082b9340> is already entered\n", + "Task was destroyed but it is pending!\n", + "task: .run_in_context() done, defined at /Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/site-packages/ipykernel/utils.py:57> wait_for= cb=[Task.__wakeup()]> cb=[ZMQStream._run_callback.._log_error() at /Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/site-packages/zmq/eventloop/zmqstream.py:563]>\n", + "/Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/site-packages/anyio/_core/_tasks.py:117: RuntimeWarning: coroutine 'Kernel.shell_main' was never awaited\n", + " with get_async_backend().create_cancel_scope(\n", + "RuntimeWarning: Enable tracemalloc to get the object allocation traceback\n", + "Task was destroyed but it is pending!\n", + "task: cb=[Task.__wakeup()]>\n", + "Task was destroyed but it is pending!\n", + "task: .run_in_context() done, defined at /Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/site-packages/ipykernel/utils.py:57> wait_for= cb=[Task.__wakeup()]> cb=[ZMQStream._run_callback.._log_error() at /Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/site-packages/zmq/eventloop/zmqstream.py:563]>\n", + "Task was destroyed but it is pending!\n", + "task: cb=[Task.__wakeup()]>\n", + "Task was destroyed but it is pending!\n", + "task: .run_in_context() done, defined at /Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/site-packages/ipykernel/utils.py:57> wait_for= cb=[Task.__wakeup()]> cb=[ZMQStream._run_callback.._log_error() at /Users/nadavyoran/.pyenv/versions/3.11.13/lib/python3.11/site-packages/zmq/eventloop/zmqstream.py:563]>\n", + "Task was destroyed but it is pending!\n", + "task: cb=[Task.__wakeup()]>\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantum program link: https://platform.classiq.io/circuit/36pyGdPoyltMPFVkjKVear2tfhr\n" + ] + } + ], + "source": [ + "from classiq import show, synthesize\n", + "\n", + "qprog = synthesize(qmod)\n", + "write_qmod(qmod, \"radio_access_network_positioning_antennas\")\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "id": "16", + "metadata": {}, + "source": [ + "### Executing the hybrid algorithm\n", + "\n", + "We now solve the problem using the generated circuit by using the execute method:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "17", + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import execute\n", + "\n", + "res = execute(qprog).result()" + ] + }, + { + "cell_type": "markdown", + "id": "18", + "metadata": {}, + "source": [ + "We can check the convergence of the run:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "19", + "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", + "id": "20", + "metadata": {}, + "source": [ + "### Analyze results\n", + "\n", + "We can also examine the statistics of the algorithm:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "21", + "metadata": {}, + "outputs": [ + { + "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", + "
probabilitycostsolutioncount
9160.0003335.117951[0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1]1
5620.0003332.448870[0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1]1
15190.0003332.197017[0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0]1
3420.0003332.016968[0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1]1
7080.0003331.991353[0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1]1
\n", + "
" + ], + "text/plain": [ + " probability cost solution count\n", + "916 0.000333 5.117951 [0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1] 1\n", + "562 0.000333 2.448870 [0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1] 1\n", + "1519 0.000333 2.197017 [0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0] 1\n", + "342 0.000333 2.016968 [0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1] 1\n", + "708 0.000333 1.991353 [0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1] 1" + ] + }, + "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", + "optimization_result.sort_values(by=\"cost\", ascending=False).head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "22", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[]], dtype=object)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "optimization_result.hist(\"cost\", weights=optimization_result[\"probability\"])" + ] + } + ], + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 9 +} diff --git a/applications/telecom/radio_access_network/radio_access_network_positioning_antennas.qmod b/applications/telecom/radio_access_network/radio_access_network_positioning_antennas.qmod new file mode 100644 index 000000000..61819b7f9 --- /dev/null +++ b/applications/telecom/radio_access_network/radio_access_network_positioning_antennas.qmod @@ -0,0 +1,2900 @@ +hamiltonian: PauliTerm[] = [ + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=54.7775 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-9.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-18.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-36.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-8.6369 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-8.5966 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-8.6577 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=-10.1144 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=-8.8651 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-10.2015 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-8.6027 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-8.5585 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-8.5694 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-8.6762 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-8.8314 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=-8.968 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-10.499 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=1.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=3.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=6.0 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=12.0 + } +]; + +qfunc main(params_list: real[8], output target: qbit[16]) { + allocate(target.len, target); + qaoa_penalty(target.len, params_list, hamiltonian, target); +} + +cscope ``` +vqe_result = vqe( +hamiltonian=hamiltonian, +maximize=True, +initial_point=[0.0, 0.09424092320471443, 0.03141364106823814, 0.0628272821364763, 0.06282728213647629, 0.03141364106823815, 0.09424092320471443, 0.0], +optimizer=Optimizer.COBYLA, +max_iteration=60, +tolerance=0.0, +step_size=0.0, +skip_compute_variance=False, +alpha_cvar=1.0 +) + +save({"vqe_result": vqe_result, "hamiltonian": hamiltonian}) +``` diff --git a/applications/telecom/radio_access_network/radio_access_network_positioning_antennas.synthesis_options.json b/applications/telecom/radio_access_network/radio_access_network_positioning_antennas.synthesis_options.json new file mode 100644 index 000000000..bbb4790a0 --- /dev/null +++ b/applications/telecom/radio_access_network/radio_access_network_positioning_antennas.synthesis_options.json @@ -0,0 +1,44 @@ +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "custom_hardware_settings": { + "basis_gates": [ + "cz", + "rz", + "x", + "cx", + "u2", + "t", + "s", + "sdg", + "cy", + "u1", + "id", + "ry", + "r", + "p", + "z", + "tdg", + "sx", + "y", + "h", + "rx", + "sxdg", + "u" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "machine_precision": 8, + "optimization_level": 1, + "output_format": ["qasm"], + "pretty_qasm": true, + "random_seed": 1890478847, + "synthesize_all_separately": false, + "timeout_seconds": 300, + "transpilation_option": "auto optimize" + } +} diff --git a/tests/notebooks/test_radio_access_network_positioning_antennas.py b/tests/notebooks/test_radio_access_network_positioning_antennas.py new file mode 100644 index 000000000..e57c6b044 --- /dev/null +++ b/tests/notebooks/test_radio_access_network_positioning_antennas.py @@ -0,0 +1,22 @@ +from tests.utils_for_testbook import ( + validate_quantum_program_size, + validate_quantum_model, + wrap_testbook, +) +from testbook.client import TestbookNotebookClient + + +@wrap_testbook("radio_access_network_positioning_antennas", timeout_seconds=2000) +def test_notebook(tb: TestbookNotebookClient) -> None: + # test models + validate_quantum_model(tb.ref("qmod")) + # test quantum programs + validate_quantum_program_size( + tb.ref_pydantic("qprog"), + expected_width=None, + expected_depth=None, + expected_cx_count=None, + ) + + # test notebook content + pass # Todo