diff --git a/.ipynb_checkpoints/Apollonian Circle Packings-checkpoint.ipynb b/.ipynb_checkpoints/Apollonian Circle Packings-checkpoint.ipynb new file mode 100644 index 0000000..de63932 --- /dev/null +++ b/.ipynb_checkpoints/Apollonian Circle Packings-checkpoint.ipynb @@ -0,0 +1,688 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculations to find the quadratic form of the octahedron packing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$P$ is the matrix of the quadratic form corresponding to $h_1^2 + h_2^2 - \\tilde{b}b = 1$." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "P = matrix([\n", + " [0, -1/2, 0, 0],\n", + " [-1/2, 0, 0, 0],\n", + " [0, 0, 1, 0],\n", + " [0, 0, 0, 1],\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 0 -2 0 0]\n", + "[-2 0 0 0]\n", + "[ 0 0 1 0]\n", + "[ 0 0 0 1]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "P.inverse()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For an Apollonian packing, you can make a matrix, $W$, where the rows are the coordinates of each of the circles in a quadruple. In an octahedral packing, this is impossible, as there are six circles in a unit. You can try creating a $6\\times 4$ matrix, but, later, we end up needing to invert $WPW^T$, the product of a $6\\times 4$, $4\\times 4$, and $4\\times 6$ matrix, which is singular. Fortunately, the sextuples come in three pairs of circles. Each pair consists of circles that aren't tangent to each other. For whatever reason (we aren't sure yet why, but the Guettler and Mallows says this is the case), the average of the coordinates of the circles in a pair is the same across the sextuple. So, we can make a matrix where the first three rows are the coordinates of circles from different pairs, i.e. three mutually tangent circles, and the fourth is the average of the coordinates in a pair. From this, you can recover the coordinates for all the circles in a sextuple.\n", + "\n", + "Here $W$ is such a matrix computed for the $(0, 0, 1, 1, 2, 2)$ root sextuple." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "W = matrix([\n", + " [2, 0, 0, 1],\n", + " [2, 0, 0, -1],\n", + " [-1, 1, 0, 0],\n", + " [3, 1, sqrt(2), 0]\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we have $$\n", + " WPW^T = \\left(\\begin{matrix}\n", + " 1 & -1 & -1 & -1\\\\\n", + " -1 & 1 & -1 & -1\\\\\n", + " -1 & -1 & 1 & -1\\\\\n", + " -1 & -1 & -1 & -1\n", + " \\end{matrix}\\right) = M\n", + "$$\n", + "So, inverting both sides, we get $$\n", + " (WPW^T)^{-1} = M^{-1}\n", + "$$ $$\n", + " (W^T)^{-1}P^{-1}W^{-1} = M^{-1}\n", + "$$ $$\n", + " P^{-1} = W^TM^{-1}W\n", + ".$$\n", + "\n", + "Like in the case with Apollonian packings, this is true for any sextuple $W$. So, we can substitute an arbitrary sextuple for $W$ and it must be equal to $P^{-1}$, letting us derive some useful quadratic forms." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 1 -1 -1 -1]\n", + "[-1 1 -1 -1]\n", + "[-1 -1 1 -1]\n", + "[-1 -1 -1 -1]" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "M = W * P * W.transpose()\n", + "M" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 1/2 0 0 -1/2]\n", + "[ 0 1/2 0 -1/2]\n", + "[ 0 0 1/2 -1/2]\n", + "[-1/2 -1/2 -1/2 1/2]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "M.inverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "bt1 = var('bt1')\n", + "b1 = var('b1')\n", + "h11 = var('h11')\n", + "h12 = var('h12')\n", + "bt2 = var('bt2')\n", + "b2 = var('b2')\n", + "h21 = var('h21')\n", + "h22 = var('h22')\n", + "bt3 = var('bt3')\n", + "b3 = var('b3')\n", + "h31 = var('h31')\n", + "h32 = var('h32')\n", + "b5_avg = var('b5_avg')\n", + "b_avg = var('b_avg')\n", + "h1_avg = var('h1_avg')\n", + "h2_avg = var('h2_avg')\n", + "\n", + "\n", + "W2 = matrix([\n", + " [bt1, b1, h11, h12],\n", + " [bt2, b2, h21, h22],\n", + " [bt3, b3, h31, h32],\n", + " [b5_avg, b_avg, h1_avg, h2_avg],\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "D = W2.transpose() * M.inverse() * W2" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 0 -2 0 0]\n", + "[-2 0 0 0]\n", + "[ 0 0 1 0]\n", + "[ 0 0 0 1]" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "P.inverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[b_avg == b1 + b2 + b3 - sqrt(2*b1*b2 + 2*(b1 + b2)*b3), b_avg == b1 + b2 + b3 + sqrt(2*b1*b2 + 2*(b1 + b2)*b3)]" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quad = 2 * factor(simplify(D[1][1]))\n", + "solve(quad == 0, b_avg)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "b1^2 + b2^2 + b3^2 - 2*b1*b_avg - 2*b2*b_avg - 2*b3*b_avg + b_avg^2" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quad" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So, we end up deriving the quadratic form $$\n", + " b_1^2 + b_2^2 + b_3^2 + b_{\\text{avg}}^2 - 2b_{\\text{avg}}(b_1 + b_2 + b_3) = 0\n", + ".$$\n", + "\n", + "This means that, given three mutually tangent circles with curvatures $b_1,b_2,b_3$, there are two solutions for $b_{\\text{avg}}$, allowing us to derive two new sets of three mutually tangent circles with curvatures $b_1' = 2b_{\\text{avg}} - b_1$ etc." + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1/2*b1*h11 - 1/2*b_avg*h11 - 1/2*b1*h1_avg - 1/2*b2*h1_avg - 1/2*b3*h1_avg + 1/2*b_avg*h1_avg + 1/2*b2*h21 - 1/2*b_avg*h21 + 1/2*b3*h31 - 1/2*b_avg*h31" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "factor(simplify(D[2][1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculations to find the generators for the \"Apollonian\" Group for the octahedral packing\n", + "\n", + "We can try the reflection group, since that is one way to derive the generators for the Apollonian group and see if it works. My worry is that it won't since the coordinate system is so different." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "S1 = matrix([\n", + " [-1, 2, 2, 2],\n", + " [0, 1, 0, 0],\n", + " [0, 0, 1, 0],\n", + " [0, 0, 0, 1],\n", + "])\n", + "\n", + "S2 = matrix([\n", + " [1, 0, 0, 0],\n", + " [2, -1, 2, 2],\n", + " [0, 0, 1, 0],\n", + " [0, 0, 0, 1]\n", + "])\n", + "\n", + "S3 = matrix([\n", + " [1, 0, 0, 0],\n", + " [0, 1, 0, 0],\n", + " [2, 2, -1, 2],\n", + " [0, 0, 0, 1]\n", + "])\n", + "\n", + "# this is the only one that differs from the generators of the Apollonian group\n", + "S4 = matrix([\n", + " [1, 0, 0, 0],\n", + " [0, 1, 0, 0],\n", + " [0, 0, 1, 0],\n", + " [2, 2, 2, 3]\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "W = matrix([\n", + " [2, 0, 0, 1],\n", + " [2, 0, 0, -1],\n", + " [-1, 1, 0, 0],\n", + " [3, 1, sqrt(2), 0]\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [], + "source": [ + "def draw_circles_from_coords(coords, color=(0,0,1)):\n", + " drawing = None\n", + " averages = coords[-1]\n", + " avgb = averages[1]\n", + " for row in coords[:-1]:\n", + " b = row[1]\n", + " if not b == 0:\n", + " x = row[2] / b\n", + " y = row[3] / b\n", + " if drawing is not None:\n", + " drawing += circle((x, y), 1 / b, rgbcolor=color)\n", + " else:\n", + " drawing = circle((x, y), 1 / b, rgbcolor=color)\n", + " newb = 2 * avgb - b\n", + " if not newb == 0:\n", + " newx = (2 * averages[2] - row[2]) / newb\n", + " newy = (2 * averages[3] - row[3]) / newb\n", + " if drawing is not None:\n", + " drawing += circle((newx, newy), 1 / newb, rgbcolor=color)\n", + " else:\n", + " drawing = circle((newx, newy), 1 / newb, rgbcolor=color)\n", + " return drawing" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [], + "source": [ + "def draw_circles_from_coords(coords, color=(0,0,1)):\n", + " drawing = None\n", + " for row in coords:\n", + " b = row[1]\n", + " if not b == 0:\n", + " x = row[2] / b\n", + " y = row[3] / b\n", + " if drawing is not None:\n", + " drawing += circle((x, y), 1 / b, rgbcolor=color)\n", + " else:\n", + " drawing = circle((x, y), 1 / b, rgbcolor=color)\n", + " return drawing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "root = matrix([\n", + " [2, 0, 0, 1],\n", + " [2, 0, 0, -1],\n", + " [-1, 1, 0, 0],\n", + " [3, 1, 2, 0]\n", + "])\n", + "\n", + "S4 = matrix([\n", + " [1, 0, 0, 0],\n", + " [0, 1, 0, 0],\n", + " [0, 0, 1, 0],\n", + " [2, 2, 2, -1],\n", + "])\n", + "\n", + "drawing = draw_circles_from_coords(root)\n", + "branches = [root]\n", + "for i in range(10):\n", + " new_branches = []\n", + " for tree in branches:\n", + " drawing += draw_circles_from_coords(tree)\n", + " new_branches.append(S1 * tree)\n", + " new_branches.append(S2 * tree)\n", + " new_branches.append(S3 * tree)\n", + " new_branches.append(S4 * tree)\n", + " branches = new_branches\n", + "drawing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hmm. Doesn't look like it worked. And my crude code to draw the circles doesn't seem to be the problem either." + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "Graphics object consisting of 8 graphics primitives" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "draw_circles_from_coords(W) + draw_circles_from_coords(S4 * W)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculations to find the curvatures of the dual circles of the octahedral packing\n", + "\n", + "Here the basic idea was to work out the intersection points of the circles and let the computer algebraically find the radii of the circles. The end up coming out, rather anticlimactically, to $(0, 0, \\sqrt 2, \\sqrt 2, \\sqrt 2, \\sqrt 2, 2\\sqrt 2, 2\\sqrt 2)$. It's rather satisfying and a bit surprising that the dual of the root sextuple of the octahedral packing is the root of the cubic packing, since the dual polyhedron of the octahedron is the cube." + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "def circle_from_points(pta, ptb, ptc):\n", + " a = var('a')\n", + " b = var('b')\n", + " r = var('r')\n", + " x = var('x')\n", + " y = var('y')\n", + " \n", + " circle_func = (x - a)^2 + (y - b)^2 == r^2\n", + " \n", + " eq1 = circle_func.subs(x == pta[0]).subs(y == pta[1])\n", + " eq2 = circle_func.subs(x == ptb[0]).subs(y == ptb[1])\n", + " eq3 = circle_func.subs(x == ptc[0]).subs(y == ptc[1])\n", + " \n", + " res = solve([eq1, eq2, eq3], a, b, r)[1]\n", + " \n", + " return (res[0].rhs(), res[1].rhs(), res[2].rhs())" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1/2*sqrt(2), 1)\n", + "sqrt(2)\n", + "(1/4*sqrt(2), 0)\n", + "2*sqrt(2)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "Graphics object consisting of 14 graphics primitives" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c1 = line([(-3, 1), (3, 1)])\n", + "c2 = line([(-3, -1), (3, -1)])\n", + "c3 = circle((-sqrt(2), 0), 1)\n", + "c4 = circle((sqrt(2), 0), 1)\n", + "c5 = circle((0, 1/2), 1/2)\n", + "c6 = circle((0, -1/2), 1/2)\n", + "\n", + "b1 = line([(-sqrt(2), -3), (-sqrt(2), 3)], rgbcolor=(1, 0, 0))\n", + "b2 = line([(sqrt(2), -3), (sqrt(2), 3)], rgbcolor=(1, 0, 0))\n", + "\n", + "x, y, r = circle_from_points((sqrt(2) / 3, 1 / 3), (0, 1), (sqrt(2), 1))\n", + "print('({}, {})'.format(x, y))\n", + "print(1 / r)\n", + "\n", + "b3 = circle(( x, y), r, rgbcolor=(1, 0, 0))\n", + "b4 = circle((-x, y), r, rgbcolor=(1, 0, 0))\n", + "b5 = circle(( x, -y), r, rgbcolor=(1, 0, 0))\n", + "b6 = circle((-x, -y), r, rgbcolor=(1, 0, 0))\n", + "\n", + "x, y, r = circle_from_points((sqrt(2) / 3, 1 / 3), (0, 0), (sqrt(2) / 3, -1 / 3))\n", + "print('({}, {})'.format(x, y))\n", + "print(1 / r)\n", + "\n", + "b7 = circle(( x, y), r, rgbcolor=(1, 0, 0))\n", + "b8 = circle((-x, y), r, rgbcolor=(1, 0, 0))\n", + "\n", + "show(c1 + c2 + c3 + c4 + c5 + c6 + b1 + b2 + b3 + b4 + b5 + b6 + b7 + b8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Futile attempt to derive the quadratic form for the cubic packing\n", + "\n", + "We attempted to derive the quadratic form for the cubic packing based on the data collected above, but the results don't match the results from the Stange at all and are significantly uglier. There's probably a mistake in here somewhere, but I'm not sure where." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "def abbc_coords(b, h1, h2):\n", + " return [(h1^2 + h2^2 - 1) / b, b, h1, h2]" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 1 -3 -3 -5/4 -1 -1 -5 3/4]\n", + "[ -3 1 -3 1/2 -1 -1 -1 -3/2]\n", + "[ -3 -3 1 -5/4 -5 -1 -1 3/4]\n", + "[-5/4 1/2 -5/4 1 3/4 -3/2 3/4 -1]\n", + "[ -1 -1 -5 3/4 1 -3 -3 -5/4]\n", + "[ -1 -1 -1 -3/2 -3 1 -3 1/2]\n", + "[ -5 -1 -1 3/4 -3 -3 1 -5/4]\n", + "[ 3/4 -3/2 3/4 -1 -5/4 1/2 -5/4 1]" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Wc = matrix([\n", + " abbc_coords(sqrt(2), -1, sqrt(2)),\n", + " abbc_coords(2*sqrt(2), 1, 0),\n", + " abbc_coords(sqrt(2), -1, -sqrt(2)),\n", + " [sqrt(2) / 4, 0, 1, 0],\n", + " abbc_coords(sqrt(2), 1, sqrt(2)),\n", + " abbc_coords(2*sqrt(2), -1, 0),\n", + " abbc_coords(sqrt(2), 1, -sqrt(2)),\n", + " [sqrt(2) / 4, 0, -1, 0]\n", + "\n", + "])\n", + "\n", + "Wc * P * Wc.transpose()" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "W = matrix([\n", + " abbc_coords(sqrt(2), -1, sqrt(2)),\n", + " abbc_coords(2*sqrt(2), 1, 0),\n", + " abbc_coords(sqrt(2), -1, -sqrt(2)),\n", + " [sqrt(2) / 4, 0, 1, 0]\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 1 -3 -3 -5/4]\n", + "[ -3 1 -3 1/2]\n", + "[ -3 -3 1 -5/4]\n", + "[-5/4 1/2 -5/4 1]" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m = W * P * W.transpose()\n", + "m" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "97*b1^2 - 304*b1*b2 + 328*b2^2 - 290*b1*b3 - 304*b2*b3 + 97*b3^2 + 32*b1*b_avg - 1088*b2*b_avg + 32*b3*b_avg + 1280*b_avg^2" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "D = W2.transpose() * m.inverse() * W2\n", + "968*factor(simplify(D[1][1]))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "SageMath 9.2", + "language": "sage", + "name": "sagemath" + }, + "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.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Apollonian Circle Packings.ipynb b/Apollonian Circle Packings.ipynb index fdcb4a1..de63932 100644 --- a/Apollonian Circle Packings.ipynb +++ b/Apollonian Circle Packings.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -42,7 +42,7 @@ "[ 0 0 0 1]" ] }, - "execution_count": 2, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 51, "metadata": {}, "outputs": [], "source": [ @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 52, "metadata": { "scrolled": true }, @@ -113,7 +113,7 @@ "[-1 -1 -1 -1]" ] }, - "execution_count": 4, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 53, "metadata": { "scrolled": true }, @@ -139,7 +139,7 @@ "[-1/2 -1/2 -1/2 1/2]" ] }, - "execution_count": 5, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" } @@ -150,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 54, "metadata": {}, "outputs": [], "source": [ @@ -182,7 +182,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -191,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 56, "metadata": {}, "outputs": [ { @@ -203,7 +203,7 @@ "[ 0 0 0 1]" ] }, - "execution_count": 8, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" } @@ -214,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 57, "metadata": {}, "outputs": [ { @@ -223,7 +223,7 @@ "[b_avg == b1 + b2 + b3 - sqrt(2*b1*b2 + 2*(b1 + b2)*b3), b_avg == b1 + b2 + b3 + sqrt(2*b1*b2 + 2*(b1 + b2)*b3)]" ] }, - "execution_count": 9, + "execution_count": 57, "metadata": {}, "output_type": "execute_result" } @@ -235,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 58, "metadata": {}, "outputs": [ { @@ -244,7 +244,7 @@ "b1^2 + b2^2 + b3^2 - 2*b1*b_avg - 2*b2*b_avg - 2*b3*b_avg + b_avg^2" ] }, - "execution_count": 10, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } @@ -266,7 +266,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 59, "metadata": {}, "outputs": [ { @@ -275,7 +275,7 @@ "1/2*b1*h11 - 1/2*b_avg*h11 - 1/2*b1*h1_avg - 1/2*b2*h1_avg - 1/2*b3*h1_avg + 1/2*b_avg*h1_avg + 1/2*b2*h21 - 1/2*b_avg*h21 + 1/2*b3*h31 - 1/2*b_avg*h31" ] }, - "execution_count": 11, + "execution_count": 59, "metadata": {}, "output_type": "execute_result" } @@ -284,6 +284,177 @@ "factor(simplify(D[2][1]))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculations to find the generators for the \"Apollonian\" Group for the octahedral packing\n", + "\n", + "We can try the reflection group, since that is one way to derive the generators for the Apollonian group and see if it works. My worry is that it won't since the coordinate system is so different." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "S1 = matrix([\n", + " [-1, 2, 2, 2],\n", + " [0, 1, 0, 0],\n", + " [0, 0, 1, 0],\n", + " [0, 0, 0, 1],\n", + "])\n", + "\n", + "S2 = matrix([\n", + " [1, 0, 0, 0],\n", + " [2, -1, 2, 2],\n", + " [0, 0, 1, 0],\n", + " [0, 0, 0, 1]\n", + "])\n", + "\n", + "S3 = matrix([\n", + " [1, 0, 0, 0],\n", + " [0, 1, 0, 0],\n", + " [2, 2, -1, 2],\n", + " [0, 0, 0, 1]\n", + "])\n", + "\n", + "# this is the only one that differs from the generators of the Apollonian group\n", + "S4 = matrix([\n", + " [1, 0, 0, 0],\n", + " [0, 1, 0, 0],\n", + " [0, 0, 1, 0],\n", + " [2, 2, 2, 3]\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "W = matrix([\n", + " [2, 0, 0, 1],\n", + " [2, 0, 0, -1],\n", + " [-1, 1, 0, 0],\n", + " [3, 1, sqrt(2), 0]\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [], + "source": [ + "def draw_circles_from_coords(coords, color=(0,0,1)):\n", + " drawing = None\n", + " averages = coords[-1]\n", + " avgb = averages[1]\n", + " for row in coords[:-1]:\n", + " b = row[1]\n", + " if not b == 0:\n", + " x = row[2] / b\n", + " y = row[3] / b\n", + " if drawing is not None:\n", + " drawing += circle((x, y), 1 / b, rgbcolor=color)\n", + " else:\n", + " drawing = circle((x, y), 1 / b, rgbcolor=color)\n", + " newb = 2 * avgb - b\n", + " if not newb == 0:\n", + " newx = (2 * averages[2] - row[2]) / newb\n", + " newy = (2 * averages[3] - row[3]) / newb\n", + " if drawing is not None:\n", + " drawing += circle((newx, newy), 1 / newb, rgbcolor=color)\n", + " else:\n", + " drawing = circle((newx, newy), 1 / newb, rgbcolor=color)\n", + " return drawing" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [], + "source": [ + "def draw_circles_from_coords(coords, color=(0,0,1)):\n", + " drawing = None\n", + " for row in coords:\n", + " b = row[1]\n", + " if not b == 0:\n", + " x = row[2] / b\n", + " y = row[3] / b\n", + " if drawing is not None:\n", + " drawing += circle((x, y), 1 / b, rgbcolor=color)\n", + " else:\n", + " drawing = circle((x, y), 1 / b, rgbcolor=color)\n", + " return drawing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "root = matrix([\n", + " [2, 0, 0, 1],\n", + " [2, 0, 0, -1],\n", + " [-1, 1, 0, 0],\n", + " [3, 1, 2, 0]\n", + "])\n", + "\n", + "S4 = matrix([\n", + " [1, 0, 0, 0],\n", + " [0, 1, 0, 0],\n", + " [0, 0, 1, 0],\n", + " [2, 2, 2, -1],\n", + "])\n", + "\n", + "drawing = draw_circles_from_coords(root)\n", + "branches = [root]\n", + "for i in range(10):\n", + " new_branches = []\n", + " for tree in branches:\n", + " drawing += draw_circles_from_coords(tree)\n", + " new_branches.append(S1 * tree)\n", + " new_branches.append(S2 * tree)\n", + " new_branches.append(S3 * tree)\n", + " new_branches.append(S4 * tree)\n", + " branches = new_branches\n", + "drawing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hmm. Doesn't look like it worked. And my crude code to draw the circles doesn't seem to be the problem either." + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "Graphics object consisting of 8 graphics primitives" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "draw_circles_from_coords(W) + draw_circles_from_coords(S4 * W)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -295,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ @@ -319,7 +490,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 64, "metadata": {}, "outputs": [ { @@ -384,7 +555,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ @@ -394,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 66, "metadata": {}, "outputs": [ { @@ -410,7 +581,7 @@ "[ 3/4 -3/2 3/4 -1 -5/4 1/2 -5/4 1]" ] }, - "execution_count": 15, + "execution_count": 66, "metadata": {}, "output_type": "execute_result" } @@ -433,7 +604,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -447,7 +618,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 68, "metadata": { "scrolled": true }, @@ -461,7 +632,7 @@ "[-5/4 1/2 -5/4 1]" ] }, - "execution_count": 17, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" } @@ -473,7 +644,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 69, "metadata": {}, "outputs": [ { @@ -482,7 +653,7 @@ "97*b1^2 - 304*b1*b2 + 328*b2^2 - 290*b1*b3 - 304*b2*b3 + 97*b3^2 + 32*b1*b_avg - 1088*b2*b_avg + 32*b3*b_avg + 1280*b_avg^2" ] }, - "execution_count": 18, + "execution_count": 69, "metadata": {}, "output_type": "execute_result" }