From c2a01d0c1977e97bf5798e64236151ed03ed2e89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20Kn=C3=BCttel?= Date: Fri, 1 Nov 2019 19:07:45 +0100 Subject: [PATCH] did some work --- computations/C_L_elements_and_products.ipynb | 10 +- computations/Untitled.ipynb | 139 ++- .../local_clifford_group_elements_raw.ipynb | 1041 ++++++++++++++++- thesis/Makefile | 3 +- thesis/chapters/graph_simulator.tex | 131 ++- thesis/chapters/introduction_qc.tex | 68 +- thesis/chapters/naive_simulator.tex | 39 +- thesis/main.bib | 28 +- thesis/main.tex | 6 + 9 files changed, 1382 insertions(+), 83 deletions(-) diff --git a/computations/C_L_elements_and_products.ipynb b/computations/C_L_elements_and_products.ipynb index 0fe8ef5..41dc501 100644 --- a/computations/C_L_elements_and_products.ipynb +++ b/computations/C_L_elements_and_products.ipynb @@ -160,7 +160,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -211,7 +211,7 @@ " ⎦⎦" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -230,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -250,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -288,7 +288,7 @@ "4, 21, 15, 7, 16, 19, 10, 14, 0, 20, 8, 9, 23, 6, 2, 11, 13, 1, 3, 17, 5]]" ] }, - "execution_count": 12, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } diff --git a/computations/Untitled.ipynb b/computations/Untitled.ipynb index 4b7ac78..292d268 100644 --- a/computations/Untitled.ipynb +++ b/computations/Untitled.ipynb @@ -6,10 +6,147 @@ "metadata": {}, "outputs": [], "source": [ + "from itertools import product\n", + "from functools import reduce\n", + "from operator import iconcat\n", "import sympy\n", "i = sympy.I\n", "exp = sympy.exp\n", - "M = sympy.Matrix" + "M = sympy.Matrix\n", + "simplify = sympy.simplify\n", + "from sympy.physics.quantum.dagger import Dagger\n", + "\n", + "sympy.init_printing()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "I = M([[1, 0], [0, 1]])\n", + "X = M([[0, 1], [1, 0]])\n", + "Y = M([[0, -i], [i, 0]])\n", + "Z = M([[1, 0], [0, -1]])\n", + "O = M([[0, 0], [0, 0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "H = M([[1, 1], [1, -1]]) / sympy.sqrt(2)\n", + "S = M([[1, 0], [0, i]])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "s2m = {\"H\": H, \"S\": S}\n", + "def evalstr(s):\n", + " m = I\n", + " \n", + " for c in s:\n", + " m *= s2m[c]\n", + " \n", + " m.simplify()\n", + " return m" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2} i}{2} & \\frac{\\sqrt{2}}{2}\\\\- \\frac{\\sqrt{2} i}{2} & \\frac{\\sqrt{2}}{2}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡ √2⋅ⅈ √2⎤\n", + "⎢ ──── ──⎥\n", + "⎢ 2 2 ⎥\n", + "⎢ ⎥\n", + "⎢-√2⋅ⅈ √2⎥\n", + "⎢────── ──⎥\n", + "⎣ 2 2 ⎦" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evalstr(\"HSHSSH\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2} i}{2}\\\\\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2} i}{2}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡√2 √2⋅ⅈ ⎤\n", + "⎢── ──── ⎥\n", + "⎢2 2 ⎥\n", + "⎢ ⎥\n", + "⎢√2 -√2⋅ⅈ ⎥\n", + "⎢── ──────⎥\n", + "⎣2 2 ⎦" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evalstr(\"HS\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHkAAAA/CAYAAADE+2c4AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAFIklEQVR4Ae2cjXXTMBSFEw4DQEcIGwAjpBuUEQIbwGECTkeAFRihsEHLBjACdIPwXdc2qurGJNF7UizrHNWW/6R7r96TLeV1uVgs1uQrcpx+bbfbF/HBuVwmA8vl8oaWvRxo3ZunwcHzYF+7v6PyXCybgQ3NO4ua2BhvLzJW+y26wLxI79uOVUK7lmPXTPX8PvzA04+YB+6/1bEn8QmvMg14S13vJOKu7NWe0upJyU9vyRlAvkHceIjI0Ixiq0zGTxaR6aXvofaz6GX/GZuP2iet7jaLDR2gcTVtuapNan6yiIxi54EVX7L/rlMRgBJfb4o1v9kn52cNofC81R/zTF2y4ouuLtVNXgdlWbOOveyO1bQFdzJ+eNYf8oWrJbeuOeyltGEhK77WTu3Jip/kb9c0dEXWm/NQ0th7GZ7ASr+Qw/FXomsi5sEnQXjfqe7n4ieZu4Z4PUsiyt0+C92syuSr8Fi8z3nN2PzUtfG5KZTB5coP9TXumm1TMRymG495pl6c9ELVj/GU9UL16DjLOY3FmqGZpMARFy78wKWpyBdU0FuzhCM/asWck8BfOyLYl0WvuvLUtmBz4Yd67ESWKCS53caa2T5qxZzrLFjCdlnXT9qiwWfOD3WYi6zeqkokXG+lsVW216hX3MvxdVMrg9ecn5bbC03+62VArjT5QgBvkuqtZ+RXPP8X2zkFDFjzw/NlZJunQZ0Wux94qL6LZ4GH2XXhx9SSh3HNR70YSG7JPLB520oNwGIY2aeN4NKXwXeytv+btIJ0bzInJz/J3HVuMf6X/X2vA9ct97za9774+pz8JJ/WjMHN5fwMJLPkXVBal6d5ayV9FyttWiu5K1X815ofF5HRb14z3t2JTfnxctdv6a3rAKcWMbRapYmSOS0Wpvx4iTyvGe/uyqb8uLhrxt4vEcZJrxlHWEeL1vx4WXIPtHXRmrc9+rOkf+iEdiz4cRUZACv00HisuWx9f84pYMCKHxd3LRwdAMRtfmvd9thbyvO8tjE/LpbcCqw14k8StxVY4/Icb/VPYDN+XBYoEFVLXg/mfrHi5Mub1HNyyYqf9rnmS40N4Yj5/OSYd2ywNT9uY/IhnNETR1e2puwNUuF3GZMPFLjqqEcEToa/ZEtOFtV3SCcr4J5k+IsUmV5cddRjavxFiowVhfFSpis0BVjsUBOS419TC+8v/6Idcu7TlmRRfTlxHFp3Svw8q/nddVGWjJvSt3TYiynWE/Vohd/97RogVUc95sLv5q6xStVVbdSjN37qa9w12/RRjWPjEXW6RPWNtSPXeS/81JNVZJeovlwijtUL+S74s4osEkjmUX1jZOc874G/BJHNo/pyijhWNwKY4+9EdllqpLLBxJtm1VGP1vh5vsZkn6XGQYXvDrpE9e2oP/cpF/yjkyH0Bk1QmAZ8Ucdj/y1oVATcoukPD6aAf1RkSNQP7o7+ZaW1GKO94cALpoDffcbrQK7n245gYNSSj3j2Xre2brHKoDhr7MWITI+ocUmxMwRT7CW5a9Ogr47NQrem2EsS2TToq1Bxu2aZYi/GXfMWW21QnDX2kiy569UKqVHcsqb9jv506x96IjsW2IsTGZAr9KgyKM4KezHuWobWgcR9VRcUZ4m9GEtuQZoFfZXsra2xZ12FCokHqFZMqgyKs8LePjf7KlSvMy662qA4a+y9u0b1bZS11junE2EA7W4i/fTzm8Yzyl1r5/UAlt/0sHv/H3LgmvlQIQwgsD479W+n43T9FyVSzpC8C/88AAAAAElFTkSuQmCC\n", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}\\\\- \\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡ √2 -√2 ⎤\n", + "⎢ ── ────⎥\n", + "⎢ 2 2 ⎥\n", + "⎢ ⎥\n", + "⎢-√2 -√2 ⎥\n", + "⎢──── ────⎥\n", + "⎣ 2 2 ⎦" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evalstr(\"SSHSS\")" ] } ], diff --git a/computations/local_clifford_group_elements_raw.ipynb b/computations/local_clifford_group_elements_raw.ipynb index 2008957..9c9a976 100644 --- a/computations/local_clifford_group_elements_raw.ipynb +++ b/computations/local_clifford_group_elements_raw.ipynb @@ -1,5 +1,15 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Computing the Elements of the Local Clifford Group\n", + "\n", + "From Anders&Briegel 2005 it is known, that the Local Clifford Group (LC) has 24 elements.\n", + "Also one can disregrad a global phase. Below are the computed elements." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -7,6 +17,8 @@ "outputs": [], "source": [ "from itertools import product\n", + "from functools import reduce\n", + "from operator import iconcat\n", "import sympy\n", "i = sympy.I\n", "exp = sympy.exp\n", @@ -116,8 +128,9 @@ " \n", " for c in s:\n", " m *= s2m[c]\n", - " \n", + " \n", " m.simplify()\n", + " \n", " return m" ] }, @@ -481,36 +494,6 @@ "cell_type": "code", "execution_count": 20, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/latex": [ - "$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2} i}{2}\\\\- \\frac{\\sqrt{2} i}{2} & \\frac{\\sqrt{2}}{2}\\end{matrix}\\right]$" - ], - "text/plain": [ - "⎡ √2 -√2⋅ⅈ ⎤\n", - "⎢ ── ──────⎥\n", - "⎢ 2 2 ⎥\n", - "⎢ ⎥\n", - "⎢-√2⋅ⅈ √2 ⎥\n", - "⎢────── ── ⎥\n", - "⎣ 2 2 ⎦" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "evalstr(\"SSSHSSS\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, "outputs": [ { "data": { @@ -528,18 +511,18 @@ "⎣2 2 2 2⎦" ] }, - "execution_count": 21, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "evalstr(\"HSH\")# = exp(i*pi/4) SSSHSSS" + "evalstr(\"HSH\") # = exp(i*pi/4) SSSHSSS" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -554,7 +537,7 @@ "⎣1 0⎦" ] }, - "execution_count": 22, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -565,7 +548,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -580,7 +563,7 @@ "⎣ⅈ 0⎦" ] }, - "execution_count": 23, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -591,7 +574,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -606,7 +589,7 @@ "⎣1 0⎦" ] }, - "execution_count": 24, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -617,7 +600,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -632,7 +615,7 @@ "⎣ⅈ 0⎦" ] }, - "execution_count": 25, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -643,7 +626,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -662,7 +645,7 @@ "⎣ 2 2 ⎦" ] }, - "execution_count": 26, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -673,7 +656,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -692,7 +675,7 @@ "⎣ 2 2 ⎦" ] }, - "execution_count": 27, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -703,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -722,7 +705,7 @@ "⎣ 2 2 ⎦" ] }, - "execution_count": 28, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -733,7 +716,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -752,7 +735,7 @@ "⎣2 2 2 2⎦" ] }, - "execution_count": 29, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -763,7 +746,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -782,7 +765,7 @@ "⎣2 2 2 ⎦" ] }, - "execution_count": 30, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -793,7 +776,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -812,7 +795,7 @@ "⎣2 2 2 2 ⎦" ] }, - "execution_count": 31, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -823,7 +806,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -842,7 +825,7 @@ "⎣ 2 2 2 2⎦" ] }, - "execution_count": 32, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -850,6 +833,954 @@ "source": [ "evalstr(\"SSHSH\")" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the string representation:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "LC = [\"H\", \"S\", \"SS\", \"HH\", \"HS\", \"SH\", \"HSS\", \"SSH\", \"SSS\", \"HSSS\", \"SSSH\",\n", + " \"SHS\", \"SHSS\", \"SSHS\", \"SSHSS\", \"SSHSSS\", \"HSH\", \"HSSH\", \"SHSSH\",\n", + " \"HSSHS\", \"HSSHSH\", \"SHSH\", \"SHSHS\", \"SSHSH\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABMAAAAOCAYAAADNGCeJAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABOElEQVQ4EX2TjU0DMQxGL0xwYoSyARIblA2Q2AA2aGfoCLBCR6ArdAS6QrvB8d7JiZLcUUtWnM//sTNM0zRAG/gr+Mz5Az+ru8fa6JNtkOdAxwx4QgdYYVvjvYz+Fy6+yMMRHlcMr+DXHs93dDu4CfYAsNUppTRy1nTiMoL7BA2B2d4tuOgMptOFjCrXqE+izTv23wvjXHZ/YmgLwO0QwGxvIw45rPJmVragaMP29rUyWr4R6FLjRe4zR0arKiPPNmCHLIfd/crI7r6dMP4sGRHAPzjU/UtNm+HgQ/WBbNn1WW8vwqco18xvYC/cyzuBGUTybBLM6DDo4xbMGzF/Fy7uTfMekcTJLRZaXehd7DLNxMWs/kWj1/TIxf/5VIO1TOXuh+/7mnEnIrjG51xFfWLrIGo/i9n9ATCSR9TdYl8YAAAAAElFTkSuQmCC\n", + "text/latex": [ + "$\\displaystyle 24$" + ], + "text/plain": [ + "24" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(LC)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAADGIAAAA/CAYAAAARr4/gAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAgAElEQVR4Ae2dj7XURtL2LxwHwPrNADKA3QgWMoDdCBZnYI4j8MEZgCPYFzIwbwQ2ZGAysL+bgb+qGWlGI7Va/b+rq545R3ekVnernl89amnmSqMHd3d3z2n6hab16+tff/31ZF344MGDqPrr9lguQ4Dy8Jl6euro7RXl7aOjHEUgAAIg0JUAjh9d8Xs3LvGYAr94UyZ2pTQvwUcyrCLNF0wF3oA3ZBBAFEsC2C+XNOTNYyyXl5MRI4KPRsxa+Zjhg/JMtfcozTMUD/4/Ith00vzCqOAZwYaJCE2at+CriOQNWFWa3wZEiJBBAARAAAQUEMD5zphJxHnMmHlD1CAAAiAAAiAAAscEfOc53yyav1jM8+yfq+X1Ymz9dXss5xH4DzX/dtWF64aaVRUsggAIgEB3Ajh+dE/BJgDJxxT4ZZMu0QVSvQQf9bWNVF8wFXgD3uhLAFt3EcB+6aLSvwxjef8caIgAPtKQxXwN8EE+Q2s9SPXMi1Uijv6fsqqOxUoEpPqF5cIzlZLeqFup3oKvGhmg8Wak+q0xBmwOBEAABEAABE4EcL4zlhFwHjNWvhAtCIAACIAACIBAOIHd85zLjRj0FIVP4f3d3cXWD+mb7hj566gebffBUR2J60nbB4rr5VFsofqo3pd1X7SN+3UZlkEABEBAGoHSx4/S46s0Xi30ST6mlPbLOr/EV+25x1rrvFzTU1K9VMNHNTnOuZL8HrPvSPUF863hjaO8xbA76kva+tj9QrI3pLG1FE+N/TLWm9p4lxh3JO+vNTwT6gGr3krVbdVHqbxCfdiyXgktVn3AeSJ+5j5/uvwZ6yOpnulx/Ill5+IvuazEPiLVL8y9tWe0+yXXy7F8pHqrta+Yeyy73FyN1r4EH6l+Gy0XiBcEQAAEQEAHgRrnO3S8xufzlT1KnMNwlziPWYHFIgiAAAiAAAiAgBoCvvOch1JU0knda4rlOwr2gW+SEm9MHJO2X3y65nUx/aIuCIAACFgnoH181a6vt381n3vssYWn9sjElVvnaHHfiXPIfm3N7KzvF/tZx5reBKx7U/O4A2/1IWB9n4qlromXJi2xeSxRH+PxmSJ8lO4m7eywj6R7w9VSu19cmmPKwCeG1m1dsLvlsV4CnzURLIMACIAACICAPALT8VrltWmptHEOk0oO7UAABEoQoDHoEU2PS/RlqQ9ws5RtaB2BwOWJGAKCfUU3I6wfKScgrCIhaNZWBBA6AQEQAIFEAtrH12h9fLJNLL+lY+rXRKaWmkXzVQDHouYaabPO0br+HE9pZqdZW07O0bY/AevejNaP88lg00azDe5ZdkWrulOzoolXtBaMJze2ieZ301rPAjik51I7u2h9GGO8Zorm6e1N30rwSc8p2PnZRfPBWOYHWmMtmB9TBaNjRqgBAiAwNIGo47WRMTGKCWffCBdRRgfz/HRYZDhp/hfR4xvQnuVTrNLDD9TrHzT9VKX3hE7BLQEamngJWBx/vEAKr5TAV8SNGATie2L7jvlOUHiA5dd8t9t/6GBwfy4a6+9SG0euTd8yG5O2ZdFpfoTcSYtdWjybpFYskKZdWjwx6EeOPUQn6bscO7j+pBfHj7s7cR9SQvLZus7SP9q8s8dyqZnrWNG9xyO13DrHpX54KM5FmtkttTGVUb0xxb1J7AifZzZBBxZo16zFm4Hp3FRb6p9yHXqujPPJDc3bgiVbXhPJ97azgZas6k5NkSZeGVownpzHiMv3F1bGC9d+k+EjV3emyrSzW+qL3Ecwxjj2hCVPXh3J1NGjriLwSc8n2PnZZfAZYiybxpINhPV3JlM9XOi1IXUtGJlRqA+uauvOSYsnRq202KXFA5YxBMrVHdkHoRRIY8rn8yGO1aEM1vWWTHjd5APWzC/fNXtDcInx9VRX8nmMaOYD8GNPJzOM8RJvqOYrNBaq95TieD7Fwj/oKvJFnyneSApMM7dQ77TIR8lYpr4kj9+MNHn8aZEP3za08y3lRRE3YlAiX9CgOj8N4y3Nfzcnl4S+o/nPND2ZywZ7X2rj0LXpW6aD8zSfiM/l72nmks+5UOD7B4ppPvmYw/tEM7Mv57JW7yOzzGWEXOQSvLaXxvIaWZk57eNrkj5pH1LKpLpKL0u+mo/NS3hLzVxuRfeSQYl56xyX+uGhOEdpZrfUxlRG9YbFc3CcL479fcPRKLTcN4P3S5xPHmE9rV+y5YJgvkG9y61kVXdqRjTxStKC8eRinSU/K+PFRfxiZsmBiy2zWGAJmtXObqkv2BcYY3a9s+TJlYKZ7vaoawX4pOcT7PzskvgMNJYdfmdC/9PHhV5+j/DFraMzkvY90qEvD1LSczVYlqMPlnpZllN27Wl5vA46Tx7oWH1VGTe3ZMIttXEJOlaMcIyW7MUR+LG5MxlKOt4E+Zr0fiHZXyg/L1k/XmEElHMbzsdHWTMy/hxhqLbeCN8i+8XDalkI7JiSdbnjeGrymsqWF8S/pfLHU1IDe5VRzaGNA1Ojb4cyn6Q/WEwj3ITBJ1s3cZM2CXHfxEQxSohpJ+3lipEL9SyLCNQ+vmrXV8QEGZ04+Go/NvM/eNbnW0xQve4MmzibWufo0A8POZ2yLdTMzqGNAYzsDVPn4ELPvbc7UUKJQm9GUXDoH3m/jNJeu7KDLW9SPV+rulP9pImXJi2p+cxp5+Cnfrxw8XJw4GomWbj4+Mq0s3Pogy98hjhY5+DJLcB04gY+BwbyrAY7DxxaZYiP9zsT+o7hC00/EZKvfmJ2147OSOj3SF5fSnUbWJbLDFiqZ1lMoON4bf482cGEeWvkcnisGP0YXWxHSezIAj+Bx5tDXyems1kzGoOe8zhEE18EjVcggRxuGn1sYfwJtEaVahb4ltovuj4RgwYGfuwRHxiWTx3gi81/q+KMhp3uaOMIVOhriBKbAgEQAIEbAtrH11R91I5vYuRfU/oHHVdf3UDDwoXADl/Vx+YdzcxEte5L0gvNWOe4ox8eCvCXZnY72pgKvBHgDVSpR8C6N3f0H+6X1A7nkwe23GHLrQ75HnQterVV3alJ0cQrVQu1w3hCBtrhp3q8cO03Oxy4qjkWLj6+Mu3sdvQd+oLaYYxxGGeHJ9c8ZOroTl0R+KSnFOz87FL5UDuMZX60xdeC+TFSMDpmhBogAAJjEtg5XnvPk7WPiTtMOMGmuUh0uHYvtmAOhi0oJ22Drxf+kaa3PCbRdU73Sb3YawRuA+Uc40/dZEniW/2JGCSWn2bxegfpD1TOT7y4vGhQfb8aWPkk7yuV8eOSRL1itXHwI+kTBRvBgAAImCKgfXytpI9Ptt/T9JL65xsdzb5i+Wo4NsdqZnNo0F3a5NY5xuqHh64O1MwuVhvGl6svMFeXgHVvxuoPHLNxPkm2jWXLTg/kW3enyOzdqu5UbJp4VdJiZjyJ5adhvHDtN7EcuA+tLFx8fGXa2cXqC/SFmTFm7Z1Yntw+kOl6U0Mug0962sDOz64SH7NjmZ921bVgfowXjI4ZoQYIgIBQArHH64Dz5OHHxFgmnFoLXIRa2BfW8F70iWu0DgwbgQ7dDI9PVJdvwuAb1Pm6YNyEEQAP3AIgyauC8aduTsTwrXojBu38PFjyjRTvaP7motBp+SkNpJ/2WFMd/mXvlzQ926vTqzxXG8ctWV9Nrqybpt9puvFEzW1OvPkOSp74sVbsST6oD/0iDV1YHkGjuNSxDtDcJRcaWZOmrGMH54r3DXozc/wgvfiQMu2kuf6R7J1J4uYtVzN3OKLuDYjMAuscc/Vb9pBmdrnatI4v7Heamn+e8Q1zFI+p82/r3szVT+0358pUhvNJ2sly2Y467lnV7RtXfes08aqhhfo0M57k8qP2m/HY5z2p63I5sC4tLGJzpJ1drj6XL6jMzBiz9lMuT+37GvisHRO+DHZ+VjX4UJ9mxzI/7XprwfyYrVZGpKvrd2a0fXHfIx67wV0DLN1cUkp7s5xjpjhO183MyyO/k5as6wuo/c3nc1oe/lidy4T9oJHLaD7X4MXezMGwbAZ4bKFp7wfZgzdG1wvPN1+crisObjhwxRLsLHIbOOV8HB3+fEIyf2l8H9aExTdZ0PSGtsFPs+CnXyxf/CQMXud8TaC4zjPqQ9xdbznaWLB0fc6kZBSS3kc0faDpHXXzM0080DR70XY/08Z+ZT/S9BPNs/d+ofKmcZQQTDF3ZXmkQRPrAK1dc6GVtfbxtYY+6tPch5S9/TOH73RMEHvuUUMz9zmq7j0eqeU53tHAMUe/dQ9pZpejTcN+sRxPyOddz/uWsaznKTY1n3XW2vaWrXszR//emE194nySDJfDlv26x3fPy1LKrepO5a+JVw0t1KeZ8SSH36jjhWu/yeHA/Wli4eLjK9POLkffni+oTzNjzNo7OTy5rz2m6+2Mugw+6ZkDOz+7GnyoT7NjmZ92vbVgfsxWIyM69nX5zoy2K/Z7xGMnuGuApZtLSmkvljux8sWv4q7F2onVW5xzvKac8DVDN/8f1jAm5jBh2Fq5eI0kcKUGL/bGCobFM8A/ul3kh7dpnOF++Ea69zTPN8RpfxVhZ5DbsL7A+FM3ddL4Vr0RY4GSHyXEd1OfBuLp/THB4Bs0Ni9afzrRpfUvaLqnZf6lAKkXzEdpY7GD6dvkJ6WA80jTK5r4w9x/U/pIbUO8+U7MR7Ttj3MfHA/N8zLfGDLUi2OnqQvLI1DaWB/p7ZkLI6y1j69F9ZEnrH1IOdpFo/gSv5HOPfa0R2nmTpTo3uORWm6dY5R+eOjGZprZRWljKtq80fO878ZlqwXirOqzzkpeyKJ1b0bpP9ovaT3OJ6+ui2LLzY74XrsWPWdVd2pSNPEqqsXgeBLFT8l44dpvojhwB4pZuPj4yrSzi9J35AuDY8zaO1E8ufER0/UGBl8Gn/QEgp2fXVE+GMv8sJdriVWRX90F8yVV97wmRqSl23dmUr9HdGf9uBQsjxmF1ujJ0hUjefUJTbs/nutqM0BZ1PGacrL7/2Fap+W70igmnGMjXKrbmTjiHKY65bANKNqfwwSPU4tvwvjC5070/u9xwu4eKbhVTkGp8ZvDxPhTN1mS+D6sK/XcOw2YfMH7V5rmp2Lw3cTOE3qCwye6fHH8jzTPN2DwHW/f0fQnTeJeMdo4+NH0iQOeFtAraua66edXKucTX/4AhVcZAmBdhmNIL+pZax9fK+jDyfZiz4nhq+XYHKOZUWnRvUh7kVnrHGP0w0O3ltPMLkYbU4E3br1ReUn9OaGPn3VvxugP3C9xPjkZLoYtNwnk67OziHVWdafC18SrghZT40kMPy3jhWu/ieHA7TWzcPHxlWlnF6Mv0Bemxpi1d2J4cttApuvNDLsMPumpAzs/uwp8TI9lftqbtfx/3BL/ywXzDdpNgSZGpr8z22Q2rwAs8/gtW4PlkkaF+ZjjdcB5sooxMYYJp8QKlwr2c3WJcxgXlT5lKvbnWHS8P9PE1+jy9bo8/46m72P7qVj/E/X9dYpJzA9pUzzgVjHpg3RdavxmuSbHn4Z5FsP3m4ai+caLn2mw4qchfEsne64L4zkcfkQkm5nfLy+qzzdjSH2FauP4R9QnlXtoXLzDvXdUvp/KeP3laRmOeigKJwDW4axya1phrX18LamPP6T8W9qHlFyjZ7YP5avp2ByqmdFq0p1plU1z6xxD9cNDG+ucbjbHZx6ML1tn1Cuxck7oIxg6ZnEfGsetUP0h2nE+eeu0ULbavGVV9232w5c08SqpxeJ4EsovZDwOd6C8mqEcOHLtLGKzo51dqL4QX1gcY9Z+CuVpdV8Dn7VjwpfBzs+qJB91YxlfsET4+P/5/F3F6UIvev+d/sf/E71LeHVnDkZNbYDvzMrhBkuwLEegTU+hx+ujzx7djxsFcYUy4U1a4nJBLPwYLd6LwvlxnsUzvJix4Aydh/OPpvP+L/JF8fF1m3yToqgXuIlKx2EwGH8OEWVVAN9wfN+EV82rSYPUR0oM32X3fzQ92+uN6v1tb53U8lBtHP+I+qRyD4mLPMc39Ry9vj2qgPXHBMD6mFGpGpZYax9fS+qjvkR+SCnl+5R+QvlSveHOPfZ4hGrm9pp07/FILbfOMVQ/PLR1mGZ2odqYCryx9UaNEkvnhD5+1r0Zqj9kv6Q6OJ9cmC2ULTcJ4bvoWvSsVd2pSdHEq6QW6svceBLKj+qp+fzp2m9COXBb7SxcfHxl2tmF6gvxBdUxN8asvRPKk9uFMF33P/oy+KRnEOz87Eryob7UjWWkCRd6+S3EYzIYHTAqsRrfmZWgeO4DLPWxnHL6mpQ9oUnSzXLFYIcer6me9/M5rVdzrA5lwkmwxGVpOtIt9hg9ghcl85t8rWZ/XvoW8yAAAqfjltjxm/Mzwhju8xHGdx+d23XNbsSYNst32b2YEnQbyfhLmrWNnJ35Jgs+qVq//pwKHq1XYDmJAFgnYUtqZI219vFVu74kkxdsZJGvRc0FLXPpyjpH6/ovRkiY0cxOs7aEVHdvYu2c0Afcujet6/d5I3edVbZWdaf6RRMvTVpS85nTDvzO9MAh3UXa2WnXl575tJbg6ecGPn4+vrVg56Nz/kVZrf/r9ivHWhAYhwC+MyuXK7DUx/IHul7rDd2QwU86+UCTlKcWlSN97gnnM1uiYLJlghIQUEuAxvm/jsTR8eDBXh1q/47W8bFi/TqdG9B6fhLe+vWF+vQ+4SI3rvUGSy+XiM8qu9K5QH8gMBqBpjdi0GD7kQDxpO6lWZu6ZG0F/c+2CCWVCIB1JbCObtWw1j6+atfn8GbTIot8LWquYSrrHK3rz/GUZnaateXkXHhbNeeEPs7WvWldv88bueussrWqO9Uvmnhp0pKaz5x24HemBw7pLtLOTru+9MyntQRPPzfw8fPxrQU7H53Tr1mq/V+3XznWgoA6Aia+M2uUNbAsB7oqS7ow9DGF+usULl8oy78grfKF85ltWsFkywQlIKCZAO3zuzdZhOim9q4bLe7oWPKS2j+m9Uk38uXGFRJ7Tp0S8Vlll8MdbUFAA4FqN2KE3CGWArDEgJey3WUbzdqWOpXMz0+9cMmZf8HhD9dKlEUTAOtoZMkN1LLWPr7W0rfnJAnHzL3YapTX4iuZo0XN8M6VAOWfn+r1fzTFPN3rFXn6y7WXO/7C5PAXMZb1Q+cl7zuhGo7qaWanWdtRXgdar/ac0JeDUb1JcYses/eYWxjLZ+2jemuOP/Xdqm7wqncOuMdW23iiYd8pcWzSwGHPs7XLtbOrpW8vL9rGmLXOWjwlcCNt2efJmvmsvVB6WSu7Er5i1rX47OVRwj65F9tReQirI33Uh+pf3c1lRO2zx8u9PObGttdvx3KT35lV4g2W5cBKYPknjcXzD+e+Jmn8hIThXyFjWEmRR8ez3G2VGO+1MclletQ+hJcv79Re9TlMbX7cfwnfu+LMza2rT5SBAAjIIZC7j1sfv48ymcuX+6c+qnyOLRHbkf7Y9dVuxPCdhMQGKa2+Zm3SWOfGQ7m6px2Pu+Gdev2ay9Te6b8WXHMZrGvSve1bM2vt46t2fbdObb9kka9FzTWcNSpHivueeDzLZTKq/lzdJdprZqdZW4ncS+iDxwCLn3VG9Sbni3yDMVvCzrMTw6je2pETXGxVdzCgVUVNvDRpWaWpyaIGfqQh+9ikgUMTwzg2op2ddn2OlFYt0syTtGEsquoef+davVXCV0xOKx+/K9LWlmBFfaj+1d1cRtQ+e7zcy25ubHv99ipnVha/M6vBGyzLUZXAkmNgRbR/8K+Z8+v9+W3sv6Qr61ffpamf8pT1PbI2JrVzlMuL2qs+hznin8uP+6c+qpznlIjtSL/k9TTeP6L4fphi5Kci8es/E+/zUoe/UuOaUUiOT3JsM7+W77n7OLU3PX4f5SqXL/c/jTdZ5zWuOEvE5uo3p6zajRg5QaEtCBQm8In6m08oll3PT8Tg9XiVIQDWZTiG9ALWIZRQBwRAAARAAARAAAR0E8A5oe78Qh0IgAAIgAAIgAAIgAAIgAAIgAAIgAAIgEA8AXxnFs9srwVY7pGJL5fCki/K/ThdGBevAi1AAARAAARGIfCWxvrLheZ0ET8/veUzTU86C5Aa14xFcnySY5v54R0ETBLodiOG5ju0NGsbdC/5QHG/dcTOd1t9wQdMB5n0IrBOZxfb0iRrS+OrJa2x5k+tb5GpRc2p/vC1s87Run6fN3zrtHPTrs+XW2HrTJ4T+nIAb57pgIPPJWnrrDK1qjvNJZfHLIv7lbFUPXM7+GAmEfYOXldOYHFlETtniZ0lrbE+CK0Phn5S4OPn41sLdj46t+vASva5sJT8SInj1r3nJcmxueINKMN3ZgGQAquAZSCogGrdWU77+lOK9UeOl5b5gs43AbEPX0XhOFckJ+ByxiiVg9S41uaTHKfk2NYcKyy/Jv0faJznGwH5xddOctlTKvtyKunzR2pcMw3J8UmObebX9F3qPi41rtjkSNYhLbZuN2JQUjXfoaVZW+z+2L0+nTy8px3vDU0vaf4jBzTtiP+i2X92D1BRAGDdLpmGWVsaXy1pbbXzWGRqUXMNP1nnaF1/qqe0c9OuLzXvTdsZPif0cYY3z3TAweeStHVWmVrVneYSvd93wgdxjgCvKy+wuLKInbPEzpLWWB+E1gdDPynw8fPxrQU7H53bdWAl+1xYSn6kxHHr3vOS5Nhc8XrL8J2ZF0/USrCMwuWtLITl3zlIiuUjXTPzmGZ/9wata6Wqca5gasDlDFMqB6lxrS0oOU7Jsa05ll7mp2H8VrrTAv1JjWuWJjk+ybHN/Fq/S93HpcYVmx/JOkTF9jCWbMH6fIfW80V/fNfdYyrju69Hf2nWlpwbyu0Hmn6hDuZfBvw8lX2f3Gl4Q376xT9oe9/zRPM/0/RP+oDZ8w7P8OhXNSduvViuotksqmK9Ubcq6JwLU6wn9JbGV0taV3tWtUWLTC1qrmEg6xyt60/1lHZu2vVt8t75vG8Tz6LA4jnhQv5m1pw3NwTOBeCwAyaj2CpTq7pTraKVl1ZdqXk+agdeV0JgcWURO2eJnSWtsT4IrQ+GflLg4+fjWwt2Pjq368Dq/Ou6Uv/3LyU/UuK4de95SXJsrnhDyrp9Zyb4e8QQbq46YOmiklbWjSWHS9fH8K+ifyKP8jUzz/nmEC438tI4zpVIHbicKUrlIDWutfckxyk5tjXHoss8xtN0v+iUL+L/SmU510pyf8s+F92HzVaKK2zjAbUqxqeeXQDeGlWk7uNS44rNgWQdomLr+UQMzXdoadYWuzNe6tOB6tVlofEMbZsPZmoeqdiT5VHqtLEO0AtfH0Equ97S+GpJa1mX7PdmkalFzfsOSF9jnaN1/anO0c5Nu75N3qWeg1s7/94kZltgzptbBKcScNgBk1FslalV3alW0cpLq67UPB+1A68rIbC4soids8TOktZYH4TWB0M/KfDx8/GtBTsfndt1YHV3J5mBlNikxHHr3vOS5Nhc8R6W9fzOTOr3iIfQdiqA5Q6YhOKeLOdwKYYX87yxd3XjXKH8gcsZpFQOUuNa209ynJJjW3Ostkw34PEPo7+kiW8ITH7RMYRv6Cv2KhVXsYBWHZWMzxq7Fcqai1L3calxxeZCsg5RsXW7EYMGl/Wd1Qwm9667WKNUqa9ZWxVg6BQEQAAEAglYGl8taQ1Mf3Y1i0wtas42iqMD6xyt63dYIqhIOzft+oKSjEoiCcCb57SAQ3l7WmVqVXeqg7Ty0qorNc9H7cDrSggsrixi5yyxs6Q11geh9cHQTwp8/Hx8a8HOR+d2HVidfmW91v/+i/xy7G3GTjeNNL8uQbJPJMe2yh0WQQAEQCCJAMY5NzZwOXOpxEHNOYzbPdfSSvyuG8iYkxxbhqyopnQzwWNq8JamZ8SDfSniJTWuGY7k+CTHNvNr9V5pHzczfh/lqRLfo80GrZcWW7cbMZa0aHAoctfdsk8p85q1SWGMOEAABGwSsDS+WtLays0WmVrUXMNP1jla15/qKe3ctOtLzTva9ScAb55zAA7lvWiVqVXdqQ7SykurrtQ8H7UDryshsLiyiJ2zxM6S1lgfhNYHQz8p8PHz8a0FOx+d23VgdXdXkgFdXKHyV3dLMrp1YP6S5Njy1aEHEAABECh7nNLEE+P/OZulOGg9hznyfCl+R9tJWS85thQ9IW1I8+kmDPLj6WlIE4N7Wv4a0r5WHalxzXolxyc5tplfr/fJ33jyS6UElOJbIzwJsT2sISymz3lwoDai7rqL0bBXV7O2Pc0oBwEQAIEWBCyNr5a0tvAOb8MiU4uaa/jJOkfr+lM9pZ2bdn2peUe7/gTgzXMOwKG8F60ytao71UFaeWnVlZrno3bgdSUEFlcWsXOW2FnSGuuD0Ppg6CcFPn4+vrVg56Nzuw6sZH//LiU/UuK4de95SXJsrnhRBgIgAAKxBDDOuYmBy5mLVA5S41q7SXKckmNbcyy1PGl+R/39SPNPeaL572j6s9Q2UvqRGtesRXJ8kmOb+fV6n9jgyS+VEiCVL8uVElvXJ2LMEKTddVfCj5q1leCDPkAABEAglYCl8dWS1lQ/xLazyNSi5lhfhNS3ztG6/hCPuOpo56ZdnyunKBuDALx5zhM4lPerVaZWdac6SCsvrbpS83zUDryuhMDiyiJ2zhI7S1pjfRBaHwz9pMDHz8e3Fux8dG7XgdX1AgiJ//uXkh8pcdy697wkOTZXvCgDARAAgVgCGOfcxMDlzEUqB6lxrd0kOU7Jsa05Fl7+TP09oonfLy86V+ebMXq+pMY1M5Ecn+TYZn7N36Xu41Ljik2QZB2SYuv2RIwJgri77mKN5qqvWZtLL8pAAARAoBUBS+OrJa3wTz0C8FEZttY5Wtef6iLt3LTrS8072vUnAG+ecwAO5b1olalV3akO0spLq67UPB+1A68rIbC4soids8TOktZYH4TWB0M/KfDx8/GtBTsfndt1YHW5CUPk//6l5EdKHAv9nE4AACAASURBVLfuPS9Jjs0VL8pAAARAIJYAxjk3MXA5c5HKQWpcazdJjlNybGuOpZfphou/0fRgPZXeTmx/0uIijzyafHKSsoyPCl7R9IQZxuqsUX8Z2xTT3zi+eVuk4/t53sq71H1calyxvpCsQ1psPZ+IofkOLc3aYvdH1AcBEACBkgQsja+WtJb0iK8vi0wtavZ5IHWddY7W9cM3bgLwhZsLSvsTgDfPOQCH8l60ytSq7lQHaeWlVVdqno/agdeVEFhcWcTOWWJnSWusD0Lrg6GfFPj4+fjWgp2Pzu06sDr/0q7EX9zlTEnJj5Q4bt17XpIcmytelIEACIBALAGMc25i4HLmIpWD1LjWbpIcZ3BsdFEvn8t+Sxe4f10LxLJqAj+Quj9o+mmpkvzwmpa/lvDD5K1/UX/fUX/PltvJnL+Jnfr+ibb1jt57P/UkU1ZU8+B9PKrX/MpRcQkef6J05GOL6iE4thZ8uz0Rg3Z4kXfdRaVyp7JmbTuSUQwCIAACTQhYGl8taW1iHtqIRaYWNdfwk3WO1vWneko7N+36UvOOdv0JwJvnHIBDeS9aZWpVd6qDtPLSqis1z0ftwOtKCCyuLGLnLLGzpDXWB6H1wdBPCnz8fHxrwc5H53YdWJ2/fycq/IusfNHPF2Jy+vXdW1J9lpb5oQj4Aqs3HF/raDgO2iYYtQaP7YEACIAAEVgeC/gYME/W4YDL2QHMgebEHaOX+aH4up3DHO0nyzhp3rl/8UWwNL2miS+cbfYKiW0RDF/U/nKxjNkGBCZvPG6wKecmyCP82WB9EwbflPOCyj85G0UUkr6nVJ1v6uA+eTp8URt+0uDhyxU7NfpA7d8eNlZSgRgcXoM+eazp+BMS1yoFIsefUB0DMK7Ot+cTMVZeOj2y9K9N4aqAktv8S5FVCFUWyYwfqOPDg7lW/VWgolMQAAETBKyPn9b1p5icmJk939jjBR/tkdkv184M+8l+7muvGZm99v2idu7Rfz0C2r058rhRL+v9etbqN626ajpF+74JT4S5R7sPZgrww0yi7/voebCyv/R1yXXro/vlqiRtzrr+NGphrayztayftPMFRs8npwRdYBTmqrK16H/tb8r2GN4bGIWzQk0QAAEQaEWAxmZz/ze2fL6y56sRjtE9z2H2uIWWj8CXtYzMeC8XxJ7Py2s8iWFvkynlfIH0HzTd3AyR0lHBNnwjQ9DNEEfbJF99oTpfKBeH1wUv+kq+MYW294m29ZZzT/P3iz5NzhIHfE6tnPkRGLcY37s9EWOdX0oI3/nFj9+53Bnpml+307A8af/FpXddVlIvbVfsl2AldbboCyxbUA7fBvIRzuqopnSWFB8fO5qPn0fcWq2Xpl+6XzgvEzOT5xt7voSP9sjsl0tjth9p2hqp+wnFpf7cVSr7ECf12i8s+CKEf686I/Dv5c1WOZn0DXNuM4JncnKn1W/SdI3go4nZMPtmrO8leAI+iM1avfoS/HCkbgS/HGk4Wj9CHnwapvjFjJvaPTO6X3xeClnXS792XzH7XmxD8t6ijjT9rT1H/9Pmp2DwxVNfW/AecRtgdBon1H/H28qbrffxVrp6bAcsy1EfjSXFa+46tUmz6OsrevgIx+hy44CrJ/Dtcw5E+1L0kxhc+atdRv7YPJGi9ja5f+LznKbvaeIfT1+/nlNc2U/DWHdaavkgdt4Mxz7fJF9qs8xsuHN5jD/F0r/bERif0Yi5EYPCeUVJeb+bMd0rmmufBsb/R+9NH/mlMY1gKSuryEe5fAzCsvn4WY5wkZ6i9XNeaUq+e3ov6kH8wuGLYbbHskO5GCaafdQhrzmbjPZEzsZC2g7kjRA5vjri2PuCXa1rHrshX6xQy1gciH9zbzbOULQ+zh1Nxc8Hj3QP5JkjKb71w+TDJ8KxToyugXwUxazXfunIdWhRlL7QTkPrafUB6x/QCxx2tB9a6hzIL8wy5xWdh5yNVWgbHX8tHxnxTDTvCjnv2WVz/UZ8xTltzrankRzbjtaPscxBsVIRsfZdaFVpq2N1W5uRobGweuLBshxisDTPMvrYXY5Yt55Ea8Y+ufUFMcE5zBZL0ZLajHv5GhdHH9rkBdXga5VfTjk6NaB5/v/Z/WlB7h9n7Itwf6V5rlPs1cvHxQQI7Yi4YoyvmJuWfL+pqCO4axL8PVU+Pc5n2mn5kUP8mi8M+A8dHKQPcOeII/8utXPTVvqZJ22Lf5GEL8Bo9igi2hY/uolf/EipJzS9pVia/jIKxcB+e0Lb/Y7es1+WWebAozzwnbd8V+kzZpjT17Jtj3z09rUmlstcHs1P+/LlUXC0zHfe4vhxBuc7fjKj4o/167HvHXlkvX7pmUi/VGG2jq/H8pIJbz+CSxUmo/koklmPFEdvc+mJCD9Ebye2wQjeiNW0ri+V/TpO1/Iydl7fyjs9fEHaun+eceUgtGzKVZHPQj34h+qc6/Xy5rz92u9LfTQfcy5c5Th+pHcEzxxp8K1f5oPrReSkSz58WpbrpOkawUdLZlp8UMgTy26y5hX7gLmIHhPWiVv6nddJ9PwIfllzjV3OyEPspqrUX8Yf4SGOpcr+ot0zS94MMZI5Nxn61Uu/dl+xKXqxlWLIDP0Yy9olkS9E+pGmtzz28X7ZbtPDbKkqo15jIeW7yv+kj7JK2632PWIvlrPmacwr8h3j3KfvXSNL+NKX8TbrJh+/463RfMx3q20CrLCVpWapunuPbxWwl+iy6vG5RIAK+qjKGL52O4TGJH5iA5+n/YMYvXLXqlNK2+ZrqvizAcfwlXO02BKv+3OxLGr2IPY5VtYzXzc2l2W9w8dZ+HyNq44/vg0bWdeMr4gbMSipL2hnZdH84gvzLxfI0+DBJ7781Aa+aF/ja6md9TXTT5yfEN+XraDStjiPP9J2P/I2aZk/zHymd2bQ8mYM9tcpBo6jxMswyyh8U85/pkZ8wvJ3mooe9OdgWuajl681spzzF/HebfyMiLFm1ST9tH+8qRVUy30vUcOSWfDxtiazRB0lmy2ZcL9BXGoyGcxHwcxKJq1yX0tPBPmhcjyX7gfwxiXWxBmx7AP0LGPn6s2809IXvc77AvjHVCn6Wagl/xiRi7rdvLmIoebsUl/wfkd5q3Y+eCR2AM8cSfCtX+aD6wXlpGc+fGIW68TpGsBHS2ZafLCwxM33uFwepHHZQYl5jT5gLgOMCev0Lf3O64L80FrnAH5Zc41dTspD7EYq1l/GH+QhjqWmj5R7ZsmbUQYz58oKXt30K/cVW6MbWyG+TNKPsaxN9ug7Hd+FVm2CEL6VVoxajYWt/o+6l9YW3yO2Yrmjseh3jDvbOBVrYglf+jLdZd3y2G3lnHipmaGL1N15fOtixr2N0riBc5g9OIXKWzGGr50Ja3aB9HrrlI/TdaqUfz6nOd2Ut6jD17Mub8y4rKL6fOPIfLPtpdwx8928Dce6myLqk7e/vn7y71T+y01F+rFr6vP93O9O7HOTKjeS0LabXms8i9H6TjnEGF8xua35PqyoJahrEnx5GsbU4DWV8d1m84sHr8dUxgOZqpdDO+trrZ/vKnQePErCJq2vqT/+dZHLDRDTdnl5fUAruelNX3xQoKnGhSfmWG7gHhRwzmniRx3yicx/D6rnrq6ej56+1sYyNtlCxs/YsIvVF66/+r6XAtLBrPXxNiXsqm0cTHh7UriM4iNJzLL94vCEFD8stYn0xjLAlPlB2DulOWLneq29U90XpFPM5xlnIgIL6Ryyxmeh6vwD5d1UE+LNm5hKLjj0td7vcuSI9EyOIEc+uLuRcuKUL1yXSB85mA3vg6U5HPp6ex0+WCao8bxAPxwREOmXo6CP1g+YhxtJjvgljZvqPOPgzfmQxPzGH6UXhOhX5yvOkxC2pS0T3J9w/So9F5ycqSJ9HzL/yq3rQqvY7kTVJ/89p4m/t8p6NWZU3ZeN/496w37KR6vrIqqzvBE3LVT6jnGzKW0s4ctNirsVkLfMXafm0Mz8JX8W6DK+lTQlMc8+Rjc+PpeU36SvARkP7+tSiaXcdb8AnWLgGy74GuX3NL+8Lplv0uB1mxftk19oOt3UdvAe/IPk1A/ftHHTJ234t3UZLb+fA/LEPldhvsExzI0C3837mPhnj+/MmnKq9nNqoJeqVmvNt+uNGNOgwAPJ5eJ8ostfgPxWlbKAzne0c2TN9E8x/NEIBz9C6otjW79SGQ9OzgOYo77IIrCUlZaG+VDta85qQ5bBJppiWh87uH2z8TM42AoVU/VTOx5rv6fpQ4WwTl1OsbU6rgTLmOJae+bQL9SuOrNgEYUr7jDhrXi5tGAyxTaKjw6ZFU5dte52POH1Q7VgdjqW6o2dcIOLR2C/J2Yndq7ezDsNfaH+vG8vz77yhvx9YWzWSfDmJqiCBTv6Dvc7atf93EaqZ3LSs5MP7tKbEwn58OmWrEuqj3aYDe2DpUd29B16fdlHyXlNPmAupKf7GB2Tn1Q/9NIp1S8xzF11U/Pg6qtH2U783nGT42zhI42e2eHNSA+Zc6XRXxL0a/QV+0IC257+TNVP7aof+7V6LjXfEw/XhVapXUppx/9jL/J/9haMjPiyyfeIYFnuGhOwtMVyynf0/42lDPopcexo5q5EfhZQtE8WOUZPPDSew6TYed1mGMaKfL3OQdJy6wukd4Lk/YpvrLin93/PdWiZr2/lGxkkv5yxLwLm+H9fLBeZhY8vGIuMPdwbxvgL0yozLflWvxGDxPDTLPZ+heEHInjzuB4azPgROjzAzS8+8eO7f1wX8c91RL7HamcRjfX/i7b3UyN4fABwPfZozjWvH/kFlrKy1yof2n3NWW3F8sZBA4yfN/GWXqiknx/rx3dIv6T++aSwxquLX1hILLPA420LZjXycOozlgk3CuDSgskwPgpkdsqHhD+xngjwQ2tZ3byRK3Rk9rGxM6vG3mnlCwvnfSlWb8V/E9sA3tzEHFMQqy9wv2txHD+S2c0zR4H51sfmg/sKyEn3fAysq5uPYpmN4IOl92P1BXp9uYmS85p8wFy6jwnr5FTyQy+d3fyy5hq7XCkPsWEk14+NP2Dc5Fha+GhIz8TyZpiBzLmq+NcA+of0FSd+ALZV/VlJP8ayqllzds7f7WwutHLWtFvYgtGwY2GELVp9jwiW51+xjkjNblWwVMYy9tit4Zw4VjPvDYJ1W9gndwckx4oWx2fHZk0VtWCswtc01vAN5XvXAUeZhvrh65aY/fqJFFH9ZFT+RG2/UhzrpyRxl1xe5GYM7ocmvj6ar5Pm+Xc08TZzXr7YuV/+vLn8YfycbS3bqvDxUpCA+RbjjwCZ3UJoxrfqjRg0aLAQvpGCB5Cbiz6n5ad0YscDg/NFdfixPy9peuasILgwVztLq62fT6pbIJxyfbSpb48q5KznGGjiX4IvcTDbhGKJ5Ua8wIIW+ZDg6xboW7Bc6yC2WccO7o/6wPFjcfwkHvwB4UeamO38aDOaLfvq4RdWkOsZl19aMSubgWtvuUwmrjf7USsmo/rIxeyakf5zuZ6g9jd+6KGolzdytY7MPjd2ZlfbOy18QRpuPsvueKLq55mdbQYVc/w0Vfks1IK/SyTpUX2+mKuP2m/GbCprcj7oyteyrJdnljHEzufmg7e3zomEfIysq5ePcplJ9MFyf8jV5/L6sv/S81p8MHETMUYvc1TDD9RnN529/LJkmjJfIw8pcaS2yY2f2nc7pxnRM7m8Oc8u5qn5b91uBP0j+mryherPX0dereEt6rPJMbG151gXTaUvMDpKUcz6o4uVYvpKqgtG54t+k+AN0ohy3Ox7xA77eLXvGF3p1czSpbdmmTWWpDfr3IXabz6H1MxPib5zNXMMknS3Ht8m/ZLPY7qfw+T6lPwlmS/Lq864h69z87bTns91Qs53dprfFPN43e1GacrJPU2vaPqJpq83kZ1/WJ6vec5+cd80vaHpGU0PaPqOpqwfTqf2u7HT/nbKD9VZayqhpcm1xtmBLjrA+LOAUWlWOOPq4/uM9Zt5psY77dAs5BPB5oGT7+p6s9gOfxGzXF6sOp3k8ZdQXIcHofublQMs5GhneWxQehtW/ypF80VJrjzOT8kodZBebfqy+APl5M3kxQ9UmnVAu/TafkYCy/aqZW4RuaiUF+vjZw391OfpBJvGwNPNkZVS163bHGZ7x9vRmeUw4US6uIzO5MigNZgdbbPl+hx9Lj+0jH30bY3MPid2zpsi74x+3qfls9BlONDuzRx9e/sd9an6fPBijgozOfngcFw5kZAPrboqWODSZQ4zqT64iKOZHH3cj0vjsn8t8zmc9hhRn+LG6Byde36QqFO6L2vkoaXmnPhH2l9aMvVtK4c397vH3LdNSeus66+ZC+tsa+inPsUd+0t4aNK1+7//EtvI6YPi4/9Tv8rpI7ctGOUSHKL96N8j+iC3/o5RM0sf5xrrTLGksdbcdWo5mtlwo38WKLHTSD5GU2zdz2FyGUvmy9o0MHblaNq3+Rohvm739CQGev+d9Eq5ZpLH639TnK4nUtCqfi9ixNc7v2KGk39bB3P6zJi4Ub5Gu+vnnsS4qzSb8ofPqVXonjuVzJhia3YMfViR8bJr/hVu/gXO08X20zsPVF+WleZ5HsRo/i2tf8EwaPnpVDZXGek9SjsLU6Y/NFf/E1oxtt7E89epHR9ocg5WsZvvUb8ayx5iBt8mcpGXQOvjZ1H9NBbyMZg/YPV6rF+eG8JaRzE7Ot4qYRbFhDH7uChhcuSmosyONtZhfZQ+nx86xD76JkdmHxU7J8qgd0Se90150PxZSLs3o/Qd7Xe03sL5YM1jRVQ+jsZCQfnQqkuMF3z7piAfLHkV9cSyY2XzUZx8PmAuQr3AoUXpnLTsfrcvWCeHLvlVNA8dhEbFP/D+0gGtc5NRvLmHI+bOrcgttK6/Zmassy2qH8fEmlZF3yAgnoDI7xF91KZzBYnfMQ7H0se58zqNLKOO3UrOiaM0s+eU6O68+2DzICCTAF1zW/xJDCWV8jXBNO09kaLkppL6oti+o4bfTZ/dkvpIbTRtO7o5xfqaGv3CbKMbowEIgEAWgSY3YtDO/ZGi5Ivf+Y4rfu0+DWM6yXtHdX6keb4B4ynN88A2PzmBZsd5xWhnVdr0T5ny5W6++/6Piln9c8oDb4IPOP+tuK3aXXdlSf7kR45+pun3iIn3YY2vrrnQCHStyfr4WUE/34TR7bF+6/zWWI5hRmMYXxhydL4xPLMYJpyTAC7DMznyXgVmR5tsuj5GX4AfmsY++sZGZh8TO+dJoXe6nvcRz5xzcE2fhTbDgHZvxugL3O/UH8c3JilYEJMP3mxATkTkQ6uugqnfdBXDbBQfLEXG6ON2ARqX3auZj+EUyEjEmLBOUIxObhugVaTOtW5pyxXy0FRiTPwBHuLY4SNPBmN4czeBzD1blLXKuv6a2bDOtoJ+VWMZjSV/HU1H/qT2Od9/7HZ/FBev321ccEVuHNT+HU2b/89SiD/T9INrHZV9CJFA9bLzF7IdI3W6fo9YkXGP7xi1sqyYpt2uTbKMOXbTOBjyf+NdwFJWxGjmmLXozuWfexyk9lWO0blx5XKZPJJ9flZCh2bGJfKEPuoRoHFV7JMUdlT/L8XMTxoZ+kX7fPbYwwByxx/NY48gxkVyvTZ8bu7X/YUsfxNSqVAdHph+JpF8Efy3tNN/2en3M5XzrzTy++VF9flmjFFfodpZnzr9lLt7yjtr47yuX3NZtadU8PZ5oxTDy2nj79dBjLIshOWzUXjVjLN3LmpqE9a36fGTclFSv9jH+hX2XCizkOOtFmahTDgVR1y0MDmyXUlmR9vqsT5U35EfesQ++jZHZh8aO+dIlXd6n/dNn2eSzsGntio+C3l2fu3eDNUXst9ZOY577JK9KjQfvKGjnEjKh1Zd2Qn3dBDKbCQfLOWG6uM2RxqX/WqbD+UUwkjSmLDOU6hObnekVbLOtW5pyyXz0ENbaPxHHuLY4aPjDIby5p5CmB9vUVYN6/prZsM625L6VY1l9P3D6R/BOebL+f7Dt90Ssfn6D12XGwe1d14rMf3/+zGt/yk0lnW93NjW/VleJpZdr4uoxZ51cd8tr7fQyrJWjnz9GmcZeuzWdE4cqplto0m3bzfwrqN9JOs8htpXOUbnxuUVHbiSxw+qmvT/qXkTJXRoZjxzwrtcAtN+IDfARWQjxboIezM76cgae7hT6gfj+4buuUAQ4+zjjEtibu5dfR6VNbsRg8R9pA9m/CSM/6Npd0ehen87Cnq09aHaWZdG/VO++AtFvot8/ZqfiMHra7/4iSwfifHpi4LaG6vYvwSWFeUN1TVyUTld1sfPkvqnse9V5ZR17z6UGdU7PN/QwiyUCSfviIsWJkdGLcnsaFs91ofqO/JDj9hH3+bI7ENj5xwp9c7o531aPgtthgHt3gzVF7LfUR3+LKz+fHBjkoIFofngTR7lRFI+tOoqmPpNV6HMRvLBUmSoPm5zpHHZr7b5UE4hjKiO2DE6VGeIHyTrlO7PknnooTU0fqpn5vuamnkI5R2y39aMs1bf1vXX4jr5Jeh/vVPdw/25Zqw1+i7pLepL7LG/Bjv0CQLGCIz+PaIvXa2/Y9TM0se5xjqTLEOP3VRPzXlLqGY2mSbdNXYa9AkCIxOga3QPn/pGY8DuRerU/h3p56f4rV+n6zxpvesGpC/Up/d/ULlxrYNJXQ6JI7Vvae18eZYWK+IBgZEJNLsRY4LEd96+oB282tMPBCfDsnZOCz/6lG/EWb/4phw+EFe9OYIOoI9oO09p+pEDoOW3tE3OyYivrixHBFYxZuSiItxF19bHT+v6F1YIngWzLSow2TI5KtHOTLu+o/z2XD8y+5Fjz835sOd9yj4L7eVRuze169vLq9RyrfnQqqumj7Qz066vlDescLKis5QvavUzeh5Gj79WXmv1a523df21fMX9WmdrXf+ut6bvH/gibX7NP873n9r/Az5vzv9XSmxS4nDRkhybK17hZcN+j+jjOnmk9fUWKln6OFdcZ5mlxWO3Rc1Zu4/U46DUuGJhS9YhObZYzsv6dA6+e5PFst7ePLV33WgxPx0r+WlsuXHtxRtbLiWO2LhRP56A1H1calzxhE/XYfN12eK+C2jNuNqNGCRk9846Wvc6JWncpvZAOCWAn9rBBgl9vaK4vsyVR9U+x1/jnfi8Jy5vaHpJ8x95GxPrf9HsP2tsc9Xn33mZt03b5S//fl+tH2ZRAMthWNUOFLkoT5j2zyGPHUxiGtNEHj/2MkUezvrwtddvy/JantnTUJsZfLRHvm55LR/V9ksoFe36QjnE1CuxL/L2RmY/cuwxuQ6tO/h5n5rPQqPvVyF+q7Xv7W1byrFqL76c8hJjudZ8aNWV45ejttqZ1dKnbYypxWnPf734WdG5xz23nPjx/xWyvh/iGGrloZWvasW/l59Wuva2n1NewjO1eLfgal1/jnd8bUtw5f5H9ZZ0/Xu5a7HP7W27UDn/CN7lgi3KA/+K7meanhTqP6cbKbFJicPFUnJsrnjFltF+0Pu6iFpsmn/HqJhlrRzt9muF5ajnLruJC1hhUXMAlpQqUo+DUuOKZSxZh+TYYjmjPgiAwJaA1H1calxbgsclUrU0javajRh0Ij/kxZ0U9z15h5/SkPwaVXuy4PCGzPUH+iAw/wrKP2j5n8TrchNLeFdxNWkbn2i7PH1PLe9p+X1cD+Jqd2OZS4JywL+2wP+QPH1ZQ++fqYw98Cvl5Sd6H+3VLRcKWVa/2a6muci/OH7UBLzTN3Ef8nxjRw7vA/DRHpyK5dp8tEalXd9ab4nlEvsixzEy+5FjL+GBnT66nfftxBNUTLlU9VlIuze16wsybaFKxBLnVTss4bMdMJ5i7cy06/OkNmqVFU5WdEYlP6Iy8cs+/vDmRs/D6PFHpDy7agnPjMzbuv5sA+10UIIrdz2qt6zr37FFi+LX/H8r4v9p2thbeueyp1RW/X/BBwKlxCYlDhcuybG54j0s6/x/1CG/R/RB5X2bmPa43kIVS/jS57L8deRTVf83DiFiUXMIl4Q6Uo+DUuOKRSxZh+TYYjnf1KdjziMqMP8r9TdQOixIzUMHFL02KXUflxpXSp6kamkaV7UbMVIygja6CdAHAP4nFD8Cr8uLtv+iy4YrbLQ3yxxJFPurnPbS2vbMhTaW0nKLeEAABEAABEAABEBgSaDned8yjpR5il3NZ6EU/WgDAiAAAiAAAiAAAiAAAiAAAiAAAiBQnQA/DeO36ltJ24CU2KTE4aIoOTZXvIdlPf+POvL3iD6wPb5j1MYSvvQ5DOtAoCsBqcdBqXHFJkuyDsmxxXJe12/6a/DrjXuWpcblCTlrlTW9WbAqNJa6j0uNKyUFUrU0javbjRiW7/ayrD1lT0UbEAABEJgJYPycSZweCy/y7vVrhPLm4J9tTsBky8RVop2Tdn2unEooG5376PFL8ABiqEPAijet6Kzjkjq9as2JVl11XKD3cxp8EOcYS7wsaY1zQf3amthr0lI/82lbsM7Yuv4014S1AtsrJ7A4PUHl/ZXIaY4vevhKFx33fhoGP91FRGyV4uAfQuQp61UptqyY0BgEQAAEShKweqy2qjvWO5WOg9nH6EpxxeLJrl9RBxj7s9P01+D9odyslRrXTZAFF6zpLYguv6tK4w/GnkVqKjFebCFttnVc3W7EIDyW7/ayrD1tz0ArEAABEDgTwPh5dQJYXFmEzoHZlhSYbJm4SrRz0q7PlVMJZaNzHz1+CR5ADHUIWPGmFZ11XFKnV6050aqrjgv0ft8JH8Q5xhIvS1rjXFC/tib2mrTUz3zaFqwztq4/zTVhrcD2ygksrizu6KLPp7T4kqZni2IRs1JiKxUHXVzyqTTYUrGVjgv9gQAIgEAmAavHaqu6k+1S6jhY+hhdKq5kMIUaltQBxodJafpr8IfRXCtIjesaYdk5a3rL0ivYW6nxB2PPflJKMd7fTKm4fAAACVpJREFUQtqaFnE9TAutSCu+2+v5oqe3NP94Er0oVjlrWbvKhEIUCIBAMwIYP6+oweLKInQOzLakwGTLxFWinZN2fa6cSigbnfvo8UvwAGKoQ8CKN63orOOSOr1qzYlWXXVccHenlZdWXfBBPgF4I59hag+a2GvSkprP2u2sM7auv6a/wPZKFywmFvS//sc0y//3f0YXqGQ/qeGKOH9OSmxS4nARlRybK16UgQAIgEAEAavHaqu6I6xxrSr1OCg1riu5sDnJOiTHFkZ3W4vOxd+vzsdLPLGuyJMAKsS1BSCkpFIehKgbJwyp+7jUuFIyK1VLq7h6PhHD8t1elrWn7KdoAwIgAAIzAYyfM4m7O7C4sgidA7MtKTDZMnGVaOekXZ8rpxLKRuc+evwSPIAY6hCw4k0rOuu4pE6vWnOiVVcdF+j9nAYfxDnGEi9LWuNcUL+2JvaatNTPfNoWrDO2rj/NNWGtwPbKCSyIxXyBA11s9ILR0DI/GeOelr/ycs+XlNikxOHKheTYXPGiDARAAAQiCVg9VlvVHWkPuecxWo7PknVIji3ayDsNSGORJ9bReX3Rp7GVimtHtrhia3qlJEDqPi41rpS8SdXSMq5uN2Lw3V6rpPHJ31cq/7IqV7eoXDs/1eTRMmmkV9SvnSxjm+fXMVP5jYa5XuP3IVnmMkIucgle2wtleQ0wYU75+BlFBCyicJ0qg9mWGZhsmbhKtHPSrs+VUwllo3MfPX6PB0ydg+N80eME4asU74PCye+HpzUnWnXtZzJvjVZeWnXlZXu/tSVelrTuZ7zPGk3sNWnp44bjrVpnbF3/sUPSa4DtlZ0RFt7vTOg7Bn4Sxjua3tA8X+jFL/7//5vTXMc/UmKTEocrFSGxUZ31/8/Xy66ua5d5fVl746n9g2UquW07sNwySS0RyjJVzqadkWM1dG8InAoOjxXkf5HnMVLjcmPeL5WsIzQ2qrc+71kv7wOos+bQ1/NmJ43inlgnNa6ZW+l3CXpH9nFqPibu4j6nSo0rhbNULaFxUb31eL5eDsLS7UaMZXQkpshdd8s+R5lXqJ0HLp7mF99ww1+ySX99oACfr4Isehfnqu+QxVFZhmjz1UEufHTi1klkGafAU1vh+OlR618FFn4+rrVgtqUCJlsmrhLtnLTrc+VUQtno3EePf+UBa+fgOF9cGWDERWX74Igp2MSsNSdadW0SWKhAKy+tugqlfdONJV6WtG4S3blAE3tNWjrbYnfz1hlb179rjAIrwPYKUTGLo+9MPhMFvmCB3y8vuvBVwv+JpcQmJY5LfhYzIbFJ/B7pyJcLiaJmwbJcOsBSN8ty6hY9KT5WL1RuZ63qJhIhx4qQ4+AWav0SqXHFKpesIzQ2acebEF+LfWIdjUd889Nb+qwg7kl6seYOqS9I75A+DmHsqRO6j3u6qLJKalwpYqVqCY2ryH7R/UaMeaChDD6jwfU+JZOjttGmnfL3ZNRczAd2KfGPzDKXIXKRS/DaXhrLa2T5c9rGzxwiYBFPD8y2zMBky8RVop2Tdn2unEooG5376PEvPWDxHBzni0sHjDmvaR8cMwPbqLXmRKuubQbLlGjlpVVXmaxve7HEy5LWbab7lmhir0lLX1fsb906Y+v6952RvwZsrwy1sgj5zoTq/O1KQtaclNikxOHKTkhsVOd0oZyrfY8yigfXJhQCD5aFQFI3YFmOZa2etB6rj3hZ1R26T1I9kecxUuM68tt6vWQdobFRPTHnQRRL0DnQtN/zDRuinlgnNa61b0stS9I7oo9z8xC6j+duJ7a91LhidXB9qVpC46J6Rcb3rjdizCd6sxha5idj3NPy15SkjtTGsvaR8oRYQQAE5BHA+HnNCVhcWYTOgdmWFJhsmbhKtHPSrs+VUwllo3MfPX4JHkAMdQhY8aYVnXVcUqdXrTnRqquOC+7E/spYrl74II6gJV6WtMa5oH5tTew1aamf+bQtWGdsXX+aa8Jage2VE1hcWWAOBEAABEAABCQSsHqstqpbogcREwg0JhD6a/CNwzo9QU/qk/RqsJCahxpa0ScImCXwsJfy6USP77r7keaf8kTz/GjSP3vF1Gq7lrW3YoztgAAI6CSA8fOaV7C4sgidA7MtKTDZMnGVaOekXZ8rpxLKRuc+evwSPIAY6hCw4k0rOuu4pE6vWnOiVVcdF1xuwlD3fSd8EOcYS7wsaY1zQf3amthr0lI/82lbsM7Yuv4014S1AtsrJ7C4ssAcCIAACIAACEgkYPVYbVW3RA8iJhBoTYB/DZ6mB+updRzr7UmNax1nqWVrektxQz8gMBqBnk/EsHy3l2Xto+0jiBcEQEAWAYyf13yAxZVF6ByYbUmByZaJq0Q7J+36XDmVUDY699Hjl+ABxFCHgBVvWtFZxyV1etWaE6266rjgTu2vecEHcY6xxMuS1jgX1K+tib0mLfUzn7YF64yt609zTVgrsL1yAosrC8yBAAiAAAiAgEQCVo/VVnVL9CBiAgEQAAEQAAEQUEqg240YfLeXUqaHsixrP4SDCiAAAiDgIYDx8woHLK4sQufAbEsKTLZMXCXaOWnX58qphLLRuY8evwQPIIY6BKx404rOOi6p06vWnGjVVccFd3daeWnVBR/kE4A38hmm9qCJvSYtqfms3c46Y+v6a/oLbK90weLKAnMgAAIgAAIgIJGA1WO1Vd0SPYiYQAAEQAAEQAAE9BJ4OEujx5H9tZp+n9e53ld1ua23vqsPlKUTIN6f1zmg3h6l94iWIAACINCGwHrswvGjDXffViQfU+AXX+bkrZPqJfior1ek+oKpwBvwRl8C2LqLAPZLF5X+ZRjL++dAQwTwkYYs5muAD/IZWutBqmcorqj/p1jLWy+9Uv3CPOCZXq4os12p3oKvyuRXWi9S/SaNE+IBARAAARCwQQDnO2PlGecxY+UL0YIACIAACIAACIQT8J3nPKBu+OL9vzu6+5PujP2yLqfOouqv22O5DAHKw1Pq6VtHb79R3u4d5SgCARAAga4EcPzoit+7cYnHFPjFmzKxK6V5CT6SYRVpvmAq8Aa8IYMAolgSwH65pCFvHmO5vJyMGBF8NGLWyscMH5Rnqr1HaZ6hePD/EcGmk+YXRgXPCDZMRGjSvAVfRSRvwKrS/DYgQoQMAiAAAiCggADOd8ZMIs5jxswbogYBEAABEAABEDgm4DvP+f89a6Q9PhsuKwAAAABJRU5ErkJggg==\n", + "text/latex": [ + "$\\displaystyle \\left[ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\\\\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}1 & 0\\\\0 & i\\end{matrix}\\right], \\ \\left[\\begin{matrix}1 & 0\\\\0 & -1\\end{matrix}\\right], \\ \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2} i}{2}\\\\\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2} i}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\\\\\frac{\\sqrt{2} i}{2} & - \\frac{\\sqrt{2} i}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}\\\\\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\\\- \\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}1 & 0\\\\0 & - i\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2} i}{2}\\\\\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2} i}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\\\- \\frac{\\sqrt{2} i}{2} & \\frac{\\sqrt{2} i}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2} i}{2}\\\\\\frac{\\sqrt{2} i}{2} & \\frac{\\sqrt{2}}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}\\\\\\frac{\\sqrt{2} i}{2} & \\frac{\\sqrt{2} i}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2} i}{2}\\\\- \\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2} i}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}\\\\- \\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2}}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2} i}{2}\\\\- \\frac{\\sqrt{2}}{2} & - \\frac{\\sqrt{2} i}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{1}{2} + \\frac{i}{2} & \\frac{1}{2} - \\frac{i}{2}\\\\\\frac{1}{2} - \\frac{i}{2} & \\frac{1}{2} + \\frac{i}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}0 & 1\\\\1 & 0\\end{matrix}\\right], \\ \\left[\\begin{matrix}0 & 1\\\\i & 0\\end{matrix}\\right], \\ \\left[\\begin{matrix}0 & i\\\\1 & 0\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{\\sqrt{2} i}{2} & - \\frac{\\sqrt{2} i}{2}\\\\\\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{1}{2} + \\frac{i}{2} & \\frac{1}{2} - \\frac{i}{2}\\\\\\frac{1}{2} + \\frac{i}{2} & - \\frac{1}{2} + \\frac{i}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{1}{2} + \\frac{i}{2} & \\frac{1}{2} + \\frac{i}{2}\\\\\\frac{1}{2} + \\frac{i}{2} & \\frac{i \\left(-1 + i\\right)}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}\\frac{1}{2} + \\frac{i}{2} & \\frac{1}{2} - \\frac{i}{2}\\\\- \\frac{1}{2} + \\frac{i}{2} & - \\frac{1}{2} - \\frac{i}{2}\\end{matrix}\\right]\\right]$" + ], + "text/plain": [ + "⎡⎡√2 √2 ⎤ ⎡√2 √2⋅ⅈ ⎤ ⎡ √2 √2 ⎤ ⎡√2 -√2 ⎤\n", + "⎢⎢── ── ⎥ ⎢── ──── ⎥ ⎢ ── ── ⎥ ⎢── ────⎥\n", + "⎢⎢2 2 ⎥ ⎡1 0⎤ ⎡1 0 ⎤ ⎡1 0⎤ ⎢2 2 ⎥ ⎢ 2 2 ⎥ ⎢2 2 ⎥\n", + "⎢⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥\n", + "⎢⎢√2 -√2 ⎥ ⎣0 ⅈ⎦ ⎣0 -1⎦ ⎣0 1⎦ ⎢√2 -√2⋅ⅈ ⎥ ⎢√2⋅ⅈ -√2⋅ⅈ ⎥ ⎢√2 √2 ⎥\n", + "⎢⎢── ────⎥ ⎢── ──────⎥ ⎢──── ──────⎥ ⎢── ── ⎥\n", + "⎣⎣2 2 ⎦ ⎣2 2 ⎦ ⎣ 2 2 ⎦ ⎣2 2 ⎦\n", + "\n", + " ⎡ √2 √2⎤ ⎡√2 -√2⋅ⅈ ⎤ ⎡ √2 √2 ⎤ ⎡ √2 √2⋅ⅈ⎤ ⎡ √2 -√2 \n", + " ⎢ ── ──⎥ ⎢── ──────⎥ ⎢ ── ── ⎥ ⎢ ── ────⎥ ⎢ ── ────\n", + " ⎢ 2 2 ⎥ ⎡1 0 ⎤ ⎢2 2 ⎥ ⎢ 2 2 ⎥ ⎢ 2 2 ⎥ ⎢ 2 2 \n", + ", ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ \n", + " ⎢-√2 √2⎥ ⎣0 -ⅈ⎦ ⎢√2 √2⋅ⅈ ⎥ ⎢-√2⋅ⅈ √2⋅ⅈ⎥ ⎢√2⋅ⅈ √2 ⎥ ⎢√2⋅ⅈ √2⋅ⅈ\n", + " ⎢──── ──⎥ ⎢── ──── ⎥ ⎢────── ────⎥ ⎢──── ── ⎥ ⎢──── ────\n", + " ⎣ 2 2 ⎦ ⎣2 2 ⎦ ⎣ 2 2 ⎦ ⎣ 2 2 ⎦ ⎣ 2 2 \n", + "\n", + "⎤ ⎡ √2 √2⋅ⅈ⎤ ⎡ √2 -√2 ⎤ ⎡ √2 -√2⋅ⅈ ⎤ ⎡1 ⅈ 1 ⅈ⎤ \n", + "⎥ ⎢ ── ────⎥ ⎢ ── ────⎥ ⎢ ── ──────⎥ ⎢─ + ─ ─ - ─⎥ \n", + "⎥ ⎢ 2 2 ⎥ ⎢ 2 2 ⎥ ⎢ 2 2 ⎥ ⎢2 2 2 2⎥ ⎡0 1⎤ ⎡0 1⎤ \n", + "⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥,\n", + "⎥ ⎢-√2 √2⋅ⅈ⎥ ⎢-√2 -√2 ⎥ ⎢-√2 -√2⋅ⅈ ⎥ ⎢1 ⅈ 1 ⅈ⎥ ⎣1 0⎦ ⎣ⅈ 0⎦ \n", + "⎥ ⎢──── ────⎥ ⎢──── ────⎥ ⎢──── ──────⎥ ⎢─ - ─ ─ + ─⎥ \n", + "⎦ ⎣ 2 2 ⎦ ⎣ 2 2 ⎦ ⎣ 2 2 ⎦ ⎣2 2 2 2⎦ \n", + "\n", + " ⎡√2⋅ⅈ -√2⋅ⅈ ⎤ ⎡1 ⅈ 1 ⅈ ⎤ ⎡1 ⅈ 1 ⅈ ⎤ ⎡ 1 ⅈ 1 \n", + " ⎢──── ──────⎥ ⎢─ + ─ ─ - ─ ⎥ ⎢─ + ─ ─ + ─ ⎥ ⎢ ─ + ─ ─ -\n", + " ⎡0 ⅈ⎤ ⎢ 2 2 ⎥ ⎢2 2 2 2 ⎥ ⎢2 2 2 2 ⎥ ⎢ 2 2 2 \n", + " ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ \n", + " ⎣1 0⎦ ⎢ √2 √2 ⎥ ⎢1 ⅈ 1 ⅈ⎥ ⎢1 ⅈ ⅈ⋅(-1 + ⅈ)⎥ ⎢ 1 ⅈ 1 \n", + " ⎢ ── ── ⎥ ⎢─ + ─ - ─ + ─⎥ ⎢─ + ─ ──────────⎥ ⎢- ─ + ─ - ─ \n", + " ⎣ 2 2 ⎦ ⎣2 2 2 2⎦ ⎣2 2 2 ⎦ ⎣ 2 2 2 \n", + "\n", + " ⅈ ⎤⎤\n", + " ─ ⎥⎥\n", + " 2 ⎥⎥\n", + " ⎥⎥\n", + " ⅈ⎥⎥\n", + "- ─⎥⎥\n", + " 2⎦⎦" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[simplify(evalstr(c)) for c in LC]" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAADUAAAAzCAYAAAA3v0BtAAAACXBIWXMAAA7EAAAOxAGVKw4bAAADFUlEQVRoBe1ai00jMRDNoisAQQe5DvhUcEkHx3UAdABKBSeuA6ACRDpIOkCkA+iAKB2E9xaP5DPjT3bXi4V2JGeTsT3znme86x2oRqPRPton2W63m0/KwhRVVanYCfMFbeu0W5Aald6AeeHgJo/FHj4oUxCorHb5oS77E3j/ww20NW4hVTb6HdH9SBmP3L0x495w/Yl2g1V6TZnb5RjguKJ/+A5mUpQUDD3D0F8YmhOg2ZzPuDL0fRMjmRoHsfgkSArALzBxXwjRCL5voKfhW7QpdX0JfDNLohLbU2ewsFKsPEE3MVFTur9WFSM1Aby1AlGeYewvTrzplxiFg9yMDA5uA6beC1LwX8xnKFICWKJi25LoeZ/o9uCW32eGyCPszFJshUilzD9MGdR0DKI0xlzuXwr3d9LdNkRKolFbdD4kinxu5ZQ1oiS3cKbgQ4ozLykYk7TTUkx0SSuXAkQbIxgQsd+m/04b5+q8pMzAJa5MAVckUuzvQ7iX5kIy5jBGipvzRDFyDN0q1YkyP1ll7n5HmFCnHn7Lkc1rI0gKoBnutRV+OSb9gf7ca7XbjnpRgWUOHMwavioFxfucsmYxKjNjkOpTtF9wop002N+pwM8Svtl4mN2YhQ76iJKCEd4wroNWMncCw05nzGD6ZcaazfxAKtvSdmx4iFTHC5rN3BCpbEvbseEhUh0vaDZz3zJS0WOSLCfOXjwp89R+bI5O0pX1Cr9yKk8upAZJwSBfBu/R+BbM0/IYrTeB/0aF1GD6MSJoZ2isjCa9SnfFGITUQirsSyHV6ypIyjurn47GhdSSSU2wdlrxh69CFParUiQps5dVwJZS6iSW6uNrkaQATQBLVGzgEj3exFQplZQK1lF6C6mlkpJoODzqnxJFbyG1SFLWw11LMdF5C6lFkjLhaVxILZlU40JqsaSQgo0LqcGzH9MAzwyuGPNYys/8I/YKv5/gOPoHMIxrI40KqVFSAM7jypeIuWHsXEgtNv3arOJAqs3q9Tl3iFSfq93Gl9z9xu5x39x52tjOPtfFDIdyhPp+/8T4DgLK/Cu7v9cMAAAAAElFTkSuQmCC\n", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}0 & i\\\\1 & 0\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡0 ⅈ⎤\n", + "⎢ ⎥\n", + "⎣1 0⎦" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[simplify(evalstr(c)) for c in LC][19]" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "product_table = []\n", + "row = []\n", + "\n", + "for i,p in enumerate(product(LC, LC)):\n", + " if(i % 24 == 0):\n", + " product_table.append(row)\n", + " row = []\n", + " row.append(p[0] + p[1])\n", + " \n", + "product_table = product_table[1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def simplify_str(s):\n", + " # Start with removing obvious identities.\n", + " s = s.replace(\"HH\", \"\").replace(\"SSSS\", \"\").replace(\"HH\", \"\")\n", + " # We precomputed some other stuff. Use that now:\n", + " s = s.replace(\"SSSHSSS\", \"HSH\")\n", + " s = s.replace(\"SHSSHS\", \"HSSH\")\n", + " s = s.replace(\"HSSHSHS\", \"HSH\")\n", + " \n", + " # Check for identities again:\n", + " s = s.replace(\"HH\", \"\").replace(\"SSSS\", \"\").replace(\"HH\", \"\")\n", + " s = s.replace(\"HH\", \"\").replace(\"SSSS\", \"\").replace(\"HH\", \"\")\n", + " return s" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "product_table = [[simplify_str(s) for s in row] for row in product_table]" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[['',\n", + " 'HS',\n", + " 'HSS',\n", + " 'H',\n", + " 'S',\n", + " 'HSH',\n", + " 'SS',\n", + " 'HSSH',\n", + " 'HSSS',\n", + " 'SSS',\n", + " 'HSSSH',\n", + " 'HSHS',\n", + " 'HSHSS',\n", + " 'HSSHS',\n", + " 'HSSHSS',\n", + " 'HSSHSSS',\n", + " 'SH',\n", + " 'SSH',\n", + " 'HSHSSH',\n", + " 'SSHS',\n", + " 'SSHSH',\n", + " 'HSHSH',\n", + " 'HSHSHS',\n", + " 'HSSHSH'],\n", + " ['SH',\n", + " 'SS',\n", + " 'SSS',\n", + " 'S',\n", + " 'SHS',\n", + " 'SSH',\n", + " 'SHSS',\n", + " 'SSSH',\n", + " '',\n", + " 'SHSSS',\n", + " 'H',\n", + " 'SSHS',\n", + " 'SSHSS',\n", + " 'SSSHS',\n", + " 'SSSHSS',\n", + " 'HSH',\n", + " 'SHSH',\n", + " 'SHSSH',\n", + " 'SSHSSH',\n", + " 'HSSH',\n", + " 'HSS',\n", + " 'SSHSH',\n", + " 'SSHSHS',\n", + " 'SSSHSH'],\n", + " ['SSH',\n", + " 'SSS',\n", + " '',\n", + " 'SS',\n", + " 'SSHS',\n", + " 'SSSH',\n", + " 'SSHSS',\n", + " 'H',\n", + " 'S',\n", + " 'SSHSSS',\n", + " 'SH',\n", + " 'SSSHS',\n", + " 'SSSHSS',\n", + " 'HS',\n", + " 'HSS',\n", + " 'HSSS',\n", + " 'SSHSH',\n", + " 'SSHSSH',\n", + " 'SSSHSSH',\n", + " 'SHSSH',\n", + " 'SHSS',\n", + " 'SSSHSH',\n", + " 'SSSHSHS',\n", + " 'HSH'],\n", + " ['H',\n", + " 'S',\n", + " 'SS',\n", + " '',\n", + " 'HS',\n", + " 'SH',\n", + " 'HSS',\n", + " 'SSH',\n", + " 'SSS',\n", + " 'HSSS',\n", + " 'SSSH',\n", + " 'SHS',\n", + " 'SHSS',\n", + " 'SSHS',\n", + " 'SSHSS',\n", + " 'SSHSSS',\n", + " 'HSH',\n", + " 'HSSH',\n", + " 'SHSSH',\n", + " 'HSSHS',\n", + " 'HSSHSH',\n", + " 'SHSH',\n", + " 'SHSHS',\n", + " 'SSHSH'],\n", + " ['HSH',\n", + " 'HSS',\n", + " 'HSSS',\n", + " 'HS',\n", + " 'HSHS',\n", + " 'HSSH',\n", + " 'HSHSS',\n", + " 'HSSSH',\n", + " 'H',\n", + " 'HSHSSS',\n", + " '',\n", + " 'HSSHS',\n", + " 'HSSHSS',\n", + " 'HSSSHS',\n", + " 'HSSSHSS',\n", + " 'SH',\n", + " 'HSHSH',\n", + " 'HSHSSH',\n", + " 'HSSHSSH',\n", + " 'SSH',\n", + " 'SS',\n", + " 'HSSHSH',\n", + " 'HSH',\n", + " 'HSSSHSH'],\n", + " ['S',\n", + " 'SHS',\n", + " 'SHSS',\n", + " 'SH',\n", + " 'SS',\n", + " 'SHSH',\n", + " 'SSS',\n", + " 'SHSSH',\n", + " 'SHSSS',\n", + " '',\n", + " 'SHSSSH',\n", + " 'SHSHS',\n", + " 'SHSHSS',\n", + " 'HSSH',\n", + " 'HSSHS',\n", + " 'HSSHSS',\n", + " 'SSH',\n", + " 'SSSH',\n", + " 'SHSHSSH',\n", + " 'SSSHS',\n", + " 'SSSHSH',\n", + " 'SHSHSH',\n", + " 'SHSHSHS',\n", + " 'HSS'],\n", + " ['HSSH',\n", + " 'HSSS',\n", + " 'H',\n", + " 'HSS',\n", + " 'HSSHS',\n", + " 'HSSSH',\n", + " 'HSSHSS',\n", + " '',\n", + " 'HS',\n", + " 'HSSHSSS',\n", + " 'HSH',\n", + " 'HSSSHS',\n", + " 'HSSSHSS',\n", + " 'S',\n", + " 'SS',\n", + " 'SSS',\n", + " 'HSSHSH',\n", + " 'HSSHSSH',\n", + " 'HSSSHSSH',\n", + " 'HSHSSH',\n", + " 'HSHSS',\n", + " 'HSSSHSH',\n", + " 'HSSSHSHS',\n", + " 'SH'],\n", + " ['SS',\n", + " 'SSHS',\n", + " 'SSHSS',\n", + " 'SSH',\n", + " 'SSS',\n", + " 'SSHSH',\n", + " '',\n", + " 'SSHSSH',\n", + " 'SSHSSS',\n", + " 'S',\n", + " 'SSHSSSH',\n", + " 'SSHSHS',\n", + " 'SSHSHSS',\n", + " 'SHSSH',\n", + " 'SHSSHS',\n", + " 'SHSSHSS',\n", + " 'SSSH',\n", + " 'H',\n", + " 'SSHSHSSH',\n", + " 'HS',\n", + " 'HSH',\n", + " 'SSHSHSH',\n", + " 'SSHSHSHS',\n", + " 'SHSS'],\n", + " ['SSSH',\n", + " '',\n", + " 'S',\n", + " 'SSS',\n", + " 'SSSHS',\n", + " 'H',\n", + " 'SSSHSS',\n", + " 'SH',\n", + " 'SS',\n", + " 'HSH',\n", + " 'SSH',\n", + " 'HS',\n", + " 'HSS',\n", + " 'SHS',\n", + " 'SHSS',\n", + " 'SHSSS',\n", + " 'SSSHSH',\n", + " 'SSSHSSH',\n", + " 'HSSH',\n", + " 'SSHSSH',\n", + " 'SSHSS',\n", + " 'HSH',\n", + " 'HSHS',\n", + " 'SHSH'],\n", + " ['HSSSH',\n", + " 'H',\n", + " 'HS',\n", + " 'HSSS',\n", + " 'HSSSHS',\n", + " '',\n", + " 'HSSSHSS',\n", + " 'HSH',\n", + " 'HSS',\n", + " 'SH',\n", + " 'HSSH',\n", + " 'S',\n", + " 'SS',\n", + " 'HSHS',\n", + " 'HSHSS',\n", + " 'HSHSSS',\n", + " 'HSSSHSH',\n", + " 'HSSSHSSH',\n", + " 'SSH',\n", + " 'HSSHSSH',\n", + " 'HSSHSS',\n", + " 'SH',\n", + " 'SHS',\n", + " 'HSHSH'],\n", + " ['SSS',\n", + " 'SSSHS',\n", + " 'SSSHSS',\n", + " 'SSSH',\n", + " '',\n", + " 'SSSHSH',\n", + " 'S',\n", + " 'SSSHSSH',\n", + " 'HSH',\n", + " 'SS',\n", + " 'HS',\n", + " 'SSSHSHS',\n", + " 'SSSHSHSS',\n", + " 'SSHSSH',\n", + " 'SSHSSHS',\n", + " 'SSHSSHSS',\n", + " 'H',\n", + " 'SH',\n", + " 'SSSHSHSSH',\n", + " 'SHS',\n", + " 'SHSH',\n", + " 'SSSHSHSH',\n", + " 'SSSHSHSHS',\n", + " 'SSHSS'],\n", + " ['SHSH',\n", + " 'SHSS',\n", + " 'SHSSS',\n", + " 'SHS',\n", + " 'SHSHS',\n", + " 'SHSSH',\n", + " 'SHSHSS',\n", + " 'SHSSSH',\n", + " 'SH',\n", + " 'SHSHSSS',\n", + " 'S',\n", + " 'HSSH',\n", + " 'HSSHS',\n", + " 'SHSSSHS',\n", + " 'SHSSSHSS',\n", + " 'SSH',\n", + " 'SHSHSH',\n", + " 'SHSHSSH',\n", + " 'HSSHSH',\n", + " 'SSSH',\n", + " 'SSS',\n", + " 'HSS',\n", + " 'HSSS',\n", + " 'SHSSSHSH'],\n", + " ['SHSSH',\n", + " 'SHSSS',\n", + " 'SH',\n", + " 'SHSS',\n", + " 'HSSH',\n", + " 'SHSSSH',\n", + " 'HSSHS',\n", + " 'S',\n", + " 'SHS',\n", + " 'HSSHSS',\n", + " 'SHSH',\n", + " 'SHSSSHS',\n", + " 'SHSSSHSS',\n", + " 'SS',\n", + " 'SSS',\n", + " '',\n", + " 'HSS',\n", + " 'HSSHSH',\n", + " 'SHSSSHSSH',\n", + " 'HSH',\n", + " 'HS',\n", + " 'SHSSSHSH',\n", + " 'SHSSSHSHS',\n", + " 'SSH'],\n", + " ['SSHSH',\n", + " 'SSHSS',\n", + " 'SSHSSS',\n", + " 'SSHS',\n", + " 'SSHSHS',\n", + " 'SSHSSH',\n", + " 'SSHSHSS',\n", + " 'SSHSSSH',\n", + " 'SSH',\n", + " 'SSHSHSSS',\n", + " 'SS',\n", + " 'SHSSH',\n", + " 'SHSSHS',\n", + " 'SSHSSSHS',\n", + " 'SSHSSSHSS',\n", + " 'SSSH',\n", + " 'SSHSHSH',\n", + " 'SSHSHSSH',\n", + " 'SHSSHSH',\n", + " 'H',\n", + " '',\n", + " 'SHSS',\n", + " 'SHSSS',\n", + " 'SSHSSSHSH'],\n", + " ['SSHSSH',\n", + " 'SSHSSS',\n", + " 'SSH',\n", + " 'SSHSS',\n", + " 'SHSSH',\n", + " 'SSHSSSH',\n", + " 'SHSSHS',\n", + " 'SS',\n", + " 'SSHS',\n", + " 'SHSSHSS',\n", + " 'SSHSH',\n", + " 'SSHSSSHS',\n", + " 'SSHSSSHSS',\n", + " 'SSS',\n", + " '',\n", + " 'S',\n", + " 'SHSS',\n", + " 'SHSSHSH',\n", + " 'SSHSSSHSSH',\n", + " 'SHSH',\n", + " 'SHS',\n", + " 'SSHSSSHSH',\n", + " 'SSHSSSHSHS',\n", + " 'SSSH'],\n", + " ['SSHSSSH',\n", + " 'SSH',\n", + " 'SSHS',\n", + " 'SSHSSS',\n", + " 'SSHSSSHS',\n", + " 'SS',\n", + " 'SSHSSSHSS',\n", + " 'SSHSH',\n", + " 'SSHSS',\n", + " 'SSSH',\n", + " 'SSHSSH',\n", + " 'SSS',\n", + " '',\n", + " 'SSHSHS',\n", + " 'SSHSHSS',\n", + " 'SSHSHSSS',\n", + " 'SSHSSSHSH',\n", + " 'SSHSSSHSSH',\n", + " 'H',\n", + " 'SSHSSHSSH',\n", + " 'SSHSSHSS',\n", + " 'SSSH',\n", + " 'SSSHS',\n", + " 'SSHSHSH'],\n", + " ['HS',\n", + " 'HSHS',\n", + " 'HSHSS',\n", + " 'HSH',\n", + " 'HSS',\n", + " 'HSHSH',\n", + " 'HSSS',\n", + " 'HSHSSH',\n", + " 'HSHSSS',\n", + " 'H',\n", + " 'HSHSSSH',\n", + " 'HSHSHS',\n", + " 'HSHSHSS',\n", + " 'SSH',\n", + " 'SSHS',\n", + " 'SSHSS',\n", + " 'HSSH',\n", + " 'HSSSH',\n", + " 'HSHSHSSH',\n", + " 'HSSSHS',\n", + " 'HSSSHSH',\n", + " 'HSHSHSH',\n", + " 'HSHSHSHS',\n", + " 'SS'],\n", + " ['HSS',\n", + " 'HSSHS',\n", + " 'HSSHSS',\n", + " 'HSSH',\n", + " 'HSSS',\n", + " 'HSSHSH',\n", + " 'H',\n", + " 'HSSHSSH',\n", + " 'HSSHSSS',\n", + " 'HS',\n", + " 'HSSHSSSH',\n", + " 'HSH',\n", + " 'HSHS',\n", + " 'HSHSSH',\n", + " 'HSHSSHS',\n", + " 'HSHSSHSS',\n", + " 'HSSSH',\n", + " '',\n", + " 'HSHSH',\n", + " 'S',\n", + " 'SH',\n", + " 'HS',\n", + " 'HSS',\n", + " 'HSHSS'],\n", + " ['SHSS',\n", + " 'HSSH',\n", + " 'HSSHS',\n", + " 'SHSSH',\n", + " 'SHSSS',\n", + " 'HSS',\n", + " 'SH',\n", + " 'HSSHSH',\n", + " 'HSSHSS',\n", + " 'SHS',\n", + " 'HSSHSSH',\n", + " 'HSSS',\n", + " 'H',\n", + " 'HSH',\n", + " 'HSHS',\n", + " 'HSHSS',\n", + " 'SHSSSH',\n", + " 'S',\n", + " '',\n", + " 'SS',\n", + " 'SSH',\n", + " 'HSSSH',\n", + " 'HSSSHS',\n", + " 'HS'],\n", + " ['HSSHSH',\n", + " 'HSSHSS',\n", + " 'HSSHSSS',\n", + " 'HSSHS',\n", + " 'HSH',\n", + " 'HSSHSSH',\n", + " 'HSHS',\n", + " 'HSSHSSSH',\n", + " 'HSSH',\n", + " 'HSHSS',\n", + " 'HSS',\n", + " 'HSHSSH',\n", + " 'HSHSSHS',\n", + " 'HSSHSSSHS',\n", + " 'HSSHSSSHSS',\n", + " 'HSSSH',\n", + " 'HS',\n", + " 'HSHSH',\n", + " 'HSHSSHSH',\n", + " '',\n", + " 'H',\n", + " 'HSHSS',\n", + " 'HSHSSS',\n", + " 'HSSHSSSHSH'],\n", + " ['HSSHS',\n", + " 'HSH',\n", + " 'HSHS',\n", + " 'HSSHSH',\n", + " 'HSSHSS',\n", + " 'HS',\n", + " 'HSSHSSS',\n", + " 'HSHSH',\n", + " 'HSHSS',\n", + " 'HSSH',\n", + " 'HSHSSH',\n", + " 'HSS',\n", + " 'HSSS',\n", + " '',\n", + " 'S',\n", + " 'SS',\n", + " 'HSSHSSH',\n", + " 'HSSHSSSH',\n", + " 'HSSSH',\n", + " 'HSSHSSSHS',\n", + " 'HSSHSSSHSH',\n", + " 'HSSH',\n", + " 'HSSHS',\n", + " 'H'],\n", + " ['SHS',\n", + " 'SHSHS',\n", + " 'SHSHSS',\n", + " 'SHSH',\n", + " 'SHSS',\n", + " 'SHSHSH',\n", + " 'SHSSS',\n", + " 'SHSHSSH',\n", + " 'SHSHSSS',\n", + " 'SH',\n", + " 'SHSHSSSH',\n", + " 'SHSHSHS',\n", + " 'SHSHSHSS',\n", + " 'SSSH',\n", + " 'SSSHS',\n", + " 'SSSHSS',\n", + " 'SHSSH',\n", + " 'SHSSSH',\n", + " 'SHSHSHSSH',\n", + " 'SHSSSHS',\n", + " 'SHSSSHSH',\n", + " 'SHSHSHSH',\n", + " 'SHSHSHSHS',\n", + " 'SSS'],\n", + " ['SHSHSH',\n", + " 'SHSHSS',\n", + " 'SHSHSSS',\n", + " 'SHSHS',\n", + " 'SHSHSHS',\n", + " 'SHSHSSH',\n", + " 'SHSHSHSS',\n", + " 'SHSHSSSH',\n", + " 'SHSH',\n", + " 'SHSHSHSSS',\n", + " 'SHS',\n", + " 'SSSH',\n", + " 'SSSHS',\n", + " 'SHSHSSSHS',\n", + " 'SHSHSSSHSS',\n", + " 'SHSSH',\n", + " 'SHSHSHSH',\n", + " 'SHSHSHSSH',\n", + " 'SSSHSH',\n", + " 'SHSSSH',\n", + " 'SHSSS',\n", + " 'SSS',\n", + " '',\n", + " 'SHSHSSSHSH']]" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "product_table" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'H': 0,\n", + " 'S': 1,\n", + " 'SS': 2,\n", + " 'HH': 3,\n", + " 'HS': 4,\n", + " 'SH': 5,\n", + " 'HSS': 6,\n", + " 'SSH': 7,\n", + " 'SSS': 8,\n", + " 'HSSS': 9,\n", + " 'SSSH': 10,\n", + " 'SHS': 11,\n", + " 'SHSS': 12,\n", + " 'SSHS': 13,\n", + " 'SSHSS': 14,\n", + " 'SSHSSS': 15,\n", + " 'HSH': 16,\n", + " 'HSSH': 17,\n", + " 'SHSSH': 18,\n", + " 'HSSHS': 19,\n", + " 'HSSHSH': 20,\n", + " 'SHSH': 21,\n", + " 'SHSHS': 22,\n", + " 'SSHSH': 23,\n", + " '': 3}" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "LC_indices = {c:i for i,c in enumerate(LC)}\n", + "LC_indices[\"\"] = 3\n", + "\n", + "LC_indices" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "product_table = [[LC_indices[p] if p in LC_indices else p for p in row] for row in product_table]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have to compute the missing elements manually. But at first flatten the list and remove duplicates." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['HSHS',\n", + " 'SSSHS',\n", + " 'HSHSS',\n", + " 'HSSSH',\n", + " 'SHSSS',\n", + " 'HSHSH',\n", + " 'SHSHSH',\n", + " 'HSHSSS',\n", + " 'HSHSSH',\n", + " 'HSHSHS',\n", + " 'SSSHSH',\n", + " 'SSHSSH',\n", + " 'HSSSHS',\n", + " 'SHSHSS',\n", + " 'HSSHSS',\n", + " 'SHSSSH',\n", + " 'SHSSHS',\n", + " 'SSSHSS',\n", + " 'SSHSHS',\n", + " 'HSSSHSH',\n", + " 'SSSHSSH',\n", + " 'HSHSSSH',\n", + " 'SHSHSSH',\n", + " 'HSHSSHS',\n", + " 'HSHSHSH',\n", + " 'SSSHSHS',\n", + " 'HSHSHSS',\n", + " 'SHSSHSS',\n", + " 'SHSHSSS',\n", + " 'HSSHSSS',\n", + " 'HSSSHSS',\n", + " 'SSHSHSS',\n", + " 'SHSSHSH',\n", + " 'SSHSHSH',\n", + " 'SSHSSHS',\n", + " 'HSSHSSH',\n", + " 'SHSSSHS',\n", + " 'SHSHSHS',\n", + " 'SSHSSSH',\n", + " 'SHSSSHSS',\n", + " 'HSHSSHSS',\n", + " 'SHSHSHSS',\n", + " 'SSHSHSSS',\n", + " 'HSSSHSSH',\n", + " 'HSHSHSHS',\n", + " 'HSHSHSSH',\n", + " 'HSSSHSHS',\n", + " 'SSHSHSSH',\n", + " 'SHSSSHSH',\n", + " 'SSSHSHSH',\n", + " 'SSHSHSHS',\n", + " 'HSSHSSSH',\n", + " 'SHSHSSSH',\n", + " 'SSHSSHSS',\n", + " 'SSSHSHSS',\n", + " 'HSHSSHSH',\n", + " 'SHSHSHSH',\n", + " 'SSHSSSHS',\n", + " 'SSSHSHSHS',\n", + " 'SSHSSHSSH',\n", + " 'SSHSSSHSH',\n", + " 'SHSHSHSSS',\n", + " 'SSSHSHSSH',\n", + " 'SHSHSHSHS',\n", + " 'HSSHSSSHS',\n", + " 'SSHSSSHSS',\n", + " 'SHSSSHSHS',\n", + " 'SHSSSHSSH',\n", + " 'SHSHSHSSH',\n", + " 'SHSHSSSHS',\n", + " 'SHSHSSSHSS',\n", + " 'SHSHSSSHSH',\n", + " 'SSHSSSHSSH',\n", + " 'HSSHSSSHSS',\n", + " 'HSSHSSSHSH',\n", + " 'SSHSSSHSHS']" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "unresolved_products = [[p for p in row if not isinstance(p, int)] for row in product_table]\n", + "unresolved_products = reduce(iconcat, unresolved_products)\n", + "unresolved_products = list(sorted(set(unresolved_products), key=lambda x: len(x)))\n", + "unresolved_products" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that we can now add new identities, which will allow us to reduce the re" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJkAAAAzCAYAAACE26oyAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAFeElEQVR4Ae1bgVHcMBD8z1AAUMKnA5h08HQAkwoCHcCkAoZ0AC1QAtBBQgehhOQ7+Ow+EqPI7/fZ0r3PtjSjsSzL8mq1Psmybj6bzQ4RK2G9Xq8qmcYz5vM523IM7G/GoZqFl8Khu7fStk/I+YX4N4p3cUlWgHiJyPJWw3cAO7cKbgIcPoL7WEuPB65DzvD2P9d1Dsg5wbWlu77V8tXdu898tOFmn89r86wpcAj+z0JO0OZLnF94kYXXKmnc/IrMV9xk1kpUQBvLmDKHIpEZ668KHIifVpbW9gs686JSoGQ0MqDJIedkYwg00w+I5yDL7HBunGg1DgcvMohqgc67RaQ1e4MlG9xXcd/i0+awV5HRRCNyctg5QFReWFeo5L5zRQO9cQgc9ioy9CuHtuThDUSzDlqyB6Q5N5tSMM9h3yLLJQYK7NUNlV9zVTqxetQ4FIkM1mGByAVaLnYyfY94bagTuMb35jCZHDKBbbIcHkiEwnkPypld6HQWzPTSxZQ5FFkyiRBLmcJAHQONlgxmfl13s8/HWzr36W1H1MEhjGN+HI6Zgev8MowD51g7rVMObPFDNc5z4Bwyh40iaxKQpFNQxzYRUVz8TbXA9R+SeuIyObDFdWqc58A5ZA7LcKmhqlLnfww0WjKWhsXhWgy/LBkW74fZN7xdK5fu7WAZW0iKZZza2EQiA1l3obkGKM6xuK/sc0hkT2nL2EJKLONUxSYdLrlZMZy4c82M6z4WVtctYwtFZhmnKjapyDhx/xkyZihtGVtIk2WcqthEwyWGSm6jCQNB8cc0NzOmBM7pkuZ1ithS2lW5VxGneQ5FIgsZc0Mklx5Ow/wuaRBfu+W7S305sXV5vvSenDiHwKF0uNzwB3L4Zcn52Ckal2SBpB0iLWcZW9gGyzi1sIktmQcAcW2cBXDOSf8K5727n1nGtk1gU+NQZMlcJ3LZ4pbicgLjvOxPSGIfacvYQj4s49TGxn+OvxGv8HbVzo8Agr50hyFpTOOenf8s4/Ia55axhe21jLMNNpSlDkQO1Ci7cYkTWTKI6QgVM9J68cf13ILAgIVCPwrw8B/ojRVsxOdDiNPjjXGyA9kxiHt1oJZg8+3AkX9+WrlGiuZkaDTnX0v3oIpFc/m9H0CW2T1vTeSMmWORyNB5xbm3SSWJ18fMsUhkifyp3w4rQCtLa1uce5XYTuFYNCdTwp2zWjXH1JwgB15XZ44HLzK8YQt03i0irZn3wRx4f9qCn8rx4EWGuYwXFr98uZZXQsAAhznEXh2oBy8y8gkS+cVLSzZF515SsCuQm+QVgRSORyEykEiBFefeXVJLv9aZY5HIoOLJOqam942shjFzfCChgPMelDO70Al8K+Db6T4naWefZcbMsciS9Ul+efbwGWi0ZDDjOZx7OfF8QWwzAb3A271z520ObKldCAzJbcvRDtTBL2vOm+JwzAxc59d3HPbiQN0oMnR08k4LN5wl76SNGcqBLa6z7XmOtuVoB+rYJiITDtRluGyrqlK+NQONlow1uiGBWzwYFu+H4tzreMhyGDPHIpGBRVXnz8ResoytTdMstyMZG3fGLjGmcwPg1ojrnPx/lEGa1ox5J3X37Cvf4TCJrQ0HWu1AvdxgeN0GS1y2Kzbcx99ZT9I5GSeVxbkXJCiG0XIsGi6hbC3n3uQ+s4ytTeMU28GFasbOIRWbSGQhOkxQuTkwi3NvWG+OtGVsbdqXsx0QSK2DUBtMvmwXbNLhcvMMPIBzseLc6xlXOI6RY7El843Hm1GcexXExSrHyrG3ZNxlQXesjxjy6BrP3xbFuTckJmN6DByH+mEa9DDOvHMvh8EwPMBiffymwA3FuTdkRyE9Bo7RhidQs4zoef4HSJuW4sfu9v0AAAAASUVORK5CYII=\n", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}\\frac{1}{2} + \\frac{i}{2} & \\frac{1}{2} + \\frac{i}{2}\\\\\\frac{1}{2} - \\frac{i}{2} & - \\frac{1}{2} + \\frac{i}{2}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡1 ⅈ 1 ⅈ ⎤\n", + "⎢─ + ─ ─ + ─ ⎥\n", + "⎢2 2 2 2 ⎥\n", + "⎢ ⎥\n", + "⎢1 ⅈ 1 ⅈ⎥\n", + "⎢─ - ─ - ─ + ─⎥\n", + "⎣2 2 2 2⎦" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evalstr(\"HSHS\")" + ] } ], "metadata": { diff --git a/thesis/Makefile b/thesis/Makefile index 4cd2f38..60e5943 100644 --- a/thesis/Makefile +++ b/thesis/Makefile @@ -4,7 +4,8 @@ bibtex=bibtex chapters = chapters/introduction.tex \ chapters/naive_simulator.tex \ - chapters/introduction_qc.tex + chapters/introduction_qc.tex \ + chapters/graph_simulator.tex all: main.pdf diff --git a/thesis/chapters/graph_simulator.tex b/thesis/chapters/graph_simulator.tex index c9bba99..2d2553e 100644 --- a/thesis/chapters/graph_simulator.tex +++ b/thesis/chapters/graph_simulator.tex @@ -1,11 +1,130 @@ -\section{The graph Simulator} +\section{The Graph Simulator} \subsection{Introduction to the Graph Formalism} The first step towards the simulation in the graph formalism has been the discovery of the stabilizer states and stabilizer circuits \cite{gottesman2009}\cite{gottesman1997}. They led to the faster simulation using stabilizer tableaux\cite{gottesman_aaronson2008} and later -to the graph formalism . +to the graph formalism\cite{schlingenmann2001}\cite{andersbriegel2005}\cite{vandennest_ea2004}. +The following discussion eludicates the graph formalism and explains how the graph simulator works. +Some parts will be kept short as they can be looked up in \cite{andersbriegel2005}. + +\begin{definition} + \begin{equation} + p \in P_n \Rightarrow p = \bigotimes\limits_{i=0}^n p_i \\ + \forall i: p_i \in P := \{\pm 1, \pm i\} \cdot \{I, X, Y, Z\} + \end{equation} + +Where $X = \left(\begin{array}{cc} 0 & 1 \\ 1 & 0\end{array}\right)$, + $Y = \left(\begin{array}{cc} 0 & i \\ -i & 0\end{array}\right)$ and + $Z = \left(\begin{array}{cc} 1 & 0 \\ 0 & -1\end{array}\right)$ are the Pauli matrices and + $I$ is the identity. +\end{definition} + + +\begin{definition} + Let $p_i \in P_n \forall i = 1, ..., n$, $[p_i, p_j] = 0 \forall i,j$ be commuting multi-local Pauli operators. + Then a $n$ qbit state $\ket{\psi}$ is called a stabilizer state iff + + \begin{equation} + \forall i: p_i\ket{\psi} = +1\ket{\psi} + \end{equation} +\end{definition} +%A $n$ qbit graph or stabilizer state is a $+1$ eigenstate of some $ p \in P_n$ where $P_n$ is the Pauli group\cite{andersbriegel2005}. + +\begin{definition} + \begin{equation} + C_n := \{U \in SU(2) | UpU^\dagger \in P_n \forall p \in P_n\} + \end{equation} + is called the Clifford group on $n$ qbits. + $C_1 =: C_L$ is called the local Clifford group. +\end{definition} + +One can show that the Clifford group $C_n$ can be generated using the elements of $C_L$ acting on all qbits and +the controlled phase gate $CZ$ between all qbits\cite{andersbriegel2005}. It is worth noting that the $CX$ gate can be +generated using $CZ$ and $C_L$ gates. + +\begin{lemma} + Let $a \in C_L$ then $\forall \phi \in [0, 2\pi)$ also $\exp(i\phi)a \in C_L$. + + \textbf{Note}: This is also true for $C_n \forall n >= 1$. +\end{lemma} +\begin{proof} + + Let $a' := \exp(i\phi)a$. $a' \in C_L$ iff $a'pa^{\prime\dagger} \in P \forall p \in P$. + + \begin{equation} + \begin{aligned} + a'pa^{\prime\dagger} &= (\exp(i\phi)a)p(\exp(i\phi)a)^\dagger \\ + & = \exp(i\phi)ap\exp(-i\phi)a^\dagger \\ + & = \exp(i\phi)\exp(-i\phi) apa^\dagger \\ + & = apa^\dagger \in P + \end{aligned} + \end{equation} +\end{proof} + +\begin{lemma} + One cannot measure phases by projecting states. +\end{lemma} +\begin{proof} + Let $\ket{\psi}$ be a state, $\ket{\varphi}\bra{\varphi}$ a projector. $\ket{\psi'} := \exp(i\phi)\ket{\psi}$ for some $\phi \in [0, 2\pi)$. + + \begin{equation} + \begin{aligned} + \bra{\psi'}\ket{\varphi}\bra{\varphi}\ket{\psi'} &= \exp(-i\phi)\bra{\psi}\ket{\varphi}\bra{\varphi}\exp(i\phi)\ket{\psi} \\ + & = \exp(-i\phi)\exp(i\phi)\bra{\psi}\ket{\varphi}\bra{\varphi}\ket{\psi} \\ + & = \bra{\psi}\ket{\varphi}\bra{\varphi}\ket{\psi} + \end{aligned} + \end{equation} +\end{proof} + +\begin{definition} + A phase $\phi \in [0, 2\pi)$ is called qbit-global, if for some qbit states $\ket{\psi}, \ket{\varphi}$ $\ket{\psi} = \exp(i\phi)\ket{\varphi}$. +\end{definition} + +\begin{lemma} + When entangling qbits via projections one can disregard qbit-global phases. + + Two qbits are entangled via projection, if for some single qbit gates $M,N$ + and two orthonormal states $\ket{a}, \ket{b}$ + + \begin{equation} + C^{M,N}(i,j) = \ket{a}\bra{a}_j \otimes M_i + \ket{b}\bra{b}_j \otimes N_i + \end{equation} + + \textbf{Remark.} + In particular when entangling states using $CX$ and $CZ$ one can disregard qbit-global phases. + This is immideatly clear when recalling \eqref{eq:CX_pr} and \eqref{eq:CZ_pr}. +\end{lemma} + +\begin{proof} + Let $\alpha, \beta \in [0, 2\pi)$ be some phases, $\ket{\psi}, \ket{\varphi}, \ket{\psi'} := \exp(i\alpha)\ket{\psi}, \ket{\varphi'} := \exp(i\beta)\ket{\varphi}$ some single qbit states, + $M, N, \ket{a}, \ket{b}, C^{M,N}(i,j)$ as defined above. + +\begin{equation} +\begin{aligned} + C^{M,N}(1, 0) (\ket{\psi'}\otimes\ket{\varphi'}) & = \ket{a}\braket{a}{\varphi'}\otimes M\ket{\psi'} + \ket{b}\braket{b}{\varphi'} \otimes N\ket{\psi'} \\ + & = \exp(i\beta)\ket{a}\braket{a}{\varphi}\otimes\exp(i\alpha)M\ket{\phi} + \exp(i\beta)\ket{b}\braket{b}{\varphi}\otimes\exp(i\alpha)N\ket{\phi}\\ + & = \exp(i(\beta + \alpha))(\ket{a}\braket{a}{\varphi}\otimes M\ket{\psi} + \ket{b}\braket{b}{\varphi} \otimes N\ket{\psi})\\ + & = \exp(i(\beta + \alpha))C^{M,N}(1, 0) (\ket{\psi}\otimes\ket{\varphi}) +\end{aligned} +\end{equation} + + Where $\exp(i(\beta + \alpha))$ is a multi-qbit-global phase which can be (following the above argumentation) disregarded. + +\end{proof} + +\begin{corrolary} + One can disregard global phases of elements of the $C_L$ group. +\end{corrolary} + +\begin{proof} + As it has been shown above a quantum computer cannot measure global phases. Also + the entanglement gates $CX, CZ$ map qbit-global phases to multi-qbit-global phases which cannot + be measured. It has been shown above that one can choose the $C_L$ operators such that they do not yield + a phase. +\end{proof} + \subsection{Graph Storage} @@ -14,3 +133,11 @@ in simulation performance and a lower memory requirement. The simulation of at least $10^6$ qbits on a common desktop computer should be possible\cite{andersbriegel2005}. Therefore one has to take care when choosing a representation of the graph state. The following + +FIXME + +\subsection{Usage} + FIXME + + \subsection{Performance} + FIXME diff --git a/thesis/chapters/introduction_qc.tex b/thesis/chapters/introduction_qc.tex index 5c0d6aa..8fa6373 100644 --- a/thesis/chapters/introduction_qc.tex +++ b/thesis/chapters/introduction_qc.tex @@ -2,6 +2,7 @@ \section{Introduction to Binary Quantum Computing} \subsection{Single Qbits} +\label{ref:singleqbitsystems} A qbit is a two-level quantum mechanical system $ \{\ket{\uparrow} \equiv \ket{1}, \ket{\downarrow} \equiv \ket{0}\} $ with $\braket{\uparrow}{\downarrow} = 0$. One can associate @@ -14,10 +15,18 @@ $\forall G \in U(2)$ $G$ can be arbitrarily good as a product of unitary generat common choices for the generators are $ X, H, R_{\phi}$ and $Z, H, R_{\phi}$ with \label{ref:singleqbitgates} -$$X := \left(\begin{array}{cc} 0 & 1 \\ 1 & 0\end{array}\right) $$ -$$Z := \left(\begin{array}{cc} 1 & 0 \\ 0 & -1\end{array}\right) $$ -$$H := \frac{1}{\sqrt{2}}\left(\begin{array}{cc} 1 & 1 \\ 1 & -1\end{array}\right) $$ -$$R_{\phi} := \left(\begin{array}{cc} 1 & 0 \\ 0 & \exp(i\phi)\end{array}\right)$$ +\begin{equation} + X := \left(\begin{array}{cc} 0 & 1 \\ 1 & 0\end{array}\right) +\end{equation} +\begin{equation} + Z := \left(\begin{array}{cc} 1 & 0 \\ 0 & -1\end{array}\right) +\end{equation} +\begin{equation} + H := \frac{1}{\sqrt{2}}\left(\begin{array}{cc} 1 & 1 \\ 1 & -1\end{array}\right) +\end{equation} +\begin{equation} + R_{\phi} := \left(\begin{array}{cc} 1 & 0 \\ 0 & \exp(i\phi)\end{array}\right) +\end{equation} \subsection{$N$ Qbit Systems} \label{ref:nqbitsystems} @@ -30,29 +39,60 @@ states. The $N$ qbit operators are the tensor product of the $N$ single qbit ope Let $\ket{0}_s := \left(\begin{array}{c} 1 \\ 0 \end{array} \right)$ and $\ket{1}_s := \left(\begin{array}{c} 0 \\ 1 \end{array} \right)$ be the basis of the one-qbit systems. Then two-qbit basis states are -$$ \ket{0} := \ket{0b00} := \ket{0}_s \otimes \ket{0}_s := \left(\begin{array}{c} 1 \\ 0 \\ 0 \\ 0 \end{array} \right)$$ -$$ \ket{1} := \ket{0b01} := \ket{0}_s \otimes \ket{1}_s := \left(\begin{array}{c} 0 \\ 1 \\ 0 \\ 0 \end{array} \right)$$ -$$ \ket{2} := \ket{0b10} := \ket{1}_s \otimes \ket{0}_s := \left(\begin{array}{c} 0 \\ 0 \\ 1 \\ 0 \end{array} \right)$$ -$$ \ket{3} := \ket{0b11} := \ket{1}_s \otimes \ket{1}_s := \left(\begin{array}{c} 0 \\ 0 \\ 0 \\ 1 \end{array} \right)$$ +\begin{equation} + \ket{0} := \ket{0b00} := \ket{0}_s \otimes \ket{0}_s := \left(\begin{array}{c} 1 \\ 0 \\ 0 \\ 0 \end{array} \right) +\end{equation} +\begin{equation} + \ket{1} := \ket{0b01} := \ket{0}_s \otimes \ket{1}_s := \left(\begin{array}{c} 0 \\ 1 \\ 0 \\ 0 \end{array} \right) +\end{equation} +\begin{equation} + \ket{2} := \ket{0b10} := \ket{1}_s \otimes \ket{0}_s := \left(\begin{array}{c} 0 \\ 0 \\ 1 \\ 0 \end{array} \right) +\end{equation} +\begin{equation} + \ket{3} := \ket{0b11} := \ket{1}_s \otimes \ket{1}_s := \left(\begin{array}{c} 0 \\ 0 \\ 0 \\ 1 \end{array} \right) +\end{equation} The $N$ qbit basis states can then be constructed in a similar manner. A general $N$ qbit state can then be written as a superposition of the basis states: -$$ \ket{\psi} = \sum\limits_{i = 0}^{2^N - 1} c_i \ket{i} $$ -$$ \sum\limits_{i = 0}^{2^N - 1} |c_i|^2 = 1$$ +\begin{equation} + \ket{\psi} = \sum\limits_{i = 0}^{2^N - 1} c_i \ket{i} +\end{equation} +\begin{equation} + \sum\limits_{i = 0}^{2^N - 1} |c_i|^2 = 1 +\end{equation} + + +FIXME: rewrite this. One can show that the gates in \ref{ref:singleqbitgates} together with an entanglement gate, such as $CX$ or $CZ$ are enough to generate an arbitrary $N$ qbit gate\cite[Chapter 4.3]{kaye_ea2007}. +The matrix representation of $CX$ and $CZ$ for two qbits is given by -$$ CX(1, 0) = \left(\begin{array}{cccc} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 1\\ 0 & 0 & 1 & 0 \end{array}\right)$$ -$$ CZ(1, 0) = \left(\begin{array}{cccc} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & -1 \end{array}\right)$$ - +\begin{equation} + CX(1, 0) = \left(\begin{array}{cccc} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 1\\ 0 & 0 & 1 & 0 \end{array}\right) +\end{equation} +\begin{equation} + CZ(1, 0) = \left(\begin{array}{cccc} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & -1 \end{array}\right) +\end{equation} Where $1$ is the act-qbit and $0$ the control-qbit. In words $CX$ ($CZ$) apply an $X$ ($Z$) gate on the act-qbit, if the control-qbit is set. +The following notation\cite{dahlberg_ea2019} can be more handy when discussing more qbits: + +\begin{equation}\label{eq:CX_pr} + CX(i, j) = \ket{0}\bra{0}_j\otimes I_i + \ket{1}\bra{1}_j \otimes X_i +\end{equation} +\begin{equation}\label{eq:CZ_pr} + CZ(i, j) = \ket{0}\bra{0}_j\otimes I_i + \ket{1}\bra{1}_j \otimes Z_i +\end{equation} + +Where $i$ is the act-qbit, $j$ the control-qbit and $I_i$, $Z_i$ are the identity and Pauli $Z$ gate +operating on qbit i. + \subsection{Measurement} \begin{postulate} @@ -75,4 +115,6 @@ Measuring a qbit will also yield a classical result $0$ or $1$ with the respecti \begin{proof} The measuerment in not injective: Measuring both $\ket{0}$ and $\frac{1}{\sqrt{2}}(\ket{0} + \ket{1}$ (can) map to $\ket{0}$. + + Any unitary matrix $U$ has the inverse $U^\dagger \equiv U^{-1}$. \end{proof} diff --git a/thesis/chapters/naive_simulator.tex b/thesis/chapters/naive_simulator.tex index 6906f05..84b51cd 100644 --- a/thesis/chapters/naive_simulator.tex +++ b/thesis/chapters/naive_simulator.tex @@ -8,15 +8,46 @@ such an algorithm is essential for education. \subsection{Simulator Core} -Recalling \ref{ref:nqbitsystems} an arbitrary state $\ket{\psi}$ can be written as such: +Recalling \ref{ref:nqbitsystems} an arbitrary $N$ qbit state $\ket{\psi}$ can be written as such: -$$ \ket{\psi} = \sum\limits_{i = 0}^{2^N - 1} c_i \ket{i} $$ +\begin{equation} + \ket{\psi} = \sum\limits_{i = 0}^{2^N - 1} c_i \ket{i} +\end{equation} Which yields $2^N$ coefficients $c_i = \braket{\psi}{i}$. These coefficients are used to -store the quantum mechanical state of the simulator and are stored in numpy arrays \cite{numpy_array}. +store the quantum mechanical state of the simulator and are stored in NumPy arrays \cite{numpy_array}. They can be modified and viewed without overhead using python and allow fast modification using so-called NumPy ufuncs\cite{numpy_ufunc}. A simulator state also contains a classical state which is a length $N$ integer array containing the measured classical bits with a default value of $-1$. -The gates are implemented as NumPy ufuncs which allows +The gates are implemented as NumPy ufuncs which allows an efficient +manipulation of NumPy arrays using C code. Every gate maps a length $2^N$ +\lstinline[basicstyle=\ttfamily, language=Python]{numpy.cdouble} and a length +$N$ \lstinline[basicstyle=\ttfamily, language=Python]{numpy.int8} array to +a length $2^N$ \lstinline[basicstyle=\ttfamily, +language=Python]{numpy.cdouble}, a length $N$ \lstinline[basicstyle=\ttfamily, +language=Python]{numpy.int8} and a \lstinline[basicstyle=\ttfamily, +language=Python]{numpy.uint64} scalar. The \lstinline[basicstyle=\ttfamily, +language=Python]{numpy.cdouble} arrays are the quantum mechanical state before +and after the gate; the \lstinline[basicstyle=\ttfamily, +language=Python]{numpy.int8} arrays are the respective classical states and the +\lstinline[basicstyle=\ttfamily, language=Python]{numpy.uint64} scalar has +a logical one at every bit that has been measured. + +\subsection{Implemented Gates} + +As stated in \ref{ref:singleqbitsystems} and \ref{ref:nqbitsystems} a just a small set of gates is required to +approximate an arbitrary unitary matrix arbitrarily good. In principle just the $X$, $R_\phi$, $H$ and $CNOT$ gate +would be sufficient for a simulator. As however both $X$ and $Z$ are often used in practice FIXME: CITATION NEEDED +$X$, $Z$, $R_\phi$, $H$ and $CNOT$ are implemented. They can be accessed using +\lstinline[basicstyle=\ttfamily]{pyqcs.X}, \lstinline[basicstyle=\ttfamily]{pyqcs.Z}, \lstinline[basicstyle=\ttfamily]{pyqcs.R}, +\lstinline[basicstyle=\ttfamily]{pyqcs.H} and \lstinline[basicstyle=\ttfamily]{pyqcs.C}. + +\subsection{Usage} + +FIXME + +\subsection{Performance} + +FIXME diff --git a/thesis/main.bib b/thesis/main.bib index d9f10b2..cadcdb8 100644 --- a/thesis/main.bib +++ b/thesis/main.bib @@ -62,8 +62,32 @@ @article{ gottesman_aaronson2008, - title={Improved Simulation of Stabilizer Circuits} + title={Improved Simulation of Stabilizer Circuits}, year=2008, - author={Daniel Gottesman, Scott Aaronson} + author={Daniel Gottesman, Scott Aaronson}, note={https://arxiv.org/abs/quant-ph/0406196v5} } + +@article{ + schlingenmann2001, + title={Stabilizer codes can be realized as graph codes}, + year=2001, + author={D. Schlingemann}, + note={https://arxiv.org/abs/quant-ph/0111080v1} +} + +@article{ + vandennest_ea2004, + title={Graphical description of the action of local Clifford transformations on graph states}, + year=2004, + author={Maarten Van den Nest et al.}, + note={PhysRevA.69.022316} +} + +@article{ + dahlberg_ea2019, + title={Counting single-qubit Clifford equivalent graph states is \#P-Complete}, + year=2019, + author={Axel Dahlberg et al.}, + note={https://arxiv.org/abs/1907.08024v1} +} diff --git a/thesis/main.tex b/thesis/main.tex index 8f1b5d5..c2fe5c4 100644 --- a/thesis/main.tex +++ b/thesis/main.tex @@ -9,12 +9,16 @@ \usepackage{geometry} \usepackage{enumerate} \usepackage{physics} +\usepackage{listings} \geometry{left=2.5cm,right=2.5cm,top=2.5cm,bottom=2.5cm} \newtheorem{definition}{Definition} \newtheorem{postulate}{Postulate} \newtheorem{corrolary}{Corrolary} +\newtheorem{lemma}{Lemma} + +\numberwithin{equation}{section} \title{Development of an Extensible Quantum Computing Simulator with a Focus on Simulation in the Graph Formalism } @@ -42,6 +46,8 @@ Simulator with a Focus on Simulation in the Graph Formalism } \include{chapters/naive_simulator} +\include{chapters/graph_simulator} + %\backmatter \bibliographystyle{unsrt}