From fe7fcd78870e3f88b5bdca259826cbbc38b87f66 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20Kn=C3=BCttel?= Date: Tue, 29 Oct 2019 15:24:15 +0100 Subject: [PATCH] computed C_L elements and products --- computations/C_L_elements_and_products.ipynb | 332 +++++++++++++++++++ 1 file changed, 332 insertions(+) create mode 100644 computations/C_L_elements_and_products.ipynb diff --git a/computations/C_L_elements_and_products.ipynb b/computations/C_L_elements_and_products.ipynb new file mode 100644 index 0000000..0fe8ef5 --- /dev/null +++ b/computations/C_L_elements_and_products.ipynb @@ -0,0 +1,332 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Computing the Elements of the Local Clifford Group\n", + "\n", + "Known is that $H = \\frac{1}{\\sqrt{2}}\\left(\\begin{array}{cc} 1 & 1 \\\\ 1 & -1\\end{array}\\right) $ and $S = \\left(\\begin{array}{cc} 1 & 0 \\\\ 0 & i\\end{array}\\right)$ generate the local clifford group $C_L$. Also it has been discussed before that $|C_L| = 24$.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sympy\n", + "\n", + "M = sympy.Matrix\n", + "simplify = sympy.simplify\n", + "sqrt = sympy.sqrt\n", + "i = sympy.I\n", + "\n", + "from sympy.physics.quantum import Dagger\n", + "\n", + "sympy.init_printing()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "H = simplify(M([[1, 1], [1, -1]]) / sqrt(2))\n", + "S = M([[1, 0], [0, i]])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "C_L = [H, S]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As discussed before one can disregard an overall phase, so when checking whether the matrix is known one has to take this invariance into account.\n", + "\n", + "Also note that $C_L$ is a subgroup of $SU(2)$, so the inverse of an $a \\in C_L$ is $a^\\dagger$. Further $a$ has the structure $ a \\equiv \\left(\\begin{array}{cc}z_1 & z_2 \\\\ -z_2^* & z_1^* \\end{array}\\right)$ with the constraint $|z_1|^2 + |z_2|^2 = 1$.\n", + "\n", + "This yields $\\forall a,b \\in L_C$: $a = b$ disregarding a global phase $\\Leftrightarrow ba^\\dagger = \\exp(i\\phi)\\mathbb{1}$ " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "basis_vectors = [M([1, 0]), M([0, 1])]\n", + "\n", + "def getitem(m, i, j):\n", + " # Note that sympy uses an extremely weird way to store the matrices,\n", + " # in particular the internal representation is vastly different from what\n", + " # is printed. For instance the H matrix is stored as a Mul object\n", + " # (even after using simplify) instead of a matrix. \n", + " # Therefore m[i][j] will NOT work. This is a workaround.\n", + " return (Dagger(basis_vectors[i]) * m * basis_vectors[j])[0]\n", + "\n", + "def is_known(C_L, a):\n", + " for c in C_L:\n", + " test = c * Dagger(a)\n", + " if(simplify(getitem(test, 0, 1)) != 0):\n", + " continue\n", + " if(simplify(getitem(test, 0, 0) / getitem(test, 1, 1)) == 1):\n", + " return True\n", + " return False" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrix([[1, 0], [0, 1]])\n", + "got 3 matrices\n", + "Matrix([[sqrt(2)/2, sqrt(2)/2], [sqrt(2)*I/2, -sqrt(2)*I/2]])\n", + "got 4 matrices\n", + "Matrix([[sqrt(2)/2, sqrt(2)*I/2], [sqrt(2)/2, -sqrt(2)*I/2]])\n", + "got 5 matrices\n", + "Matrix([[1, 0], [0, -1]])\n", + "got 6 matrices\n", + "Matrix([[sqrt(2)/2, sqrt(2)*I/2], [sqrt(2)*I/2, sqrt(2)/2]])\n", + "got 7 matrices\n", + "Matrix([[sqrt(2)/2, -sqrt(2)/2], [sqrt(2)/2, sqrt(2)/2]])\n", + "got 8 matrices\n", + "Matrix([[1, 0], [0, -I]])\n", + "got 9 matrices\n", + "Matrix([[sqrt(2)/2, -sqrt(2)/2], [sqrt(2)*I/2, sqrt(2)*I/2]])\n", + "got 10 matrices\n", + "Matrix([[sqrt(2)/2, -sqrt(2)*I/2], [sqrt(2)/2, sqrt(2)*I/2]])\n", + "got 11 matrices\n", + "Matrix([[sqrt(2)/2, -sqrt(2)*I/2], [sqrt(2)*I/2, -sqrt(2)/2]])\n", + "got 12 matrices\n", + "After interation 0 there are 12 known matrices\n", + "Matrix([[1/2 + I/2, 1/2 - I/2], [1/2 - I/2, 1/2 + I/2]])\n", + "got 13 matrices\n", + "Matrix([[sqrt(2)/2, sqrt(2)/2], [-sqrt(2)/2, sqrt(2)/2]])\n", + "got 14 matrices\n", + "Matrix([[0, 1], [1, 0]])\n", + "got 15 matrices\n", + "Matrix([[sqrt(2)/2, sqrt(2)/2], [-sqrt(2)*I/2, sqrt(2)*I/2]])\n", + "got 16 matrices\n", + "Matrix([[0, 1], [I, 0]])\n", + "got 17 matrices\n", + "Matrix([[1/2 - I/2, 1/2 + I/2], [-1/2 + I/2, 1/2 + I/2]])\n", + "got 18 matrices\n", + "Matrix([[0, I], [1, 0]])\n", + "got 19 matrices\n", + "Matrix([[sqrt(2)/2, sqrt(2)*I/2], [-sqrt(2)*I/2, -sqrt(2)/2]])\n", + "got 20 matrices\n", + "Matrix([[1/2 - I/2, -1/2 + I/2], [-1/2 + I/2, -1/2 + I/2]])\n", + "got 21 matrices\n", + "Matrix([[0, -1], [1, 0]])\n", + "got 22 matrices\n", + "Matrix([[sqrt(2)/2, -sqrt(2)/2], [-sqrt(2)*I/2, -sqrt(2)*I/2]])\n", + "got 23 matrices\n", + "Matrix([[1/2 - I/2, I*(-1 + I)/2], [-1/2 + I/2, I*(-1 + I)/2]])\n", + "got 24 matrices\n", + "After interation 1 there are 24 known matrices\n", + "After interation 2 there are 24 known matrices\n", + "After interation 3 there are 24 known matrices\n", + "After interation 4 there are 24 known matrices\n" + ] + } + ], + "source": [ + "for i in range(5):\n", + " for m in (H, S):\n", + " for c in C_L:\n", + " c = simplify(c*m)\n", + " if(is_known(C_L, c)):\n", + " continue\n", + " print(c)\n", + " C_L.append(c)\n", + " print(\"got\", len(C_L), \"matrices\")\n", + " print(\"After interation\", i, \"there are\", len(C_L), \"known matrices\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\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}\\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}1 & 0\\\\0 & -1\\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}}{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}}{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} i}{2}\\\\\\frac{\\sqrt{2} i}{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{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\\\- \\frac{\\sqrt{2}}{2} & \\frac{\\sqrt{2}}{2}\\end{matrix}\\right], \\ \\left[\\begin{matrix}0 & 1\\\\1 & 0\\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}0 & 1\\\\i & 0\\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 & i\\\\1 & 0\\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{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}\\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{1}{2} - \\frac{i}{2} & \\frac{i \\left(-1 + i\\right)}{2}\\\\- \\frac{1}{2} + \\frac{i}{2} & \\frac{i \\left(-1 + i\\right)}{2}\\end{matrix}\\right]\\right]$" + ], + "text/plain": [ + "⎡⎡√2 √2 ⎤ ⎡ √2 √2 ⎤ ⎡√2 √2⋅ⅈ ⎤ ⎡ √2 √2⋅\n", + "⎢⎢── ── ⎥ ⎢ ── ── ⎥ ⎢── ──── ⎥ ⎢ ── ───\n", + "⎢⎢2 2 ⎥ ⎡1 0⎤ ⎡1 0⎤ ⎢ 2 2 ⎥ ⎢2 2 ⎥ ⎡1 0 ⎤ ⎢ 2 2 \n", + "⎢⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ \n", + "⎢⎢√2 -√2 ⎥ ⎣0 ⅈ⎦ ⎣0 1⎦ ⎢√2⋅ⅈ -√2⋅ⅈ ⎥ ⎢√2 -√2⋅ⅈ ⎥ ⎣0 -1⎦ ⎢√2⋅ⅈ √2\n", + "⎢⎢── ────⎥ ⎢──── ──────⎥ ⎢── ──────⎥ ⎢──── ──\n", + "⎣⎣2 2 ⎦ ⎣ 2 2 ⎦ ⎣2 2 ⎦ ⎣ 2 2 \n", + "\n", + "ⅈ⎤ ⎡√2 -√2 ⎤ ⎡ √2 -√2 ⎤ ⎡√2 -√2⋅ⅈ ⎤ ⎡ √2 -√2⋅ⅈ ⎤ ⎡1 ⅈ 1\n", + "─⎥ ⎢── ────⎥ ⎢ ── ────⎥ ⎢── ──────⎥ ⎢ ── ──────⎥ ⎢─ + ─ ─\n", + " ⎥ ⎢2 2 ⎥ ⎡1 0 ⎤ ⎢ 2 2 ⎥ ⎢2 2 ⎥ ⎢ 2 2 ⎥ ⎢2 2 2\n", + " ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ \n", + " ⎥ ⎢√2 √2 ⎥ ⎣0 -ⅈ⎦ ⎢√2⋅ⅈ √2⋅ⅈ⎥ ⎢√2 √2⋅ⅈ ⎥ ⎢√2⋅ⅈ -√2 ⎥ ⎢1 ⅈ 1\n", + " ⎥ ⎢── ── ⎥ ⎢──── ────⎥ ⎢── ──── ⎥ ⎢──── ──── ⎥ ⎢─ - ─ ─\n", + " ⎦ ⎣2 2 ⎦ ⎣ 2 2 ⎦ ⎣2 2 ⎦ ⎣ 2 2 ⎦ ⎣2 2 2\n", + "\n", + " ⅈ⎤ ⎡ √2 √2⎤ ⎡ √2 √2 ⎤ ⎡ 1 ⅈ 1 ⅈ⎤ ⎡\n", + " - ─⎥ ⎢ ── ──⎥ ⎢ ── ── ⎥ ⎢ ─ - ─ ─ + ─⎥ ⎢\n", + " 2⎥ ⎢ 2 2 ⎥ ⎡0 1⎤ ⎢ 2 2 ⎥ ⎡0 1⎤ ⎢ 2 2 2 2⎥ ⎡0 ⅈ⎤ ⎢\n", + " ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢\n", + " ⅈ⎥ ⎢-√2 √2⎥ ⎣1 0⎦ ⎢-√2⋅ⅈ √2⋅ⅈ⎥ ⎣ⅈ 0⎦ ⎢ 1 ⅈ 1 ⅈ⎥ ⎣1 0⎦ ⎢\n", + " + ─⎥ ⎢──── ──⎥ ⎢────── ────⎥ ⎢- ─ + ─ ─ + ─⎥ ⎢\n", + " 2⎦ ⎣ 2 2 ⎦ ⎣ 2 2 ⎦ ⎣ 2 2 2 2⎦ ⎣\n", + "\n", + " √2 √2⋅ⅈ⎤ ⎡ 1 ⅈ 1 ⅈ⎤ ⎡ √2 -√2 ⎤ ⎡ 1 ⅈ ⅈ⋅(-1 \n", + " ── ────⎥ ⎢ ─ - ─ - ─ + ─⎥ ⎢ ── ──── ⎥ ⎢ ─ - ─ ──────\n", + " 2 2 ⎥ ⎢ 2 2 2 2⎥ ⎡0 -1⎤ ⎢ 2 2 ⎥ ⎢ 2 2 2 \n", + " ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ \n", + "-√2⋅ⅈ -√2 ⎥ ⎢ 1 ⅈ 1 ⅈ⎥ ⎣1 0 ⎦ ⎢-√2⋅ⅈ -√2⋅ⅈ ⎥ ⎢ 1 ⅈ ⅈ⋅(-1 \n", + "────── ────⎥ ⎢- ─ + ─ - ─ + ─⎥ ⎢────── ──────⎥ ⎢- ─ + ─ ──────\n", + " 2 2 ⎦ ⎣ 2 2 2 2⎦ ⎣ 2 2 ⎦ ⎣ 2 2 2 \n", + "\n", + "+ ⅈ)⎤⎤\n", + "────⎥⎥\n", + " ⎥⎥\n", + " ⎥⎥\n", + "+ ⅈ)⎥⎥\n", + "────⎥⎥\n", + " ⎦⎦" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "C_L" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These are the 24 elements of $C_L$. Required to do further computations is the lookup table containing all the \n", + "products between $C_L$ matrices:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from itertools import product\n", + "\n", + "product_table = []\n", + "row = []\n", + "\n", + "for i,p in enumerate(product(C_L, C_L)):\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": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$\\displaystyle \\left[ \\left[ 2, \\ 4, \\ 0, \\ 12, \\ 1, \\ 7, \\ 15, \\ 5, \\ 10, \\ 19, \\ 8, \\ 22, \\ 3, \\ 14, \\ 13, \\ 6, \\ 23, \\ 18, \\ 17, \\ 9, \\ 21, \\ 20, \\ 11, \\ 16\\right], \\ \\left[ 3, \\ 5, \\ 1, \\ 13, \\ 6, \\ 8, \\ 17, \\ 9, \\ 2, \\ 20, \\ 11, \\ 23, \\ 10, \\ 15, \\ 16, \\ 0, \\ 21, \\ 19, \\ 14, \\ 4, \\ 22, \\ 18, \\ 7, \\ 12\\right], \\ \\left[ 0, \\ 1, \\ 2, \\ 3, \\ 4, \\ 5, \\ 6, \\ 7, \\ 8, \\ 9, \\ 10, \\ 11, \\ 12, \\ 13, \\ 14, \\ 15, \\ 16, \\ 17, \\ 18, \\ 19, \\ 20, \\ 21, \\ 22, \\ 23\\right], \\ \\left[ 1, \\ 6, \\ 3, \\ 10, \\ 5, \\ 9, \\ 0, \\ 8, \\ 11, \\ 4, \\ 2, \\ 7, \\ 13, \\ 16, \\ 15, \\ 17, \\ 12, \\ 14, \\ 19, \\ 20, \\ 18, \\ 22, \\ 23, \\ 21\\right], \\ \\left[ 12, \\ 7, \\ 4, \\ 14, \\ 15, \\ 10, \\ 18, \\ 19, \\ 0, \\ 21, \\ 22, \\ 16, \\ 8, \\ 6, \\ 23, \\ 2, \\ 20, \\ 9, \\ 13, \\ 1, \\ 11, \\ 17, \\ 5, \\ 3\\right], \\ \\left[ 13, \\ 8, \\ 5, \\ 15, \\ 17, \\ 2, \\ 19, \\ 20, \\ 1, \\ 22, \\ 23, \\ 12, \\ 11, \\ 0, \\ 21, \\ 3, \\ 18, \\ 4, \\ 16, \\ 6, \\ 7, \\ 14, \\ 9, \\ 10\\right], \\ \\left[ 10, \\ 9, \\ 6, \\ 16, \\ 0, \\ 11, \\ 14, \\ 4, \\ 3, \\ 18, \\ 7, \\ 21, \\ 2, \\ 17, \\ 12, \\ 1, \\ 22, \\ 20, \\ 15, \\ 5, \\ 23, \\ 19, \\ 8, \\ 13\\right], \\ \\left[ 14, \\ 10, \\ 7, \\ 6, \\ 18, \\ 0, \\ 9, \\ 21, \\ 4, \\ 11, \\ 16, \\ 3, \\ 22, \\ 2, \\ 20, \\ 12, \\ 17, \\ 1, \\ 23, \\ 15, \\ 5, \\ 13, \\ 19, \\ 8\\right], \\ \\left[ 15, \\ 2, \\ 8, \\ 0, \\ 19, \\ 1, \\ 4, \\ 22, \\ 5, \\ 7, \\ 12, \\ 10, \\ 23, \\ 3, \\ 18, \\ 13, \\ 14, \\ 6, \\ 21, \\ 17, \\ 9, \\ 16, \\ 20, \\ 11\\right], \\ \\left[ 16, \\ 11, \\ 9, \\ 17, \\ 14, \\ 3, \\ 20, \\ 18, \\ 6, \\ 23, \\ 21, \\ 13, \\ 7, \\ 1, \\ 22, \\ 10, \\ 19, \\ 5, \\ 12, \\ 0, \\ 8, \\ 15, \\ 4, \\ 2\\right], \\ \\left[ 6, \\ 0, \\ 10, \\ 2, \\ 9, \\ 4, \\ 1, \\ 11, \\ 7, \\ 5, \\ 3, \\ 8, \\ 16, \\ 12, \\ 17, \\ 14, \\ 13, \\ 15, \\ 20, \\ 18, \\ 19, \\ 23, \\ 21, \\ 22\\right], \\ \\left[ 17, \\ 3, \\ 11, \\ 1, \\ 20, \\ 6, \\ 5, \\ 23, \\ 9, \\ 8, \\ 13, \\ 2, \\ 21, \\ 10, \\ 19, \\ 16, \\ 15, \\ 0, \\ 22, \\ 14, \\ 4, \\ 12, \\ 18, \\ 7\\right], \\ \\left[ 4, \\ 15, \\ 12, \\ 8, \\ 7, \\ 19, \\ 2, \\ 10, \\ 22, \\ 1, \\ 0, \\ 5, \\ 14, \\ 23, \\ 6, \\ 18, \\ 3, \\ 13, \\ 9, \\ 21, \\ 17, \\ 11, \\ 16, \\ 20\\right], \\ \\left[ 5, \\ 17, \\ 13, \\ 11, \\ 8, \\ 20, \\ 3, \\ 2, \\ 23, \\ 6, \\ 1, \\ 9, \\ 15, \\ 21, \\ 0, \\ 19, \\ 10, \\ 16, \\ 4, \\ 22, \\ 14, \\ 7, \\ 12, \\ 18\\right], \\ \\left[ 7, \\ 18, \\ 14, \\ 22, \\ 10, \\ 21, \\ 12, \\ 0, \\ 16, \\ 15, \\ 4, \\ 19, \\ 6, \\ 20, \\ 2, \\ 9, \\ 8, \\ 23, \\ 1, \\ 11, \\ 13, \\ 5, \\ 3, \\ 17\\right], \\ \\left[ 8, \\ 19, \\ 15, \\ 23, \\ 2, \\ 22, \\ 13, \\ 1, \\ 12, \\ 17, \\ 5, \\ 20, \\ 0, \\ 18, \\ 3, \\ 4, \\ 11, \\ 21, \\ 6, \\ 7, \\ 16, \\ 9, \\ 10, \\ 14\\right], \\ \\left[ 9, \\ 14, \\ 16, \\ 7, \\ 11, \\ 18, \\ 10, \\ 3, \\ 21, \\ 0, \\ 6, \\ 4, \\ 17, \\ 22, \\ 1, \\ 20, \\ 2, \\ 12, \\ 5, \\ 23, \\ 15, \\ 8, \\ 13, \\ 19\\right], \\ \\left[ 11, \\ 20, \\ 17, \\ 21, \\ 3, \\ 23, \\ 16, \\ 6, \\ 13, \\ 14, \\ 9, \\ 18, \\ 1, \\ 19, \\ 10, \\ 5, \\ 7, \\ 22, \\ 0, \\ 8, \\ 12, \\ 4, \\ 2, \\ 15\\right], \\ \\left[ 22, \\ 21, \\ 18, \\ 20, \\ 12, \\ 16, \\ 23, \\ 15, \\ 14, \\ 13, \\ 19, \\ 17, \\ 4, \\ 9, \\ 8, \\ 7, \\ 5, \\ 11, \\ 2, \\ 10, \\ 3, \\ 1, \\ 0, \\ 6\\right], \\ \\left[ 23, \\ 22, \\ 19, \\ 18, \\ 13, \\ 12, \\ 21, \\ 17, \\ 15, \\ 16, \\ 20, \\ 14, \\ 5, \\ 4, \\ 11, \\ 8, \\ 9, \\ 7, \\ 3, \\ 2, \\ 10, \\ 6, \\ 1, \\ 0\\right], \\ \\left[ 21, \\ 23, \\ 20, \\ 19, \\ 16, \\ 13, \\ 22, \\ 14, \\ 17, \\ 12, \\ 18, \\ 15, \\ 9, \\ 5, \\ 7, \\ 11, \\ 4, \\ 8, \\ 10, \\ 3, \\ 2, \\ 0, \\ 6, \\ 1\\right], \\ \\left[ 20, \\ 16, \\ 21, \\ 9, \\ 23, \\ 14, \\ 11, \\ 13, \\ 18, \\ 3, \\ 17, \\ 6, \\ 19, \\ 7, \\ 5, \\ 22, \\ 1, \\ 10, \\ 8, \\ 12, \\ 0, \\ 2, \\ 15, \\ 4\\right], \\ \\left[ 18, \\ 12, \\ 22, \\ 4, \\ 21, \\ 15, \\ 7, \\ 16, \\ 19, \\ 10, \\ 14, \\ 0, \\ 20, \\ 8, \\ 9, \\ 23, \\ 6, \\ 2, \\ 11, \\ 13, \\ 1, \\ 3, \\ 17, \\ 5\\right]\\right]$" + ], + "text/plain": [ + "[[2, 4, 0, 12, 1, 7, 15, 5, 10, 19, 8, 22, 3, 14, 13, 6, 23, 18, 17, 9, 21, 20\n", + ", 11, 16], [3, 5, 1, 13, 6, 8, 17, 9, 2, 20, 11, 23, 10, 15, 16, 0, 21, 19, 14\n", + ", 4, 22, 18, 7, 12], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16\n", + ", 17, 18, 19, 20, 21, 22, 23], [1, 6, 3, 10, 5, 9, 0, 8, 11, 4, 2, 7, 13, 16, \n", + "15, 17, 12, 14, 19, 20, 18, 22, 23, 21], [12, 7, 4, 14, 15, 10, 18, 19, 0, 21,\n", + " 22, 16, 8, 6, 23, 2, 20, 9, 13, 1, 11, 17, 5, 3], [13, 8, 5, 15, 17, 2, 19, 2\n", + "0, 1, 22, 23, 12, 11, 0, 21, 3, 18, 4, 16, 6, 7, 14, 9, 10], [10, 9, 6, 16, 0,\n", + " 11, 14, 4, 3, 18, 7, 21, 2, 17, 12, 1, 22, 20, 15, 5, 23, 19, 8, 13], [14, 10\n", + ", 7, 6, 18, 0, 9, 21, 4, 11, 16, 3, 22, 2, 20, 12, 17, 1, 23, 15, 5, 13, 19, 8\n", + "], [15, 2, 8, 0, 19, 1, 4, 22, 5, 7, 12, 10, 23, 3, 18, 13, 14, 6, 21, 17, 9, \n", + "16, 20, 11], [16, 11, 9, 17, 14, 3, 20, 18, 6, 23, 21, 13, 7, 1, 22, 10, 19, 5\n", + ", 12, 0, 8, 15, 4, 2], [6, 0, 10, 2, 9, 4, 1, 11, 7, 5, 3, 8, 16, 12, 17, 14, \n", + "13, 15, 20, 18, 19, 23, 21, 22], [17, 3, 11, 1, 20, 6, 5, 23, 9, 8, 13, 2, 21,\n", + " 10, 19, 16, 15, 0, 22, 14, 4, 12, 18, 7], [4, 15, 12, 8, 7, 19, 2, 10, 22, 1,\n", + " 0, 5, 14, 23, 6, 18, 3, 13, 9, 21, 17, 11, 16, 20], [5, 17, 13, 11, 8, 20, 3,\n", + " 2, 23, 6, 1, 9, 15, 21, 0, 19, 10, 16, 4, 22, 14, 7, 12, 18], [7, 18, 14, 22,\n", + " 10, 21, 12, 0, 16, 15, 4, 19, 6, 20, 2, 9, 8, 23, 1, 11, 13, 5, 3, 17], [8, 1\n", + "9, 15, 23, 2, 22, 13, 1, 12, 17, 5, 20, 0, 18, 3, 4, 11, 21, 6, 7, 16, 9, 10, \n", + "14], [9, 14, 16, 7, 11, 18, 10, 3, 21, 0, 6, 4, 17, 22, 1, 20, 2, 12, 5, 23, 1\n", + "5, 8, 13, 19], [11, 20, 17, 21, 3, 23, 16, 6, 13, 14, 9, 18, 1, 19, 10, 5, 7, \n", + "22, 0, 8, 12, 4, 2, 15], [22, 21, 18, 20, 12, 16, 23, 15, 14, 13, 19, 17, 4, 9\n", + ", 8, 7, 5, 11, 2, 10, 3, 1, 0, 6], [23, 22, 19, 18, 13, 12, 21, 17, 15, 16, 20\n", + ", 14, 5, 4, 11, 8, 9, 7, 3, 2, 10, 6, 1, 0], [21, 23, 20, 19, 16, 13, 22, 14, \n", + "17, 12, 18, 15, 9, 5, 7, 11, 4, 8, 10, 3, 2, 0, 6, 1], [20, 16, 21, 9, 23, 14,\n", + " 11, 13, 18, 3, 17, 6, 19, 7, 5, 22, 1, 10, 8, 12, 0, 2, 15, 4], [18, 12, 22, \n", + "4, 21, 15, 7, 16, 19, 10, 14, 0, 20, 8, 9, 23, 6, 2, 11, 13, 1, 3, 17, 5]]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def get_matrix_index(C_L, a):\n", + " for i,c in enumerate(C_L):\n", + " test = c * Dagger(a)\n", + " if(simplify(getitem(test, 0, 1)) != 0):\n", + " continue\n", + " if(simplify(getitem(test, 0, 0) / getitem(test, 1, 1)) == 1):\n", + " return i\n", + " return None\n", + "\n", + "product_table_indices = [[get_matrix_index(C_L, m) for m in row] for row in product_table]\n", + "product_table_indices" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}