diff --git a/demos/Benchmark quimb.ipynb b/demos/Benchmark quimb.ipynb index 482ff994..38072e5e 100644 --- a/demos/Benchmark quimb.ipynb +++ b/demos/Benchmark quimb.ipynb @@ -6,15 +6,7 @@ "source": [ "## Benchmark: `to_tensor` versus `to_quimb_tensor`\n", "\n", - "We implement a class `CircuitBenchmark` which performs time profiling of the above two functions:\n", - "* The constructor sets up fields `n` for the number of circuits to be averaged in one go and `full_reduce` which specifies whether the function with the same name from `PyZX` ought to be used before converting the diagrams to circuits.\n", - "* A private method `run_tensor` is used to generate a circuit, convert it to a graph, use kets 0 as inputs and bras 0 as outputs and calculate the required times for this diagram.\n", - "* Another private method `run_tensors` which simply calls `run_tensor` multiple times and returns the average times.\n", - "* A public method `run_with_qubits` which takes a range as input and uses it to change the number of qubits in each iteration; returns two lists containing the times for obtaining the normal and quimb tensor networks, respectively.\n", - "* A public method `run_with_depths` which is the same as before but now the number of qubits is fixed and the the depth varies.\n", - "* A public method `display_plot` which plots tensor and quimb times.\n", - "* A static method `display_tabel` which tabulates the tensor and quimb times.\n", - "* A public method `display_tabel_and_plot` which both tabulates and plots the same data." + "We start by implementing a class `CircuitGenerator` that generates a ZX circuit in the form of a graph. There are two main methods that we use: the first is to simply call the method `CNOT_HAD_PHASE_circuit` from PyZX library, and the other generates multiple layers, each one consisting of CZ gates and two Z spiders on the first line with random phases. The latter has the effect of producing dense graphs." ] }, { @@ -30,30 +22,129 @@ "import quimb as qu\n", "import numpy as np\n", "import pyzx as zx\n", - "import time\n", + "import time, random\n", + "\n", + "class CircuitGenerator:\n", + " def __init__(self, dense: bool = False, qubits: int = 5, depth: int = 10):\n", + " assert qubits > 0, \"The number of qubits must be positive.\"\n", + " assert depth > 0, \"The depth must be positive.\"\n", + " self.__dense = dense\n", + " self.__qubits = qubits\n", + " self.__depth = depth\n", + " \n", + " def __call__(self) -> zx.Graph:\n", + " if self.__dense:\n", + " return self.__dense_graph(qubits = self.__qubits, layers_count = self.__depth)\n", + " else:\n", + " return zx.generate.CNOT_HAD_PHASE_circuit(qubits = self.__qubits,\n", + " depth = self.__depth,\n", + " clifford = False).to_graph()\n", + " \n", + " def __dense_graph(self, qubits, layers_count: int = 10) -> zx.Graph:\n", + " g = zx.Graph()\n", + " inputs = [g.add_vertex(zx.VertexType.BOUNDARY, qubit = i, row = 0) for i in range(qubits)]\n", + " outputs = [g.add_vertex(zx.VertexType.BOUNDARY, qubit = i, row = 4 * layers_count + 1) for i in range(qubits)]\n", "\n", - "class CircuitBenchmark:\n", - " def __init__(self, n: int, full_reduce: bool = False):\n", + " # This local function adds a new layer having a particular shape;\n", + " # we need the previous `qubits` nodes along each line, together with the\n", + " # index `cnt` of the layer we need to construct.\n", + " # It returns the new last vertex on each line.\n", + " def add_layer(prev, cnt):\n", + " # Create the vertices.\n", + " layer = [g.add_vertex(zx.VertexType.Z,\n", + " qubit = (i + 1) // 2,\n", + " row = 4 * cnt + (1 if i % 4 < 2 else 2)) for i in range(2 * qubits - 2)]\n", + " # Construct the edges between these `2 * qubits - 2` vertices in a zig-zag shape.\n", + " H, S = zx.EdgeType.HADAMARD, zx.EdgeType.SIMPLE\n", + " for i in range(2 * qubits - 3):\n", + " g.add_edge(g.edge(layer[i], layer[i + 1]), edgetype = H if i % 2 == 0 else S)\n", + "\n", + " # We collect the first (front) and the last (end) vertex on each of the `qubits` lines.\n", + " front_indices, end_indices = [], []\n", + " front_indices.append(0)\n", + " end_indices.append(0)\n", + " for i in range(1, qubits - 1):\n", + " front_indices.append(2 * i - (i & 1))\n", + " end_indices.append(2 * i - (i + 1 & 1))\n", + " front_indices.append(2 * qubits - 3)\n", + " end_indices.append(2 * qubits - 3)\n", + " \n", + " # Connect the previous layer (or the inputs if this is to be the first one)\n", + " # to the current layer.\n", + " for i in range(qubits):\n", + " g.add_edge(g.edge(prev[i], layer[front_indices[i]]), zx.EdgeType.SIMPLE)\n", + "\n", + " # Add two randomised red vertices along each wire:\n", + " # Their phases are k * pi / 4 and l * pi / 4, where k and l are independent\n", + " # and uniformly distributed over {0, 1, ..., 7}.\n", + " prev = []\n", + " for i in range(qubits): \n", + " [k, l] = [g.add_vertex(zx.VertexType.X,\n", + " phase = (random.randrange(8)) / 4.,\n", + " qubit = i,\n", + " row = 4 * cnt + j + 3) for j in range(2)]\n", + " g.add_edge(g.edge(layer[end_indices[i]], k), edgetype = zx.EdgeType.SIMPLE)\n", + " g.add_edge(g.edge(k, l), edgetype = zx.EdgeType.SIMPLE)\n", + " prev.append(l)\n", + " return prev\n", + "\n", + " # Add all layers whilst updating the prev vertices.\n", + " prev = inputs\n", + " for cnt in range(layers_count):\n", + " prev = add_layer(prev, cnt)\n", + "\n", + " # Connect the prev vertices with the outputs.\n", + " for i in range(qubits):\n", + " g.add_edge(g.edge(prev[i], outputs[i]), zx.EdgeType.SIMPLE)\n", + "\n", + " # Set the inputs and outputs\n", + " g.auto_detect_io()\n", + " return g" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we implement a class `CircuitBenchmark` which performs time profiling of `to_tensor` and `to_quimb_tensor`:\n", + "* The constructor sets up fields `n` for the number of circuits to be averaged in one go, `dense` flag which specifies whether dense graphs are to be used or not, and `full_reduce` which specifies whether the function with the same name from `PyZX` ought to be used before converting the diagrams to circuits.\n", + "* A private method `run_tensor` is used to generate a circuit, convert it to a graph, use kets 0 as inputs and bras 0 as outputs and calculate the required times for this diagram.\n", + "* Another private method `run_tensors` which simply calls `run_tensor` multiple (`n`) times and returns the average times.\n", + "* A public method `run_with_qubits` which takes the depth and a range to change the number of qubits in each iteration as inputs; returns two lists containing the times for obtaining the normal and quimb tensor networks, respectively.\n", + "* A public method `run_with_depths` which is the same as before but now the number of qubits is fixed and the depth varies.\n", + "* A public method `display_plot` which plots tensor and quimb times.\n", + "* A static method `get_tabel` which returns a string that tabulates tensor and quimb times.* A public method `display_tabel_and_plot` which both tabulates and plots the same data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class CircuitBenchmark():\n", + " def __init__(self, n: int, dense: bool = False, full_reduce: bool = False):\n", " self.__n = n\n", + " self.__dense = dense\n", " self.__full_reduce = full_reduce\n", " \n", " def run_with_qubits(self, depth, qubits_range):\n", + " tensor_times, quimb_times = [], []\n", " self.__depth = depth\n", - " tensor_times = []\n", - " quimb_times = []\n", " for qubits in qubits_range:\n", " self.__qubits = qubits\n", + " self.__generator = CircuitGenerator(self.__dense, qubits, depth)\n", " tensor_time, quimb_time = self.__run_tensors()\n", " tensor_times.append(tensor_time)\n", " quimb_times.append(quimb_time)\n", " return tensor_times, quimb_times\n", "\n", " def run_with_depths(self, qubits, depth_range):\n", + " tensor_times, quimb_times = [], []\n", " self.__qubits = qubits\n", - " tensor_times = []\n", - " quimb_times = []\n", " for depth in depth_range:\n", " self.__depth = depth\n", + " self.__generator = CircuitGenerator(self.__dense, qubits, depth)\n", " tensor_time, quimb_time = self.__run_tensors()\n", " tensor_times.append(tensor_time)\n", " quimb_times.append(quimb_time)\n", @@ -61,13 +152,12 @@ " \n", " def __run_tensor(self):\n", " # Generate a circuit and convert it to a graph object\n", - " circuit = zx.generate.CNOT_HAD_PHASE_circuit(qubits = self.__qubits, depth = self.__depth, clifford = False)\n", - " g = circuit.to_graph()\n", - " if self.__full_reduce:\n", - " zx.full_reduce(g)\n", + " g = self.__generator()\n", " g.apply_state(\"0\" * self.__qubits) # use kets 0 as inputs\n", " g.apply_effect(\"0\" * self.__qubits) # use bras 0 as outputs\n", " zx.to_gh(g) # get rid of red spiders\n", + " if self.__full_reduce:\n", + " zx.full_reduce(g)\n", "\n", " # Profiling to_tensor\n", " t = time.time()\n", @@ -92,14 +182,18 @@ " return (np.mean(self.__tensor_times), np.mean(self.__quimb_times))\n", " \n", " def display_plot(self, tensor_times, quimb_times, range, has_qubits: bool):\n", - " this_type, other_type, quantity = (\"qubits\", \"depth\", self.__depth) if has_qubits else \\\n", + " var_type, fixed_type, fixed_quant = (\"qubits\", \"depth\", self.__depth) if has_qubits else \\\n", " (\"depth\", \"qubits\", self.__qubits)\n", " fig, ax = plt.subplots()\n", " ax.plot(range, tensor_times, label = \"to_tensor\")\n", " ax.plot(range, quimb_times, label = \"to_quimb_tensor\")\n", - " ax.set_xlabel(this_type)\n", + " ax.set_xlabel(var_type)\n", " ax.set_ylabel(\"time (s)\")\n", - " ax.set_title(\"From {} to {} {}, fixed {} of {}\".format(range[0], range[-1], this_type, other_type, quantity))\n", + " ax.set_title(\n", + " \"From {} to {} {}, fixed {} of {}\".format(\n", + " range[0], range[-1], var_type, fixed_type, fixed_quant\n", + " )\n", + " )\n", " ax.legend()\n", " \n", " @staticmethod\n", @@ -113,40 +207,46 @@ " else:\n", " s += \" | \"\n", " s += str(x).rjust(7) if isinstance(x, int) else \"{:.3f}\".format(x).rjust(7)\n", + " s += '\\n'\n", " return s\n", " \n", " s = list_to_row(f\"{var}:\", range_var)\n", - " s += '\\n'\n", " s += list_to_row(\"Tensor times:\", tensor_times)\n", - " s += '\\n'\n", " s += list_to_row(\"Quimb times:\", quimb_times)\n", - " s += '\\n'\n", " return s\n", " \n", " def display_tabel_and_plot(self, tensor_times, quimb_times, range, has_qubits: bool):\n", - " this_type, other_type, quantity = (\"Qubits\", \"depth\", self.__depth) if has_qubits else \\\n", - " (\"Depth\", \"qubits\", self.__qubits)\n", + " var_type, fixed_type, fixed_quant = (\"Qubits\", \"depth\", self.__depth) if has_qubits else \\\n", + " (\"Depth\", \"qubits\", self.__qubits)\n", " str_full_reduce = \" (with full_reduce = True)\" if self.__full_reduce else \"\"\n", - " print(\"For {} {}{}:\\n\".format(quantity, other_type, str_full_reduce))\n", - " print(CircuitBenchmark.get_table(this_type, range, tensor_times, quimb_times))\n", - " self.display_plot(tensor_times, quimb_times, range, has_qubits)" + " print(\"For {} {}{}:\\n\".format(fixed_quant, fixed_type, str_full_reduce))\n", + " print(CircuitBenchmark.get_table(var_type, range, tensor_times, quimb_times))\n", + " self.display_plot(tensor_times, quimb_times, range, has_qubits)\n", + " \n", + " def test(self, has_qubits: bool, fixed_quant: int, range, with_table: bool = False):\n", + " tensor_times, quimb_times = self.run_with_qubits(fixed_quant, range) if has_qubits \\\n", + " else self.run_with_depths(fixed_quant, range)\n", + " if with_table:\n", + " self.display_tabel_and_plot(tensor_times, quimb_times, range, has_qubits)\n", + " else:\n", + " self.display_plot(tensor_times, quimb_times, range, has_qubits)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We now compare `to_tensor` against `to_quimb_tensor` by fixing the depth and varying the number of qubits, while `full_reduce` is, by default, `False`:" + "We now compare `to_tensor` against `to_quimb_tensor` by fixing the depth and varying the number of qubits, while `dense` and `full_reduce` are, by default, `False`:" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -158,11 +258,8 @@ } ], "source": [ - "depth = 20\n", - "qubits_range = range(2, 21)\n", - "cb = CircuitBenchmark(15)\n", - "tensor_times, quimb_times = cb.run_with_qubits(depth, qubits_range)\n", - "cb.display_plot(tensor_times, quimb_times, qubits_range, has_qubits = True)" + "cb = CircuitBenchmark(3)\n", + "cb.test(has_qubits = True, fixed_quant = 20, range = range(2, 21))" ] }, { @@ -176,12 +273,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -193,10 +290,7 @@ } ], "source": [ - "qubits = 15\n", - "depth_range = range(2, 40)\n", - "tensor_times, quimb_times = cb.run_with_depths(qubits, depth_range)\n", - "cb.display_plot(tensor_times, quimb_times, depth_range, has_qubits = False)" + "cb.test(has_qubits = False, fixed_quant = 15, range = range(2, 40))" ] }, { @@ -210,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -219,15 +313,47 @@ "text": [ "For 20 depth (with full_reduce = True):\n", "\n", - "Qubits: 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10\n", - "Tensor times: 0.001 | 0.001 | 0.002 | 0.003 | 0.007 | 0.005 | 0.327 | 0.058 | 0.068\n", - "Quimb times: 0.001 | 0.002 | 0.003 | 0.005 | 0.007 | 0.007 | 0.009 | 0.008 | 0.009\n", + "Qubits: 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15\n", + "Tensor times: 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000\n", + "Quimb times: 0.001 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000 | 0.000\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cb = CircuitBenchmark(5, full_reduce = True)\n", + "cb.test(has_qubits = True, fixed_quant = 20, range = range(2, 16), with_table = True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now the times are negligible, graphs are reduced to simple scalars.\n", + "\n", + "(When the depth is fixed, there are certain situations when the normal method is better, but overall Quimb is better because, as the the number of qubits gets higher, not only it firmly outperforms, but some circuits take exponentially more time to be contracted with `to_tensor`, which leads to spikes in the graph. This is mostly likely due to the fact that `full_reduce` can introduce spiders with many wires, which in turn results in an exponential time increase with `to_tensor`.)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -239,17 +365,18 @@ } ], "source": [ - "cb = CircuitBenchmark(n = 25, full_reduce = True)\n", - "qubits_range = range(2, 11)\n", - "tensor_times, quimb_times = cb.run_with_qubits(depth, qubits_range)\n", - "cb.display_tabel_and_plot(tensor_times, quimb_times, qubits_range, has_qubits = True)" + "cb.test(has_qubits = False, fixed_quant = 15, range = range(2, 24))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "When the depth is fixed, there are certain situations when the normal method is better, but overall Quimb is better because, as the the number of qubits gets higher, not only it firmly outperforms, but some circuits take exponentially more time to be contracted with `to_tensor`." + "Simple scalars here as well.\n", + "\n", + "(As with `full_reduce = False`, we got two functions that grow almost the same at the beginning, up to a constant factor, with Quimb having the better constant; then `to_tensor` time increases exponentially due to more frequent spikes which occur because of spiders with many wires.)\n", + "\n", + "Now we do some experiments with dense graphs:" ] }, { @@ -258,20 +385,38 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "For 15 qubits (with full_reduce = True):\n", - "\n", - "Depth: 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10\n", - "Tensor times: 0.007 | 0.008 | 0.009 | 0.009 | 0.011 | 0.014 | 0.020 | 0.020 | 0.025\n", - "Quimb times: 0.003 | 0.004 | 0.004 | 0.004 | 0.005 | 0.005 | 0.006 | 0.006 | 0.006\n", - "\n" - ] - }, + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cb = CircuitBenchmark(5, dense = True)\n", + "cb.test(has_qubits = False, fixed_quant = 10, range = range(1, 31))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When the number of qubits is fixed, both curves increase linearly but, perhaps surprisingly, `to_tensor` has the better constant." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/gElEQVR4nO3deXwV9bn48c+TnGwkIUDYCSTsyhoxsgio1VqXqqjFuoPW3l6vdWn7q639tdda7+29tr1Xe3/V1tpqFWsLFqvltrTaVq2JrEFRBIQECBBkyQlbFrKe5/fHTMJJOCEhyeQsed6v13llzsx3Zp7JSeY58/3OfL+iqhhjjDGtxYU7AGOMMZHJEoQxxpiQLEEYY4wJyRKEMcaYkCxBGGOMCckShDHGmJAsQZheR0QuEpFSj7adIyIqIr5Orj9RRDaKSIWI3C8iT4vIv3oQZ4mIfNqD7d4hIgWnWf5nEVnc3fsNsZ/rRGSviFSKyDle7y9WWYKIAe4/+wn3n6HpNbyHYxgmIitE5BP3BJnTTvlOn6BEZFSrY6109/l/OhV8F3hwov0G8Jaqpqvq/1PVu1X137px+2Glqleo6gvQfjLpov8C7lXVNFV9v/XCEP8zb3gUR1SzBBE7rnb/GZpenwQv7Ow32jMQAP4CfM7j/aCqe4KPFZjq7v8Vr/fdA7KBzeEOIgZ05PcY/D/zmZ4IKtpYgohh7rfqL4tIEVDkzvsnESkWkcPuN/7hrcrfIyJFbhXHv4nIWBFZJSLHReRlEUkMtS9VPaiqPwXWdyCuF4FRwP+6396+4c6/RkQ2i8hREXlbRM7u4KEuAt5R1ZI29pciIs+LyBER2QKc12r5cBF5RUTKRGSXiNwftOwREVkuIsvc38l7IjL9dMfhulVE9oiIX0S+3ZGDEJE3gU8BT7rbm+DG/e/u8m+KyNqmZC8i/+L+vpJFJE5EHhKRHSJS7n5WA4K2fbuI7HaXnTYeEcl0/zaOi8g69++gwF12ShWa+1l9seUm5EkROSYiH4vIJa3Lup/t08Ac91iPusuvFJEt7u96n4h8vY0Y40TkO+4xHRKRJSKSISJJIlIJxAMfiMiOjvzuTRtU1V5R/gJKgE+HmK/AX4EBQApwMeAHZgBJwE9wTqzB5f8A9AUmA7XA34ExQAawBVjcTiw+dzs5ZxIzMAGoAi4FEnCqWoqBxHa2I8AO4I7TlHkMyHd/DyOBj4BSd1kcsAF4GEh0j3UncJm7/BGgHljoxvV1YBeQ0MZx5LjH/wv3dz7d/T2e3cHP8m3gi0Hvnwf+PSjWd9yYxgNHgHPcZQ8Aa4As97P9OfBbd9kkoBK4wF32ONAQ6m/GLb8UeBlIBaYA+4CCVsfnCxUzcIe77a+6v68bgWPAgDbKFrTa935gvjvdH5jRRoxfcP8+xgBpwO+BF1v9LY9r5+/vIFAGvAFMD/f/cSS+wh6AvbrhQ3T+2CuBo+7rNXe+AhcHlXsW+GHQ+zT35JcTVH5u0PINwDeD3v838ON2YulsgvhX4OWg93HuiemidrYz3z32tNOU2QlcHvT+S5xMELOAPa3Kfwv4lTv9CLCmVVzBJ7HWx9F0As0KmrcOuKmDn2XzCdR9/zxuggja/mFgK/CtoPlbgUuC3g9zP1sfTvJbGrQsFagj9JeKeHe9s4Lm/QdnliA+AaTV8d/eRtnWCWIP8M9A33Z+T38H7gl6P7HpeIP+lk+XIObiJPA+7ud9AOjX3f+b0f6yKqbYca2q9nNf1wbN3xs0PRzY3fRGVSuBcmBEUJmDQdMnQrxP67aIW2odWwAn9hFtruFYDLziHsvpth38e9gdNJ0NDHertY66VR3/FxgSVKZ5XTeuUnebp3MgaLqabvq9qVON9hbOifqpoEXZwKtBx7AVaMQ5jhbHr6pVOJ97KINwkkpbv6+O2KfuWTho/Y7eNPE54Epgt4j8Q0TmtFGuxd+LO+2j5efWJlV9V1VPqGq1qv4nzher+R2MsdewBBH7gv9RP8E5kQAgIqlAJs439Z7Wuhvh1rEJTnVQm7GJSApwA/BCO/va726ryaig6b3ArqDk2k+dO4iuDCrTvK6IxOFU4zTdBNCj3SGLyGeBOTjfoH8UtGgvcEWr40hW1X20On4R6YPzuYdShlNF1Nbvq8r92Sdo3tBW2xjhfn7B63/CqU753anqelVdAAwGXsOp6gqlxd+Lu48GWn6hOROKU11pgliC6F1+C9wpIrkikoRTdbBW22jcPVMikoxTxw2Q5L5vy0Gc+uMmLwOfFZFLRCQB+D84dferTrON63Dq4d9qJ7SXgW+JSH8RyQLuC1q2DqhwG4BTRCReRKaISHBD9rkicr3bMPsVN641bRzHaYnzDEankoqIDAR+CXwR58rpahFpSmRPA98XkWy37CARWeAuWw5cJSLzxLnJ4FHa+N9X1Uac+vxHRKSPiExy99W0vAwnad/m/q6+AIxttZnBwP0ikiAiNwBnAytD7O4gkOXGhIgkisitIpKhqvXAcZy700L5LfBVERktImk4f8vLVLWhjfLNxLlNeq67v2QReRAYCLzb3rq9jSWIXkRV/4ZT1/8KzrfKscBN3biLEzjtAQAfu+/b8p/Ad9wqka+r6jbgNpyGcz9wNc5tiHWn2cZinIbJ9k6438OpgtiF0yD5YtMC94R4FZDrLvfjnIQzgtb/A05j6xHgduB69wR2ynG0Ewc438xPl/RO5xngD6q6UlXLgbuAX4pIJvA/wArgDRGpwElgs9xj3Ax8GfgNzud+BKearC334lSJHcBpA/lVq+X/BDyIU001OcTxrMVpRPcD3wcWuvG29ibOragHRMTvzrsdKBGR48DdwK1txPgczuf4Ds7nVkPLxH866cDPcH4P+4DLca6+2qp267Wk/f8tY3ovEXkEp7Hztm7a3i+B36nq692xvZ4gInfgNCzPC3cspmd5/fCUMSaIqn6x/VLGRAarYjLGGBOSVTEZY4wJya4gjDHGhBQzbRADBw7UnJyccIdhjDFRZcOGDX5VHRRqWcwkiJycHAoLC8MdhjHGRBURafNJeatiMsYYE5IlCGOMMSFZgjDGGBNSzLRBhFJfX09paSk1NTXhDsV0o+TkZLKyskhISAh3KMbEtJhOEKWlpaSnp5OTk0PLziVNtFJVysvLKS0tZfTo0eEOx5iYFtNVTDU1NWRmZlpyiCEiQmZmpl0VGtMDYjpBAJYcYpB9psb0jJhPEMYY09oufxVvbD7QfsFezhKEx44ePcpPf/rTM16vpKSE3/zmNx5EZIz50esfc/evN7Dv6OmGLDGWIDwWjQmioaHdQbmMiVqNAeXd4nICCr9Ze6bDbfculiA89tBDD7Fjxw5yc3N58MEHefDBB5kyZQpTp05l2bJlp10vPz+f3NxcnnjiCRobG3nwwQc577zzmDZtGj//+c8BePvtt7noootYuHAhZ511FrfeeitNPfQ+9NBDTJo0iWnTpvH1rzuDnZWUlHDxxRczbdo0LrnkEvbs2QPAHXfcwd13382sWbP4xje+4fFvxZjw2bTvGMdO1JORksBv1+2lpr4x3CFFrJi+zTXY9/53M1s+Od6t25w0vC/fvXryacs89thjfPTRR2zcuJFXXnmFp59+mg8++AC/3895553HBRdcwLBhw0Ku91//9V/88Y9/BOCZZ54hIyOD9evXU1tby9y5c/nMZz4DwPvvv8/mzZsZPnw4c+fO5d133+Xss8/m1Vdf5eOPP0ZEOHr0KAD33XcfixcvZvHixTz33HPcf//9vPbaa4BzW/CqVauIj4/vvl+SMRGmoKgMgEcXTOaBpRtZuWk/18/ICnNUkcmuIHpQQUEBN998M/Hx8QwZMoQLL7yQ9evXd2jdN954gyVLlpCbm8usWbMoLy+nqKgIgJkzZ5KVlUVcXBy5ubmUlJSQkZFBcnIyd911F7///e/p06cPAKtXr+aWW24B4Pbbb6egoKB5HzfccIMlBxPz8ov8TB7el2umD2fsoFReWG3VTG3pNVcQ7X3Tj3Sqyk9+8hMuu+yyFvPffvttkpKSmt/Hx8fT0NCAz+dj3bp1/P3vf2f58uU8+eSTvPnmm6fdR2pqqiexGxMpqmobeG/PEb4wbzQiwqI5OXx3xWY27j1K7sh+4Q4v4nh6BSEil4vINhEpFpGHQixPEpFl7vK1IpLjzr9VRDYGvQIikutlrF5JT0+noqICgPnz57Ns2TIaGxspKyvjnXfeYebMme2uB3DZZZfxs5/9jPr6egC2b99OVVVVm/utrKzk2LFjXHnllTzxxBN88MEHAJx//vksXboUgJdeeon58+d3y3EaEw3W7iqnvlGZP84Z/uD6GSNITYxnyeqS8AYWoTy7ghCReOAp4FKgFFgvIitUdUtQsbuAI6o6TkRuAn4A3KiqLwEvuduZCrymqhu9itVLmZmZzJ07lylTpnDFFVcwbdo0pk+fjojwwx/+kKFDh4Zcb9q0acTHxzN9+nTuuOMOHnjgAUpKSpgxYwaqyqBBg5rbDkKpqKhgwYIF1NTUoKo8/vjjAPzkJz/hzjvv5Ec/+hGDBg3iV7/6lReHbUxEyi/yk+SLIy+nPwDpyQl87twslq7by7evPJvMtKR2ttC7eDYmtYjMAR5R1cvc998CUNX/DCrzultmtYj4gAPAIA0KSkT+w1lNv326/eXl5WnrAYO2bt3K2Wef3V2HZCKIfbamMy59/B8MzUjmxbtmNc8rPlTBpx9/h29cPpF7LhoXxujCQ0Q2qGpeqGVeVjGNAPYGvS9154Uso6oNwDEgs1WZG4HfhtqBiHxJRApFpLCsrKxbgjbGxKb9x05QdKiS+eMHtpg/bnA6c8dl8tKaPTQ0BsIUXWSK6LuYRGQWUK2qH4VarqrPqGqequYNGhRySNWIt2nTJnJzc1u8Zs2a1f6KxpgzUlDkB2DeuFPPFYvm5LDv6An+/vGhng4ronl5F9M+YGTQ+yx3XqgypW4VUwZQHrT8Jtq4eogVU6dOZePGjeEOw5iYV1DsZ2BaImcNTT9l2SVnDWZ4RjJLVpdw2eTQ7YK9kZdXEOuB8SIyWkQScU72K1qVWQEsdqcXAm82tT+ISBzweWCphzEaY3qBQEB5t9jPvHEDiYs7tTdgX3wct87O5t3icooPVYTYQu/kWYJw2xTuBV4HtgIvq+pmEXlURK5xiz0LZIpIMfA1IPhW2AuAvaq606sYjTG9w9YDx/FX1jFvfNtV0TedN5LE+DiW2INzzTx9UE5VVwIrW817OGi6BrihjXXfBmZ7GZ8xpnc42f4wsM0ymWlJXDV9GK9sKOXByyaSnmxD2kZ0I7UxxnSHgmI/E4akMTQj+bTlFs/JoaqukVffb91c2jtZgjDGxLSa+kbW7Toc8u6l1qaP7Mf0kf14YVUJXj0jFk0sQXiss+NBdMaKFSt47LHHzmidtLS0Dpd9/vnn+eSTT840LGPCan3JYWobAqc8/9CWxXOy2VFWxaod5e0XjnGWIDzWkwnimmuu4aGHTunyqtuEK0GoKoGAPcBkOqegyE9CvDBrzIAOlb9y6jAGpCbywqoSbwOLAr2mN1f+/BAc2NS92xw6Fa44/Tf24AGDLr30UieUP/8ZEeE73/kON954Y8j1VJX77ruPv/71r4wcOZLExES+8IUvsHDhQnJycigsLGTgwIEUFhby9a9/nbfffpvnn3+ewsJCnnzySe644w5SUlJ4//33OXToEM899xxLlixh9erVzJo1i+eff755X1/96ld54403GDp0KEuXLiXUQ4fLly+nsLCQW2+9lZSUFFavXs2WLVv42te+RmVlJQMHDuT5559n2LBhXHTRRcyaNYu33nqLo0eP8uyzzzJ//nw2b97MnXfeSV1dHYFAgFdeeYXx48fz+OOP89xzzwHwxS9+ka985SuUlJRw2WWXMWvWLDZs2MDKlSvJzs7u5AdlerP8Ij/nZvenT2LHTnfJCfHcdN5Inv7HDkqPVJPVv4/HEUYuu4Lw2GOPPcbYsWPZuHEjs2fPZuPGjXzwwQf87W9/48EHH2T//v0h13v11VfZtm0bW7ZsYcmSJaxateqM933kyBFWr17NE088wTXXXMNXv/pVNm/ezKZNm5ofzquqqiIvL4/Nmzdz4YUX8r3vfS/kthYuXEheXh4vvfQSGzduxOfzcd9997F8+XI2bNjAF77wBb797ZPdZTU0NLBu3Tp+/OMfN2/z6aef5oEHHmDjxo0UFhaSlZXFhg0b+NWvfsXatWtZs2YNv/jFL3j//fcBKCoq4p577mHz5s2WHEyn+Ctr2bL/OPNPc3trKLfOdv7eXlq7x4uwokbvuYJo55t+T2hrwKBrrrnmlLLvvPNOc9nhw4dz8cUXn/H+rr76akSEqVOnMmTIEKZOnQrA5MmTKSkpITc3l7i4uOarmNtuu43rr7++Q9vetm0bH330UfNVUWNjY4uR8Zq2c+6551JSUgLAnDlz+P73v09paSnXX38948ePp6CggOuuu655LIrrr7+e/Px8rrnmGrKzs5k92+50Np33bnH7t7eGMqJfCpdOGsKy9Xt54JLxJCf0zoG07AoiCvl8vuY6+ZqamjbLNQ0kFBcX12JQobi4OBoaGkKuI3LqU6ahqCqTJ09m48aNbNy4kU2bNvHGG2+csu+mAYwAbrnlFlasWEFKSgpXXnmlDWBkPJdf5CcjJYEpIzLOeN3Fc3I4XFXHnz4MfZXfG1iC8FhnBwy64IILmsvu37+ft956q3lZTk4OGzZsAOCVV17pUnyBQIDly5cD8Jvf/IZ58+Z16FgmTpxIWVkZq1evBqC+vp7Nmzefdl87d+5kzJgx3H///SxYsIAPP/yQ+fPn89prr1FdXU1VVRWvvvqqDWJkuoWqUlDkdK8RH6J7jfbMGZvJuMFpvXowIUsQHgseMGj16tXNAwZdfPHFpx0w6LrrrmP8+PFMmjSJRYsWMWfOnOZl3/3ud3nggQfIy8vr8hjSqamprFu3jilTpvDmm2/y8MMPt1n2jjvu4O677yY3N5fGxkaWL1/ON7/5TaZPn05ubm677SQvv/wyU6ZMITc3l48++ohFixYxY8YM7rjjDmbOnMmsWbP44he/yDnnnNOlYzIGoPhQJQeO1zCvg7e3tuYMSZrNB6XH2Lj3aPcGFyU8GzCop8X6gEF33HEHV111FQsXLgx3KBEhlj5b443nCnbx6B+3kP+NTzFyQOfuRKqsbWD2f/ydz0wawuM35nZvgBEiXAMGGWNM2BQU+8nJ7NPp5ACQluTjczNG8McP9+OvrO3G6KJD77mLKUJt2rSJ22+/vcW8pKQk1q5d22Je8HMLXvvyl7/Mu+++22LeAw88wJ133tljMRjTFXUNAdbsLOdzM7K6vK3b5+TwwurdLFu/ly9/qncNSRrzCUJVO3xnTjhE4oBBTz31VLhDOK1YqRY13nlvzxGq6xo73f4QbNzgNOaNG8hLa3bzzxeMwRffeypeYvpIk5OTKS8vtxNKDFFVysvLSU4+fa+cpncrKPITHyfMGdt6iPvOWTQnm0+O1fC3rb1rSNKYvoLIysqitLSUsrKycIdiulFycjJZWV2vOjCxK7/Yz/SsDPp205gOl5w9hBH9UliyuoTLp/SeIUljOkEkJCQwevTocIdhjOlBR6vr2FR6lPsuHt9t24yPE26dPYof/mUbRQcrGD/k1HGtY1FMVzEZY3qfVTvKCSgd7t67o27MG0mir3cNSeppghCRy0Vkm4gUi8gp/VCLSJKILHOXrxWRnKBl00RktYhsFpFNImKVzsaYduUX+UlL8jF9ZL9u3W5mWhJXTxvOK++Vcrymvlu3Hak8SxAiEg88BVwBTAJuFpFJrYrdBRxR1XHAE8AP3HV9wK+Bu1V1MnAR0Ds+EWNMlxQUlzF7TCYJHtxttPj8bKrrGvn9htJu33Yk8vIKYiZQrKo7VbUOWAosaFVmAfCCO70cuESce1I/A3yoqh8AqGq5qjZ6GKsxJgbsLq9i7+ETXDChe6uXmkzL6kfuyH4sWbO7V9wd6WWCGAHsDXpf6s4LWUZVG4BjQCYwAVAReV1E3hORb4TagYh8SUQKRaTQ7lQyxrxT1Lnuvc/E4vOz2VlWxbvFsT8kaaQ2UvuAecCt7s/rROSS1oVU9RlVzVPVvFCjoBljepeCojJG9Eth9EDvuoq/cuowMlMTeaEX9PLqZYLYB4wMep/lzgtZxm13yADKca423lFVv6pWAyuBGR7GaoyJcg2NAVbtKGfeuIGe9p6Q5Ivnppkj+fvWg+w9XO3ZfiKBlwliPTBeREaLSCJwE7CiVZkVwGJ3eiHwpjoVe68DU0Wkj5s4LgS2eBirMSbKfbjvGBU1Dcz3qP0h2K2zeseQpJ4lCLdN4V6ck/1W4GVV3Swij4pI0xibzwKZIlIMfA14yF33CPA4TpLZCLynqn/yKlZjTPTL3+5HBOaO9T5BDO+XwmcmDWXZ+j3U1Mfu/TOePkmtqitxqoeC5z0cNF0D3NDGur/GudXVGGPaVVBcxpThGfRPTeyR/S06P5u/bD7AHz/cz8JzY7Prl0htpDbGmA6rrG3g/T1Hu/3p6dOZMyaT8YPTeGFVScze8moJwhgT9dbsKKchoN3SvXdHiQiLzs9h077YHZLUEoQxJurlF5WRkhDPudn9e3S/150zgrQkX8z2z2QJwhgT9fKL/cwcPYAkX3yP7jctycfCc7P404f7KauIvSFJLUEYY6LavqMn2FlW1aPtD8Fum51NXWOAZetj75ZXSxDGmKhWUOR0szN/fHh6Uxg3OI354wfy0to9NDQGwhKDVyxBGGOiWn6Rn8HpSUwYkha2GBbNyWH/sRr+tvVg2GLwgiUIY0zUCgS0R7rXaM/FZw1mRL8UXlgVW43VliCMMVFry/7jHK6q65HuNU4nPk64bXY2q3eWs/1gRVhj6U6WIIwxUesdt/1hrofde3fUjec1DUlaEu5Quo0lCGNM1Coo8nPW0HQGp4d/ROIBqYlcM304v39vX8wMSWoJwhgTlU7UNVJYcsTTwYHO1OI5OVTXNfJKjAxJagnCGBOV1pUcpq4xwPwJkTNY2NSsDM4Z1Y8XV+8mEIj+/pksQRhjolL+9jIS4+OYmTMg3KG0sHhODjv9Vby7wx/uULrMEoQxJioVFPvJy+lPSmLPdq/RniumDmVgWmJM3PJqCcIYE3UOVdTw8YGKHu29taOSfPHcdN4o/v5x9A9JagnCGBN13i12qm8uCFP3Gu25ZdYo4kT49drovoqwBGGMiTr52/0MSE1k0rC+4Q4lJGdI0iEsW783qock9TRBiMjlIrJNRIpF5KEQy5NEZJm7fK2I5Ljzc0TkhIhsdF9PexmnMSZ6qCoFxX7OH5tJXFz4utdoz6I5ORytrmfFB5+EO5RO8yxBiEg88BRwBTAJuFlEJrUqdhdwRFXHAU8APwhatkNVc93X3V7FaYyJLtsPVnKoojZs3Xt31OwxA5gwJI0lq6N3SFIvryBmAsWqulNV64ClwIJWZRYAL7jTy4FLJJw9bhljIl6+273GvAhtf2giIiyak8NH+47zfpQOSeplghgB7A16X+rOC1lGVRuAY0Cmu2y0iLwvIv8QkfmhdiAiXxKRQhEpLCsr697ojTERKb/Iz5hBqYzolxLuUNp13TkjSE/ysWRVSbhD6ZRIbaTeD4xS1XOArwG/EZFTWqNU9RlVzVPVvEGDIvvbhDGm62obGlm7q5z5EdS9xumkJvn43LlZ/GlTdA5J6mWC2AeMDHqf5c4LWUZEfEAGUK6qtapaDqCqG4AdwAQPYzXGRIENu49QUx+I+OqlYLfPyaa+UVm6LvqGJPUyQawHxovIaBFJBG4CVrQqswJY7E4vBN5UVRWRQW4jNyIyBhgP7PQwVmNMFCgo8uOLE2aPiazuNU5n7KCTQ5LWR9mQpJ4lCLdN4V7gdWAr8LKqbhaRR0XkGrfYs0CmiBTjVCU13Qp7AfChiGzEaby+W1UPexWrMSY65Bf5OWdUP9KTE8IdyhlZPCeHA8dr+OuW6BqS1OflxlV1JbCy1byHg6ZrgBtCrPcK8IqXsRljosuRqjo++uQYX7kk+mqbP3XWYLL6p7BkdQlXTh0W7nA6LFIbqY0xpoV3d/hRJSL7X2pPfJxw++xs1uw8zLYD0TMkqSUIY0xUyN/uJz3Zx/SsjHCH0imfzxtJUpQNSWoJwhgT8YK71/DFR+dpq3/QkKTHTkTHkKTR+Zs2xvQqu/xV7Dt6Iqpubw1l8fk5nKiPniFJLUEYYyJeQXP33tHX/hBsyogMZozqx4tromNIUksQxpiI9852PyMHpJCdmRruULps8fk57PJXkV8c+UOSWoIwxkS0+sYAa3aWM29cdFcvNbliyjAGpiXxYhQ0VluCMMZEtA/2HqWytiHiu/fuqERfHLfMHMnfPz4U8UOSWoIwxkS0/CI/cQLnj81sv3CUuGVWtjMk6ZrIHpLUEoQxJqLlF5UxNasf/fokhjuUbjM0I5nLJg9h6fq9nKiL3CFJLUEYYyLW8Zp6Pig9FjXde5+JRXNyOHainv+N4CFJLUEYYyLW6h3lNAY0KrvXaM+s0QOYOCSd51dF7pCkliCMMRGroMhPn8R4ZozqH+5Qup2IsOj8bLbsP857e46EO5yQ2k0QIpIlIl8XkT+IyHoReUdEfioinxURSzDGGM/kF5Uxe0wmib7YPNVcmzuC9GQfS1ZHZmP1aX/rIvIr4DmgDvgBcDNwD/A34HKgQEQu8DpIY0zvs/dwNSXl1cyLwfaHJqlJPhaem8XKTfs5VFET7nBO0d54EP+tqh+FmP8R8Ht3pLhR3R+WMaa3a+peI1aef2jL7bOz+dW7JSxdt5f7Lxkf7nBaOO0VRKjkICL9RWSau7xOVYu9Cs4Y03sVFPkZ2jeZcYPTwh2Kp8YMSuOCCYN4ae3uiBuStEMVeyLytoj0FZEBwHvAL0TkCW9DM8b0Vo0Bp3vveeMHIiLhDsdzi+dkc/B4LW9sjqwhSTva8pOhqseB64ElqjoLuKS9lUTkchHZJiLFIvJQiOVJIrLMXb5WRHJaLR8lIpUi8vUOxmmMiQEf7TvGsRP1MV+91OSiiYMZOSCFFyKsf6aOJgifiAwDPg/8sSMriEg88BRwBTAJuFlEJrUqdhdwRFXHAU/gNIQHexz4cwdjNMbEiKb2h7kx3EAdrGlI0nW7DvPxgePhDqdZRxPEo8DrQLGqrheRMUBRO+vMdMvvVNU6YCmwoFWZBcAL7vRy4BJxrydF5FpgF7C5gzEaY2JEflEZk4b1ZWBaUrhD6TEnhySNnFteO5QgVPV3qjpNVe9x3+9U1c+1s9oIYG/Q+1J3XsgyqtoAHAMyRSQN+CbwvdPtQES+JCKFIlJYVlbWkUMxxkS4qtoGNuw+0muql5r065PIgtzhvBpBQ5K29xzEd9yG6baWXywiV3V/WDwCPKGqlacrpKrPqGqequYNGhQbfcUb09ut23WY+sbY7F6jPYvmOEOSLo+QIUnbew5iE/C/IlKDc/dSGZAMjAdycR6Y+4821t0HjAx6n+XOC1WmVER8QAZQDswCForID4F+QEBEalT1yY4dljEmWuUX+Un0xXFeTpvfTWPWlBEZnJvdnxdXl3Dn+TnExYX3Dq72noP4g6rOBe7GaQuIB44DvwZmqupXVbWtup31wHgRGe0+UHcTsKJVmRXAYnd6IfCmOuarao6q5gA/Bv7DkoMxvUNBcRmzRg8gOSE+3KGExaI52ZSUV/NOUfirzdu7ggBAVYtov1G69ToNInIvTuN2PPCcqm4WkUeBQlVdATwLvCgixcBhnCRijOmlDhyrYfvBSj43IyvcoYTNFVOG8W9pW1myejcXTRwc1lg6lCA6S1VXAitbzXs4aLoGuKGdbTziSXDGmIjTdHtrb2x/aJLoi+OWWaP4yZtF7CmvZlRmn7DFEptdJBpjolJBURmZqYmcPbRvuEMJq1tmjnKGJF0b3lteLUEYYyJCIKh7jXA3zobb0IxkLp88lGVhHpK0o30xTRCRv4vIR+77aSLyHW9DM8b0Jh8fqMBfWRfT3XufiUVzsjl2op4VH7S++bPndPQK4hfAt4B6AFX9EGtQNsZ0o4Ji566d+ePtmSaAmaMHcNbQdF5YtTtsQ5J2NEH0UdV1reY1dHcwxpjeK7/Iz/jBaQzNSA53KBFBRFg0J4ct+4+zYXd4hiTtaILwi8hYQAFEZCGw37OojDG9Sk19I+t2He7Vdy+Fcu05w0lP9vFCmPpn6miC+DLwc+AsEdkHfAX4F6+CMsb0LoUlR6htCPS6/pfa0yfRx+fzRvLnTfs5dLznhyTtaGd9O1X108Ag4CxVnaeqJZ5GZozpNfKLy0iIF2aNzgx3KBHnttnZNASU367b237hbtahB+VEpB+wCMjBGRsCAFW936vAjDG9R0GRnxmj+pOa5Omzu1Fp9MBULnSHJL3nU2NJiO+5pxM6uqeVOMlhE7Ah6GWMMV3ir6xl8yfHrXrpNBafn82hilpe33ygR/fb0XSdrKpf8zQSY0yv9G5z9xp2e2tbLpwwmFED+rBk1W6umja8x/bb0SuIF0Xkn0RkmIgMaHp5GpkxplcoKPKTkZLA1BEZ4Q4lYjUPSVpymC2f9NyQpB1NEHXAj4DVnKxeKvQqKGNM76DqdK8xd1wm8b28e4323JCXRXJCHC+uKemxfXY0QfwfYJw7RsNo9zXGy8CMMbFvR1kl+4/VMG+cVS+1p1+fRK7NHcFr73/CseqeGZK0owmiGKj2MhBjTO+TX+S0P1gDdcfcPiebE/WN/G5Dz9zy2tFG6ipgo4i8BdQ2zbTbXI0xXVFQ5Cc7sw8jB4RvzINoMnl4BnnZ/XlxzW6+MHe0573edvQK4jXg+8Aq7DZXY0w3qGsIsGZnuV09nKFF5+ewu7yaf/TAkKQdHXL0Ba8DMcb0Lu/vOUJVXaO1P5yhyycPZVB6EktWlfApj4ckPe0VhIi87P7cJCIftn61t3ERuVxEtolIsYg8FGJ5kogsc5evFZEcd/5MEdnovj4Qkes6eXzGmAhVUOwnTmDOWOte40wk+uK4ZeYo3t5exu7yKk/31V4V0wPuz6uAq0O82iQi8cBTwBXAJOBmEZnUqthdwBFVHQc8AfzAnf8RkKequcDlwM9FxJ7BNyaG5Bf5mT6yHxkpCeEOJercMmsU8SL8eo23vbyeNkGoalOX3veo6u7gF3BPO9ueCRS7Hf3VAUuBBa3KLACaqq+WA5eIiKhqtao2jTeRjNvNuDEmNhyrrufD0qM2OFAnDembzGVTvB+StKON1JeGmHdFO+uMAILvxSp154Us4yaEY0AmgIjMEpHNOP0/3R2UMJqJyJdEpFBECsvKvG+wMcZ0j1U7/ATUbm/tisVzcjhe08AfNno3JGl7bRD/IiKbgImt2h92Ae22QXSFqq5V1cnAecC3ROSUYaZU9RlVzVPVvEGD7JuIMdEiv9hPWpKP3JH9wh1K1Dovp78zJOlq74Ykbe8K4jc4bQ0raNn2cK6q3tbOuvuAkUHvs9x5Icu4bQwZQHlwAVXdClQCU9rZnzEmShQU+Zk9ZkCPdl0da0SExefnsHX/cQo9GpK0vTaIY6paoqo3t2qDONyBba8HxovIaBFJBG7CSTTBVgCL3emFwJuqqu46PgARyQbOAkrO4LiMMRFqd3kVew5XW/tDN1iQO5y+yT5eWFXiyfY9uzNIVRtE5F7gdSAeeE5VN4vIo0Chqq4AnsXpKbYYOIyTRADmAQ+JSD0QwGkk93sVqzGm5zR1r2HjT3ddn0Qf/3btFEZ59CS6p7eOqupKnMGGguc9HDRdA9wQYr0XgRe9jM0YEx4FRX6GZyQzZmBquEOJCQtyW9/7032sAtAY02MaGgOs2uFn3viBNA1dbCKXJQhjTI/5cN8xjtc0WPtDlLAEYYzpMQVFfkRg7jhrf4gGliCMMT2moMjP5OF9GZCaGO5QTAdYgjDG9IjK2gbe23PEem+NIpYgjDE9Ys2OchoCygV2e2vUsARhjOkRBcV+khPiODenf7hDMR1kCcIY0yPyi8qYOTqTJF98uEMxHWQJwhjjuU+OnmBHWZVVL0UZSxDGGM8VWPcaUckShDHGc/nFfgalJzFxSHq4QzFnwBKEMcZTgYDybrGfeeOse41oYwnCGOOpLfuPc7iqzkaPi0KWIIwxnmru3tu614g6liCMMZ4qKC5j4pB0Bvc9ZdRgE+EsQRhjPFNT38j6kiN291KUsgRhjPHMul2HqWsIWPtDlLIEYYzxTH5RGYnxccwanRnuUEwneJogRORyEdkmIsUi8lCI5UkissxdvlZEctz5l4rIBhHZ5P682Ms4jTHeyC/yc252f1ISrXuNaORZghCReOAp4ApgEnCziExqVewu4IiqjgOeAH7gzvcDV6vqVGAxNj61MVHnUEUNHx+osPaHKOblFcRMoFhVd6pqHbAUWNCqzALgBXd6OXCJiIiqvq+qn7jzNwMpIpLkYazGmG72brFze+sFNrxo1PIyQYwA9ga9L3XnhSyjqg3AMaB1ZeXngPdUtbb1DkTkSyJSKCKFZWVl3Ra4Mabr8ov89O+TwOThfcMdiumkiG6kFpHJONVO/xxquao+o6p5qpo3aJB9SzEmUqgqBUV+zh83kLg4614jWnmZIPYBI4PeZ7nzQpYRER+QAZS777OAV4FFqrrDwziNMd2s6FAlhypqmW9PT0c1LxPEemC8iIwWkUTgJmBFqzIrcBqhARYCb6qqikg/4E/AQ6r6rocxGmM88M52p8rXGqijm2cJwm1TuBd4HdgKvKyqm0XkURG5xi32LJApIsXA14CmW2HvBcYBD4vIRvc12KtYjTHdq6DYz5iBqWT17xPuUEwX+LzcuKquBFa2mvdw0HQNcEOI9f4d+HcvYzPGeKO2oZG1Ow9zQ15WuEMxXRTRjdTGmOjz3u6jnKhvtN5bY4AlCGNMt8ovKiM+Tpgz1rrXiHaWIIwx3aqg2M85I/uRnpwQ7lBMF1mCMMZ0myNVdWzad8zuXooRliCMMd1m1Y5yVLHuvWOEJQhjTLfJLyojPcnH9Kx+4Q7FdANLEMaYbqGq5Bf5mTM2E1+8nVpigafPQRhjeo+S8mr2HT3B3ReOCXcosUUVThyB4/vg+CdBP4OmR18In/2vbt+1JQhjTLcoKHK615hv3Xt3XCAAVWWhT/rHP4EK92dDTcv1JA7Sh0Hf4TD4bOflAUsQxphu8U6Rn6z+KWRnWvcaADQ2QOWBEN/6P2mZAAINLdeLS3BO/H1HwPAZcNZVznTfYe7P4ZA6GOK9P31bgjDGdFlDY4A1O8q5avowRHpB994Ntaee6FsngsqDoIGW6/lSIGOE8+0/+3w3EQw/eeLvOwL6ZEJcZLThWIIwxnTZB6VHqahtYN64GKheqquC4/tPX+df7T91vaS+J0/4g89uedJvmp/cD6IogVqCMMZ0WX6RHxGYOy7Cu9cIBJyT/OGdcHR36ARQc+zU9VIGnDzRjzi35Um/73DniiA59kbOswRhjOmy/CI/00Zk0K9PYrhDcer+j5dC+Q4nERze5f7cCUdKoDF49GKBtMHOSX7AGMiee+q3/r7DISElXEcTVpYgjDFdcrymno17j/bs7a2N9XB0z8kTf/DryG4I1J8s60txTv4Dx8OEy5zpzLHQL9v55u+LgKQWoSxBGGO6ZM2OchoD2v3tDw21zsk+VBI4uge08WTZxDQYMBqGTIazr3GSQNMrfWhU1ftHEksQxpguyS/y0ycxnhnZ/c585foTTrVPqCRwrLTlXUBJGU4SGDEDpi5smQRSB1kS8IAlCGNMlxQU+5k1egBJvvjQBeqqWrYDBL+O72tZNqU/DBgLI2fD9DEtk0CfAZYEepinCUJELgf+B4gHfqmqj7VangQsAc4FyoEbVbVERDKB5cB5wPOqeq+XcRpjOqf0SDW7/FXcmZcJ+z9olQB2OQ3FlQdarpQ6yDnhj74gKAGMhv6jnSRgIoZnCUJE4oGngEuBUmC9iKxQ1S1Bxe4CjqjqOBG5CfgBcCNQA/wrMMV9GWPCTRUOfAj+ouYrgqQ9W1iftJNBbx+Ht4PKpg11TvzjPu2c/IOvBGLwdtBY5eUVxEygWFV3AojIUmABEJwgFgCPuNPLgSdFRFS1CigQkXEexmeM6Yj6GvhwGaz5KZR9fHJ+3xEcqR/ElviZLPjUPCRzrJMA+udAUlrYwjXdx8sEMQLYG/S+FJjVVhlVbRCRY0AmEOIxRWNMj6osg/W/dF7Vfhg6DRY85Two1j+HxvhkPv/vf+WSs4Zw7fzp4Y7WeCCqG6lF5EvAlwBGjRoV5miMiRGHtjpXCx8scx4qm3AFzPky5Mxr0Ui8ufQoR6vrbfS4GOZlgtgHjAx6n+XOC1WmVER8QAZOY3WHqOozwDMAeXl52qVojenNVGHHm05iKP6b83DZObfB7H9xHjALIb/IudCfO84SRKzyMkGsB8aLyGicRHATcEurMiuAxcBqYCHwpqraid6YntJQC5t+B6ufgkNbIG0IXPyvkPeFdu8oyi8q4+xhfRmUntRDwZqe5lmCcNsU7gVex7nN9TlV3SwijwKFqroCeBZ4UUSKgcM4SQQAESkB+gKJInIt8JlWd0AZYzqryg+Fz8G6X0DVIRgyBa59GqZcD772T/jVdQ1s2H2EO+eO7oFgTbh42gahqiuBla3mPRw0XQPc0Ma6OV7GZkyvVLbNbV9Y6oxSNv4zMOde55mEM3gIbe2uw9Q3KvOseimmRXUjtTGmA1Rh1z+caqSiN8CXDNNvgtn3wKCJndpkQZGfRF8cM0fbg22xzBKEMbGqoRY+esVJDAc/cp5g/tS3nfaF1K59888vKmNmzgCSE9roXsPEBEsQxsSa6sNQ+KzTvlB5EAZPcp5fmLIQEpK7vPmDx2vYfrCS62dkdUOwJpJZgjAmVviLnPaFjb+FhhNONxdznoYxn+rWTu4K3Ntbrf0h9lmCMCaaqUJJAax+Erb/BeKTYNrnnQfbBp/tyS4Liv1kpiYyaZj1qRTrLEEYE40a6mDzq05iOPAh9BkIFz4E593lDKHpEVUlv8jP3HEDiYuzrrdjnSUIY6JJ9WHY8DysewYq9sPAiXD1/3OuGnpg3OSPD1Tgr6xlnnWv0StYgjAmGpTvgDU/g40vQX21065wzZMw9mKIi+uxMJraH6z/pd7BEoQxkUoVdq9yblPdthLiE2Dq52HOPc7Yy2GQX+xn7KBUhmV4f7Viws8ShDGRprEeNr/mtC/s3wgpA+CCB+G8L0L6kLCFVVPfyNqd5dw803pO7i0sQZieo+p071B/whmnuP4E1Ls/66qdqpOmV1210ydQ2mBndLL0IU5Hcj1Qzx42J47Ahhec9oXj+yBzPFz1BEy7CRL79Ggo9Y0BSvxVbDtYwfYDFWw/WMnWA8epbQhY9VIvYgnCnBRodE/aQSfpFifxqhDLm16tlreVAOhiZ71JGU7SSB/qJIy0ISeTR9qQk/NT+kfPAPeHd8Kap+H9Xzu/r9EXOIlh3KWety8EAsreI9VsO1DB9oMVbDtYSdHBCnaUVVLf6HxWcQI5mamcPbQvn88byQUTBnkak4kcliBiQV01HNsLR3Y7A8TXVZ/+m3lbCaCh5sz37UtxvtUnpjo/E/o4rz4D3Peppy5vXTaxz8np4LINtc6TwBUHneNqnnZf+zY4P+urT40rLiEoeQwNSiqtrkhSB4MvseufwZlShb1rYdVP4OM/QZwPpi50+kcaNs2D3SkHjtecTAQHKtl+sIKiQxXU1Aeay2X1T2HCkHQumjiYiUPTmDAknbGD0qxLjV7KEkQ0qK+BY6VwtASO7nFeR3a707uhqqyNFcU92fY59SSdNrTtE3OoE3eLsu57X4r3d9CkDYahU09fprYCKg9BxQE3kTRNH3LeHylxTsbVbYxkmzKg/SuStCGQlN71q5LGBtj6B6fhed8GSO4H878G5/0T9B3WtW27/JW1bHerhrYdrGyerqhtaC4zOD2JiUPTuWVmdnMiGD8knbQkOyWYk+yvIRI01MHx0lNP/E3JoGJ/y/JxCZCRBf2zYeIV0C/bfY2CvsNPJgVfUvRUs3RFUrrzyhx7+nKN9U4yrThw8iqk+erETSrlO5z3jXWnru9LOc0VSdB06kCIa/WNu+YYvLcE1v7cudobMBY++98w/Wbn8+qEYyfqKTrotA84VwXO1UF51cnYM1ISmDg0nWvPGcGEIU4imDAknf6pYbhqMlHHEkRPaGxwGh1bn/ibkkHFJ6AnL/OReMgY4Zz0x17inPj7uwmgX7ZzMmp9AjLti09wEmjf4acvp+o0GDddgTRfkTQllQPOuAq7/uGc+FuTOKfn1OArj6I3oK4SsufBFT+ECZd3+Oqruq6B4kOVbDtQQZH7c/vBCvYfO1klmJoYz/gh6Xz67CFMGJrOhCFpTBySzqD0JKQ3fEkwnrAE0R0Cjc5Jo+nk3+IqYDcc2wfaGLSCQN8Rzgl/9Hz3xD8q6CpgBMTbRxM2Ik4bSp8BMPis05etP+EmkqDk0eLq5CAc2upc6c35Mgw/p81N1TUE2Ok/mQCargz2HK6maSDeRF8c4walMXtMJhOGpDNxaBrjB6czol+KdX1hup2dhToiEHCGZWx94m9KBsdKIVDfcp30Yc7JfuQsmJrd8iqgb1anG0YbGgNU1TVSVdtAVW0DlbUNVNU2uj8bOFHfSECVxoDzUoVGbZpWGgPO+0BAnXLN09Dozgu45QIBd7lbplE5Oe2u07Svk+spgQDtbLvVvOb9BO0zoMTFCcm+eJIS4kjyxZHki3d+JsQFzXfn+eJITmhafnJeUnC5Vts5Wb7lds7oG3dCivO59s/u8CqNAWV3eVWLxuLtByvY5a+iIeBkgvg4YfTAVKYMz+D6c7Ka2wlGDeiDL77nnpw2vZunCUJELgf+B2dM6l+q6mOtlicBS4BzgXLgRlUtcZd9C7gLaATuV9XXPQtU1Rmj9+iekw3BR4Kqgo7ugcbaluukDnK+8Q8/ByZfG3QVkOO0D7j97gcCSnV948mTeXUDlUeOU1UbNK/5ZO/Oqzt1XlPZ2oZA6+g7JT5OiBOIE3GnnffN03FCvDsvLq6NMk3rutuKd9eLi4OEuLiWZYLXdd/Hu9t2poO2484LqFJbH6C2oZHahgC1DQFq6hupqQ9w7ES9u8xZXhNUTrt6J21TcmmVaJLPINEEz/PFxVF65ERzO0FxWSV17ucoAiP792HCkHQ+M3mIe1WQzuiBqST5rBrRhJdnCUJE4oGngEuBUmC9iKxQ1S1Bxe4CjqjqOBG5CfgBcKOITAJuAiYDw4G/icgE1Rb1NN2jtBBeuPqUWyUDyQOo75tFTd/xVA+9iOPJIziaOJTyhGEcjBvE8YZEqurcE7y/gap9TSf7A1TVljaf+KvrGzt0whKB1EQfqUnxpCb5SEvykZroY0S/RNKC57mvpnnBZdOSfCQnxhHf4sTddPKlxYk4Vqkq9Y3anCxq6t3kEiLROPNPzmuRaIKST4ty9QGOVNWdXKe+kZqg5U1XAKEMy0hm/JB05o7LbE4E4wan0SfRLuRNZPLyL3MmUKyqOwFEZCmwAAhOEAuAR9zp5cCT4lzfLwCWqmotsEtEit3tre7uILfX9uNDuZQ98QPZ2ZjJjvpM9jQOpKomBY6GWqPKfUFyQtzJk7Z7gh6Ylkh2Zp+QJ/OmE/nJk318c7mUhPiYPnH3FBEh0Sck+uJID8P+GxoD1DU6iaTGTTR1jQGG9E0mIyUhDBEZ03leJogRwN6g96XArLbKqGqDiBwDMt35a1qtO8KLIJP7DefN7AdITfQxMMlHTlvf0IPm9Un0kZoYb3XB5hS++Dh88XH0sbtITQyI6mtbEfkS8CWAUaM614HYqMw+/PTWc7szLGOMiQlefgXeB4wMep/lzgtZRkR8QAZOY3VH1kVVn1HVPFXNGzTI+ocxxpju5GWCWA+MF5HRIpKI0+i8olWZFcBid3oh8Kaqqjv/JhFJEpHRwHhgnYexGmOMacWzKia3TeFe4HWc21yfU9XNIvIoUKiqK4BngRfdRujDOEkEt9zLOA3aDcCXPbmDyRhjTJtEu3rTeITIy8vTwsLCcIdhjDFRRUQ2qGpeqGV2G44xxpiQLEEYY4wJyRKEMcaYkCxBGGOMCSlmGqlFpAzY3YVNDATaGHIsqsTKcYAdSySKleMAO5Ym2aoa8kGymEkQXSUihW215EeTWDkOsGOJRLFyHGDH0hFWxWSMMSYkSxDGGGNCsgRx0jPhDqCbxMpxgB1LJIqV4wA7lnZZG4QxxpiQ7ArCGGNMSJYgjDHGhNSrE4SIPCcih0Tko3DH0lUiMlJE3hKRLSKyWUQeCHdMnSUiySKyTkQ+cI/le+GOqStEJF5E3heRP4Y7lq4QkRIR2SQiG0UkqnvGFJF+IrJcRD4Wka0iMifcMXWGiEx0P4+m13ER+Uq3bb83t0GIyAVAJbBEVaeEO56uEJFhwDBVfU9E0oENwLWquqWdVSOOOy55qqpWikgCUAA8oKpr2lk1IonI14A8oK+qXhXueDpLREqAPFWN+ofLROQFIF9Vf+mOV9NHVY+GOawuEZF4nIHVZqlqVx4abtarryBU9R2ccSiinqruV9X33OkKYCsejePtNXVUum8T3FdUfpMRkSzgs8Avwx2LcYhIBnABzng0qGpdtCcH1yXAju5KDtDLE0SsEpEc4BxgbZhD6TS3WmYjcAj4q6pG67H8GPgGEAhzHN1BgTdEZIM7Hny0Gg2UAb9yq/5+KSKp4Q6qG9wE/LY7N2gJIsaISBrwCvAVVT0e7ng6S1UbVTUXZzzymSISdVWAInIVcEhVN4Q7lm4yT1VnAFcAX3araKORD5gB/ExVzwGqgIfCG1LXuNVk1wC/687tWoKIIW59/SvAS6r6+3DH0x3cS/+3gMvDHEpnzAWucevulwIXi8ivwxtS56nqPvfnIeBVYGZ4I+q0UqA06Kp0OU7CiGZXAO+p6sHu3KgliBjhNuw+C2xV1cfDHU9XiMggEennTqcAlwIfhzWoTlDVb6lqlqrm4Fz+v6mqt4U5rE4RkVT35gfc6pjPAFF595+qHgD2ishEd9YlQNTdzNHKzXRz9RI4l1q9loj8FrgIGCgipcB3VfXZ8EbVaXOB24FNbt09wP9V1ZXhC6nThgEvuHdlxAEvq2pU3yIaA4YArzrfQ/ABv1HVv4Q3pC65D3jJrZrZCdwZ5ng6zU3YlwL/3O3b7s23uRpjjGmbVTEZY4wJyRKEMcaYkCxBGGOMCckShDHGmJAsQRhjjAnJEoQxXSAij4jI1zuxXq6IXNnV7RjjJUsQxoRHLnBle4WMCSdLEMacIRH5tohsF5ECYKI7b6yI/MXtyC5fRM5y5z8vIk+LSKG7zlXuw1mPAje6ffjf6G56koi8LSI7ReT+8BydMSf16iepjTlTInIuTrcZuTj/P+/hjL3xDHC3qhaJyCzgp8DF7mo5OP0WjcXpV2oc8DDO2Ar3utt9BDgL+BSQDmwTkZ+pan2PHJgxIViCMObMzAdeVdVqABFZASQD5wO/c7uiAEgKWudlVQ0ARSKyEycRhPInVa0FakXkEE73FqUeHIMxHWIJwpiuiwOOut2Th9K6P5u2+repDZpuxP4/TZhZG4QxZ+Yd4FoRSXF7N70aqAZ2icgN4PSsKyLTg9a5QUTiRGQsMAbYBlTgVCUZE7EsQRhzBtxhXZcBHwB/Bta7i24F7hKRD4DNwIKg1fYA69zyd6tqDU5bxKRWjdTGRBTrzdUYD4nI88AfVXV5uGMx5kzZFYQxxpiQ7ArCGGNMSHYFYYwxJiRLEMYYY0KyBGGMMSYkSxDGGGNCsgRhjDEmpP8PBUr5F2HTPsAAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -283,53 +428,73 @@ } ], "source": [ - "depth_range = range(2, 11)\n", - "tensor_times, quimb_times = cb.run_with_depths(qubits, depth_range)\n", - "cb.display_tabel_and_plot(tensor_times, quimb_times, depth_range, has_qubits = False)" + "cb = CircuitBenchmark(n = 5, dense = True, full_reduce = True)\n", + "cb.test(has_qubits = False, fixed_quant = 5, range = range(1, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When `full_reduce` comes into play, there are two possible scenarios: either the graph is simplied enough so that we end up with a small graph and `to_tensor` slightly outperforms `to_quimb_tensor` because the former employs a numerical order path whereas the latter needs to find a path before doing the contraction, or the simplification leads to a complex graph where there are spiders with many wires and that leads to an explosion (spike) in time for `to_tensor` which is not the case for `to_quimb_tensor`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As with `full_reduce = False`, we got two functions that grow almost the same at the beginning, up to a constant factor, with Quimb having the (much) better constant; then `to_tensor` time increases exponentially.\n", - "\n", "### Comparing different contraction path finder strategies\n", "Now we will look at different contraction strategies that Quimb can use when performing the contraction. It is very important to note that finding the contraction path and actually performing the contraction are done separately and there is a performance trade off between them.\n", "\n", - "We employ some Hyper optimizers, namely **Greedy** (an agglomerative approach), **Betweenness** (community detection) and **KaHyPar** (a divisive approach, i.e. building the contraction tree from the top down), as per [this](https://quantum-journal.org/papers/q-2021-03-15-410/) paper.\n", + "We employ some Hyper optimizers, namely **Greedy** (an agglomerative approach), **KaHyPar** (a divisive approach, i.e. building the contraction tree from the top down), and **Optimal** (an approach that finds the optimal contraction path using dynamic programming) as per [this](https://quantum-journal.org/papers/q-2021-03-15-410/) paper. Unfortunately **Betweenness** (community detection) can't be used because it only works with simple graphs, i.e. without hyperedges, which is not the case here.\n", "\n", "The class `QuimbStrategies` that we use for this benchmark is very similar to the one above, having methods with the same labels." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "class QuimbStrategies:\n", - " def __init__(self, n: int, strategies):\n", + " def __init__(self, n: int, strategies, dense: bool = False, full_reduce: bool = False):\n", " self.__n = n\n", " self.__strategies = strategies\n", + " self.__dense = dense\n", + " self.__full_reduce = full_reduce\n", " \n", " def run_with_qubits(self, depth, qubits_range):\n", - " self.__depth = depth\n", " times = [[] for _ in range(1 + len(self.__strategies))]\n", + " self.__depth = depth\n", " \n", " for qubits in qubits_range:\n", " self.__qubits = qubits\n", + " self.__generator = CircuitGenerator(self.__dense, qubits, depth)\n", + " methods_times = self.__run_tensors()\n", + " for i, time in enumerate(methods_times):\n", + " times[i].append(time)\n", + " return times\n", + " \n", + " def run_with_depths(self, qubits, depth_range):\n", + " times = [[] for _ in range(1 + len(self.__strategies))]\n", + " self.__qubits = qubits\n", + " \n", + " for depth in depth_range:\n", + " self.__depth = depth\n", + " self.__generator = CircuitGenerator(self.__dense, qubits, depth)\n", " methods_times = self.__run_tensors()\n", " for i, time in enumerate(methods_times):\n", " times[i].append(time)\n", " return times\n", " \n", " def __run_tensor(self):\n", - " circuit = zx.generate.CNOT_HAD_PHASE_circuit(qubits = self.__qubits, depth = self.__depth, clifford = False)\n", - " g = circuit.to_graph()\n", + " g = self.__generator()\n", " g.apply_state(\"0\" * self.__qubits)\n", " g.apply_effect(\"0\" * self.__qubits)\n", " zx.to_gh(g)\n", + " if self.__full_reduce:\n", + " zx.full_reduce(g)\n", " \n", " t = time.time()\n", " tensor = zx.to_quimb_tensor(g).contract(output_inds = ())\n", @@ -349,25 +514,34 @@ " return [np.mean(collection_of_times) for collection_of_times in self.__times]\n", " \n", " def display_plot(self, times, range, has_qubits: bool):\n", - " this_type, other_type, quantity = (\"qubits\", \"depth\", self.__depth) if has_qubits else \\\n", - " (\"depth\", \"qubits\", self.__qubits)\n", + " var_type, fixed_type, fixed_quant = (\"qubits\", \"depth\", self.__depth) if has_qubits else \\\n", + " (\"depth\", \"qubits\", self.__qubits)\n", " fig, ax = plt.subplots()\n", " for i, method_times in enumerate(times):\n", " ax.plot(range, method_times, '--', label = \"basic\" if i == 0 else self.__strategies[i - 1])\n", - " ax.set_xlabel(this_type)\n", + " ax.set_xlabel(var_type)\n", " ax.set_ylabel(\"time (s)\")\n", - " ax.set_title(\"From {} to {} {}, fixed {} of {}\".format(range[0], range[-1], this_type, other_type, quantity))\n", - " ax.legend()" + " ax.set_title(\n", + " \"From {} to {} {}, fixed {} of {}\".format(\n", + " range[0], range[-1], var_type, fixed_type, fixed_quant\n", + " )\n", + " )\n", + " ax.legend()\n", + " \n", + " def test(self, has_qubits: bool, fixed_quant: int, range):\n", + " times = self.run_with_qubits(fixed_quant, range) if has_qubits \\\n", + " else self.run_with_depths(fixed_quant, range)\n", + " qs.display_plot(times, range, has_qubits)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 46, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -380,14 +554,109 @@ ], "source": [ "qs = QuimbStrategies(1, [\"hyper-greedy\", \"hyper-kahypar\", \"hyper-betweenness\", \"optimal\"])\n", - "qs.display_plot(qs.run_with_qubits(depth, qubits_range), qubits_range, has_qubits = True)" + "qs.test(has_qubits = True, fixed_quant = 20, range = range(2, 51))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We conclude that the hyper optimizers perform well and almost the same, but are worse than the basic greedy path optimizer that Quimb employs because of the time needed to find the paths." + "We conclude that the hyper optimizers perform well and almost the same when the number of qubits varies, but are worse than the basic greedy path optimizer because of the time needed to find the paths." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "qs = QuimbStrategies(3, [\"hyper-greedy\", \"hyper-kahypar\", \"hyper-betweenness\", \"optimal\"])\n", + "qs.test(has_qubits = False, fixed_quant = 15, range = range(1, 51))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When the depth varies and the number of qubits is fixed, the same behaviour can be observed as when comparing `to_tensor` against `to_quimb_tensor`. The graphs increase linearly; the slope for the custom methods are (almost) identical and worse than the one for the basic optimizer. Ocasional spikes occur for all methods." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "qs = QuimbStrategies(5, [\"hyper-greedy\", \"hyper-kahypar\"], dense = True)\n", + "qs.test(has_qubits = False, fixed_quant = 5, range = range(1, 11))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A rather striking fact can be observed when dense circuits are used without `full_reduce`: the custom optimisers perform poorly on dense circuits, i.e. time increases exponentially with the depth, whilst the basic one is able to mantain a linear increase with respect to the depth." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "qs = QuimbStrategies(2, \n", + " [\"hyper-greedy\", \"hyper-kahypar\"], \n", + " dense = True, \n", + " full_reduce = True)\n", + "qs.test(has_qubits = False, fixed_quant = 5, range = range(2, 5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When performing `full_reduce` before transforming the diagram into a tensor network, the same behaviour can be observed, even more extreme: **Hyper-KaHyPar** method takes more than 5 seconds to process a dense graph with five qubits and four layers.\n", + "\n", + "This effect of increasing the time when `full_reduce` is performed on dense graphs is due to obtaining small but very connected graphs where the basic approach performs better by not having to search for multiple paths and choosing the best one like the other approaches do." ] } ], diff --git a/pyzx/quimb.py b/pyzx/quimb.py index 94f632a1..b0eceab5 100644 --- a/pyzx/quimb.py +++ b/pyzx/quimb.py @@ -66,6 +66,8 @@ def to_quimb_tensor(g: BaseGraph) -> 'qtn.TensorNetwork': # Grab the float factor and exponent from the scalar scalar_float = np.exp(1j * np.pi * g.scalar.phase) * g.scalar.floatfactor + for node in g.scalar.phasenodes: # Each node is a Fraction + scalar_float *= 1 + np.exp(1j * np.pi * node) scalar_exp = math.log10(math.sqrt(2)) * g.scalar.power2 # If the TN is empty, create a single 0-tensor with scalar factor, otherwise diff --git a/tests/test_quimb.py b/tests/test_quimb.py index 3ab5b4ff..d52c5f13 100644 --- a/tests/test_quimb.py +++ b/tests/test_quimb.py @@ -37,6 +37,7 @@ from pyzx.graph import Graph from pyzx.utils import EdgeType, VertexType from pyzx.quimb import to_quimb_tensor +from pyzx.simplify import full_reduce @unittest.skipUnless(np, "numpy needs to be installed for this to run") @unittest.skipUnless(qu, "quimb needs to be installed for this to run") @@ -111,6 +112,18 @@ def test_phases_tensor(self): self.assertTrue(abs((tn & qtn.Tensor(data = [0, 1], inds = ("0",)) & qtn.Tensor(data = [0, 1j], inds = ("3",))) .contract(output_inds = ()) + 1) < 1e-9) + + def test_scalar(self): + g = Graph() + x = g.add_vertex(VertexType.Z, row = 0, phase = 1 / 2) + y = g.add_vertex(VertexType.Z, row = 1, phase = 1 / 4) + g.add_edge(g.edge(x, y), edgetype = EdgeType.SIMPLE) + + full_reduce(g) + val = to_quimb_tensor(g).contract(output_inds = ()) + expected_val = 1 + np.exp(1j * np.pi * 3 / 4) + self.assertTrue(abs(val - expected_val) < 1e-9) + if __name__ == '__main__': unittest.main()