Upload New File

ChinesischesOrakel.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Ein chinesisches Orakel und zyklische Matrizen über $\\mathbb{Z}/2\\mathbb{Z}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notebook zum gleichnamigen Artikel\n",
+    "\n",
+    "enthält Untersuchungen der auftretenden Matrizen, erlaubt Verallgemeinerung der Zaubertricks in P. Diaconis, R. Graham, Magical Mathematics, Princeton University Press (2012), DOI: 10.1515/978-1-400-83938-4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Der ursprüngliche Zaubertrick"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MS = MatrixSpace(GF(2),14)\n",
+    "M14=MS([[1,1,0,1,0,0,0,0,0,0,0,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0,0],[0,0,1,1,0,1,0,0,0,0,0,0,0,0],[0,0,0,1,1,0,1,0,0,0,0,0,0,0],\n",
+    "            [0,0,0,0,1,1,0,1,0,0,0,0,0,0],[0,0,0,0,0,1,1,0,1,0,0,0,0,0],[0,0,0,0,0,0,1,1,0,1,0,0,0,0],[0,0,0,0,0,0,0,1,1,0,1,0,0,0],\n",
+    "            [0,0,0,0,0,0,0,0,1,1,0,1,0,0],[0,0,0,0,0,0,0,0,0,1,1,0,1,0],[0,0,0,0,0,0,0,0,0,0,1,1,0,1],[1,0,0,0,0,0,0,0,0,0,0,1,1,0],\n",
+    "            [0,1,0,0,0,0,0,0,0,0,0,0,1,1],[1,0,1,0,0,0,0,0,0,0,0,0,0,1]])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Die letzten drei Zeilen sind linear abhängig:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\n",
+      "(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\n",
+      "(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(M14[11]+M14[0]+M14[1]+M14[2]+M14[4]+M14[7]+M14[8]+M14[9])\n",
+    "print(M14[12]+M14[1]+M14[2]+M14[3]+M14[5]+M14[8]+M14[9]+M14[10])\n",
+    "print(M14[13]+M14[2]+M14[3]+M14[4]+M14[6]+M14[9]+M14[10]+M14[11])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Vector space of degree 14 and dimension 3 over Finite Field of size 2\n",
+       "Basis matrix:\n",
+       "[1 0 0 1 0 1 1 1 0 0 1 0 1 1]\n",
+       "[0 1 0 1 1 1 0 0 1 0 1 1 1 0]\n",
+       "[0 0 1 0 1 1 1 0 0 1 0 1 1 1]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "kernel=M14.right_kernel()\n",
+    "kernel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Verallgemeinerung"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Die folgende Funktion erlaubt die Konstruktion der Matrix $M$ für beliebige Muster."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def konstruiereGscamMatrix(n,pattern):\n",
+    "    MS = MatrixSpace(GF(2),n)\n",
+    "    m=copy(MS.zero_matrix())\n",
+    "    k=len(pattern)\n",
+    "    \n",
+    "    for i in range(0,n):\n",
+    "        for j in range(0,len(pattern)):\n",
+    "            if (i+j<n):\n",
+    "                m[i,i+j]=pattern[j]\n",
+    "            else:\n",
+    "                k=(i+j)%n\n",
+    "                m[i,k]=pattern[j]\n",
+    "    \n",
+    "    return m"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ein Beispiel:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Vector space of degree 21 and dimension 3 over Finite Field of size 2\n",
+       "Basis matrix:\n",
+       "[1 0 0 1 0 1 1 1 0 0 1 0 1 1 1 0 0 1 0 1 1]\n",
+       "[0 1 0 1 1 1 0 0 1 0 1 1 1 0 0 1 0 1 1 1 0]\n",
+       "[0 0 1 0 1 1 1 0 0 1 0 1 1 1 0 0 1 0 1 1 1]"
+      ]
+     },
+     "execution_count": 69,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "M21=konstruiereGscamMatrix(21,[1,1,0,1])\n",
+    "M21.right_kernel()#gibt die Basis des Vektorraums der Vektoren v an mit M21*v=0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Hilfsfunktionen, um alle Muster der Länge $k$ aufzuzählen, die von der Form $m=[1,\\tilde{m},1]$ mit $\\tilde{m}\\in \\{0,1\\}^{k-2}$ beliebig ist:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math as m\n",
+    "import numpy as np\n",
+    "\n",
+    "def binary(number,total): \n",
+    "#konvertiert eine Zahl zu einer Binärzahl von rechts nach links\n",
+    "    bits = int(m.log(total,2))\n",
+    "    N = number\n",
+    "    b_num = np.zeros(bits)\n",
+    "    for i in np.arange(bits):\n",
+    "        if( N/((2)**(bits-i-1)) >= 1 ):\n",
+    "            b_num[i] = 1\n",
+    "            N = N - 2 ** (bits-i-1)\n",
+    "    B = [] \n",
+    "    for j in np.arange(len(b_num)):\n",
+    "        B.append(int(b_num[j]))\n",
+    "    return B\n",
+    "\n",
+    "def detListePattern(k):\n",
+    "    t=2^(k-2)\n",
+    "    liste=[]\n",
+    "    for i in range(0,t):\n",
+    "        l1=binary(i,t)\n",
+    "        l1.append(1)\n",
+    "        l1.insert(0,1)\n",
+    "        liste.append(l1)\n",
+    "    return liste"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Für alle Muster $m$ der Länge $k=3$ und $k+1\\le n\\le 52$ wird das Tupel $(n, Rang(M_n^m))$ ausgegeben. (bzw. nach Code-Anpassung für $k=4,5,6$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Muster\n",
+      "[1, 0, 1]\n",
+      "(n,Rang(M))\n",
+      "[[4, 2], [5, 4], [6, 4], [7, 6], [8, 6], [9, 8], [10, 8], [11, 10], [12, 10], [13, 12], [14, 12], [15, 14], [16, 14], [17, 16], [18, 16], [19, 18], [20, 18], [21, 20], [22, 20], [23, 22], [24, 22], [25, 24], [26, 24], [27, 26], [28, 26], [29, 28], [30, 28], [31, 30], [32, 30], [33, 32], [34, 32], [35, 34], [36, 34], [37, 36], [38, 36], [39, 38], [40, 38], [41, 40], [42, 40], [43, 42], [44, 42], [45, 44], [46, 44], [47, 46], [48, 46], [49, 48], [50, 48], [51, 50], [52, 50]]\n",
+      "Muster\n",
+      "[1, 1, 1]\n",
+      "(n,Rang(M))\n",
+      "[[4, 4], [5, 5], [6, 4], [7, 7], [8, 8], [9, 7], [10, 10], [11, 11], [12, 10], [13, 13], [14, 14], [15, 13], [16, 16], [17, 17], [18, 16], [19, 19], [20, 20], [21, 19], [22, 22], [23, 23], [24, 22], [25, 25], [26, 26], [27, 25], [28, 28], [29, 29], [30, 28], [31, 31], [32, 32], [33, 31], [34, 34], [35, 35], [36, 34], [37, 37], [38, 38], [39, 37], [40, 40], [41, 41], [42, 40], [43, 43], [44, 44], [45, 43], [46, 46], [47, 47], [48, 46], [49, 49], [50, 50], [51, 49], [52, 52]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "k=3 #oder k=4,5,6\n",
+    "liste=detListePattern(k)\n",
+    "for pattern in liste:\n",
+    "    print(\"Muster\")\n",
+    "    print(pattern)\n",
+    "    print(\"(n,Rang(M))\")\n",
+    "    liste=[]\n",
+    "    for i in range(k+1,53):\n",
+    "        liste.append([i,rank(konstruiereGscamMatrix(i,pattern))])\n",
+    "    print(liste)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Die nächste Funktion bestimmt für ein vorgegebenes Muster und eine vorgegebene Dimension $n$ (=Kartenanzahl) das assoziierte Polynom."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def liefereAssoziiertesPolynom(n,pattern):\n",
+    "    R.<x> = PolynomialRing(GF(2))\n",
+    "    pol=1\n",
+    "    for i in range(1,len(pattern)):\n",
+    "        pol=pol+pattern[i]*x^(n-i)\n",
+    "    return pol"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "x^13 + x^11 + 1"
+      ]
+     },
+     "execution_count": 73,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "liefereAssoziiertesPolynom(14,[1,1,0,1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Damit lässt sich noch auf andere Weise der Rang der Matrix $M_n^m$ ermitteln."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def bestimmeRang(n,pattern):\n",
+    "    R.<x> = PolynomialRing(GF(2))\n",
+    "    g=gcd(liefereAssoziiertesPolynom(n,pattern),x^n-1)\n",
+    "    return n-g.degree()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Und schließlich bestimmen wir noch eine Basis des Kerns:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#MS = MatrixSpace(GF(2),n)\n",
+    "def createShiftList(n):\n",
+    "    lst = []\n",
+    "    for i in range(n-1):\n",
+    "        lst.append(0)\n",
+    "    lst.append(1)\n",
+    "    return(lst)\n",
+    "\n",
+    "def ermittleKern(n,pattern):\n",
+    "    R.<x> = PolynomialRing(GF(2))\n",
+    "    \n",
+    "    #bestimme Dimension des Kerns\n",
+    "    g=gcd(liefereAssoziiertesPolynom(n,pattern),x^n-1)\n",
+    "    k=g.degree()\n",
+    "    \n",
+    "    h=R((x^n-1)/g)\n",
+    "    list_h=h.list()\n",
+    "    for i in range(len(list_h),n):\n",
+    "        list_h.append(0)\n",
+    "        \n",
+    "    k=g.degree()\n",
+    "    \n",
+    "    if (k==0): return []\n",
+    "\n",
+    "    VS = VectorSpace(GF(2),n)\n",
+    "    t1=VS(list_h)\n",
+    "    list_kern=[t1]\n",
+    "    shift=matrix.circulant(vector(GF(2),createShiftList(n),sparse=True))\n",
+    "    t=t1\n",
+    "    for i in range(1,k):\n",
+    "        t=shift*t\n",
+    "        list_kern.append(t)\n",
+    "    \n",
+    "    return list_kern"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0),\n",
+       " (0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0),\n",
+       " (0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1)]"
+      ]
+     },
+     "execution_count": 76,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ermittleKern(14,[1,1,0,1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Die nächste Funktion bringt den Kern der Matrix $M_n^m$ noch auf die Form, dass die ersten $k$ Spalten ($k$=Dimension des Kerns) die Einheitsmatrix darstellen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def transformiereKern(list_kern):\n",
+    "    k=len(list_kern)\n",
+    "    for i in range(0,k-1):\n",
+    "        for j in range(i+1,k):\n",
+    "            if (list_kern[i][j]==1):\n",
+    "                list_kern[i]=list_kern[i]+list_kern[j]\n",
+    "    return list_kern"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1),\n",
+       " (0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0),\n",
+       " (0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1)]"
+      ]
+     },
+     "execution_count": 78,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "transformiereKern(ermittleKern(14,[1,1,0,1]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Beispiel 1: das Muster m=$[1,1,0,0,1]$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mat=konstruiereGscamMatrix(15,[1,1,0,0,1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Vector space of degree 15 and dimension 4 over Finite Field of size 2\n",
+       "Basis matrix:\n",
+       "[1 0 0 0 1 0 0 1 1 0 1 0 1 1 1]\n",
+       "[0 1 0 0 1 1 0 1 0 1 1 1 1 0 0]\n",
+       "[0 0 1 0 0 1 1 0 1 0 1 1 1 1 0]\n",
+       "[0 0 0 1 0 0 1 1 0 1 0 1 1 1 1]"
+      ]
+     },
+     "execution_count": 80,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mat.right_kernel()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1),\n",
+       " (0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0),\n",
+       " (0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0),\n",
+       " (0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1)]"
+      ]
+     },
+     "execution_count": 82,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "transformiereKern(ermittleKern(15,[1,1,0,0,1]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Beispiel 2: das Muster $m=[1,1,\\ldots,1]$ mit $k$ Einsen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mat=konstruiereGscamMatrix(15,[1,1,1,1,1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Vector space of degree 15 and dimension 4 over Finite Field of size 2\n",
+       "Basis matrix:\n",
+       "[1 0 0 0 1 1 0 0 0 1 1 0 0 0 1]\n",
+       "[0 1 0 0 1 0 1 0 0 1 0 1 0 0 1]\n",
+       "[0 0 1 0 1 0 0 1 0 1 0 0 1 0 1]\n",
+       "[0 0 0 1 1 0 0 0 1 1 0 0 0 1 1]"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mat.right_kernel()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[(1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1),\n",
+       " (0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1),\n",
+       " (0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1),\n",
+       " (0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1)]"
+      ]
+     },
+     "execution_count": 83,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "transformiereKern(ermittleKern(15,[1,1,1,1,1]))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SageMath 8.8",
+   "language": "sage",
+   "name": "sagemath"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}