diff --git a/fractal_dimension/circle_counting_new/src/lib.rs b/fractal_dimension/circle_counting_new/src/lib.rs index 97e65d7..2b37898 100644 --- a/fractal_dimension/circle_counting_new/src/lib.rs +++ b/fractal_dimension/circle_counting_new/src/lib.rs @@ -1,6 +1,6 @@ +use ansi_term::Color::Yellow; use linregress::{FormulaRegressionBuilder, RegressionDataBuilder}; use nalgebra::{DMatrix, DVector}; -use ansi_term::Color::Yellow; pub fn fractal_dimension( generators: Vec>, @@ -42,18 +42,8 @@ pub fn fractal_dimension( continue; } let mut add = false; - let mut count = 0; - let mut can_add = true; for (j, curvature) in new_tuple.iter().enumerate() { let mut skip = false; - if *curvature < 0.0 { - count += 1; - } - if count > 1 { - can_add = false; - add = false; - break; - } for vertex in &faces[i] { if j == *vertex { skip = true; @@ -73,7 +63,7 @@ pub fn fractal_dimension( if add { next.push((new_tuple, i, false)); } else { - if !bad && can_add { + if !bad { next.push((new_tuple, i, true)); } } @@ -81,7 +71,7 @@ pub fn fractal_dimension( } } std::mem::swap(&mut current, &mut next); - + i += 1; if generations != 0 && i > generations { break; @@ -104,7 +94,10 @@ pub fn fractal_dimension( if debug { println!("{}", Yellow.paint("Done counting circles!")); println!("sample points:\n{:?}", xs); - println!("\nnumber of circles fewer than each of those sample points:\n{:?}", totals); + println!( + "\nnumber of circles fewer than each of those sample points:\n{:?}", + totals + ); } let xs: Vec = xs.iter().map(|x| x.ln()).collect(); diff --git a/fractal_dimension/circle_counting_new/src/main.rs b/fractal_dimension/circle_counting_new/src/main.rs index b236f17..a648699 100644 --- a/fractal_dimension/circle_counting_new/src/main.rs +++ b/fractal_dimension/circle_counting_new/src/main.rs @@ -46,10 +46,11 @@ fn main() { let beginning = std::time::Instant::now(); - let (generators, root, faces, orthogonal_generators) = read_file(&opt.data_file).unwrap_or_else(|err| { - eprintln!("{}", err); - process::exit(-1); - }); + let (generators, root, faces, orthogonal_generators) = read_file(&opt.data_file) + .unwrap_or_else(|err| { + eprintln!("{}", err); + process::exit(-1); + }); let after_parsing = std::time::Instant::now(); if time { @@ -103,8 +104,17 @@ fn main() { println!("{:?}\n", orthogonal_generators); } - let delta = - fractal_dimension(generators, root, faces, opt.max, opt.n, debug, generations, orthogonal_generators).unwrap(); + let delta = fractal_dimension( + generators, + root, + faces, + opt.max, + opt.n, + debug, + generations, + orthogonal_generators, + ) + .unwrap(); let after_computing = std::time::Instant::now(); if time { let duration1 = after_computing.duration_since(after_parsing); diff --git a/fractal_dimension/fractal_dimension.nb b/fractal_dimension/fractal_dimension.nb index ed10393..1a891a5 100644 --- a/fractal_dimension/fractal_dimension.nb +++ b/fractal_dimension/fractal_dimension.nb @@ -10,10 +10,10 @@ NotebookFileLineBreakTest NotebookFileLineBreakTest NotebookDataPosition[ 158, 7] -NotebookDataLength[ 306388, 7089] -NotebookOptionsPosition[ 302923, 7040] -NotebookOutlinePosition[ 303414, 7058] -CellTagsIndexPosition[ 303371, 7055] +NotebookDataLength[ 308006, 7148] +NotebookOptionsPosition[ 304440, 7098] +NotebookOutlinePosition[ 304931, 7116] +CellTagsIndexPosition[ 304888, 7113] WindowFrame->Normal*) (* Beginning of Notebook Content *) @@ -312,7 +312,7 @@ Cell[BoxData[{ "\[IndentingNewLine]", RowBox[{"FindFace", "[", RowBox[{"g", ",", "emb"}], "]"}]}]}], "]"}]}], ";"}], - "\n"}], "\[IndentingNewLine]", + "\[IndentingNewLine]"}], "\n", RowBox[{ RowBox[{"FindFace", "[", RowBox[{ @@ -1005,8 +1005,9 @@ Cell[BoxData["16384"], "Output", 3.8346675010015087`*^9, 3.83467065066402*^9, 3.834670688395502*^9, 3.834670724619562*^9, 3.8346707922130203`*^9, 3.834672572650928*^9, { 3.834672606536978*^9, 3.834672633714957*^9}, 3.834688011488668*^9, - 3.834741745404797*^9, 3.834840168954259*^9, 3.835099016743781*^9}, - CellLabel->"Out[20]=",ExpressionUUID->"43f23c83-5fed-4792-9475-e7e7c052b010"] + 3.834741745404797*^9, 3.834840168954259*^9, 3.835099016743781*^9, + 3.8351796489040537`*^9}, + CellLabel->"Out[20]=",ExpressionUUID->"bbf5dd8e-e10c-4275-a0dc-b914393f11a3"] }, Open ]], Cell[BoxData[ @@ -1362,7 +1363,7 @@ Cell[BoxData[ }]}], ";"}]], "Input", CellChangeTimes->{{3.834742774681567*^9, 3.8347428287244883`*^9}, { 3.834743896750102*^9, 3.8347439689703417`*^9}}, - CellLabel->"In[47]:=",ExpressionUUID->"ac2fc7fb-1a08-4495-8c53-210ad6f3664b"], + CellLabel->"In[27]:=",ExpressionUUID->"ac2fc7fb-1a08-4495-8c53-210ad6f3664b"], Cell[BoxData[ RowBox[{ @@ -3368,7 +3369,7 @@ Cell[BoxData[ RowBox[{"-", "17.94427190999916`"}], ",", "1.`"}], "}"}]}], "}"}]}], ";"}]], "Input", CellChangeTimes->{{3.8351052258837433`*^9, 3.83510523223288*^9}}, - CellLabel->"In[41]:=",ExpressionUUID->"1c98ab0f-7be0-4b82-83f8-0a1739369b4d"], + CellLabel->"In[32]:=",ExpressionUUID->"1c98ab0f-7be0-4b82-83f8-0a1739369b4d"], Cell[BoxData[ RowBox[{ @@ -7036,10 +7037,67 @@ Cell[BoxData[ RowBox[{"-", "25.18033988749895`"}], ",", RowBox[{"-", "1.`"}], ",", "1.`"}], "}"}]}], "}"}]}], ";"}]], "Input", CellChangeTimes->{{3.835099208339944*^9, 3.835099213546089*^9}}, - CellLabel->"In[32]:=",ExpressionUUID->"239a4292-049d-4293-9674-7e78c28ca011"] + CellLabel->"In[33]:=",ExpressionUUID->"239a4292-049d-4293-9674-7e78c28ca011"], + +Cell[BoxData[ + RowBox[{ + RowBox[{"g6v7f1", "=", GridBox[{ + {"1", + RowBox[{"-", "1"}], + RowBox[{"-", "1"}], + RowBox[{"-", "1"}], + RowBox[{"-", "1"}], + RowBox[{"-", "1"}]}, + { + RowBox[{"-", "1"}], "1", + RowBox[{"-", "1"}], + RowBox[{"-", "3"}], + RowBox[{"-", "1"}], + RowBox[{"-", "1"}]}, + { + RowBox[{"-", "1"}], + RowBox[{"-", "1"}], "1", + RowBox[{"-", "1"}], + RowBox[{"-", "3"}], + RowBox[{ + RowBox[{"-", "5"}], "-", + RowBox[{"4", + SqrtBox["2"]}]}]}, + { + RowBox[{"-", "1"}], + RowBox[{"-", "3"}], + RowBox[{"-", "1"}], "1", + RowBox[{"-", "1"}], + RowBox[{ + RowBox[{"-", "5"}], "-", + RowBox[{"4", + SqrtBox["2"]}]}]}, + { + RowBox[{"-", "1"}], + RowBox[{"-", "1"}], + RowBox[{"-", "3"}], + RowBox[{"-", "1"}], "1", + RowBox[{"-", "1"}]}, + { + RowBox[{"-", "1"}], + RowBox[{"-", "1"}], + RowBox[{ + RowBox[{"-", "5"}], "-", + RowBox[{"4", + SqrtBox["2"]}]}], + RowBox[{ + RowBox[{"-", "5"}], "-", + RowBox[{"4", + SqrtBox["2"]}]}], + RowBox[{"-", "1"}], "1"} + }]}], ";"}]], "Input", + CellChangeTimes->{{3.835179658699398*^9, 3.835179697234489*^9}, + 3.835179904759911*^9, {3.8351799445200777`*^9, 3.835179974915256*^9}, + 3.83518031842799*^9}, + CellLabel->"In[45]:=",ExpressionUUID->"b6c05a3c-d9ef-41f8-9987-9bf57f74096c"] }, -WindowSize->{1425., 776.25}, -WindowMargins->{{7.5, Automatic}, {7.5, Automatic}}, +WindowSize->{679.5, 776.25}, +WindowMargins->{{Automatic, 7.5}, {7.5, Automatic}}, TaggingRules->{ "WelcomeScreenSettings" -> {"FEStarting" -> False}, "TryRealOnly" -> False}, FrontEndVersion->"12.3 for Linux x86 (64-bit) (June 19, 2021)", @@ -7058,39 +7116,40 @@ CellTagsIndex->{} (*NotebookFileOutline Notebook[{ Cell[558, 20, 418, 9, 29, "Input",ExpressionUUID->"e1bc883b-2413-4a7d-abe0-4a19eb3f78fd"], -Cell[979, 31, 1029, 27, 29, "Input",ExpressionUUID->"025b5df5-f2a6-4cee-a294-e76ee16e74d4"], +Cell[979, 31, 1029, 27, 71, "Input",ExpressionUUID->"025b5df5-f2a6-4cee-a294-e76ee16e74d4"], Cell[2011, 60, 509, 11, 29, "Input",ExpressionUUID->"54cc4a6c-be37-4091-ac21-3dfd11eb53ea"], Cell[2523, 73, 439, 11, 29, "Input",ExpressionUUID->"d3298122-6e10-4115-8e61-a949acba4e08"], -Cell[2965, 86, 1415, 34, 29, "Input",ExpressionUUID->"4e2a5664-aeb5-4dfb-88fb-7e7839ba2141"], +Cell[2965, 86, 1415, 34, 71, "Input",ExpressionUUID->"4e2a5664-aeb5-4dfb-88fb-7e7839ba2141"], Cell[4383, 122, 342, 8, 29, "Input",ExpressionUUID->"c9a1b25a-8cb3-40d1-ac83-1d2405398934"], -Cell[4728, 132, 1140, 33, 29, "Input",ExpressionUUID->"30b57c08-a123-4e7d-9b0a-b512fcfecee8"], -Cell[5871, 167, 740, 20, 29, "Input",ExpressionUUID->"e30807a9-5381-4ad1-b9fd-a6a877ae69fe"], -Cell[6614, 189, 671, 19, 29, "Input",ExpressionUUID->"d1264330-efcb-4ca7-a1c2-f6744f28eebe"], -Cell[7288, 210, 708, 19, 29, "Input",ExpressionUUID->"efd0e321-9f31-4641-bf42-f73e16044635"], -Cell[7999, 231, 548, 14, 29, "Input",ExpressionUUID->"810323e6-91cb-44f2-ad55-323fbec422eb"], -Cell[8550, 247, 702, 19, 29, "Input",ExpressionUUID->"948959db-c926-4458-9e45-ef7f3fb99ba5"], +Cell[4728, 132, 1140, 33, 92, "Input",ExpressionUUID->"30b57c08-a123-4e7d-9b0a-b512fcfecee8"], +Cell[5871, 167, 740, 20, 51, "Input",ExpressionUUID->"e30807a9-5381-4ad1-b9fd-a6a877ae69fe"], +Cell[6614, 189, 671, 19, 51, "Input",ExpressionUUID->"d1264330-efcb-4ca7-a1c2-f6744f28eebe"], +Cell[7288, 210, 708, 19, 71, "Input",ExpressionUUID->"efd0e321-9f31-4641-bf42-f73e16044635"], +Cell[7999, 231, 548, 14, 51, "Input",ExpressionUUID->"810323e6-91cb-44f2-ad55-323fbec422eb"], +Cell[8550, 247, 702, 19, 71, "Input",ExpressionUUID->"948959db-c926-4458-9e45-ef7f3fb99ba5"], Cell[9255, 268, 996, 28, 71, "Input",ExpressionUUID->"e7b8a43b-0fbc-4073-928d-10a091e21dd7"], -Cell[10254, 298, 4042, 107, 298, "Input",ExpressionUUID->"5cb4f612-3c02-42ac-ad57-4fb2daf3366b"], -Cell[14299, 407, 10810, 230, 422, "Input",ExpressionUUID->"df61872a-1e93-4b2b-ad66-1c8fee203402"], -Cell[25112, 639, 7334, 180, 422, "Input",ExpressionUUID->"dab3b84f-3f49-42e4-9bc4-79cb6408f946"], -Cell[32449, 821, 912, 24, 29, "Input",ExpressionUUID->"bd52b017-bd99-4bdf-9126-b7c62804c9f2"], -Cell[33364, 847, 5346, 111, 113, "Input",ExpressionUUID->"4186f080-27d0-474f-9433-7cdeb3a7a49d"], +Cell[10254, 298, 4042, 107, 381, "Input",ExpressionUUID->"5cb4f612-3c02-42ac-ad57-4fb2daf3366b"], +Cell[14299, 407, 10810, 230, 608, "Input",ExpressionUUID->"df61872a-1e93-4b2b-ad66-1c8fee203402"], +Cell[25112, 639, 7334, 180, 608, "Input",ExpressionUUID->"dab3b84f-3f49-42e4-9bc4-79cb6408f946"], +Cell[32449, 821, 912, 24, 92, "Input",ExpressionUUID->"bd52b017-bd99-4bdf-9126-b7c62804c9f2"], +Cell[33364, 847, 5346, 111, 216, "Input",ExpressionUUID->"4186f080-27d0-474f-9433-7cdeb3a7a49d"], Cell[CellGroupData[{ Cell[38735, 962, 357, 5, 29, "Input",ExpressionUUID->"a546161f-063b-4b38-811b-1f5d9ac28696"], -Cell[39095, 969, 2810, 39, 33, "Output",ExpressionUUID->"43f23c83-5fed-4792-9475-e7e7c052b010"] +Cell[39095, 969, 2838, 40, 33, "Output",ExpressionUUID->"bbf5dd8e-e10c-4275-a0dc-b914393f11a3"] }, Open ]], -Cell[41920, 1011, 2787, 67, 262, "Input",ExpressionUUID->"3971d33a-d19f-42ea-9b17-0801f7a59659"], -Cell[44710, 1080, 3212, 89, 130, "Input",ExpressionUUID->"3db5443f-dda7-4082-8ab7-96e274634389"], -Cell[47925, 1171, 1383, 34, 65, "Input",ExpressionUUID->"52eb731d-d72b-4ff7-afc4-5691e9750e37"], -Cell[49311, 1207, 843, 23, 65, "Input",ExpressionUUID->"6e172e8f-4972-4597-9559-948bf406a2c4"], -Cell[50157, 1232, 1861, 70, 147, "Input",ExpressionUUID->"a88926ed-6f50-457b-9480-401929196ff8"], -Cell[52021, 1304, 1550, 60, 137, "Input",ExpressionUUID->"ac2fc7fb-1a08-4495-8c53-210ad6f3664b"], -Cell[53574, 1366, 9993, 307, 257, "Input",ExpressionUUID->"609d9edf-fd45-4e4e-aae5-f4d3cc6359f5"], -Cell[63570, 1675, 4066, 151, 216, "Input",ExpressionUUID->"294e535d-e3a7-4a1d-8c24-303f127653b2"], -Cell[67639, 1828, 7538, 274, 221, "Input",ExpressionUUID->"45d67d9a-02e6-48ac-8e3a-435a001307e6"], -Cell[75180, 2104, 5347, 201, 250, "Input",ExpressionUUID->"65e20246-7792-4c97-b2ee-553e60d6428e"], -Cell[80530, 2307, 49457, 1063, 2753, "Input",ExpressionUUID->"1c98ab0f-7be0-4b82-83f8-0a1739369b4d"], -Cell[129990, 3372, 172929, 3666, 9909, "Input",ExpressionUUID->"239a4292-049d-4293-9674-7e78c28ca011"] +Cell[41948, 1012, 2787, 67, 283, "Input",ExpressionUUID->"3971d33a-d19f-42ea-9b17-0801f7a59659"], +Cell[44738, 1081, 3212, 89, 267, "Input",ExpressionUUID->"3db5443f-dda7-4082-8ab7-96e274634389"], +Cell[47953, 1172, 1383, 34, 116, "Input",ExpressionUUID->"52eb731d-d72b-4ff7-afc4-5691e9750e37"], +Cell[49339, 1208, 843, 23, 65, "Input",ExpressionUUID->"6e172e8f-4972-4597-9559-948bf406a2c4"], +Cell[50185, 1233, 1861, 70, 147, "Input",ExpressionUUID->"a88926ed-6f50-457b-9480-401929196ff8"], +Cell[52049, 1305, 1550, 60, 137, "Input",ExpressionUUID->"ac2fc7fb-1a08-4495-8c53-210ad6f3664b"], +Cell[53602, 1367, 9993, 307, 504, "Input",ExpressionUUID->"609d9edf-fd45-4e4e-aae5-f4d3cc6359f5"], +Cell[63598, 1676, 4066, 151, 216, "Input",ExpressionUUID->"294e535d-e3a7-4a1d-8c24-303f127653b2"], +Cell[67667, 1829, 7538, 274, 221, "Input",ExpressionUUID->"45d67d9a-02e6-48ac-8e3a-435a001307e6"], +Cell[75208, 2105, 5347, 201, 250, "Input",ExpressionUUID->"65e20246-7792-4c97-b2ee-553e60d6428e"], +Cell[80558, 2308, 49457, 1063, 6383, "Input",ExpressionUUID->"1c98ab0f-7be0-4b82-83f8-0a1739369b4d"], +Cell[130018, 3373, 172929, 3666, 21934, "Input",ExpressionUUID->"239a4292-049d-4293-9674-7e78c28ca011"], +Cell[302950, 7041, 1486, 55, 181, "Input",ExpressionUUID->"b6c05a3c-d9ef-41f8-9987-9bf57f74096c"] } ] *) diff --git a/old_stuff/.ipynb_checkpoints/Apollonian Circle Packings-checkpoint.ipynb b/old_stuff/.ipynb_checkpoints/Apollonian Circle Packings-checkpoint.ipynb new file mode 100644 index 0000000..817ef9b --- /dev/null +++ b/old_stuff/.ipynb_checkpoints/Apollonian Circle Packings-checkpoint.ipynb @@ -0,0 +1,3554 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculations to find the quadratic form of the octahedral 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": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}-2 \\, \\pi - \\frac{2 \\, R}{r {\\left(\\frac{R^{2}}{r^{2}} + 1\\right)}} + 2 \\, \\arctan\\left(\\frac{R}{r}\\right)$$" + ], + "text/plain": [ + "-2*pi - 2*R/(r*(R^2/r^2 + 1)) + 2*arctan(R/r)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "var('r, R')\n", + "d = diff(2 * atan(R / r) * r - 2 * pi * r, r)\n", + "show(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "scrolled": true + }, + "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": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}2$$" + ], + "text/plain": [ + "2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(1,\\,0,\\,0,\\,0\\right)$$" + ], + "text/plain": [ + "(1, 0, 0, 0)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(0,\\,1,\\,0,\\,0\\right)$$" + ], + "text/plain": [ + "(0, 1, 0, 0)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(0,\\,0,\\,1,\\,0\\right)$$" + ], + "text/plain": [ + "(0, 0, 1, 0)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(0,\\,0,\\,0,\\,1\\right)$$" + ], + "text/plain": [ + "(0, 0, 0, 1)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mat = matrix([\n", + " [2, -2, -2, -2],\n", + " [-2, 2, -2, -2],\n", + " [-2, -2, 2, -2],\n", + " [-2, -2, -2, 2]\n", + "])\n", + "\n", + "a1 = vector([1, 0, 0, 0])\n", + "a2 = vector([0, 1, 0, 0])\n", + "a3 = vector([0, 0, 1, 0])\n", + "a4 = vector([0, 0, 0, 1])\n", + "\n", + "av1 = 2 / (a1 * mat * a1) * a1\n", + "av2 = 2 / (a2 * mat * a2) * a2\n", + "av3 = 2 / (a3 * mat * a3) * a3\n", + "av4 = 2 / (a4 * mat * a4) * a4\n", + "\n", + "show(a1 * mat * a1)\n", + "\n", + "show(av1)\n", + "show(av2)\n", + "show(av3)\n", + "show(av4)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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": 4, + "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. It turns out that 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": 5, + "metadata": {}, + "outputs": [], + "source": [ + "W = matrix([\n", + " [2, 0, 0, 1],\n", + " [2, 0, 0, -1],\n", + " [-1, 1, 0, 0],\n", + " [6, 2, 2*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": 6, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 1 -1 -1 -2]\n", + "[-1 1 -1 -2]\n", + "[-1 -1 1 -2]\n", + "[-2 -2 -2 -4]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "M = W * P * W.transpose()\n", + "M" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$M^{-1}$ is the matrix of the quadratic form, although it is nice to normalize it to have ones along the diagonal, which is fine since it is equal to zero.\n", + "$$\n", + "\\left(\\begin{matrix}\n", + " 1 & 0 & 0 & -1/2\\\\\n", + " 0 & 1 & 0 & -1/2\\\\\n", + " 0 & 0 & 1 & -1/2\\\\\n", + " -1/2 & -1/2 & -1/2 & 1/4\n", + "\\end{matrix}\\right)\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 1/2 0 0 -1/4]\n", + "[ 0 1/2 0 -1/4]\n", + "[ 0 0 1/2 -1/4]\n", + "[-1/4 -1/4 -1/4 1/8]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "M.inverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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": 9, + "metadata": {}, + "outputs": [], + "source": [ + "D = W2.transpose() * M.inverse() * W2" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "P.inverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "b1^2 + b2^2 + b3^2 - b1*b_avg - b2*b_avg - b3*b_avg + 1/4*b_avg^2" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 * factor(simplify(D[1][1]))" + ] + }, + { + "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{sum}}^2/4 - b_{\\text{sum}}(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": "markdown", + "metadata": {}, + "source": [ + "# Calculations to find the generators for the \"Apollonian\" Group for the octahedral packing\n", + "\n", + "We can try the Weyl 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": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def weyl_generators(matrix, alphas):\n", + " retval = []\n", + " for alpha in alphas:\n", + " scale_factor = (alpha.transpose() * matrix * alpha)[0][0]\n", + " retval.append(identity_matrix(len(alphas)) - 2 * alpha * alpha.transpose() * matrix / scale_factor)\n", + " return retval" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def standard_basis(dim):\n", + " return [ matrix(dim, 1, [0] * i + [1] + [0] * (dim - i - 1)) for i in range(dim) ]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 2 0 0 -1]\n", + "[ 0 2 0 -1]\n", + "[ 0 0 2 -1]\n", + "[ -1 -1 -1 1/2]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "4 * M.inverse()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[\n", + "[-1 0 0 1] [ 1 0 0 0] [ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [ 0 -1 0 1] [ 0 1 0 0] [ 0 1 0 0]\n", + "[ 0 0 1 0] [ 0 0 1 0] [ 0 0 -1 1] [ 0 0 1 0]\n", + "[ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1], [ 4 4 4 -1]\n", + "]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S_i = weyl_generators(4 * M.inverse(), standard_basis(4))\n", + "S_i" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "S1 = S_i[0]\n", + "S2 = S_i[1]\n", + "S3 = S_i[2]\n", + "S4 = S_i[3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can test this out on the packing on page 3 of the Guettler and Mallows. The root sextuple is (-1, 2, 2, 4, 4 7), so the coordinates would be (-1, 2, 4, 6). After applying $s_1$, it should swap out $s_1$ for its pair, resulting in (7, 2, 4, 6). Likewise for $s_2$ and $s_3$. Then, for $s_4$, it should give the average between the triple (-1, 2, 4) and the other tangent triple, i.e. (-1, 2, 4, 14)." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(7, 2, 4, 6)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "root = vector([-1, 2, 4, 6])\n", + "S1 * root" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1, 4, 4, 6)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S2 * root" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1, 2, 2, 6)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S3 * root" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1, 2, 4, 14)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S4 * root" + ] + }, + { + "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": 21, + "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": 22, + "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": 63, + "metadata": { + "scrolled": true + }, + "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", + "btest = []\n", + "coordsnew = abbc_coords(1/r, x/r, y/r)\n", + "bnew = coordsnew[0]\n", + "btest.append(circle((coordsnew[2]/bnew, coordsnew[3]/bnew), 1/bnew))\n", + "coordsnew = abbc_coords(1/r, -x/r, y/r)\n", + "bnew = coordsnew[0]\n", + "btest.append(circle((coordsnew[2]/bnew, coordsnew[3]/bnew), 1/bnew))\n", + "coordsnew = abbc_coords(1/r, x/r, -y/r)\n", + "bnew = coordsnew[0]\n", + "btest.append(circle((coordsnew[2]/bnew, coordsnew[3]/bnew), 1/bnew))\n", + "coordsnew = abbc_coords(1/r, -x/r, -y/r)\n", + "bnew = coordsnew[0]\n", + "btest.append(circle((coordsnew[2]/bnew, coordsnew[3]/bnew), 1/bnew))\n", + "\n", + "#show(sum(btest))\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": [ + "# The quadratic form for the cubical packing\n", + "\n", + "We first made a matrix, $W_c$, whose rows are the abbc coordinates of the circles in the root octuple. Then we found the row echelon form of that matrix, resulting in a system of linear relations the coordinates must satisfy. Then, from there, we could derive the rest of the coordinates from the first four (we chose the first four to be the \"cubicle\" from the Stange), allowing us to derive the quadratic form." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The idea here is that by multiplying $W_c$ by an arbitrary vector in $\\mathbf{R}^8$ and setting that equal to $\\vec{0}$, we can find a basis for the null space of $W_c$, which will end up giving us a bunch of linear relations the curvatures must satisfy. The thing to notice is that $W_c\\vec{v} = 0$ for some $\\vec{v}\\in\\mathbf{R}^8$ gives the system of equations with coefficient matrix $W^T$. So finding the row echelon form of $W^T$ will give us the coefficients in the simplified system of linear relations, with each row equal to 0." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 1 0 0 0 1/2 1/2 1/2 -1/2]\n", + "[ 0 1 0 0 1/2 1/2 -1/2 1/2]\n", + "[ 0 0 1 0 1/2 -1/2 1/2 1/2]\n", + "[ 0 0 0 1 -1/2 1/2 1/2 1/2]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Wc = matrix([\n", + " [4, 0, 0, 1],\n", + " [0, 2, 0, 1],\n", + " [2, 1, -sqrt(2), -1],\n", + " [2, 1, sqrt(2), -1],\n", + " [2, 1, -sqrt(2), 1],\n", + " [2, 1, sqrt(2), 1],\n", + " [4, 0, 0, -1],\n", + " [0, 2, 0, -1],\n", + "])\n", + "\n", + "Wc.transpose().rref()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From here we can conclude that $$\n", + "\\begin{align*}\n", + " 2b_1 &= -b_5 - b_6 - b_7 + b_8\\\\\n", + " 2b_2 &= -b_5 - b_6 + b_7 - b_8\\\\\n", + " 2b_3 &= -b_5 + b_6 - b_7 - b_8\\\\\n", + " 2b_4 &= b_5 - b_6 - b_7 - b_8\n", + "\\end{align*}\n", + "$$\n", + "This differs slightly from Stange's system of equations because we put the circles in a slightly different order." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In any case, this gives us the tools to derive the full octuple from just four coordinates, letting us use those four coordinates to represent the entire octuple, and finally making $WPW^T$ nonsingular, allowing us to find the quadratic form the same way we did for the Descartes quadratic form and the octahedral quadratic form." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "W = matrix([\n", + " [4, 0, 0, 1],\n", + " [0, 2, 0, 1],\n", + " [2, 1, -sqrt(2), -1],\n", + " [2, 1, sqrt(2), -1],\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 1 -3 -3 -3]\n", + "[-3 1 -3 -3]\n", + "[-3 -3 1 -3]\n", + "[-3 -3 -3 1]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m = W * P * W.transpose()\n", + "m" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 2 -6/5 -6/5 -6/5]\n", + "[-6/5 2 -6/5 -6/5]\n", + "[-6/5 -6/5 2 -6/5]\n", + "[-6/5 -6/5 -6/5 2]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "32 * m.inverse() * 2/5" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[bt1 b1 h11 h21]\n", + "[bt2 b2 h12 h22]\n", + "[bt3 b3 h13 h23]\n", + "[bt4 b4 h14 h24]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "W2 = matrix([\n", + " [\n", + " var('bt' + str(i)),\n", + " var('b' + str(i)),\n", + " var('h1' + str(i)),\n", + " var('h2' + str(i)),\n", + " ] for i in range(1, 5)\n", + "])\n", + "W2" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "D = W2.transpose() * m.inverse() * W2" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5*b1^2 - 6*b1*b2 + 5*b2^2 - 6*b1*b3 - 6*b2*b3 + 5*b3^2 - 6*b1*b4 - 6*b2*b4 - 6*b3*b4 + 5*b4^2" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "32 * simplify(expand(D[1][1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This spits out the lovely quadratic form $$\n", + " 8(b_1^2 + b_2^2 + b_3^2 + b_4^2) = 3(b_1 + b_2 + b_3 + b_4)^2\n", + ".$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's the generators for the Weyl group. They might or might not be generators for the packing itself, however." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[\n", + "[ -1 6/5 6/5 6/5] [ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [6/5 -1 6/5 6/5] [ 0 1 0 0]\n", + "[ 0 0 1 0] [ 0 0 1 0] [6/5 6/5 -1 6/5]\n", + "[ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1],\n", + "\n", + "[ 1 0 0 0]\n", + "[ 0 1 0 0]\n", + "[ 0 0 1 0]\n", + "[6/5 6/5 6/5 -1]\n", + "]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S_i = weyl_generators(m.inverse(), standard_basis(4))\n", + "S_i" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[ 1 0 0 0 1/2 1/2 1/2 -1/2]\n", + "[ 0 1 0 0 1/2 1/2 -1/2 1/2]\n", + "[ 0 0 1 0 1/2 -1/2 1/2 1/2]\n", + "[ 0 0 0 1 -1/2 1/2 1/2 1/2]\n", + "[ 0 0 0 0 0 0 0 0]\n", + "[ 0 0 0 0 0 0 0 0]\n", + "[ 0 0 0 0 0 0 0 0]\n", + "[ 0 0 0 0 0 0 0 0]" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(Wc * P * Wc.transpose()).rref()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generalization of this method\n", + "This method seems remarkably general. Given a matrix representing a root unit of a packing, we can find the linear relation between the coordinates, and thus represent the packing with only four coordinates, allowing us to find the quadratic form." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "def quadform_from_root(root_matrix):\n", + " n = root_matrix.dimensions()[1]\n", + " 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", + " ])\n", + " \n", + " # step 1: find linear relation between coords\n", + " relations_temp = vector([ var('b' + str(i)) for i in range(1, n + 1)]) * root_matrix.transpose().rref()\n", + " relations = []\n", + " for i, expr in enumerate(relations_temp):\n", + " relations.append(var('b' + str(i + 1)) == expr)\n", + " \n", + " # step 2: find matrix of quadratic form\n", + " W = root_matrix[-4:]\n", + " M = W * P * W.transpose()\n", + " \n", + " # step 3: repeat with arbitrary matrix\n", + " W2 = matrix([\n", + " [\n", + " var('bt' + str(i)),\n", + " var('b' + str(i)),\n", + " var('h1' + str(i)),\n", + " var('h2' + str(i)),\n", + " ] for i in range(1, 5)\n", + " ])\n", + " D = factor(simplify(expand(W2.transpose() * M.inverse() * W2)))\n", + " \n", + " return relations[4:], M.inverse(), D[1][1]" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[2 \\, b_{5} = b_{1} + b_{2} + b_{3} - b_{4}, 2 \\, b_{6} = b_{1} + b_{2} - b_{3} + b_{4}, 2 \\, b_{7} = b_{1} - b_{2} + b_{3} + b_{4}, 2 \\, b_{8} = -b_{1} + b_{2} + b_{3} + b_{4}\\right]$$" + ], + "text/plain": [ + "[2*b5 == b1 + b2 + b3 - b4,\n", + " 2*b6 == b1 + b2 - b3 + b4,\n", + " 2*b7 == b1 - b2 + b3 + b4,\n", + " 2*b8 == -b1 + b2 + b3 + b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrr}\n", + "5 & -3 & -3 & -3 \\\\\n", + "-3 & 5 & -3 & -3 \\\\\n", + "-3 & -3 & 5 & -3 \\\\\n", + "-3 & -3 & -3 & 5\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 5 -3 -3 -3]\n", + "[-3 5 -3 -3]\n", + "[-3 -3 5 -3]\n", + "[-3 -3 -3 5]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}5 \\, b_{1}^{2} - 6 \\, b_{1} b_{2} + 5 \\, b_{2}^{2} - 6 \\, b_{1} b_{3} - 6 \\, b_{2} b_{3} + 5 \\, b_{3}^{2} - 6 \\, b_{1} b_{4} - 6 \\, b_{2} b_{4} - 6 \\, b_{3} b_{4} + 5 \\, b_{4}^{2}$$" + ], + "text/plain": [ + "5*b1^2 - 6*b1*b2 + 5*b2^2 - 6*b1*b3 - 6*b2*b3 + 5*b3^2 - 6*b1*b4 - 6*b2*b4 - 6*b3*b4 + 5*b4^2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\left(\\begin{array}{rrrr}\n", + "-1 & \\frac{6}{5} & \\frac{6}{5} & \\frac{6}{5} \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "\\frac{6}{5} & -1 & \\frac{6}{5} & \\frac{6}{5} \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "\\frac{6}{5} & \\frac{6}{5} & -1 & \\frac{6}{5} \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "\\frac{6}{5} & \\frac{6}{5} & \\frac{6}{5} & -1\n", + "\\end{array}\\right)\\right]$$" + ], + "text/plain": [ + "[\n", + "[ -1 6/5 6/5 6/5] [ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [6/5 -1 6/5 6/5] [ 0 1 0 0]\n", + "[ 0 0 1 0] [ 0 0 1 0] [6/5 6/5 -1 6/5]\n", + "[ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1],\n", + "\n", + "[ 1 0 0 0]\n", + "[ 0 1 0 0]\n", + "[ 0 0 1 0]\n", + "[6/5 6/5 6/5 -1]\n", + "]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# cubical\n", + "relation, mat, equation = quadform_from_root(Wc)\n", + "show([2 * eq for eq in relation])\n", + "show(32 * mat)\n", + "show(32 * equation)\n", + "show(weyl_generators(mat, standard_basis(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{5} = b_{1} + b_{3} + b_{4}, b_{6} = b_{2} + b_{3} + b_{4}\\right]$$" + ], + "text/plain": [ + "[b5 == b1 + b3 + b4, b6 == b2 + b3 + b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrr}\n", + "17 & 15 & -6 & -6 \\\\\n", + "15 & 17 & -6 & -6 \\\\\n", + "-6 & -6 & 4 & 0 \\\\\n", + "-6 & -6 & 0 & 4\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[17 15 -6 -6]\n", + "[15 17 -6 -6]\n", + "[-6 -6 4 0]\n", + "[-6 -6 0 4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}17 \\, b_{1}^{2} + 30 \\, b_{1} b_{2} + 17 \\, b_{2}^{2} - 12 \\, b_{1} b_{3} - 12 \\, b_{2} b_{3} + 4 \\, b_{3}^{2} - 12 \\, b_{1} b_{4} - 12 \\, b_{2} b_{4} + 4 \\, b_{4}^{2}$$" + ], + "text/plain": [ + "17*b1^2 + 30*b1*b2 + 17*b2^2 - 12*b1*b3 - 12*b2*b3 + 4*b3^2 - 12*b1*b4 - 12*b2*b4 + 4*b4^2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\left(\\begin{array}{rrrr}\n", + "-1 & -\\frac{30}{17} & \\frac{12}{17} & \\frac{12}{17} \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "-\\frac{30}{17} & -1 & \\frac{12}{17} & \\frac{12}{17} \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "3 & 3 & -1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "3 & 3 & 0 & -1\n", + "\\end{array}\\right)\\right]$$" + ], + "text/plain": [ + "[\n", + "[ -1 -30/17 12/17 12/17] [ 1 0 0 0]\n", + "[ 0 1 0 0] [-30/17 -1 12/17 12/17]\n", + "[ 0 0 1 0] [ 0 0 1 0]\n", + "[ 0 0 0 1], [ 0 0 0 1],\n", + "\n", + "[ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [ 0 1 0 0]\n", + "[ 3 3 -1 0] [ 0 0 1 0]\n", + "[ 0 0 0 1], [ 3 3 0 -1]\n", + "]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# octahedral\n", + "relation, mat, equation = quadform_from_root(matrix([\n", + " [2, 0, 0, 1],\n", + " [2, 0, 0, -1],\n", + " [1, 1, sqrt(2), 0],\n", + " [1, 1, -sqrt(2), 0],\n", + " [4, 2, 0, 1],\n", + " [4, 2, 0, -1],\n", + "]))\n", + "show(relation)\n", + "show(8 * mat)\n", + "show(8 * equation)\n", + "show(weyl_generators(8 * mat, standard_basis(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\right]$$" + ], + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrr}\n", + "1 & -1 & -1 & -1 \\\\\n", + "-1 & 1 & -1 & -1 \\\\\n", + "-1 & -1 & 1 & -1 \\\\\n", + "-1 & -1 & -1 & 1\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 1 -1 -1 -1]\n", + "[-1 1 -1 -1]\n", + "[-1 -1 1 -1]\n", + "[-1 -1 -1 1]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}b_{1}^{2} - 2 \\, b_{1} b_{2} + b_{2}^{2} - 2 \\, b_{1} b_{3} - 2 \\, b_{2} b_{3} + b_{3}^{2} - 2 \\, b_{1} b_{4} - 2 \\, b_{2} b_{4} - 2 \\, b_{3} b_{4} + b_{4}^{2}$$" + ], + "text/plain": [ + "b1^2 - 2*b1*b2 + b2^2 - 2*b1*b3 - 2*b2*b3 + b3^2 - 2*b1*b4 - 2*b2*b4 - 2*b3*b4 + b4^2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\left(\\begin{array}{rrrr}\n", + "-1 & 2 & 2 & 2 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "2 & -1 & 2 & 2 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "2 & 2 & -1 & 2 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "2 & 2 & 2 & -1\n", + "\\end{array}\\right)\\right]$$" + ], + "text/plain": [ + "[\n", + "[-1 2 2 2] [ 1 0 0 0] [ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [ 2 -1 2 2] [ 0 1 0 0] [ 0 1 0 0]\n", + "[ 0 0 1 0] [ 0 0 1 0] [ 2 2 -1 2] [ 0 0 1 0]\n", + "[ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1], [ 2 2 2 -1]\n", + "]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# tetrahedral\n", + "relation, mat, equation = quadform_from_root(matrix([\n", + " [2, 0, 0, 1],\n", + " [2, 0, 0, -1],\n", + " [-1, 1, 0, 0],\n", + " [3, 1, 2, 0]\n", + "]))\n", + "show(relation)\n", + "show(4 * mat)\n", + "show(4 * equation)\n", + "show(weyl_generators(4 * mat, standard_basis(4)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# $n$-Gon Base Pyramid\n", + "\n", + "The goal here is to find the quadratic form for an arbitrary $n$-gon base pyramid. The key to the whole process is a magic formula Dylan found for the bilinear form between two circles in an $n$-gon base pyramidal packing, namely $$\n", + " \\frac{1 - \\cos\\left(\\frac{2\\pi}{n}\\right) - 4\\sin^2\\left(\\frac{p\\pi}{n}\\right)}{1-\\cos\\left(\\frac{2\\pi}{n}\\right)}\n", + "$$\n", + "\n", + "where $p$ is how many circles are between the two circles in question. If we are finding the bilinear form between the central circle and any other circle it will always be $-1$ so we don't need to worry about that case." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "# function to compute W^T*P*W for n-gon pyramidal packing\n", + "def wmatrix(n):\n", + " vals = []\n", + " for i in range(n+1):\n", + " row = []\n", + " for j in range(n+1):\n", + " if i == j: # same vertex bilinear form'd with itself, so 1\n", + " row.append(1)\n", + " elif i ==0 or j == 0: # vertex bilinear form'd with special point, so tangent and therefore -1\n", + " row.append(-1)\n", + " else:\n", + " p = abs(i - j) # otherwise Dylan's crazy formula\n", + " row.append(\n", + " (1 - cos(2 * pi / n) - 4 * sin(pi * p / n)^2) / (1 - cos(2 * pi / n))\n", + " )\n", + " vals.append(row)\n", + " return matrix(vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "# just convenience function for quadratic forms\n", + "def qform(matrix, vector):\n", + " return vector * matrix * vector" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "def linear_relations_and_quadratic_form_from_wtpw(mat, indices=None):\n", + " if indices is None:\n", + " indices = range(mat.dimensions()[0] + 1)\n", + " n = mat.dimensions()[0]\n", + " \n", + " # work out initial relations\n", + " relations_temp = vector([ var('b' + str(i)) for i in range(1, n + 1) ]) * mat.transpose().rref()\n", + " relations = []\n", + " for i in range(n):\n", + " relations.append(var('b' + str(i + 1)) == relations_temp[i])\n", + " \n", + " # rewrite the relations in terms of the variables we care about, depends on the step\n", + " targets = [ var('b' + str(i)) for i in indices[4:] ]\n", + " show(relations)\n", + " show(targets)\n", + " #relations = solve(relations, *targets)[0]\n", + " \n", + " # find the matrix corresponding to the quadratic form, picking the appropriate rows from the matrix\n", + " mat = matrix([\n", + " [ mat[i - 1][j - 1] for j in indices[:4] ] for i in indices[:4]\n", + " ])\n", + "\n", + " Q = mat.inverse()\n", + " \n", + " # find the quadratic form in variables; proper units will satisfy this being equal to zero\n", + " vec = vector([ var('b' + str(i)) for i in indices[:4] ])\n", + " nqform = vec * Q * vec\n", + " \n", + " return relations, Q, expand(nqform)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{1} = b_{1}, b_{2} = b_{2}, b_{3} = b_{3}, b_{4} = b_{4}, b_{5} = b_{2} - 2 \\, b_{3} + 2 \\, b_{4}, b_{6} = 2 \\, b_{2} - 3 \\, b_{3} + 2 \\, b_{4}, b_{7} = 2 \\, b_{2} - 2 \\, b_{3} + b_{4}\\right]$$" + ], + "text/plain": [ + "[b1 == b1,\n", + " b2 == b2,\n", + " b3 == b3,\n", + " b4 == b4,\n", + " b5 == b2 - 2*b3 + 2*b4,\n", + " b6 == 2*b2 - 3*b3 + 2*b4,\n", + " b7 == 2*b2 - 2*b3 + b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{2}, b_{4}, b_{6}\\right]$$" + ], + "text/plain": [ + "[b2, b4, b6]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 9 -1 -1 -1]\n", + "[-1 1 -1 -1]\n", + "[-1 -1 1 -1]\n", + "[-1 -1 -1 1]\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}9 \\, b_{1}^{2} - 2 \\, b_{1} b_{3} + b_{3}^{2} - 2 \\, b_{1} b_{5} - 2 \\, b_{3} b_{5} + b_{5}^{2} - 2 \\, b_{1} b_{7} - 2 \\, b_{3} b_{7} - 2 \\, b_{5} b_{7} + b_{7}^{2}$$" + ], + "text/plain": [ + "9*b1^2 - 2*b1*b3 + b3^2 - 2*b1*b5 - 2*b3*b5 + b5^2 - 2*b1*b7 - 2*b3*b7 - 2*b5*b7 + b7^2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[3 \\, b_{1} = 3 \\, b_{1}, 3 \\, b_{2} = 3 \\, b_{2}, 3 \\, b_{3} = 3 \\, b_{3}, 3 \\, b_{4} = 3 \\, b_{4}, 3 \\, b_{5} = 3 \\, b_{2} - 6 \\, b_{3} + 6 \\, b_{4}, 3 \\, b_{6} = 6 \\, b_{2} - 9 \\, b_{3} + 6 \\, b_{4}, 3 \\, b_{7} = 6 \\, b_{2} - 6 \\, b_{3} + 3 \\, b_{4}\\right]$$" + ], + "text/plain": [ + "[3*b1 == 3*b1,\n", + " 3*b2 == 3*b2,\n", + " 3*b3 == 3*b3,\n", + " 3*b4 == 3*b4,\n", + " 3*b5 == 3*b2 - 6*b3 + 6*b4,\n", + " 3*b6 == 6*b2 - 9*b3 + 6*b4,\n", + " 3*b7 == 6*b2 - 6*b3 + 3*b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\left(\\begin{array}{rrrr}\n", + "-1 & \\frac{2}{9} & \\frac{2}{9} & \\frac{2}{9} \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "2 & -1 & 2 & 2 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "2 & 2 & -1 & 2 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "2 & 2 & 2 & -1\n", + "\\end{array}\\right)\\right]$$" + ], + "text/plain": [ + "[\n", + "[ -1 2/9 2/9 2/9] [ 1 0 0 0] [ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [ 2 -1 2 2] [ 0 1 0 0] [ 0 1 0 0]\n", + "[ 0 0 1 0] [ 0 0 1 0] [ 2 2 -1 2] [ 0 0 1 0]\n", + "[ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1], [ 2 2 2 -1]\n", + "]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "relations, Q, nqform = linear_relations_and_quadratic_form_from_wtpw(wmatrix(6), [1, 3, 5, 7, 2, 4, 6])\n", + "print(12 * Q)\n", + "show(12 * nqform)\n", + "show([3 * rel for rel in relations])\n", + "show(weyl_generators(12 * Q, standard_basis(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "# function to compute the linear relations and quadratic formula for an ngon base pyramid\n", + "# the circles will be numbered 1 in the center, then 2 through n winding around the circle by step, so\n", + "# for n = 4 with step = 1, we have\n", + "# b3\n", + "# b4 b1 b2\n", + "# b5\n", + "# and the quadratic form is in terms of b1, b2, b3, and b4\n", + "# and for n = 6 with step = 2, we have\n", + "# b4 b3\n", + "# b5 b1 b2\n", + "# b6 b7\n", + "# and the quadratic form is in terms of b1, b3, b5, and b7\n", + "def ngon_linear_relations_and_quadratic_form(n, step=1):\n", + " mat = wmatrix(n)\n", + " \n", + " # work out initial relations\n", + " relations_temp = vector([ var('b' + str(i)) for i in range(1, n + 2) ]) * mat.transpose().rref()\n", + " relations = []\n", + " for i in range(4, n + 1):\n", + " relations.append(var('b' + str(i + 1)) == relations_temp[i])\n", + " \n", + " # rewrite the relations in terms of the variables we care about, depends on the step\n", + " shuffled = (list(range(1, n + 2)) * step)[::step]\n", + " targets = [ var('b' + str(i)) for i in shuffled[4:] ]\n", + " relations = solve(relations, *targets)[0]\n", + " \n", + " # find the matrix corresponding to the quadratic form, picking the appropriate rows from the matrix\n", + " Q = mat[:4*step:step,:4*step:step].inverse()\n", + " \n", + " # find the quadratic form in variables; proper units will satisfy this being equal to zero\n", + " nqform = qform(Q, vector([ var('b' + str(i)) for i in range(1, 5) ]))\n", + " \n", + " return relations, Q, expand(nqform)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{5} = -b_{3} {\\left(\\sqrt{2} + 1\\right)} + b_{4} {\\left(\\sqrt{2} + 1\\right)} + b_{2}, b_{6} = b_{4} {\\left(\\sqrt{2} + 2\\right)} + b_{2} {\\left(\\sqrt{2} + 1\\right)} - 2 \\, b_{3} {\\left(\\sqrt{2} + 1\\right)}, b_{7} = -b_{3} {\\left(2 \\, \\sqrt{2} + 3\\right)} + b_{2} {\\left(\\sqrt{2} + 2\\right)} + b_{4} {\\left(\\sqrt{2} + 2\\right)}, b_{8} = b_{2} {\\left(\\sqrt{2} + 2\\right)} - 2 \\, b_{3} {\\left(\\sqrt{2} + 1\\right)} + b_{4} {\\left(\\sqrt{2} + 1\\right)}, b_{9} = b_{2} {\\left(\\sqrt{2} + 1\\right)} - b_{3} {\\left(\\sqrt{2} + 1\\right)} + b_{4}\\right]$$" + ], + "text/plain": [ + "[b5 == -b3*(sqrt(2) + 1) + b4*(sqrt(2) + 1) + b2,\n", + " b6 == b4*(sqrt(2) + 2) + b2*(sqrt(2) + 1) - 2*b3*(sqrt(2) + 1),\n", + " b7 == -b3*(2*sqrt(2) + 3) + b2*(sqrt(2) + 2) + b4*(sqrt(2) + 2),\n", + " b8 == b2*(sqrt(2) + 2) - 2*b3*(sqrt(2) + 1) + b4*(sqrt(2) + 1),\n", + " b9 == b2*(sqrt(2) + 1) - b3*(sqrt(2) + 1) + b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrr}\n", + "-\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} + 1 & -2 & -\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 3 & -2 \\\\\n", + "-2 & -\\frac{4}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1} & -2 & \\frac{4}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1} \\\\\n", + "-\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 3 & -2 & -\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} + 1 & -2 \\\\\n", + "-2 & \\frac{4}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1} & -2 & -\\frac{4}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1}\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ -(sqrt(2) + 2)/(sqrt(2) - 2) + 1 -2 -(sqrt(2) + 2)/(sqrt(2) - 2) - 3 -2]\n", + "[ -2 -4/((sqrt(2) + 2)/(sqrt(2) - 2) - 1) -2 4/((sqrt(2) + 2)/(sqrt(2) - 2) - 1)]\n", + "[ -(sqrt(2) + 2)/(sqrt(2) - 2) - 3 -2 -(sqrt(2) + 2)/(sqrt(2) - 2) + 1 -2]\n", + "[ -2 4/((sqrt(2) + 2)/(sqrt(2) - 2) - 1) -2 -4/((sqrt(2) + 2)/(sqrt(2) - 2) - 1)]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}b_{1}^{2} - 4 \\, b_{1} b_{2} - 6 \\, b_{1} b_{3} - 4 \\, b_{2} b_{3} + b_{3}^{2} - 4 \\, b_{1} b_{4} - 4 \\, b_{3} b_{4} - \\frac{\\sqrt{2} b_{1}^{2}}{\\sqrt{2} - 2} - \\frac{2 \\, \\sqrt{2} b_{1} b_{3}}{\\sqrt{2} - 2} - \\frac{\\sqrt{2} b_{3}^{2}}{\\sqrt{2} - 2} - \\frac{2 \\, b_{1}^{2}}{\\sqrt{2} - 2} - \\frac{4 \\, b_{1} b_{3}}{\\sqrt{2} - 2} - \\frac{2 \\, b_{3}^{2}}{\\sqrt{2} - 2} - \\frac{4 \\, b_{2}^{2}}{\\frac{\\sqrt{2}}{\\sqrt{2} - 2} + \\frac{2}{\\sqrt{2} - 2} - 1} + \\frac{8 \\, b_{2} b_{4}}{\\frac{\\sqrt{2}}{\\sqrt{2} - 2} + \\frac{2}{\\sqrt{2} - 2} - 1} - \\frac{4 \\, b_{4}^{2}}{\\frac{\\sqrt{2}}{\\sqrt{2} - 2} + \\frac{2}{\\sqrt{2} - 2} - 1}$$" + ], + "text/plain": [ + "b1^2 - 4*b1*b2 - 6*b1*b3 - 4*b2*b3 + b3^2 - 4*b1*b4 - 4*b3*b4 - sqrt(2)*b1^2/(sqrt(2) - 2) - 2*sqrt(2)*b1*b3/(sqrt(2) - 2) - sqrt(2)*b3^2/(sqrt(2) - 2) - 2*b1^2/(sqrt(2) - 2) - 4*b1*b3/(sqrt(2) - 2) - 2*b3^2/(sqrt(2) - 2) - 4*b2^2/(sqrt(2)/(sqrt(2) - 2) + 2/(sqrt(2) - 2) - 1) + 8*b2*b4/(sqrt(2)/(sqrt(2) - 2) + 2/(sqrt(2) - 2) - 1) - 4*b4^2/(sqrt(2)/(sqrt(2) - 2) + 2/(sqrt(2) - 2) - 1)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\left(\\begin{array}{rrrr}\n", + "-1 & -\\frac{4}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1} & -\\frac{2 \\, {\\left(\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} + 3\\right)}}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1} & -\\frac{4}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1} \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "-\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} + 1 & -1 & -\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} + 1 & 2 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "-\\frac{2 \\, {\\left(\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} + 3\\right)}}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1} & -\\frac{4}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1} & -1 & -\\frac{4}{\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} - 1} \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "-\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} + 1 & 2 & -\\frac{\\sqrt{2} + 2}{\\sqrt{2} - 2} + 1 & -1\n", + "\\end{array}\\right)\\right]$$" + ], + "text/plain": [ + "[\n", + "[ -1 -4/((sqrt(2) + 2)/(sqrt(2) - 2) - 1) -2*((sqrt(2) + 2)/(sqrt(2) - 2) + 3)/((sqrt(2) + 2)/(sqrt(2) - 2) - 1) -4/((sqrt(2) + 2)/(sqrt(2) - 2) - 1)] [ 1 0 0 0] [ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [-(sqrt(2) + 2)/(sqrt(2) - 2) + 1 -1 -(sqrt(2) + 2)/(sqrt(2) - 2) + 1 2] [ 0 1 0 0] [ 0 1 0 0]\n", + "[ 0 0 1 0] [ 0 0 1 0] [-2*((sqrt(2) + 2)/(sqrt(2) - 2) + 3)/((sqrt(2) + 2)/(sqrt(2) - 2) - 1) -4/((sqrt(2) + 2)/(sqrt(2) - 2) - 1) -1 -4/((sqrt(2) + 2)/(sqrt(2) - 2) - 1)] [ 0 0 1 0]\n", + "[ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1], [-(sqrt(2) + 2)/(sqrt(2) - 2) + 1 2 -(sqrt(2) + 2)/(sqrt(2) - 2) + 1 -1]\n", + "]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "relations, Q, nqform = ngon_linear_relations_and_quadratic_form(8)\n", + "\n", + "show(relations)\n", + "show(8 * Q)\n", + "show(8 * nqform)\n", + "show(weyl_generators(8 * Q, standard_basis(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[3 \\, b_{2} = 2 \\, b_{3} - b_{5} + 2 \\, b_{7}, 3 \\, b_{4} = 2 \\, b_{3} + 2 \\, b_{5} - b_{7}, 3 \\, b_{6} = -b_{3} + 2 \\, b_{5} + 2 \\, b_{7}\\right]$$" + ], + "text/plain": [ + "[3*b2 == 2*b3 - b5 + 2*b7, 3*b4 == 2*b3 + 2*b5 - b7, 3*b6 == -b3 + 2*b5 + 2*b7]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrr}\n", + "9 & -1 & -1 & -1 \\\\\n", + "-1 & 1 & -1 & -1 \\\\\n", + "-1 & -1 & 1 & -1 \\\\\n", + "-1 & -1 & -1 & 1\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 9 -1 -1 -1]\n", + "[-1 1 -1 -1]\n", + "[-1 -1 1 -1]\n", + "[-1 -1 -1 1]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}9 \\, b_{1}^{2} - 2 \\, b_{1} b_{2} + b_{2}^{2} - 2 \\, b_{1} b_{3} - 2 \\, b_{2} b_{3} + b_{3}^{2} - 2 \\, b_{1} b_{4} - 2 \\, b_{2} b_{4} - 2 \\, b_{3} b_{4} + b_{4}^{2}$$" + ], + "text/plain": [ + "9*b1^2 - 2*b1*b2 + b2^2 - 2*b1*b3 - 2*b2*b3 + b3^2 - 2*b1*b4 - 2*b2*b4 - 2*b3*b4 + b4^2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\left(\\begin{array}{rrrr}\n", + "-1 & \\frac{2}{9} & \\frac{2}{9} & \\frac{2}{9} \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "2 & -1 & 2 & 2 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "2 & 2 & -1 & 2 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "2 & 2 & 2 & -1\n", + "\\end{array}\\right)\\right]$$" + ], + "text/plain": [ + "[\n", + "[ -1 2/9 2/9 2/9] [ 1 0 0 0] [ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [ 2 -1 2 2] [ 0 1 0 0] [ 0 1 0 0]\n", + "[ 0 0 1 0] [ 0 0 1 0] [ 2 2 -1 2] [ 0 0 1 0]\n", + "[ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1], [ 2 2 2 -1]\n", + "]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\frac{2}{9} \\, b_{2} + \\frac{2}{9} \\, b_{3} + \\frac{2}{9} \\, b_{4}$$" + ], + "text/plain": [ + "2/9*b2 + 2/9*b3 + 2/9*b4" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "relations, Q, nqform = ngon_linear_relations_and_quadratic_form(6, 2)\n", + "\n", + "show([3 * eq for eq in relations])\n", + "show(12 * Q)\n", + "show(12 * nqform)\n", + "show(weyl_generators(12 * Q, standard_basis(4)))\n", + "\n", + "sols = solve(nqform, b1)\n", + "s1 = sols[0].rhs()\n", + "s2 = sols[1].rhs()\n", + "show(s1 + s2)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "class Circle:\n", + " def __init__(self, bt, b, h1, h2):\n", + " self.bt = bt\n", + " self.b = b\n", + " self.h1 = h1\n", + " self.h2 = h2\n", + " self.vec = vector(bt, b, h1, h2)\n", + " \n", + " def __mul__(self, other):\n", + " self.vec *= other\n", + " self.bt = self.vec[0]\n", + " self.b = self.vec[1]\n", + " self.h1 = self.vec[2]\n", + " self.h2 = self.vec[3]\n", + " \n", + " def draw(self, plt):\n", + " pass\n", + " \n", + " \n", + "def from_xyr(x, y, r):\n", + " b = 1/r\n", + " h1 = b * x\n", + " h2 = b * y\n", + " return Circle((1 - h1^2 - h2^2) / b, b, h1, h2)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(-2/3*sqrt(3), -1)\t1/3*sqrt(3)\n", + "(-1/6*sqrt(3), -1)\t1/6*sqrt(3)\n", + "(0, 1)\tsqrt(3)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "Graphics object consisting of 14 graphics primitives" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "b1, b2, b3, b4, b5, b6, b7 = var('b1 b2 b3 b4 b5 b6 b7')\n", + "test = [relation.subs([b1 == 0, b2 == 1, b3 == 0, b4 == 1]) for relation in relations]\n", + "\n", + "plt = line([(-2*sqrt(3), 1), (2*sqrt(3), 1)])\n", + "plt += line([(-2*sqrt(3), -1), (2*sqrt(3), -1)])\n", + "plt += circle((-sqrt(3), 0), 1)\n", + "plt += circle((-1/3 * sqrt(3), -2/3), 1/3)\n", + "plt += circle((0, -3/4), 1/4)\n", + "plt += circle((1/3 * sqrt(3), -2/3), 1/3)\n", + "plt += circle((sqrt(3), 0), 1)\n", + "\n", + "plt += line([(-sqrt(3), 2*sqrt(3)), (-sqrt(3), -2*sqrt(3))], rgbcolor=(1,0,0))\n", + "plt += line([( sqrt(3), 2*sqrt(3)), ( sqrt(3), -2*sqrt(3))], rgbcolor=(1,0,0))\n", + "\n", + "x, y = var('x y')\n", + "c1 = (x + sqrt(3))^2 + y^2 == 1\n", + "c2 = (x + 1/3*sqrt(3))^2 + (y + 2/3)^2 == 1/9\n", + "c3 = x^2 + (y + 3/4)^2 == 1/16\n", + "i1 = solve([c1, c2], [x, y])[0]\n", + "x1 = i1[0].rhs()\n", + "y1 = i1[1].rhs()\n", + "i2 = solve([c2, c3], [x, y])[0]\n", + "x2 = i2[0].rhs()\n", + "y2 = i2[1].rhs()\n", + "\n", + "x, y, r = circle_from_points((-sqrt(3), -1), (-1/3*sqrt(3), -1), (x1, y1))\n", + "print('({}, {})\\t{}'.format(x, y, r))\n", + "\n", + "plt += circle((x, y), r, rgbcolor=(1,0,0))\n", + "plt += circle((-x, y), r, rgbcolor=(1,0,0))\n", + "\n", + "x, y, r = circle_from_points((-1/3*sqrt(3), -1), (0, -1), (x2, y2))\n", + "print('({}, {})\\t{}'.format(x, y, r))\n", + "\n", + "plt += circle((x, y), r, rgbcolor=(1,0,0))\n", + "plt += circle((-x, y), r, rgbcolor=(1,0,0))\n", + "\n", + "x, y, r = circle_from_points((-sqrt(3), 1), (x1, y1), (sqrt(3), 1))\n", + "print('({}, {})\\t{}'.format(x, y, r))\n", + "\n", + "plt += circle((x, y), r, rgbcolor=(1, 0, 0))\n", + "\n", + "show(plt)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{5} = b_{2} - 2 \\, b_{3} + 2 \\, b_{4}, b_{6} = 2 \\, b_{2} - 3 \\, b_{3} + 2 \\, b_{4}, b_{7} = 2 \\, b_{2} - 2 \\, b_{3} + b_{4}\\right]$$" + ], + "text/plain": [ + "[b5 == b2 - 2*b3 + 2*b4, b6 == 2*b2 - 3*b3 + 2*b4, b7 == 2*b2 - 2*b3 + b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}6 \\, b_{1}^{2} - 4 \\, b_{1} b_{2} + \\frac{2}{3} \\, b_{2}^{2} + 4 \\, b_{1} b_{3} - 4 \\, b_{2} b_{3} + 6 \\, b_{3}^{2} - 4 \\, b_{1} b_{4} - \\frac{4}{3} \\, b_{2} b_{4} - 4 \\, b_{3} b_{4} + \\frac{2}{3} \\, b_{4}^{2}$$" + ], + "text/plain": [ + "6*b1^2 - 4*b1*b2 + 2/3*b2^2 + 4*b1*b3 - 4*b2*b3 + 6*b3^2 - 4*b1*b4 - 4/3*b2*b4 - 4*b3*b4 + 2/3*b4^2" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "relations, Q, nqform = ngon_linear_relations_and_quadratic_form(6)\n", + "show(relations)\n", + "show(simplify(8 * nqform))" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[b5 == -1/2*b3*(sqrt(5) + 3) + 1/2*b4*(sqrt(5) + 3) + b2, b6 == -1/2*b3*(3*sqrt(5) + 5) + 1/2*b2*(sqrt(5) + 3) + b4*(sqrt(5) + 2), b7 == b4*(sqrt(5) + 3) + b2*(sqrt(5) + 2) - 2*b3*(sqrt(5) + 2), b8 == -b3*(2*sqrt(5) + 5) + b2*(sqrt(5) + 3) + b4*(sqrt(5) + 3), b9 == b2*(sqrt(5) + 3) - 2*b3*(sqrt(5) + 2) + b4*(sqrt(5) + 2), b10 == -1/2*b3*(3*sqrt(5) + 5) + 1/2*b4*(sqrt(5) + 3) + b2*(sqrt(5) + 2), b11 == 1/2*b2*(sqrt(5) + 3) - 1/2*b3*(sqrt(5) + 3) + b4]\n" + ] + } + ], + "source": [ + "relations, Q, nqform = ngon_linear_relations_and_quadratic_form(10)\n", + "print(relations)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-1/2*b2*bt1 - 1/2*b1*bt2 + h11*h12 + h21*h22" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vec1 = vector([var('bt1'), var('b1'), var('h11'), var('h21')])\n", + "vec2 = vector([var('bt2'), var('b2'), var('h12'), var('h22')])\n", + "vec1 * P * vec2" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}-\\frac{2 \\, \\sin\\left(\\frac{\\pi k}{n}\\right)^{2}}{\\sin\\left(\\frac{\\pi}{n}\\right)^{2}} + 1$$" + ], + "text/plain": [ + "-2*sin(pi*k/n)^2/sin(pi/n)^2 + 1" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "k = var('k', domain=RR)\n", + "n = var('n', domain=RR)\n", + "\n", + "c1 = 1\n", + "c2i = sin(2 * pi * k / n)\n", + "c2r = cos(2 * pi * k / n)\n", + "\n", + "dist = sin(pi * k / n)\n", + "r = dist.subs(k==1) / 2\n", + "dist /= r\n", + "\n", + "bf = 1/2 * (1 + 1 * (1 - dist^2))\n", + "show(bf)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 \t 0\n", + "1 \t x - 1\n", + "2 \t 2*x^2 - 2\n", + "3 \t 4*x^3 - 3*x - 1\n", + "4 \t 8*x^4 - 8*x^2\n", + "5 \t 16*x^5 - 20*x^3 + 5*x - 1\n", + "6 \t 32*x^6 - 48*x^4 + 18*x^2 - 2\n", + "7 \t 64*x^7 - 112*x^5 + 56*x^3 - 7*x - 1\n", + "8 \t 128*x^8 - 256*x^6 + 160*x^4 - 32*x^2\n", + "9 \t 256*x^9 - 576*x^7 + 432*x^5 - 120*x^3 + 9*x - 1\n", + "10 \t 512*x^10 - 1280*x^8 + 1120*x^6 - 400*x^4 + 50*x^2 - 2\n" + ] + } + ], + "source": [ + "T = []\n", + "x = var('x')\n", + "T.append(1)\n", + "T.append(x)\n", + "\n", + "def nextT():\n", + " i = len(T)\n", + " T.append(expand(2 * x * T[i - 1] - T[i - 2]))\n", + " #print(i, '\\t', T[i] - 1)\n", + " \n", + "for _ in range(9):\n", + " nextT()\n", + "\n", + "for i, poly in enumerate(T):\n", + " print(i, '\\t', poly - 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-x^6 + x^5 + x^4 - x^3 - 2*x^2 + 2*x" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "expand(x * (1 - x) * (x^4 - x^2 + 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "S1 = matrix([\n", + " [-1, 0, 0, 2],\n", + " [0, 1, 0, 0],\n", + " [0, 0, 1, 0],\n", + " [0, 0, 0, 1],\n", + "])\n", + "S2 = matrix([\n", + " [1, 0, 0, 0],\n", + " [0, -1, 0, 2],\n", + " [0, 0, 1, 0],\n", + " [0, 0, 0, 1],\n", + "])\n", + "S3 = matrix([\n", + " [1, 0, 0, 0],\n", + " [0, 1, 0, 0],\n", + " [0, 0, -1, 2],\n", + " [0, 0, 0, 1],\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", + "Ss = [S4, S4 * S1, S4 * S1 * S2, S4 * S1 * S3, S4 * S1 * S2 * S3, S4 * S2, S4 * S2 * S3, S4 * S3]\n", + "v1 = vector(var('b' + str(i + 1)) for i in range(4))\n", + "v2 = vector(var('b' + str(i + 1)) for i in range(6))\n", + "temp = [matrix * v1 for matrix in Ss]\n", + "new = []\n", + "for blah in temp:\n", + " new.append([var('b' + str(i+1) + 'p') == blah[i] for i in range(len(blah))])\n", + "\n", + "for eqs in new:\n", + " for i in range(len(eqs)):\n", + " eqs[i] = eqs[i].subs(var('b4') == var('b1') + var('b6'))\n", + " eqs[i] = eqs[i].subs(var('b4p') == var('b1p') + var('b6p'))" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{1} = b_{1}, b_{2} = b_{2}, b_{3} = b_{3}, b_{4} = b_{1} + b_{2} - b_{3}, b_{5} = b_{4}, b_{6} = b_{2} - b_{3} - b_{4}\\right]$$" + ], + "text/plain": [ + "[b1 == b1,\n", + " b2 == b2,\n", + " b3 == b3,\n", + " b4 == b1 + b2 - b3,\n", + " b5 == b4,\n", + " b6 == b2 - b3 - b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{4}, b_{5}, b_{6}\\right]$$" + ], + "text/plain": [ + "[b4, b5, b6]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{1} = b_{1}, b_{2} = b_{2}, b_{3} = b_{3}, b_{4} = b_{1} + b_{2} - b_{3}, b_{5} = b_{4}, b_{6} = b_{2} - b_{3} - b_{4}\\right]$$" + ], + "text/plain": [ + "[b1 == b1,\n", + " b2 == b2,\n", + " b3 == b3,\n", + " b4 == b1 + b2 - b3,\n", + " b5 == b4,\n", + " b6 == b2 - b3 - b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrr}\n", + "4 & 0 & -2 & 2 \\\\\n", + "0 & 4 & -2 & 2 \\\\\n", + "-2 & -2 & 1 & -3 \\\\\n", + "2 & 2 & -3 & 9\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 4 0 -2 2]\n", + "[ 0 4 -2 2]\n", + "[-2 -2 1 -3]\n", + "[ 2 2 -3 9]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}4 \\, b_{0}^{2} + 4 \\, b_{1}^{2} - 4 \\, b_{0} b_{2} - 4 \\, b_{1} b_{2} + b_{2}^{2} + 4 \\, b_{0} b_{3} + 4 \\, b_{1} b_{3} - 6 \\, b_{2} b_{3} + 9 \\, b_{3}^{2}$$" + ], + "text/plain": [ + "4*b0^2 + 4*b1^2 - 4*b0*b2 - 4*b1*b2 + b2^2 + 4*b0*b3 + 4*b1*b3 - 6*b2*b3 + 9*b3^2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\left(\\begin{array}{rrrr}\n", + "-1 & 0 & 1 & -1 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & -1 & 1 & -1 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "4 & 4 & -1 & 6 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "-\\frac{4}{9} & -\\frac{4}{9} & \\frac{2}{3} & -1\n", + "\\end{array}\\right)\\right]$$" + ], + "text/plain": [ + "[\n", + "[-1 0 1 -1] [ 1 0 0 0] [ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [ 0 -1 1 -1] [ 0 1 0 0] [ 0 1 0 0]\n", + "[ 0 0 1 0] [ 0 0 1 0] [ 4 4 -1 6] [ 0 0 1 0]\n", + "[ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1], [-4/9 -4/9 2/3 -1]\n", + "]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "W = matrix([\n", + " [2, 0, 0, 1],\n", + " [4, 2, 0, -1],\n", + " [2, 0, 0, -1],\n", + " [4, 2, 0, 1],\n", + " [1, 1, sqrt(2), 0],\n", + " [1, 1, -sqrt(2), 0],\n", + "])\n", + "\n", + "relations, Q, nqform = linear_relations_and_quadratic_form_from_wtpw(W * P * W.transpose())#, [1, 2, 3, 4, 5, 6])\n", + "show(relations)\n", + "show(8 * Q)\n", + "show(8 * nqform)\n", + "show(weyl_generators(8 * Q, standard_basis(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "def diagonalize(mat):\n", + " eigs = WPWT.eigenvectors_right()\n", + " eigvs = []\n", + " eigvals = []\n", + " for eig in eigs:\n", + " for eigv in eig[1]:\n", + " eigvs.append(eigv)\n", + " for _ in range(eig[2]):\n", + " eigvals.append(eig[0])\n", + " Q = matrix(eigvs)\n", + " D = diagonal_matrix(eigvals)\n", + " return (Q, D)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\left(\\begin{array}{rrrrrrrr}\n", + "-1 & 2 & 6 & 2 & 10 & 6 & 2 & 6 \\\\\n", + "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrrrrrr}\n", + "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "2 & -1 & 2 & 6 & 6 & 10 & 6 & 2 \\\\\n", + "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrrrrrr}\n", + "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "6 & 2 & -1 & 2 & 2 & 6 & 10 & 6 \\\\\n", + "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrrrrrr}\n", + "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "2 & 6 & 2 & -1 & 6 & 2 & 6 & 10 \\\\\n", + "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrrrrrr}\n", + "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n", + "10 & 6 & 2 & 6 & -1 & 2 & 6 & 2 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrrrrrr}\n", + "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n", + "6 & 10 & 6 & 2 & 2 & -1 & 2 & 6 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrrrrrr}\n", + "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n", + "2 & 6 & 10 & 6 & 6 & 2 & -1 & 2 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrrrrrr}\n", + "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n", + "6 & 2 & 6 & 10 & 2 & 6 & 2 & -1\n", + "\\end{array}\\right)\\right]$$" + ], + "text/plain": [ + "[\n", + "[-1 2 6 2 10 6 2 6] [ 1 0 0 0 0 0 0 0]\n", + "[ 0 1 0 0 0 0 0 0] [ 2 -1 2 6 6 10 6 2]\n", + "[ 0 0 1 0 0 0 0 0] [ 0 0 1 0 0 0 0 0]\n", + "[ 0 0 0 1 0 0 0 0] [ 0 0 0 1 0 0 0 0]\n", + "[ 0 0 0 0 1 0 0 0] [ 0 0 0 0 1 0 0 0]\n", + "[ 0 0 0 0 0 1 0 0] [ 0 0 0 0 0 1 0 0]\n", + "[ 0 0 0 0 0 0 1 0] [ 0 0 0 0 0 0 1 0]\n", + "[ 0 0 0 0 0 0 0 1], [ 0 0 0 0 0 0 0 1],\n", + "\n", + "[ 1 0 0 0 0 0 0 0] [ 1 0 0 0 0 0 0 0]\n", + "[ 0 1 0 0 0 0 0 0] [ 0 1 0 0 0 0 0 0]\n", + "[ 6 2 -1 2 2 6 10 6] [ 0 0 1 0 0 0 0 0]\n", + "[ 0 0 0 1 0 0 0 0] [ 2 6 2 -1 6 2 6 10]\n", + "[ 0 0 0 0 1 0 0 0] [ 0 0 0 0 1 0 0 0]\n", + "[ 0 0 0 0 0 1 0 0] [ 0 0 0 0 0 1 0 0]\n", + "[ 0 0 0 0 0 0 1 0] [ 0 0 0 0 0 0 1 0]\n", + "[ 0 0 0 0 0 0 0 1], [ 0 0 0 0 0 0 0 1],\n", + "\n", + "[ 1 0 0 0 0 0 0 0] [ 1 0 0 0 0 0 0 0]\n", + "[ 0 1 0 0 0 0 0 0] [ 0 1 0 0 0 0 0 0]\n", + "[ 0 0 1 0 0 0 0 0] [ 0 0 1 0 0 0 0 0]\n", + "[ 0 0 0 1 0 0 0 0] [ 0 0 0 1 0 0 0 0]\n", + "[10 6 2 6 -1 2 6 2] [ 0 0 0 0 1 0 0 0]\n", + "[ 0 0 0 0 0 1 0 0] [ 6 10 6 2 2 -1 2 6]\n", + "[ 0 0 0 0 0 0 1 0] [ 0 0 0 0 0 0 1 0]\n", + "[ 0 0 0 0 0 0 0 1], [ 0 0 0 0 0 0 0 1],\n", + "\n", + "[ 1 0 0 0 0 0 0 0] [ 1 0 0 0 0 0 0 0]\n", + "[ 0 1 0 0 0 0 0 0] [ 0 1 0 0 0 0 0 0]\n", + "[ 0 0 1 0 0 0 0 0] [ 0 0 1 0 0 0 0 0]\n", + "[ 0 0 0 1 0 0 0 0] [ 0 0 0 1 0 0 0 0]\n", + "[ 0 0 0 0 1 0 0 0] [ 0 0 0 0 1 0 0 0]\n", + "[ 0 0 0 0 0 1 0 0] [ 0 0 0 0 0 1 0 0]\n", + "[ 2 6 10 6 6 2 -1 2] [ 0 0 0 0 0 0 1 0]\n", + "[ 0 0 0 0 0 0 0 1], [ 6 2 6 10 2 6 2 -1]\n", + "]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 1 -1 -3 -1 -5 -3 -1 -3]\n", + "[-1 1 -1 -3 -3 -5 -3 -1]\n", + "[-3 -1 1 -1 -1 -3 -5 -3]\n", + "[-1 -3 -1 1 -3 -1 -3 -5]\n", + "[-5 -3 -1 -3 1 -1 -3 -1]\n", + "[-3 -5 -3 -1 -1 1 -1 -3]\n", + "[-1 -3 -5 -3 -3 -1 1 -1]\n", + "[-3 -1 -3 -5 -1 -3 -1 1]\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrrrrr}\n", + "-16 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 8 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 8 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 8 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[-16 0 0 0 0 0 0 0]\n", + "[ 0 8 0 0 0 0 0 0]\n", + "[ 0 0 8 0 0 0 0 0]\n", + "[ 0 0 0 8 0 0 0 0]\n", + "[ 0 0 0 0 0 0 0 0]\n", + "[ 0 0 0 0 0 0 0 0]\n", + "[ 0 0 0 0 0 0 0 0]\n", + "[ 0 0 0 0 0 0 0 0]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrrrrr}\n", + "1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\\\\n", + "1 & 0 & 0 & 1 & -1 & 0 & 0 & -1 \\\\\n", + "0 & 1 & 0 & -1 & 0 & -1 & 0 & 1 \\\\\n", + "0 & 0 & 1 & 1 & 0 & 0 & -1 & -1 \\\\\n", + "1 & 0 & 0 & -1 & 0 & 1 & -1 & 0 \\\\\n", + "0 & 1 & 0 & -1 & 0 & 1 & 0 & -1 \\\\\n", + "0 & 0 & 1 & -1 & 0 & 0 & 1 & -1 \\\\\n", + "0 & 0 & 0 & 0 & 1 & -1 & 1 & -1\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 1 1 1 1 1 1 1 1]\n", + "[ 1 0 0 1 -1 0 0 -1]\n", + "[ 0 1 0 -1 0 -1 0 1]\n", + "[ 0 0 1 1 0 0 -1 -1]\n", + "[ 1 0 0 -1 0 1 -1 0]\n", + "[ 0 1 0 -1 0 1 0 -1]\n", + "[ 0 0 1 -1 0 0 1 -1]\n", + "[ 0 0 0 0 1 -1 1 -1]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0, 0\t\t[1/8]\n", + "0, 1\t\t[0]\n", + "0, 2\t\t[0]\n", + "0, 3\t\t[0]\n", + "0, 4\t\t[0]\n", + "0, 5\t\t[0]\n", + "1, 0\t\t[0]\n", + "1, 1\t\t[3/8]\n", + "1, 2\t\t[1/8]\n", + "1, 3\t\t[-1/8]\n", + "1, 4\t\t[0]\n", + "1, 5\t\t[0]\n", + "2, 0\t\t[0]\n", + "2, 1\t\t[1/8]\n", + "2, 2\t\t[3/8]\n", + "2, 3\t\t[1/8]\n", + "2, 4\t\t[0]\n", + "2, 5\t\t[0]\n", + "3, 0\t\t[0]\n", + "3, 1\t\t[-1/8]\n", + "3, 2\t\t[1/8]\n", + "3, 3\t\t[3/8]\n", + "3, 4\t\t[0]\n", + "3, 5\t\t[0]\n", + "4, 0\t\t[0]\n", + "4, 1\t\t[0]\n", + "4, 2\t\t[0]\n", + "4, 3\t\t[0]\n", + "4, 4\t\t[1/2]\n", + "4, 5\t\t[-1/4]\n", + "5, 0\t\t[0]\n", + "5, 1\t\t[0]\n", + "5, 2\t\t[0]\n", + "5, 3\t\t[0]\n", + "5, 4\t\t[-1/4]\n", + "5, 5\t\t[1/2]\n" + ] + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrrrrr}\n", + "1 & -1 & -3 & -1 & -5 & -3 & -1 & -3 \\\\\n", + "-1 & 1 & -1 & -3 & -3 & -5 & -3 & -1 \\\\\n", + "-3 & -1 & 1 & -1 & -1 & -3 & -5 & -3 \\\\\n", + "-1 & -3 & -1 & 1 & -3 & -1 & -3 & -5 \\\\\n", + "-5 & -3 & -1 & -3 & 1 & -1 & -3 & -1 \\\\\n", + "-3 & -5 & -3 & -1 & -1 & 1 & -1 & -3 \\\\\n", + "-1 & -3 & -5 & -3 & -3 & -1 & 1 & -1 \\\\\n", + "-3 & -1 & -3 & -5 & -1 & -3 & -1 & 1\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 1 -1 -3 -1 -5 -3 -1 -3]\n", + "[-1 1 -1 -3 -3 -5 -3 -1]\n", + "[-3 -1 1 -1 -1 -3 -5 -3]\n", + "[-1 -3 -1 1 -3 -1 -3 -5]\n", + "[-5 -3 -1 -3 1 -1 -3 -1]\n", + "[-3 -5 -3 -1 -1 1 -1 -3]\n", + "[-1 -3 -5 -3 -3 -1 1 -1]\n", + "[-3 -1 -3 -5 -1 -3 -1 1]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "WPWT = matrix([\n", + " [1, -1, -3, -1, -5, -3, -1, -3],\n", + " [-1, 1, -1, -3, -3, -5, -3, -1],\n", + " [-3, -1, 1, -1, -1, -3, -5, -3],\n", + " [-1, -3, -1, 1, -3, -1, -3, -5],\n", + " [-5, -3, -1, -3, 1, -1, -3, -1],\n", + " [-3, -5, -3, -1, -1, 1, -1, -3],\n", + " [-1, -3, -5, -3, -3, -1, 1, -1],\n", + " [-3, -1, -3, -5, -1, -3, -1, 1]\n", + "])\n", + "show(weyl_generators(WPWT, standard_basis(8)))\n", + "# WPWT = W * P * W.transpose()\n", + "Q, D = diagonalize(WPWT) \n", + "print(WPWT)\n", + "show(D)\n", + "show(Q)\n", + "Qi = expand(Q.inverse())\n", + "for i in range(6):\n", + " for j in range(6):\n", + " print('{}, {}\\t\\t{}'.format(i, j, expand(Qi[:,i].transpose() * Qi[:,j])))\n", + "show(expand(Q.inverse() * D * Q))" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(1,\\,1,\\,-\\frac{1}{3},\\,-\\frac{1}{3}\\right)$$" + ], + "text/plain": [ + "(1, 1, -1/3, -1/3)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(1,\\,-\\frac{1}{3},\\,1,\\,-\\frac{1}{3}\\right)$$" + ], + "text/plain": [ + "(1, -1/3, 1, -1/3)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(1,\\,-3,\\,-3,\\,1\\right)$$" + ], + "text/plain": [ + "(1, -3, -3, 1)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(1,\\,-\\frac{1}{3},\\,-\\frac{1}{3},\\,1\\right)$$" + ], + "text/plain": [ + "(1, -1/3, -1/3, 1)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(1,\\,-3,\\,1,\\,-3\\right)$$" + ], + "text/plain": [ + "(1, -3, 1, -3)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(1,\\,1,\\,-3,\\,-3\\right)$$" + ], + "text/plain": [ + "(1, 1, -3, -3)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "S1 = matrix([\n", + " [1, 0, 3, 3],\n", + " [0, 1, 3, 3],\n", + " [0, 0, 0, -1],\n", + " [0, 0, -1, 0]\n", + "]).transpose()\n", + "S2 = matrix([\n", + " [1, 3, 0, 3],\n", + " [0, 0, 0, -1],\n", + " [0, 3, 1, 3],\n", + " [0, -1, 0, 0]\n", + "]).transpose()\n", + "S3 = matrix([\n", + " [0, 0, 0, -1],\n", + " [3, 1, 0, 3],\n", + " [3, 0, 1, 3],\n", + " [-1, 0, 0, 0]\n", + "]).transpose()\n", + "S4 = matrix([\n", + " [1, 3, 3, 0],\n", + " [0, 0, -1, 0],\n", + " [0, -1, 0, 0],\n", + " [0, 3, 3, 1]\n", + "]).transpose()\n", + "S5 = matrix([\n", + " [0, 0, -1, 0],\n", + " [3, 1, 3, 0],\n", + " [-1, 0, 0, 0],\n", + " [3, 0, 3, 1]\n", + "]).transpose()\n", + "S6 = matrix([\n", + " [0, -1, 0, 0],\n", + " [-1, 0, 0, 0],\n", + " [3, 3, 1, 0],\n", + " [3, 3, 0, 1]\n", + "]).transpose()\n", + "\n", + "for mat in [S1, S2, S3, S4, S5, S6]:\n", + " for eigvec in mat.eigenvectors_left():\n", + " if (eigvec[0] == -1):\n", + " show(eigvec[1][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{1} = b_{1}, b_{2} = b_{2}, b_{3} = b_{3}, b_{4} = b_{4}, b_{5} = \\frac{1}{2} \\, b_{1} + \\frac{1}{2} \\, b_{2} + \\frac{1}{2} \\, b_{3} - \\frac{1}{2} \\, b_{4}, b_{6} = \\frac{1}{2} \\, b_{1} + \\frac{1}{2} \\, b_{2} - \\frac{1}{2} \\, b_{3} + \\frac{1}{2} \\, b_{4}, b_{7} = \\frac{1}{2} \\, b_{1} - \\frac{1}{2} \\, b_{2} + \\frac{1}{2} \\, b_{3} + \\frac{1}{2} \\, b_{4}, b_{8} = -\\frac{1}{2} \\, b_{1} + \\frac{1}{2} \\, b_{2} + \\frac{1}{2} \\, b_{3} + \\frac{1}{2} \\, b_{4}\\right]$$" + ], + "text/plain": [ + "[b1 == b1,\n", + " b2 == b2,\n", + " b3 == b3,\n", + " b4 == b4,\n", + " b5 == 1/2*b1 + 1/2*b2 + 1/2*b3 - 1/2*b4,\n", + " b6 == 1/2*b1 + 1/2*b2 - 1/2*b3 + 1/2*b4,\n", + " b7 == 1/2*b1 - 1/2*b2 + 1/2*b3 + 1/2*b4,\n", + " b8 == -1/2*b1 + 1/2*b2 + 1/2*b3 + 1/2*b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[b_{5}, b_{6}, b_{7}, b_{8}\\right]$$" + ], + "text/plain": [ + "[b5, b6, b7, b8]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[2 \\, b_{1} = 2 \\, b_{1}, 2 \\, b_{2} = 2 \\, b_{2}, 2 \\, b_{3} = 2 \\, b_{3}, 2 \\, b_{4} = 2 \\, b_{4}, 2 \\, b_{5} = b_{1} + b_{2} + b_{3} - b_{4}, 2 \\, b_{6} = b_{1} + b_{2} - b_{3} + b_{4}, 2 \\, b_{7} = b_{1} - b_{2} + b_{3} + b_{4}, 2 \\, b_{8} = -b_{1} + b_{2} + b_{3} + b_{4}\\right]$$" + ], + "text/plain": [ + "[2*b1 == 2*b1,\n", + " 2*b2 == 2*b2,\n", + " 2*b3 == 2*b3,\n", + " 2*b4 == 2*b4,\n", + " 2*b5 == b1 + b2 + b3 - b4,\n", + " 2*b6 == b1 + b2 - b3 + b4,\n", + " 2*b7 == b1 - b2 + b3 + b4,\n", + " 2*b8 == -b1 + b2 + b3 + b4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrr}\n", + "\\frac{5}{4} & -\\frac{3}{4} & -\\frac{3}{4} & -\\frac{3}{4} \\\\\n", + "-\\frac{3}{4} & \\frac{5}{4} & -\\frac{3}{4} & -\\frac{3}{4} \\\\\n", + "-\\frac{3}{4} & -\\frac{3}{4} & \\frac{5}{4} & -\\frac{3}{4} \\\\\n", + "-\\frac{3}{4} & -\\frac{3}{4} & -\\frac{3}{4} & \\frac{5}{4}\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 5/4 -3/4 -3/4 -3/4]\n", + "[-3/4 5/4 -3/4 -3/4]\n", + "[-3/4 -3/4 5/4 -3/4]\n", + "[-3/4 -3/4 -3/4 5/4]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\frac{5}{4} \\, b_{1}^{2} - \\frac{3}{2} \\, b_{1} b_{2} + \\frac{5}{4} \\, b_{2}^{2} - \\frac{3}{2} \\, b_{1} b_{3} - \\frac{3}{2} \\, b_{2} b_{3} + \\frac{5}{4} \\, b_{3}^{2} - \\frac{3}{2} \\, b_{1} b_{4} - \\frac{3}{2} \\, b_{2} b_{4} - \\frac{3}{2} \\, b_{3} b_{4} + \\frac{5}{4} \\, b_{4}^{2}$$" + ], + "text/plain": [ + "5/4*b1^2 - 3/2*b1*b2 + 5/4*b2^2 - 3/2*b1*b3 - 3/2*b2*b3 + 5/4*b3^2 - 3/2*b1*b4 - 3/2*b2*b4 - 3/2*b3*b4 + 5/4*b4^2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left[\\left(\\begin{array}{rrrr}\n", + "-1 & \\frac{6}{5} & \\frac{6}{5} & \\frac{6}{5} \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "\\frac{6}{5} & -1 & \\frac{6}{5} & \\frac{6}{5} \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "\\frac{6}{5} & \\frac{6}{5} & -1 & \\frac{6}{5} \\\\\n", + "0 & 0 & 0 & 1\n", + "\\end{array}\\right), \\left(\\begin{array}{rrrr}\n", + "1 & 0 & 0 & 0 \\\\\n", + "0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 \\\\\n", + "\\frac{6}{5} & \\frac{6}{5} & \\frac{6}{5} & -1\n", + "\\end{array}\\right)\\right]$$" + ], + "text/plain": [ + "[\n", + "[ -1 6/5 6/5 6/5] [ 1 0 0 0] [ 1 0 0 0]\n", + "[ 0 1 0 0] [6/5 -1 6/5 6/5] [ 0 1 0 0]\n", + "[ 0 0 1 0] [ 0 0 1 0] [6/5 6/5 -1 6/5]\n", + "[ 0 0 0 1], [ 0 0 0 1], [ 0 0 0 1],\n", + "\n", + "[ 1 0 0 0]\n", + "[ 0 1 0 0]\n", + "[ 0 0 1 0]\n", + "[6/5 6/5 6/5 -1]\n", + "]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# cubical\n", + "Wc = matrix([\n", + " [4, 0, 0, 1],\n", + " [0, 2, 0, 1],\n", + " [2, 1, -sqrt(2), -1],\n", + " [2, 1, sqrt(2), -1],\n", + " [2, 1, -sqrt(2), 1],\n", + " [2, 1, sqrt(2), 1],\n", + " [4, 0, 0, -1],\n", + " [0, 2, 0, -1],\n", + "])\n", + "relation, mat, equation = linear_relations_and_quadratic_form_from_wtpw(Wc * P * Wc.transpose(), [1, 2, 3, 4, 5, 6, 7, 8])\n", + "show([2 * eq for eq in relation])\n", + "show(8 * mat)\n", + "show(8 * equation)\n", + "show(weyl_generators(mat, standard_basis(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}-\\frac{1}{2 \\, {\\left(2 \\, \\sqrt{6} - 5\\right)}}$$" + ], + "text/plain": [ + "-1/2/(2*sqrt(6) - 5)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def abbc_coords_3d(b, h1, h2, h3):\n", + " return (1-h1^2-h2^2-h3^2)/b\n", + "\n", + "show(simplify(abbc_coords_3d(10-4*sqrt(6), 0, 0, 0)))" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrr}\n", + "-\\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\sqrt{6} + \\frac{5}{2} \\\\\n", + "1 & 1 & 1 & 1 & -4 \\, \\sqrt{6} + 10 \\\\\n", + "1 & -1 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 1 & -1 & 0 \\\\\n", + "-\\frac{1}{2} \\, \\sqrt{2} & -\\frac{1}{2} \\, \\sqrt{2} & \\frac{1}{2} \\, \\sqrt{2} & \\frac{1}{2} \\, \\sqrt{2} & 0\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ -1/2 -1/2 -1/2 -1/2 sqrt(6) + 5/2]\n", + "[ 1 1 1 1 -4*sqrt(6) + 10]\n", + "[ 1 -1 0 0 0]\n", + "[ 0 0 1 -1 0]\n", + "[ -1/2*sqrt(2) -1/2*sqrt(2) 1/2*sqrt(2) 1/2*sqrt(2) 0]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "W = matrix([\n", + " [-1/2, -1/2, -1/2, -1/2, 5/2+sqrt(6)],\n", + " [1, 1, 1, 1, 10-4*sqrt(6)],\n", + " [1, -1, 0, 0, 0],\n", + " [0, 0, 1, -1, 0],\n", + " [-1/sqrt(2), -1/sqrt(2), 1/sqrt(2), 1/sqrt(2), 0]\n", + "])\n", + "show(W)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrr}\n", + "0 & -\\frac{1}{2} & 0 & 0 & 0 \\\\\n", + "-\\frac{1}{2} & 0 & 0 & 0 & 0 \\\\\n", + "0 & 0 & 1 & 0 & 0 \\\\\n", + "0 & 0 & 0 & 1 & 0 \\\\\n", + "0 & 0 & 0 & 0 & 1\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 0 -1/2 0 0 0]\n", + "[-1/2 0 0 0 0]\n", + "[ 0 0 1 0 0]\n", + "[ 0 0 0 1 0]\n", + "[ 0 0 0 0 1]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "P = matrix([\n", + " [0, -1/2, 0, 0, 0],\n", + " [-1/2, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0],\n", + " [0, 0, 0, 1, 0],\n", + " [0, 0, 0, 0, 1]\n", + "])\n", + "show(P)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrr}\n", + "2 & 0 & 0 & 0 & -\\frac{3}{2} \\, \\sqrt{6} + \\frac{5}{4} \\\\\n", + "0 & 2 & 0 & 0 & -\\frac{3}{2} \\, \\sqrt{6} + \\frac{5}{4} \\\\\n", + "0 & 0 & 2 & 0 & -\\frac{3}{2} \\, \\sqrt{6} + \\frac{5}{4} \\\\\n", + "0 & 0 & 0 & 2 & -\\frac{3}{2} \\, \\sqrt{6} + \\frac{5}{4} \\\\\n", + "-\\frac{3}{2} \\, \\sqrt{6} + \\frac{5}{4} & -\\frac{3}{2} \\, \\sqrt{6} + \\frac{5}{4} & -\\frac{3}{2} \\, \\sqrt{6} + \\frac{5}{4} & -\\frac{3}{2} \\, \\sqrt{6} + \\frac{5}{4} & {\\left(2 \\, \\sqrt{6} + 5\\right)} {\\left(2 \\, \\sqrt{6} - 5\\right)}\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 2 0 0 0 -3/2*sqrt(6) + 5/4]\n", + "[ 0 2 0 0 -3/2*sqrt(6) + 5/4]\n", + "[ 0 0 2 0 -3/2*sqrt(6) + 5/4]\n", + "[ 0 0 0 2 -3/2*sqrt(6) + 5/4]\n", + "[ -3/2*sqrt(6) + 5/4 -3/2*sqrt(6) + 5/4 -3/2*sqrt(6) + 5/4 -3/2*sqrt(6) + 5/4 (2*sqrt(6) + 5)*(2*sqrt(6) - 5)]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show(W.transpose() * P * W)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrrrrrrrrrrrrr}\n", + "1 & -1 & -1 & -3 & -1 & -3 & -3 & -5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 \\\\\n", + "-1 & 1 & -3 & -1 & -3 & -1 & -5 & -3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 \\\\\n", + "-1 & -3 & 1 & -1 & -3 & -5 & -1 & -3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 \\\\\n", + "-3 & -1 & -1 & 1 & -5 & -3 & -3 & -1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 \\\\\n", + "-1 & -3 & -3 & -5 & 1 & -1 & -1 & -3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 \\\\\n", + "-3 & -1 & -5 & -3 & -1 & 1 & -3 & -1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 \\\\\n", + "-3 & -5 & -1 & -3 & -1 & -3 & 1 & -1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 \\\\\n", + "-5 & -3 & -3 & -1 & -3 & -1 & -1 & 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & 1 & -1 & -1 & -3 & -1 & -3 & -3 & -5 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -1 & 1 & -3 & -1 & -3 & -1 & -5 & -3 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -1 & -3 & 1 & -1 & -3 & -5 & -1 & -3 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -3 & -1 & -1 & 1 & -5 & -3 & -3 & -1 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -1 & -3 & -3 & -5 & 1 & -1 & -1 & -3 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -3 & -1 & -5 & -3 & -1 & 1 & -3 & -1 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -3 & -5 & -1 & -3 & -1 & -3 & 1 & -1 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -5 & -3 & -3 & -1 & -3 & -1 & -1 & 1\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 1 -1 -1 -3 -1 -3 -3 -5 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5]\n", + "[ -1 1 -3 -1 -3 -1 -5 -3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3]\n", + "[ -1 -3 1 -1 -3 -5 -1 -3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3]\n", + "[ -3 -1 -1 1 -5 -3 -3 -1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1]\n", + "[ -1 -3 -3 -5 1 -1 -1 -3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3]\n", + "[ -3 -1 -5 -3 -1 1 -3 -1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1]\n", + "[ -3 -5 -1 -3 -1 -3 1 -1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1]\n", + "[ -5 -3 -3 -1 -3 -1 -1 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 1 -1 -1 -3 -1 -3 -3 -5]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -1 1 -3 -1 -3 -1 -5 -3]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -1 -3 1 -1 -3 -5 -1 -3]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -3 -1 -1 1 -5 -3 -3 -1]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -1 -3 -3 -5 1 -1 -1 -3]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -3 -1 -5 -3 -1 1 -3 -1]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -3 -5 -1 -3 -1 -3 1 -1]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -5 -3 -3 -1 -3 -1 -1 1]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bt = 2 * (2 + sqrt(3))\n", + "b = 1 / (2 + sqrt(3))\n", + "\n", + "W = matrix([\n", + " [2, 2, 2, 2, 2, 2, 2, 2, bt, bt, bt, bt, bt, bt, bt, bt],\n", + " [1, 1, 1, 1, 1, 1, 1, 1, b, b, b, b, b, b, b, b],\n", + " [1, 1, 1, 1, -1, -1, -1, -1] * 2,\n", + " [1, 1, -1, -1, 1, 1, -1, -1] * 2,\n", + " [1, -1, 1, -1, 1, -1, 1, -1] * 2\n", + "])\n", + "\n", + "show(W.transpose() * P * W)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "SageMath 9.3", + "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.6" + }, + "name": "Apollonian Circle Packings.ipynb" + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/old_stuff/Apollonian Circle Packings.ipynb b/old_stuff/Apollonian Circle Packings.ipynb index a2f52bf..817ef9b 100644 --- a/old_stuff/Apollonian Circle Packings.ipynb +++ b/old_stuff/Apollonian Circle Packings.ipynb @@ -621,7 +621,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 63, "metadata": { "scrolled": true }, @@ -631,26 +631,20 @@ "output_type": "stream", "text": [ "(1/2*sqrt(2), 1)\n", - "sqrt(2)\n" + "sqrt(2)\n", + "(1/4*sqrt(2), 0)\n", + "2*sqrt(2)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "Graphics object consisting of 4 graphics primitives" + "Graphics object consisting of 14 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1/4*sqrt(2), 0)\n", - "2*sqrt(2)\n" - ] } ], "source": [ @@ -682,7 +676,7 @@ "bnew = coordsnew[0]\n", "btest.append(circle((coordsnew[2]/bnew, coordsnew[3]/bnew), 1/bnew))\n", "\n", - "show(sum(btest))\n", + "#show(sum(btest))\n", "\n", "b3 = circle(( x, y), r, rgbcolor=(1, 0, 0))\n", "b4 = circle((-x, y), r, rgbcolor=(1, 0, 0))\n", @@ -696,7 +690,7 @@ "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)" + "show(c1 + c2 + c3 + c4 + c5 + c6 + b1 + b2 + b3 + b4 + b5 + b6 + b7 + b8)" ] }, { @@ -2062,7 +2056,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "Graphics object consisting of 14 graphics primitives" ] @@ -3285,7 +3279,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 58, "metadata": {}, "outputs": [ { @@ -3313,7 +3307,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 59, "metadata": {}, "outputs": [ { @@ -3362,7 +3356,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 60, "metadata": {}, "outputs": [ { @@ -3410,7 +3404,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 61, "metadata": {}, "outputs": [ { @@ -3451,22 +3445,72 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 62, "metadata": {}, "outputs": [ { - "ename": "AttributeError", - "evalue": "'sage.matrix.matrix_symbolic_dense.Matrix_symbolic_dense' object has no attribute 'full_simplify'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 10\u001b[0m ])\n\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mW\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mP\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mW\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfull_simplify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/usr/lib/python3.9/site-packages/sage/structure/element.pyx\u001b[0m in \u001b[0;36msage.structure.element.Element.__getattr__ (build/cythonized/sage/structure/element.c:4716)\u001b[0;34m()\u001b[0m\n\u001b[1;32m 491\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'LeftZeroSemigroup_with_category.element_class'\u001b[0m \u001b[0mobject\u001b[0m \u001b[0mhas\u001b[0m \u001b[0mno\u001b[0m \u001b[0mattribute\u001b[0m \u001b[0;34m'blah_blah'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 492\u001b[0m \"\"\"\n\u001b[0;32m--> 493\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetattr_from_category\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 494\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[0mcdef\u001b[0m \u001b[0mgetattr_from_category\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/lib/python3.9/site-packages/sage/structure/element.pyx\u001b[0m in \u001b[0;36msage.structure.element.Element.getattr_from_category (build/cythonized/sage/structure/element.c:4828)\u001b[0;34m()\u001b[0m\n\u001b[1;32m 504\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 505\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mP\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_abstract_element_class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 506\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgetattr_from_other_class\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 507\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 508\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__dir__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/lib/python3.9/site-packages/sage/cpython/getattr.pyx\u001b[0m in \u001b[0;36msage.cpython.getattr.getattr_from_other_class (build/cythonized/sage/cpython/getattr.c:2625)\u001b[0;34m()\u001b[0m\n\u001b[1;32m 370\u001b[0m \u001b[0mdummy_error_message\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 371\u001b[0m \u001b[0mdummy_error_message\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 372\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdummy_error_message\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 373\u001b[0m \u001b[0mattribute\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m<\u001b[0m\u001b[0mobject\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0mattr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 374\u001b[0m \u001b[0;31m# Check for a descriptor (__get__ in Python)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAttributeError\u001b[0m: 'sage.matrix.matrix_symbolic_dense.Matrix_symbolic_dense' object has no attribute 'full_simplify'" - ] + "data": { + "text/html": [ + "" + ], + "text/latex": [ + "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrrrrrrrrrrrrr}\n", + "1 & -1 & -1 & -3 & -1 & -3 & -3 & -5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 \\\\\n", + "-1 & 1 & -3 & -1 & -3 & -1 & -5 & -3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 \\\\\n", + "-1 & -3 & 1 & -1 & -3 & -5 & -1 & -3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 \\\\\n", + "-3 & -1 & -1 & 1 & -5 & -3 & -3 & -1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 \\\\\n", + "-1 & -3 & -3 & -5 & 1 & -1 & -1 & -3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 \\\\\n", + "-3 & -1 & -5 & -3 & -1 & 1 & -3 & -1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 \\\\\n", + "-3 & -5 & -1 & -3 & -1 & -3 & 1 & -1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 \\\\\n", + "-5 & -3 & -3 & -1 & -3 & -1 & -1 & 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & 1 & -1 & -1 & -3 & -1 & -3 & -3 & -5 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -1 & 1 & -3 & -1 & -3 & -1 & -5 & -3 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -1 & -3 & 1 & -1 & -3 & -5 & -1 & -3 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -3 & -1 & -1 & 1 & -5 & -3 & -3 & -1 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -1 & -3 & -3 & -5 & 1 & -1 & -1 & -3 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -3 & -1 & -5 & -3 & -1 & 1 & -3 & -1 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -3 & -5 & -1 & -3 & -1 & -3 & 1 & -1 \\\\\n", + "-\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 5 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 3 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} - 1 & -\\sqrt{3} - \\frac{1}{\\sqrt{3} + 2} + 1 & -5 & -3 & -3 & -1 & -3 & -1 & -1 & 1\n", + "\\end{array}\\right)$$" + ], + "text/plain": [ + "[ 1 -1 -1 -3 -1 -3 -3 -5 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5]\n", + "[ -1 1 -3 -1 -3 -1 -5 -3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3]\n", + "[ -1 -3 1 -1 -3 -5 -1 -3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3]\n", + "[ -3 -1 -1 1 -5 -3 -3 -1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1]\n", + "[ -1 -3 -3 -5 1 -1 -1 -3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3]\n", + "[ -3 -1 -5 -3 -1 1 -3 -1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1]\n", + "[ -3 -5 -1 -3 -1 -3 1 -1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1]\n", + "[ -5 -3 -3 -1 -3 -1 -1 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 1 -1 -1 -3 -1 -3 -3 -5]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -1 1 -3 -1 -3 -1 -5 -3]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -1 -3 1 -1 -3 -5 -1 -3]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -3 -1 -1 1 -5 -3 -3 -1]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -1 -3 -3 -5 1 -1 -1 -3]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -3 -1 -5 -3 -1 1 -3 -1]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -3 -5 -1 -3 -1 -3 1 -1]\n", + "[-sqrt(3) - 1/(sqrt(3) + 2) - 5 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 3 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) - 1 -sqrt(3) - 1/(sqrt(3) + 2) + 1 -5 -3 -3 -1 -3 -1 -1 1]" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -3501,7 +3545,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.9.6" }, "name": "Apollonian Circle Packings.ipynb" },