{
"cells": [
{
"cell_type": "markdown",
"id": "3eecf8a2-f230-4b87-8772-49d72eb96672",
"metadata": {},
"source": [
"SageDays 129: SageMath Introduction
\n",
"\n",
"SageMath is an open source software that combines numerous other open source software packages into a common interface and language built on the widely used and popular Python (ver3). It can perform computations that are useful for a variety of purposes in both teaching and research.\n",
"\n",
"In this introduction, we will demonstrate some basic features of SageMath using the Jupyter notebook interface. (There is also a commandline interace that is essentially the same.)\n",
"\n",
"If you have any questions, please feel free to ask at any time.\n",
"\n",
"We will begin with some basic computations, demonstrating SageMath's basic abilities to be used to perform standard calculations in arithmetic, linear algebra, and calculus."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "8f4eb78c-e032-4e8d-8236-88151f491bc8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2+2"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "a2ca42f8-0608-4a09-ad59-c2a48c74e9f8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"81"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3^4"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "b1bd2948-4c19-488e-b4ad-d9e3158bc8c1",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3628800"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"factorial(10)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "c41dbfc6-a2b8-4b6d-9810-517fdae4c040",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"factorial(100)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "ccf6983a-cd26-4e9a-92f2-26396a64ff40",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"factorial(1000)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "a6445906-dba2-4b56-9b56-1d264a733625",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2^8 * 3^4 * 5^2 * 7"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"factor(factorial(10))"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "51e3bc60-c794-48bf-91e7-d78d9c9eaed4",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1 2]\n",
"[3 4]"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"M = matrix([[1,2],[3,4]])\n",
"M"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "903e993c-0bd3-426d-8e33-dbe6349ff3e9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-2"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"M.det()"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "4da57a93-f4a7-403a-a262-a7cafcc6b1bf",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(-0.3722813232690144?, [(1, -0.6861406616345072?)], 1),\n",
" (5.372281323269015?, [(1, 2.186140661634508?)], 1)]"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"M.eigenvectors_right()"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "7adec041-4552-4346-9c28-ef3057823dd8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"x*cos(x)*e^(-x) + x^2*e^(-x)*sin(x)/(x + 3)"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = SR.var('x')\n",
"f = x^2*e^-x/(x+3) * sin(x) + x * e^-x * cos(x)\n",
"f"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "8598b693-605d-42a9-9187-7d7b2bb889e2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-x*cos(x)*e^(-x) + x^2*cos(x)*e^(-x)/(x + 3) - x*e^(-x)*sin(x) - x^2*e^(-x)*sin(x)/(x + 3) + cos(x)*e^(-x) + 2*x*e^(-x)*sin(x)/(x + 3) - x^2*e^(-x)*sin(x)/(x + 3)^2"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"f.derivative(x)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "e6bc6b22-5169-41ac-9a91-f2230cf6557a",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"Graphics object consisting of 1 graphics primitive"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plot(f, [x, 0, 10])"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "68c2aee1-5bf9-4e88-bd1a-70aa12827187",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(x - y)/(x^2 + y^2 + 1)"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y = SR.var('y')\n",
"g = (x - y) / (x^2 + y^2 + 1)\n",
"g"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "67724cc7-cd5d-435c-901c-70a1df63ee9e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(-2*(x - y)*x/(x^2 + y^2 + 1)^2 + 1/(x^2 + y^2 + 1), -2*(x - y)*y/(x^2 + y^2 + 1)^2 - 1/(x^2 + y^2 + 1))"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.gradient()"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "c3eda9c0-bdc1-40fd-8820-152abf0e6b88",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[-(x^2 - 2*x*y - y^2 - 1)/(x^2 + y^2 + 1)^2,\n",
" -(x^2 + 2*x*y - y^2 + 1)/(x^2 + y^2 + 1)^2]"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[gf.factor() for gf in g.gradient()]"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "33e34211-22fd-4c4f-bc6a-9ab9f0a34bb9",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n"
],
"text/plain": [
"Graphics3d Object"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"plot3d(g, [x, -2, 2], [y, -2, 2], mesh=True)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "51b031db-7a54-4b9a-abad-597f201b464c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-8*(x^4 + 2*x^2*y^2 + y^4 - x^2 + 4*x*y - y^2)/(x^2 + y^2 + 1)^5"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.hessian().det().factor()"
]
},
{
"cell_type": "markdown",
"id": "f7fc0541-5acb-4592-8c69-4a3382d1a3d9",
"metadata": {},
"source": [
"We can also display the output using latex"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "26b156a5-2498-40c4-9994-c00743783ae3",
"metadata": {},
"outputs": [],
"source": [
"%display latex"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "1a58e393-e50d-467d-b74f-ee5621845ea2",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\\(\\displaystyle \\left(\\begin{array}{rr}\n",
"1 & 2 \\\\\n",
"3 & 4\n",
"\\end{array}\\right)\\)"
],
"text/latex": [
"$\\displaystyle \\left(\\begin{array}{rr}\n",
"1 & 2 \\\\\n",
"3 & 4\n",
"\\end{array}\\right)$"
],
"text/plain": [
"[1 2]\n",
"[3 4]"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"M"
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "052b6e69-2833-4e34-b4ee-53199f6bdc6c",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\\(\\displaystyle -\\frac{8 \\, {\\left(x^{4} + 2 \\, x^{2} y^{2} + y^{4} - x^{2} + 4 \\, x y - y^{2}\\right)}}{{\\left(x^{2} + y^{2} + 1\\right)}^{5}}\\)"
],
"text/latex": [
"$\\displaystyle -\\frac{8 \\, {\\left(x^{4} + 2 \\, x^{2} y^{2} + y^{4} - x^{2} + 4 \\, x y - y^{2}\\right)}}{{\\left(x^{2} + y^{2} + 1\\right)}^{5}}$"
],
"text/plain": [
"-8*(x^4 + 2*x^2*y^2 + y^4 - x^2 + 4*x*y - y^2)/(x^2 + y^2 + 1)^5"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.hessian().det().factor()"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "4b4c786c-ba61-446f-8c7c-50199535c2cd",
"metadata": {},
"outputs": [],
"source": [
"%display plain # revert back to normal display"
]
},
{
"cell_type": "markdown",
"id": "58477ed5-8dcc-4dd0-9228-faad413e8bc6",
"metadata": {},
"source": [
"SageMath also can make interactive plots that can be useful for teaching. For more examples, please see:\n",
"\n",
"- https://wiki.sagemath.org/interact/\n",
"- https://wiki.sagemath.org/interact/graphics"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "125ffd6d-681d-4aa4-8ef0-4f6e87f18ca6",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "d814b7f9af714ef19d9c50ce5d49a409",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"Interactive function with 1 widget\n",
" order: SelectionSlider(description='order', options=(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), value=1)"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = SR.var('x')\n",
"x0 = 0\n",
"f = sin(x) * e^(-x)\n",
"p = plot(f, -1, 5, thickness=2)\n",
"dot = point((x0, f(x=x0)), pointsize=80, rgbcolor=(1, 0, 0))\n",
"\n",
"@interact\n",
"def _(order=slider([1 .. 12])):\n",
" ft = f.taylor(x, x0, order)\n",
" pt = plot(ft, -1, 5, color='green', thickness=2)\n",
" pretty_print(html(r'$f(x)\\;=\\;%s$' % latex(f)))\n",
" pretty_print(html(r'$\\hat{f}(x;%s)\\;=\\;%s+\\mathcal{O}(x^{%s})$' % (x0, latex(ft), order+1)))\n",
" show(dot + p + pt, ymin=-.5, ymax=1)"
]
},
{
"cell_type": "markdown",
"id": "5c5becbb-c871-4ba7-9f9e-737d81338e47",
"metadata": {},
"source": [
"Python, and hence SageMath, cares about what type of object you are working with. (This is called the *class* of the instance.) So they can have different behaviors (e.g., nontrivial primes over $\\mathbb{Z}$ exist but not over $\\mathbb{Q}$). However, SageMath works behind the scenes to minimize the amount of work you need to do in order to perform arithmetic operations. (This is called *coercion*.) However, you can explicitly cast objects when needed, as in this example with polynomials."
]
},
{
"cell_type": "code",
"execution_count": 28,
"id": "48cc93e8-1c68-407d-aff6-d2381bbdbfb7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(15) * (x + 1)"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"R. = QQ[]\n",
"p = (x+1)*15\n",
"p.factor()"
]
},
{
"cell_type": "code",
"execution_count": 29,
"id": "6c85ff7e-25f1-408d-9f76-1ca53c8ccfa5",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Univariate Polynomial Ring in x over Rational Field"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"parent(p)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"id": "e672f3f0-5c2d-48c9-85c7-59e1ea275d5b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Univariate Polynomial Ring in x over Rational Field"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"parent(p / 15)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "870e6677-8672-4d7a-a4ec-7dce88b5fa5c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Fraction Field of Univariate Polynomial Ring in x over Rational Field"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"parent(p / (x + 1))"
]
},
{
"cell_type": "code",
"execution_count": 32,
"id": "c451128a-bbbb-4248-b96f-a2dbbdb7b9b9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"15"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(p / (x + 1)).factor()"
]
},
{
"cell_type": "code",
"execution_count": 33,
"id": "d65fd682-7714-42b0-a2ca-b464b55f064b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3 * 5"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ZZ(p / (x + 1)).factor()"
]
},
{
"cell_type": "markdown",
"id": "b6c6df8e-40e9-4f46-b38b-9ab5dd1724b8",
"metadata": {},
"source": [
"SageMath has an extensive documentation about (almost) all of the functions and features, as well as a number of specific tutorials available on its website (many available in different languages, but not the reference manual):\n",
"\n",
"- https://doc.sagemath.org/\n",
"- https://doc.sagemath.org/html/en/reference/index.html\n",
"\n",
"This is great if you already know that SageMath has a feature and how to use it. Most of the time you might not know what the command is or how to use it. While you can find it in the documentation, this can be annoying and cumbersome to do. Instead, SageMath provides a way to do it by using **tab completion** and the ``?`` command. "
]
},
{
"cell_type": "code",
"execution_count": 34,
"id": "a4d84877-a86d-44bd-9f09-33f98fd89fc2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\u001b[0;31mSignature:\u001b[0m \u001b[0mfactor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mproof\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint_\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malgorithm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'pari'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mDocstring:\u001b[0m \n",
" Return the factorization of \"n\". The result depends on the type of\n",
" \"n\".\n",
"\n",
" If \"n\" is an integer, returns the factorization as an object of\n",
" type \"Factorization\".\n",
"\n",
" If \"n\" is not an integer, \"n.factor(proof=proof, **kwds)\" gets\n",
" called. See \"n.factor??\" for more documentation in this case.\n",
"\n",
" Warning:\n",
"\n",
" This means that applying \"factor()\" to an integer result of a\n",
" symbolic computation will not factor the integer, because it is\n",
" considered as an element of a larger symbolic ring.EXAMPLES:\n",
"\n",
" sage: f(n) = n^2\n",
" sage: is_prime(f(3))\n",
" False\n",
" sage: factor(f(3))\n",
" 9\n",
"\n",
" INPUT:\n",
"\n",
" * \"n\" -- nonzero integer\n",
"\n",
" * \"proof\" -- boolean or \"None\" (default: \"None\")\n",
"\n",
" * \"int_\" -- boolean (default: \"False\"); whether to return answers\n",
" as Python integers\n",
"\n",
" * \"algorithm\" -- string\n",
"\n",
" * \"'pari'\" -- (default) use the PARI C library\n",
"\n",
" * \"'kash'\" -- use KASH computer algebra system (requires that\n",
" kash be installed)\n",
"\n",
" * \"'magma'\" -- use Magma (requires magma be installed)\n",
"\n",
" * \"verbose\" -- integer (default: 0); PARI's debug variable is set\n",
" to this. E.g., set to 4 or 8 to see lots of output during\n",
" factorization.\n",
"\n",
" OUTPUT: factorization of n\n",
"\n",
" The qsieve and ecm commands give access to highly optimized\n",
" implementations of algorithms for doing certain integer\n",
" factorization problems. These implementations are not used by the\n",
" generic \"factor()\" command, which currently just calls PARI (note\n",
" that PARI also implements sieve and ecm algorithms, but they are\n",
" not as optimized). Thus you might consider using them instead for\n",
" certain numbers.\n",
"\n",
" The factorization returned is an element of the class\n",
" \"Factorization\"; use \"Factorization??\" to see more details, and\n",
" examples below for usage. A \"Factorization\" contains both the unit\n",
" factor (+1 or -1) and a sorted list of \"(prime, exponent)\" pairs.\n",
"\n",
" The factorization displays in pretty-print format but it is easy to\n",
" obtain access to the \"(prime, exponent)\" pairs and the unit, to\n",
" recover the number from its factorization, and even to multiply two\n",
" factorizations. See examples below.\n",
"\n",
" EXAMPLES:\n",
"\n",
" sage: factor(500)\n",
" 2^2 * 5^3\n",
" sage: factor(-20)\n",
" -1 * 2^2 * 5\n",
" sage: f=factor(-20)\n",
" sage: list(f)\n",
" [(2, 2), (5, 1)]\n",
" sage: f.unit()\n",
" -1\n",
" sage: f.value()\n",
" -20\n",
" sage: factor(-next_prime(10^2) * next_prime(10^7))\n",
" -1 * 101 * 10000019\n",
"\n",
" sage: factor(293292629867846432923017396246429, algorithm='flint')\n",
" 3 * 4852301647696687 * 20148007492971089\n",
"\n",
" sage: factor(-500, algorithm='kash')\n",
" -1 * 2^2 * 5^3\n",
"\n",
" sage: factor(-500, algorithm='magma') # optional - magma\n",
" -1 * 2^2 * 5^3\n",
"\n",
" sage: factor(0)\n",
" Traceback (most recent call last):\n",
" ...\n",
" ArithmeticError: factorization of 0 is not defined\n",
" sage: factor(1)\n",
" 1\n",
" sage: factor(-1)\n",
" -1\n",
" sage: factor(2^(2^7) + 1)\n",
" 59649589127497217 * 5704689200685129054721\n",
"\n",
" Sage calls PARI's\n",
" https://pari.math.u-bordeaux.fr/dochtml/help/factor, which has\n",
" \"proof=False\" by default. Sage has a global proof flag, set to\n",
" \"True\" by default (see \"sage.structure.proof.proof\", or use\n",
" \"proof.[tab]\"). To override the default, call this function with\n",
" \"proof=False\".\n",
"\n",
" sage: factor(3^89 - 1, proof=False)\n",
" 2 * 179 * 1611479891519807 * 5042939439565996049162197\n",
"\n",
" sage: factor(2^197 + 1) # long time\n",
" 3 * 197002597249 * 1348959352853811313 * 251951573867253012259144010843\n",
"\n",
" Any object which has a factor method can be factored like this:\n",
"\n",
" sage: K. = QuadraticField(-1)\n",
" sage: f = factor(122 - 454*i); f\n",
" (-1) * (i - 1)^3 * (2*i - 1)^3 * (3*i + 2) * (i + 4)\n",
"\n",
" To access the data in a factorization:\n",
"\n",
" sage: f = factor(420); f\n",
" 2^2 * 3 * 5 * 7\n",
" sage: [x for x in f]\n",
" [(2, 2), (3, 1), (5, 1), (7, 1)]\n",
" sage: [p for p, e in f]\n",
" [2, 3, 5, 7]\n",
" sage: [e for p, e in f]\n",
" [2, 1, 1, 1]\n",
" sage: [p^e for p, e in f]\n",
" [4, 3, 5, 7]\n",
"\n",
" We can factor Python, numpy and gmpy2 numbers:\n",
"\n",
" sage: factor(math.pi)\n",
" 3.141592653589793\n",
" sage: import numpy\n",
" sage: factor(numpy.int8(30))\n",
" 2 * 3 * 5\n",
" sage: import gmpy2\n",
" sage: factor(gmpy2.mpz(30))\n",
" 2 * 3 * 5\n",
"\u001b[0;31mInit docstring:\u001b[0m Initialize self. See help(type(self)) for accurate signature.\n",
"\u001b[0;31mFile:\u001b[0m ~/sage/src/sage/arith/misc.py\n",
"\u001b[0;31mType:\u001b[0m function"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"factor?"
]
},
{
"cell_type": "code",
"execution_count": 35,
"id": "c2903a66-8d10-4412-a0b0-0e1ea63acfd0",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\u001b[0;31mType:\u001b[0m Polynomial_rational_flint\n",
"\u001b[0;31mString form:\u001b[0m 15*x + 15\n",
"\u001b[0;31mFile:\u001b[0m ~/sage/src/sage/rings/polynomial/polynomial_rational_flint.pyx\n",
"\u001b[0;31mDocstring:\u001b[0m \n",
" Univariate polynomials over the rationals, implemented via FLINT.\n",
"\n",
" Internally, we represent rational polynomial as the quotient of an\n",
" integer polynomial and a positive denominator which is coprime to\n",
" the content of the numerator.\n",
"\u001b[0;31mInit docstring:\u001b[0m\n",
" Initialises the associated data for the polynomial \"self\".\n",
"\n",
" INPUT:\n",
"\n",
" * \"parent\" -- polynomial ring, the parent of \"self\"\n",
"\n",
" * \"x\" -- data for the new polynomial \"self\", e.g. a polynomial, an\n",
" integer, a rational, a list of rationals, a dictionary with keys\n",
" the degrees and the rational coefficients, etc (default: \"None\")\n",
"\n",
" * \"check\" -- whether the integrity of the data needs to be\n",
" verified, largely ignored by this method (default: \"True\")\n",
"\n",
" * \"is_gen\" -- whether \"self\" shall be initialised as the generator\n",
" of the parent polynomial ring\n",
"\n",
" * \"construct\" -- whether the element shall always be constructed as\n",
" an independent copy of any input data (default: \"False\")\n",
"\u001b[0;31mCall docstring:\u001b[0m\n",
" Call this polynomial with the given parameters, which can be\n",
" interpreted as polynomial composition or evaluation by this method.\n",
"\n",
" If the argument is not simply an integer, a rational, or a\n",
" polynomial, the call is passed on to the generic implementation in\n",
" the Polynomial class.\n",
"\n",
" EXAMPLES:\n",
"\n",
" The first example illustrates polynomial composition:\n",
"\n",
" sage: R. = QQ[]\n",
" sage: f = t^2 - 1\n",
" sage: g = t + 1\n",
" sage: f(g) # indirect doctest\n",
" t^2 + 2*t\n",
"\n",
" Now we illustrate how a polynomial can be evaluated at a rational\n",
" number:\n",
"\n",
" sage: f(-2/3) # indirect doctest\n",
" -5/9"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"p?"
]
},
{
"cell_type": "code",
"execution_count": 36,
"id": "2a8b0026-91ac-4883-9b4b-9f0c0d2e8459",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\u001b[0;31mType:\u001b[0m FiniteFieldFactory\n",
"\u001b[0;31mString form:\u001b[0m \n",
"\u001b[0;31mFile:\u001b[0m ~/sage/src/sage/rings/finite_rings/finite_field_constructor.py\n",
"\u001b[0;31mDocstring:\u001b[0m \n",
"WARNING: the enclosing module is marked 'needs sage.rings.finite_rings',\n",
"so doctests may not pass.\n",
"\n",
" Return the globally unique finite field of given order with\n",
" generator labeled by the given name and possibly with given\n",
" modulus.\n",
"\n",
" INPUT:\n",
"\n",
" * \"order\" -- a prime power\n",
"\n",
" * \"name\" -- string, optional. Note that there can be a substantial\n",
" speed penalty (in creating extension fields) when omitting the\n",
" variable name, since doing so triggers the computation of pseudo-\n",
" Conway polynomials in order to define a coherent lattice of\n",
" extensions of the prime field. The speed penalty grows with the\n",
" size of extension degree and with the number of factors of the\n",
" extension degree.\n",
"\n",
" * \"modulus\" -- (optional) either a defining polynomial for the\n",
" field, or a string specifying an algorithm to use to generate\n",
" such a polynomial. If \"modulus\" is a string, it is passed to\n",
" \"irreducible_element()\" as the parameter \"algorithm\"; see there\n",
" for the permissible values of this parameter. In particular, you\n",
" can specify \"modulus=\"primitive\"\" to get a primitive polynomial.\n",
" You may not specify a modulus if you do not specify a variable\n",
" name.\n",
"\n",
" * \"impl\" -- (optional) a string specifying the implementation of\n",
" the finite field. Possible values are:\n",
"\n",
" * \"'modn'\" -- ring of integers modulo p (only for prime fields)\n",
"\n",
" * \"'givaro'\" -- Givaro, which uses Zech logs (only for fields of\n",
" at most 65521 elements)\n",
"\n",
" * \"'ntl'\" -- NTL using GF2X (only in characteristic 2)\n",
"\n",
" * \"'pari'\" or \"'pari_ffelt'\" -- PARI's \"FFELT\" type (only for\n",
" extension fields)\n",
"\n",
" * \"elem_cache\" -- (default: order < 500) cache all elements to\n",
" avoid creation time; ignored unless \"impl='givaro'\"\n",
"\n",
" * \"repr\" -- (default: \"'poly'\") ignored unless \"impl='givaro'\";\n",
" controls the way elements are printed to the user:\n",
"\n",
" * 'log': repr is \"log_repr()\"\n",
"\n",
" * 'int': repr is \"int_repr()\"\n",
"\n",
" * 'poly': repr is \"poly_repr()\"\n",
"\n",
" * \"check_irreducible\" -- verify that the polynomial modulus is\n",
" irreducible\n",
"\n",
" * \"proof\" -- boolean (default: \"True\"); if \"True\", use provable\n",
" primality test; otherwise only use pseudoprimality test\n",
"\n",
" ALIAS: You can also use \"GF\" instead of \"FiniteField\" -- they are\n",
" identical.\n",
"\n",
" EXAMPLES:\n",
"\n",
" sage: k. = FiniteField(9); k\n",
" Finite Field in a of size 3^2\n",
" sage: parent(a)\n",
" Finite Field in a of size 3^2\n",
" sage: charpoly(a, 'y')\n",
" y^2 + 2*y + 2\n",
"\n",
" We illustrate the proof flag. The following example would hang for\n",
" a very long time if we didn't use \"proof=False\".\n",
"\n",
" Note:\n",
"\n",
" Magma only supports \"proof=False\" for making finite fields, so\n",
" falsely appears to be faster than Sage -- see\n",
" https://github.com/sagemath/sage/issues/10975.\n",
"\n",
" sage: k = FiniteField(10^1000 + 453, proof=False)\n",
" sage: k = FiniteField((10^1000 + 453)^2, 'a', proof=False) # long time -- about 5 seconds\n",
"\n",
" sage: F. = GF(5)[]\n",
" sage: K. = GF(5**5, name='a', modulus=x^5 - x +1 )\n",
" sage: f = K.modulus(); f\n",
" x^5 + 4*x + 1\n",
" sage: type(f)\n",
" \n",
"\n",
" By default, the given generator is not guaranteed to be primitive\n",
" (a generator of the multiplicative group), use\n",
" \"modulus=\"primitive\"\" if you need this:\n",
"\n",
" sage: K. = GF(5^45)\n",
" sage: a.multiplicative_order()\n",
" 7105427357601001858711242675781\n",
" sage: a.is_square()\n",
" True\n",
" sage: K. = GF(5^45, modulus='primitive')\n",
" sage: b.multiplicative_order()\n",
" 28421709430404007434844970703124\n",
"\n",
" The modulus must be irreducible:\n",
"\n",
" sage: K. = GF(5**5, name='a', modulus=x^5 - x)\n",
" Traceback (most recent call last):\n",
" ...\n",
" ValueError: finite field modulus must be irreducible but it is not\n",
"\n",
" You can't accidentally fool the constructor into thinking the\n",
" modulus is irreducible when it is not, since it actually tests\n",
" irreducibility modulo p. Also, the modulus has to be of the right\n",
" degree (this is always checked):\n",
"\n",
" sage: F. = QQ[]\n",
" sage: factor(x^5 + 2)\n",
" x^5 + 2\n",
" sage: K. = GF(5^5, modulus=x^5 + 2)\n",
" Traceback (most recent call last):\n",
" ...\n",
" ValueError: finite field modulus must be irreducible but it is not\n",
" sage: K. = GF(5^5, modulus=x^3 + 3*x + 3, check_irreducible=False)\n",
" Traceback (most recent call last):\n",
" ...\n",
" ValueError: the degree of the modulus does not equal the degree of the field\n",
"\n",
" Any type which can be converted to the polynomial ring GF(p)[x] is\n",
" accepted as modulus:\n",
"\n",
" sage: K. = GF(13^3, modulus=[1,0,0,2])\n",
" sage: K. = GF(13^10, modulus=pari(\"ffinit(13,10)\"))\n",
" sage: var('x')\n",
" x\n",
" sage: K. = GF(13^2, modulus=x^2 - 2)\n",
" sage: K. = GF(13^2, modulus=sin(x))\n",
" Traceback (most recent call last):\n",
" ...\n",
" TypeError: self must be a numeric expression\n",
"\n",
" If you wish to live dangerously, you can tell the constructor not\n",
" to test irreducibility using \"check_irreducible=False\", but this\n",
" can easily lead to crashes and hangs -- so do not do it unless you\n",
" know that the modulus really is irreducible!\n",
"\n",
" sage: K. = GF(5**2, name='a', modulus=x^2 + 2, check_irreducible=False)\n",
"\n",
" Even for prime fields, you can specify a modulus. This will not\n",
" change how Sage computes in this field, but it will change the\n",
" result of the \"modulus()\" and \"gen()\" methods:\n",
"\n",
" sage: k. = GF(5, modulus='primitive')\n",
" sage: k.modulus()\n",
" x + 3\n",
" sage: a\n",
" 2\n",
"\n",
" The order of a finite field must be a prime power:\n",
"\n",
" sage: GF(1)\n",
" Traceback (most recent call last):\n",
" ...\n",
" ValueError: the order of a finite field must be at least 2\n",
" sage: GF(100)\n",
" Traceback (most recent call last):\n",
" ...\n",
" ValueError: the order of a finite field must be a prime power\n",
"\n",
" Finite fields with explicit random modulus are not cached:\n",
"\n",
" sage: k. = GF(5**10, modulus='random')\n",
" sage: n. = GF(5**10, modulus='random')\n",
" sage: while k.modulus() == n.modulus():\n",
" ....: n. = GF(5**10, modulus='random')\n",
" sage: n is k\n",
" False\n",
" sage: GF(5**10, 'a') is GF(5**10, 'a')\n",
" True\n",
"\n",
" We check that various ways of creating the same finite field yield\n",
" the same object, which is cached:\n",
"\n",
" sage: K = GF(7, 'a')\n",
" sage: L = GF(7, 'b')\n",
" sage: K is L # name is ignored for prime fields\n",
" True\n",
" sage: K is GF(7, modulus=K.modulus())\n",
" True\n",
" sage: K = GF(4,'a'); K.modulus()\n",
" x^2 + x + 1\n",
" sage: L = GF(4,'a', K.modulus())\n",
" sage: K is L\n",
" True\n",
" sage: M = GF(4,'a', K.modulus().change_variable_name('y'))\n",
" sage: K is M\n",
" True\n",
"\n",
" You may print finite field elements as integers. This currently\n",
" only works if the order of field is <2^{16}, though:\n",
"\n",
" sage: k. = GF(2^8, repr='int')\n",
" sage: a\n",
" 2\n",
"\n",
" The following demonstrate coercions for finite fields using Conway\n",
" polynomials:\n",
"\n",
" sage: k = GF(5^2); a = k.gen()\n",
" sage: l = GF(5^5); b = l.gen()\n",
" sage: a + b\n",
" 3*z10^5 + z10^4 + z10^2 + 3*z10 + 1\n",
"\n",
" Note that embeddings are compatible in lattices of such finite\n",
" fields:\n",
"\n",
" sage: m = GF(5^3); c = m.gen()\n",
" sage: (a+b)+c == a+(b+c)\n",
" True\n",
" sage: (a*b)*c == a*(b*c)\n",
" True\n",
" sage: from sage.categories.pushout import pushout\n",
" sage: n = pushout(k, l)\n",
" sage: o = pushout(l, m)\n",
" sage: q = pushout(n, o)\n",
" sage: q(o(b)) == q(n(b))\n",
" True\n",
"\n",
" Another check that embeddings are defined properly:\n",
"\n",
" sage: k = GF(3**10)\n",
" sage: l = GF(3**20)\n",
" sage: l(k.gen()**10) == l(k.gen())**10\n",
" True\n",
"\n",
" Using pseudo-Conway polynomials is slow for highly composite\n",
" extension degrees:\n",
"\n",
" sage: k = GF(3^120) # long time\n",
" sage: GF(3^40).gen().minimal_polynomial()(k.gen()^((3^120-1)/(3^40-1))) # long time\n",
" 0\n",
"\n",
" Before https://github.com/sagemath/sage/issues/17569, the boolean\n",
" keyword argument \"conway\" was required when creating finite fields\n",
" without a variable name. This keyword argument is now removed\n",
" (https://github.com/sagemath/sage/issues/21433). You can still pass\n",
" in \"prefix\" as an argument, which has the effect of changing the\n",
" variable name of the algebraic closure:\n",
"\n",
" sage: K = GF(3^10, prefix='w'); L = GF(3^10); K is L\n",
" False\n",
" sage: K.variable_name(), L.variable_name()\n",
" ('w10', 'z10')\n",
" sage: list(K.polynomial()) == list(L.polynomial())\n",
" True\n",
"\u001b[0;31mInit docstring:\u001b[0m\n",
"WARNING: the enclosing module is marked 'needs sage.rings.finite_rings',\n",
"so doctests may not pass.\n",
"\n",
" Initialization.\n",
"\n",
" EXAMPLES:\n",
"\n",
" sage: TestSuite(GF).run()\n",
"\u001b[0;31mCall docstring:\u001b[0m\n",
" This is the method invoked to create objects. It first creates a\n",
" key from the given parameters, then if an object with that key\n",
" already exists returns it, and otherwise creates one and stores a\n",
" weak reference to it in its dictionary.\n",
"\n",
" Do not override this method. Instead, override \"create_key\" and\n",
" \"create_object\" and put the docstring in the body of the class.\n",
"\n",
" EXAMPLES:\n",
"\n",
" sage: from sage.structure.test_factory import test_factory\n",
" sage: _ = test_factory(1,2,3); _\n",
" Making object (1, 2, 3)\n",
" \n",
"\n",
" It already created one, so don't re-create:\n",
"\n",
" sage: test_factory(1,2,3)\n",
" \n",
" sage: test_factory(1,2,3) is test_factory(1,2,3)\n",
" True\n",
"\n",
" Of course, with a different key, a new object will be created:\n",
"\n",
" sage: test_factory(1,2,3) is test_factory(1,2,4)\n",
" Making object (1, 2, 4)\n",
" False"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"GF?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "37015c26-4856-42ff-be6b-eb152e3e8b0c",
"metadata": {},
"outputs": [],
"source": [
"Poly"
]
},
{
"cell_type": "code",
"execution_count": 38,
"id": "d0402269-3d0d-4a55-a3dc-baed4ae3ca5b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(-1, 1)]"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"p.roots()"
]
},
{
"cell_type": "code",
"execution_count": 39,
"id": "dc0c088d-742d-4994-b32d-eefa8ceb967b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\u001b[0;31mDocstring:\u001b[0m \n",
" Return the roots of this polynomial (by default, in the base ring\n",
" of this polynomial).\n",
"\n",
" INPUT:\n",
"\n",
" * \"ring\" -- the ring to find roots in\n",
"\n",
" * \"multiplicities\" -- boolean (default: \"True\"); if \"True\" return\n",
" list of pairs (r, n), where r is the root and n is the\n",
" multiplicity. If \"False\", just return the unique roots, with no\n",
" information about multiplicities.\n",
"\n",
" * \"algorithm\" -- the root-finding algorithm to use. We attempt to\n",
" select a reasonable algorithm by default, but this lets the\n",
" caller override our choice.\n",
"\n",
" By default, this finds all the roots that lie in the base ring of\n",
" the polynomial. However, the ring parameter can be used to specify\n",
" a ring to look for roots in.\n",
"\n",
" If the polynomial and the output ring are both exact (integers,\n",
" rationals, finite fields, etc.), then the output should always be\n",
" correct (or raise an exception, if that case is not yet handled).\n",
"\n",
" If the output ring is approximate (floating-point real or complex\n",
" numbers), then the answer will be estimated numerically, using\n",
" floating-point arithmetic of at least the precision of the output\n",
" ring. If the polynomial is ill-conditioned, meaning that a small\n",
" change in the coefficients of the polynomial will lead to a\n",
" relatively large change in the location of the roots, this may give\n",
" poor results. Distinct roots may be returned as multiple roots,\n",
" multiple roots may be returned as distinct roots, real roots may be\n",
" lost entirely (because the numerical estimate thinks they are\n",
" complex roots). Note that polynomials with multiple roots are\n",
" always ill-conditioned; there's a footnote at the end of the\n",
" docstring about this.\n",
"\n",
" If the output ring is a \"RealIntervalField\" or\n",
" \"ComplexIntervalField\" of a given precision, then the answer will\n",
" always be correct (or an exception will be raised, if a case is not\n",
" implemented). Each root will be contained in one of the returned\n",
" intervals, and the intervals will be disjoint. (The returned\n",
" intervals may be of higher precision than the specified output\n",
" ring.)\n",
"\n",
" At the end of this docstring (after the examples) is a description\n",
" of all the cases implemented in this function, and the algorithms\n",
" used. That section also describes the possibilities for the\n",
" \"algorithm\" keyword, for the cases where multiple algorithms exist.\n",
"\n",
" EXAMPLES:\n",
"\n",
" sage: x = QQ['x'].0\n",
" sage: f = x^3 - 1\n",
" sage: f.roots()\n",
" [(1, 1)]\n",
" sage: f.roots(ring=CC) # ... - low order bits slightly different on ppc\n",
" [(1.00000000000000, 1),\n",
" (-0.500000000000000 - 0.86602540378443...*I, 1),\n",
" (-0.500000000000000 + 0.86602540378443...*I, 1)]\n",
" sage: f = (x^3 - 1)^2\n",
" sage: f.roots()\n",
" [(1, 2)]\n",
" sage: f = -19*x + 884736\n",
" sage: f.roots()\n",
" [(884736/19, 1)]\n",
" sage: (f^20).roots()\n",
" [(884736/19, 20)]\n",
"\n",
" sage: K. = CyclotomicField(3)\n",
" sage: f = K.defining_polynomial()\n",
" sage: f.roots(ring=GF(7))\n",
" [(4, 1), (2, 1)]\n",
" sage: g = f.change_ring(GF(7))\n",
" sage: g.roots()\n",
" [(4, 1), (2, 1)]\n",
" sage: g.roots(multiplicities=False)\n",
" [4, 2]\n",
"\n",
" A new ring. In the example below, we add the special method\n",
" \"_roots_univariate_polynomial()\" to the base ring, and observe that\n",
" this method is called instead to find roots of polynomials over\n",
" this ring. This facility can be used to easily extend root finding\n",
" to work over new rings you introduce:\n",
"\n",
" sage: R. = QQ[]\n",
" sage: (x^2 + 1).roots()\n",
" []\n",
" sage: def my_roots(f, *args, **kwds):\n",
" ....: return f.change_ring(CDF).roots()\n",
" sage: QQ._roots_univariate_polynomial = my_roots\n",
" sage: (x^2 + 1).roots() # abs tol 1e-14\n",
" [(2.7755575615628914e-17 - 1.0*I, 1), (0.9999999999999997*I, 1)]\n",
" sage: del QQ._roots_univariate_polynomial\n",
"\n",
" An example over RR, which illustrates that only the roots in RR are\n",
" returned:\n",
"\n",
" sage: x = RR['x'].0\n",
" sage: f = x^3 - 2\n",
" sage: f.roots()\n",
" [(1.25992104989487, 1)]\n",
" sage: f.factor()\n",
" (x - 1.25992104989487) * (x^2 + 1.25992104989487*x + 1.58740105196820)\n",
" sage: x = RealField(100)['x'].0\n",
" sage: f = x^3 - 2\n",
" sage: f.roots()\n",
" [(1.2599210498948731647672106073, 1)]\n",
"\n",
" sage: x = CC['x'].0\n",
" sage: f = x^3 - 2\n",
" sage: f.roots()\n",
" [(1.25992104989487, 1),\n",
" (-0.62996052494743... - 1.09112363597172*I, 1),\n",
" (-0.62996052494743... + 1.09112363597172*I, 1)]\n",
" sage: f.roots(algorithm='pari')\n",
" [(1.25992104989487, 1),\n",
" (-0.629960524947437 - 1.09112363597172*I, 1),\n",
" (-0.629960524947437 + 1.09112363597172*I, 1)]\n",
"\n",
" Another example showing that only roots in the base ring are\n",
" returned:\n",
"\n",
" sage: x = polygen(ZZ)\n",
" sage: f = (2*x - 3) * (x - 1) * (x + 1)\n",
" sage: f.roots()\n",
" [(1, 1), (-1, 1)]\n",
" sage: f.roots(ring=QQ)\n",
" [(3/2, 1), (1, 1), (-1, 1)]\n",
"\n",
" An example where we compute the roots lying in a subring of the\n",
" base ring:\n",
"\n",
" sage: Pols. = QQ[]\n",
" sage: pol = (n - 1/2)^2 * (n - 1)^2 * (n - 2)\n",
" sage: pol.roots(ZZ)\n",
" [(2, 1), (1, 2)]\n",
"\n",
" An example involving large numbers:\n",
"\n",
" sage: x = RR['x'].0\n",
" sage: f = x^2 - 1e100\n",
" sage: f.roots()\n",
" [(-1.00000000000000e50, 1), (1.00000000000000e50, 1)]\n",
" sage: f = x^10 - 2 * (5*x - 1)^2\n",
" sage: f.roots(multiplicities=False)\n",
" [-1.6772670339941..., 0.19995479628..., 0.20004530611..., 1.5763035161844...]\n",
"\n",
" sage: x = CC['x'].0\n",
" sage: i = CC.0\n",
" sage: f = (x - 1) * (x - i)\n",
" sage: f.roots(multiplicities=False)\n",
" [1.00000000000000, 1.00000000000000*I]\n",
" sage: g = (x - 1.33 + 1.33*i) * (x - 2.66 - 2.66*i)\n",
" sage: g.roots(multiplicities=False)\n",
" [1.33000000000000 - 1.33000000000000*I, 2.66000000000000 + 2.66000000000000*I]\n",
"\n",
" Describing roots using radical expressions:\n",
"\n",
" sage: x = QQ['x'].0\n",
" sage: f = x^2 + 2\n",
" sage: f.roots(SR)\n",
" [(-I*sqrt(2), 1), (I*sqrt(2), 1)]\n",
" sage: f.roots(SR, multiplicities=False)\n",
" [-I*sqrt(2), I*sqrt(2)]\n",
"\n",
" The roots of some polynomials cannot be described using radical\n",
" expressions:\n",
"\n",
" sage: (x^5 - x + 1).roots(SR)\n",
" []\n",
"\n",
" For some other polynomials, no roots can be found at the moment due\n",
" to the way roots are computed.\n",
" https://github.com/sagemath/sage/issues/17516 addresses these\n",
" defects. Until that gets implemented, one such example is the\n",
" following:\n",
"\n",
" sage: f = x^6 - 300*x^5 + 30361*x^4 - 1061610*x^3 + 1141893*x^2 - 915320*x + 101724\n",
" sage: f.roots()\n",
" []\n",
"\n",
" A purely symbolic roots example:\n",
"\n",
" sage: X = var('X')\n",
" sage: f = expand((X - 1) * (X - I)^3 * (X^2 - sqrt(2))); f\n",
" X^6 - (3*I + 1)*X^5 - sqrt(2)*X^4 + (3*I - 3)*X^4 + (3*I + 1)*sqrt(2)*X^3\n",
" + (I + 3)*X^3 - (3*I - 3)*sqrt(2)*X^2 - I*X^2 - (I + 3)*sqrt(2)*X + I*sqrt(2)\n",
" sage: f.roots()\n",
" [(I, 3), (-2^(1/4), 1), (2^(1/4), 1), (1, 1)]\n",
"\n",
" The same operation, performed over a polynomial ring with symbolic\n",
" coefficients:\n",
"\n",
" sage: X = SR['X'].0\n",
" sage: f = (X - 1) * (X - I)^3 * (X^2 - sqrt(2)); f\n",
" X^6 + (-3*I - 1)*X^5 + (-sqrt(2) + 3*I - 3)*X^4 + ((3*I + 1)*sqrt(2) + I + 3)*X^3\n",
" + (-(3*I - 3)*sqrt(2) - I)*X^2 + (-(I + 3)*sqrt(2))*X + I*sqrt(2)\n",
" sage: f.roots()\n",
" [(I, 3), (-2^(1/4), 1), (2^(1/4), 1), (1, 1)]\n",
" sage: f.roots(multiplicities=False)\n",
" [I, -2^(1/4), 2^(1/4), 1]\n",
"\n",
" A couple of examples where the base ring does not have a\n",
" factorization algorithm (yet). Note that this is currently done via\n",
" a rather naive enumeration, so could be very slow:\n",
"\n",
" sage: R = Integers(6)\n",
" sage: S. = R['x']\n",
" sage: p = x^2 - 1\n",
" sage: p.roots()\n",
" Traceback (most recent call last):\n",
" ...\n",
" NotImplementedError: root finding with multiplicities for this polynomial\n",
" not implemented (try the multiplicities=False option)\n",
" sage: p.roots(multiplicities=False)\n",
" [5, 1]\n",
" sage: R = Integers(9)\n",
" sage: A = PolynomialRing(R, 'y')\n",
" sage: y = A.gen()\n",
" sage: f = 10*y^2 - y^3 - 9\n",
" sage: f.roots(multiplicities=False)\n",
" [1, 0, 3, 6]\n",
"\n",
" An example over the complex double field (where root finding is\n",
" fast, thanks to NumPy):\n",
"\n",
" sage: R. = CDF[]\n",
" sage: f = R.cyclotomic_polynomial(5); f\n",
" x^4 + x^3 + x^2 + x + 1.0\n",
" sage: f.roots(multiplicities=False) # abs tol 1e-9\n",
" [-0.8090169943749469 - 0.5877852522924724*I, -0.8090169943749473 + 0.5877852522924724*I,\n",
" 0.30901699437494773 - 0.951056516295154*I, 0.30901699437494756 + 0.9510565162951525*I]\n",
" sage: [z^5 for z in f.roots(multiplicities=False)] # abs tol 2e-14\n",
" [0.9999999999999957 - 1.2864981197413038e-15*I, 0.9999999999999976 + 3.062854959141552e-15*I,\n",
" 1.0000000000000024 + 1.1331077795295987e-15*I, 0.9999999999999953 - 2.0212861992297117e-15*I]\n",
" sage: f = CDF['x']([1,2,3,4]); f\n",
" 4.0*x^3 + 3.0*x^2 + 2.0*x + 1.0\n",
" sage: r = f.roots(multiplicities=False)\n",
" sage: [f(a).abs() for a in r] # abs tol 1e-14\n",
" [2.574630599127759e-15, 1.457101633618084e-15, 1.1443916996305594e-15]\n",
"\n",
" Another example over RDF:\n",
"\n",
" sage: x = RDF['x'].0\n",
" sage: ((x^3 - 1)).roots() # abs tol 4e-16\n",
" [(1.0000000000000002, 1)]\n",
" sage: ((x^3 - 1)).roots(multiplicities=False) # abs tol 4e-16\n",
" [1.0000000000000002]\n",
"\n",
" More examples involving the complex double field:\n",
"\n",
" sage: x = CDF['x'].0\n",
" sage: i = CDF.0\n",
" sage: f = x^3 + 2*i; f\n",
" x^3 + 2.0*I\n",
" sage: f.roots()\n",
" [(-1.09112363597172... - 0.62996052494743...*I, 1),\n",
" (...1.25992104989487...*I, 1),\n",
" (1.09112363597172... - 0.62996052494743...*I, 1)]\n",
" sage: f.roots(multiplicities=False)\n",
" [-1.09112363597172... - 0.62996052494743...*I, ...1.25992104989487...*I,\n",
" 1.09112363597172... - 0.62996052494743...*I]\n",
" sage: [abs(f(z)) for z in f.roots(multiplicities=False)] # abs tol 1e-14\n",
" [8.95090418262362e-16, 8.728374398092689e-16, 1.0235750533041806e-15]\n",
" sage: f = i*x^3 + 2; f\n",
" I*x^3 + 2.0\n",
" sage: f.roots()\n",
" [(-1.09112363597172... + 0.62996052494743...*I, 1),\n",
" (...1.25992104989487...*I, 1),\n",
" (1.09112363597172... + 0.62996052494743...*I, 1)]\n",
" sage: abs(f(f.roots()[0][0])) # abs tol 1e-13\n",
" 1.1102230246251565e-16\n",
"\n",
" Examples using real root isolation:\n",
"\n",
" sage: x = polygen(ZZ)\n",
" sage: f = x^2 - x - 1\n",
" sage: f.roots()\n",
" []\n",
" sage: f.roots(ring=AA)\n",
" [(-0.618033988749895?, 1), (1.618033988749895?, 1)]\n",
"\n",
" sage: # needs sage.rings.real_interval_field\n",
" sage: f.roots(ring=RIF)\n",
" [(-0.6180339887498948482045868343657?, 1), (1.6180339887498948482045868343657?, 1)]\n",
" sage: f.roots(ring=RIF, multiplicities=False)\n",
" [-0.6180339887498948482045868343657?, 1.6180339887498948482045868343657?]\n",
" sage: f.roots(ring=RealIntervalField(150))\n",
" [(-0.6180339887498948482045868343656381177203091798057628621354486227?, 1),\n",
" (1.618033988749894848204586834365638117720309179805762862135448623?, 1)]\n",
" sage: f = f^2 * (x - 1)\n",
" sage: f.roots(ring=RIF)\n",
" [(-0.6180339887498948482045868343657?, 2),\n",
" (1.0000000000000000000000000000000?, 1),\n",
" (1.6180339887498948482045868343657?, 2)]\n",
" sage: f.roots(ring=RIF, multiplicities=False)\n",
" [-0.6180339887498948482045868343657?,\n",
" 1.0000000000000000000000000000000?,\n",
" 1.6180339887498948482045868343657?]\n",
"\n",
" Examples using complex root isolation:\n",
"\n",
" sage: x = polygen(ZZ)\n",
" sage: p = x^5 - x - 1\n",
" sage: p.roots()\n",
" []\n",
" sage: p.roots(ring=CIF) # needs sage.rings.complex_interval_field\n",
" [(1.167303978261419?, 1),\n",
" (-0.764884433600585? - 0.352471546031727?*I, 1),\n",
" (-0.764884433600585? + 0.352471546031727?*I, 1),\n",
" (0.181232444469876? - 1.083954101317711?*I, 1),\n",
" (0.181232444469876? + 1.083954101317711?*I, 1)]\n",
" sage: p.roots(ring=ComplexIntervalField(200)) # needs sage.rings.complex_interval_field\n",
" [(1.167303978261418684256045899854842180720560371525489039140082?, 1),\n",
" (-0.76488443360058472602982318770854173032899665194736756700778? - 0.35247154603172624931794709140258105439420648082424733283770?*I, 1),\n",
" (-0.76488443360058472602982318770854173032899665194736756700778? + 0.35247154603172624931794709140258105439420648082424733283770?*I, 1),\n",
" (0.18123244446987538390180023778112063996871646618462304743774? - 1.08395410131771066843034449298076657427364024315511565430114?*I, 1),\n",
" (0.18123244446987538390180023778112063996871646618462304743774? + 1.08395410131771066843034449298076657427364024315511565430114?*I, 1)]\n",
" sage: rts = p.roots(ring=QQbar); rts\n",
" [(1.167303978261419?, 1),\n",
" (-0.7648844336005847? - 0.3524715460317263?*I, 1),\n",
" (-0.7648844336005847? + 0.3524715460317263?*I, 1),\n",
" (0.1812324444698754? - 1.083954101317711?*I, 1),\n",
" (0.1812324444698754? + 1.083954101317711?*I, 1)]\n",
" sage: p.roots(ring=AA)\n",
" [(1.167303978261419?, 1)]\n",
" sage: p = (x - rts[4][0])^2 * (3*x^2 + x + 1)\n",
" sage: p.roots(ring=QQbar)\n",
" [(-0.1666666666666667? - 0.552770798392567?*I, 1),\n",
" (-0.1666666666666667? + 0.552770798392567?*I, 1),\n",
" (0.1812324444698754? + 1.083954101317711?*I, 2)]\n",
" sage: p.roots(ring=CIF) # needs sage.rings.complex_interval_field\n",
" [(-0.1666666666666667? - 0.552770798392567?*I, 1),\n",
" (-0.1666666666666667? + 0.552770798392567?*I, 1),\n",
" (0.1812324444698754? + 1.083954101317711?*I, 2)]\n",
"\n",
" In some cases, it is possible to isolate the roots of polynomials\n",
" over complex ball fields:\n",
"\n",
" sage: Pol. = CBF[]\n",
" sage: set((x^2 + 2).roots(multiplicities=False))\n",
" {[+/- ...e-19] + [-1.414213562373095 +/- ...e-17]*I,\n",
" [+/- ...e-19] + [1.414213562373095 +/- ...e-17]*I}\n",
" sage: (x^3 - 1/2).roots(RBF, multiplicities=False)\n",
" [[0.7937005259840997 +/- ...e-17]]\n",
" sage: ((x - 1)^2).roots(multiplicities=False, proof=False)\n",
" doctest:...\n",
" UserWarning: roots may have been lost...\n",
" [[1.000000000... +/- ...] + [+/- ...]*I,\n",
" [1.000000000... +/- ...] + [+/- ...]*I]\n",
" sage: ((x - 1)^2).roots(multiplicities=False, proof=False, warn=False)\n",
" [[1.000000000... +/- ...] + [+/- ...]*I,\n",
" [1.000000000... +/- ...] + [+/- ...]*I]\n",
"\n",
" Note that coefficients in a number field with defining polynomial\n",
" x^2 + 1 are considered to be Gaussian rationals (with the generator\n",
" mapping to +I), if you ask for complex roots.\n",
"\n",
" sage: K. = QuadraticField(-1)\n",
" sage: y = polygen(K)\n",
" sage: p = y^4 - 2 - im\n",
" sage: p.roots(ring=CC)\n",
" [(-1.2146389322441... - 0.14142505258239...*I, 1),\n",
" (-0.14142505258239... + 1.2146389322441...*I, 1),\n",
" (0.14142505258239... - 1.2146389322441...*I, 1),\n",
" (1.2146389322441... + 0.14142505258239...*I, 1)]\n",
" sage: p = p^2 * (y^2 - 2)\n",
" sage: p.roots(ring=CIF)\n",
" [(-1.414213562373095?, 1), (1.414213562373095?, 1),\n",
" (-1.214638932244183? - 0.141425052582394?*I, 2),\n",
" (-0.141425052582394? + 1.214638932244183?*I, 2),\n",
" (0.141425052582394? - 1.214638932244183?*I, 2),\n",
" (1.214638932244183? + 0.141425052582394?*I, 2)]\n",
"\n",
" Note that one should not use NumPy when wanting high precision\n",
" output as it does not support any of the high precision types:\n",
"\n",
" sage: R. = RealField(200)[]\n",
" sage: f = x^2 - R(pi)\n",
" sage: f.roots()\n",
" [(-1.7724538509055160272981674833411451827975494561223871282138, 1),\n",
" (1.7724538509055160272981674833411451827975494561223871282138, 1)]\n",
" sage: f.roots(algorithm='numpy')\n",
" doctest... UserWarning: NumPy does not support arbitrary precision arithmetic.\n",
" The roots found will likely have less precision than you expect.\n",
" [(-1.77245385090551..., 1), (1.77245385090551..., 1)]\n",
"\n",
" We can also find roots over number fields:\n",
"\n",
" sage: K. = CyclotomicField(15)\n",
" sage: R. = PolynomialRing(K)\n",
" sage: (x^2 + x + 1).roots()\n",
" [(z^5, 1), (-z^5 - 1, 1)]\n",
"\n",
" There are many combinations of floating-point input and output\n",
" types that work. (Note that some of them are quite pointless like\n",
" using \"algorithm='numpy'\" with high-precision types.)\n",
"\n",
" sage: rflds = (RR, RDF, RealField(100))\n",
" sage: cflds = (CC, CDF, ComplexField(100))\n",
" sage: def cross(a, b):\n",
" ....: return list(cartesian_product_iterator([a, b]))\n",
" sage: flds = cross(rflds, rflds) + cross(rflds, cflds) + cross(cflds, cflds)\n",
" sage: for (fld_in, fld_out) in flds:\n",
" ....: x = polygen(fld_in)\n",
" ....: f = x^3 - fld_in(2)\n",
" ....: x2 = polygen(fld_out)\n",
" ....: f2 = x2^3 - fld_out(2)\n",
" ....: for algo in (None, 'pari', 'numpy'):\n",
" ....: rts = f.roots(ring=fld_out, multiplicities=False)\n",
" ....: rts = sorted(rts, key=lambda x: x.imag())\n",
" ....: if fld_in == fld_out and algo is None:\n",
" ....: print(\"{} {}\".format(fld_in, rts))\n",
" ....: for rt in rts:\n",
" ....: assert(abs(f2(rt)) <= 1e-10)\n",
" ....: assert(rt.parent() == fld_out)\n",
" Real Field with 53 bits of precision [1.25992104989487]\n",
" Real Double Field [1.25992104989...]\n",
" Real Field with 100 bits of precision [1.2599210498948731647672106073]\n",
" Complex Field with 53 bits of precision [-0.62996052494743... - 1.09112363597172*I, 1.25992104989487, -0.62996052494743... + 1.09112363597172*I]\n",
" Complex Double Field [-0.629960524947... - 1.0911236359717...*I, 1.25992104989487..., -0.629960524947... + 1.0911236359717...*I]\n",
" Complex Field with 100 bits of precision [-0.62996052494743658238360530364 - 1.0911236359717214035600726142*I, 1.2599210498948731647672106073, -0.62996052494743658238360530364 + 1.0911236359717214035600726142*I]\n",
"\n",
" Note that we can find the roots of a polynomial with algebraic\n",
" coefficients:\n",
"\n",
" sage: rt2 = sqrt(AA(2))\n",
" sage: rt3 = sqrt(AA(3))\n",
" sage: x = polygen(AA)\n",
" sage: f = (x - rt2) * (x - rt3); f\n",
" x^2 - 3.146264369941973?*x + 2.449489742783178?\n",
" sage: rts = f.roots(); rts\n",
" [(1.414213562373095?, 1), (1.732050807568878?, 1)]\n",
" sage: rts[0][0] == rt2\n",
" True\n",
" sage: f.roots(ring=RealIntervalField(150))\n",
" [(1.414213562373095048801688724209698078569671875376948073176679738?, 1),\n",
" (1.732050807568877293527446341505872366942805253810380628055806980?, 1)]\n",
"\n",
" We can handle polynomials with huge coefficients.\n",
"\n",
" This number doesn't even fit in an IEEE double-precision float, but\n",
" \"RR\" and \"CC\" allow a much larger range of floating-point numbers:\n",
"\n",
" sage: bigc = 2^1500\n",
" sage: CDF(bigc)\n",
" +infinity\n",
" sage: CC(bigc)\n",
" 3.50746621104340e451\n",
"\n",
" Polynomials using such large coefficients can't be handled by\n",
" numpy, but pari can deal with them:\n",
"\n",
" sage: x = polygen(QQ)\n",
" sage: p = x + bigc\n",
" sage: p.roots(ring=RR, algorithm='numpy')\n",
" Traceback (most recent call last):\n",
" ...\n",
" LinAlgError: Array must not contain infs or NaNs\n",
" sage: p.roots(ring=RR, algorithm='pari')\n",
" [(-3.50746621104340e451, 1)]\n",
" sage: p.roots(ring=AA)\n",
" [(-3.5074662110434039?e451, 1)]\n",
" sage: p.roots(ring=QQbar)\n",
" [(-3.5074662110434039?e451, 1)]\n",
" sage: p = bigc*x + 1\n",
" sage: p.roots(ring=RR)\n",
" [(-2.85106096489671e-452, 1)]\n",
" sage: p.roots(ring=AA)\n",
" [(-2.8510609648967059?e-452, 1)]\n",
" sage: p.roots(ring=QQbar)\n",
" [(-2.8510609648967059?e-452, 1)]\n",
" sage: p = x^2 - bigc\n",
" sage: p.roots(ring=RR)\n",
" [(-5.92238652153286e225, 1), (5.92238652153286e225, 1)]\n",
" sage: p.roots(ring=QQbar)\n",
" [(-5.9223865215328558?e225, 1), (5.9223865215328558?e225, 1)]\n",
"\n",
" Check that https://github.com/sagemath/sage/issues/30522 is fixed:\n",
"\n",
" sage: PolynomialRing(SR, names=\"x\")(\"x^2\").roots()\n",
" [(0, 2)]\n",
"\n",
" Check that https://github.com/sagemath/sage/issues/30523 is fixed:\n",
"\n",
" sage: PolynomialRing(SR, names=\"x\")(\"x^2 + q\").roots()\n",
" [(-sqrt(-q), 1), (sqrt(-q), 1)]\n",
"\n",
" ALGORITHM:\n",
"\n",
" For brevity, we will use \"RR\" to mean any \"RealField\" of any\n",
" precision; similarly for \"RIF\", \"CC\", and \"CIF\". Since Sage has no\n",
" specific implementation of Gaussian rationals (or of number fields\n",
" with embedding, at all), when we refer to Gaussian rationals below\n",
" we will accept any number field with defining polynomial x^2+1,\n",
" mapping the field generator to +I.\n",
"\n",
" We call the base ring of the polynomial K, and the ring given by\n",
" the \"ring\" argument L. (If \"ring\" is not specified, then L is the\n",
" same as K.)\n",
"\n",
" If K and L are floating-point (\"RDF\", \"CDF\", \"RR\", or \"CC\"), then a\n",
" floating-point root-finder is used. If L is \"RDF\" or \"CDF\", then we\n",
" default to using NumPy's \"roots()\"; otherwise, we use PARI's\n",
" function https://pari.math.u-bordeaux.fr/dochtml/help/polroots.\n",
" This choice can be overridden with \"algorithm='pari'\" or\n",
" \"algorithm='numpy'\". If the algorithm is unspecified and NumPy's\n",
" \"roots()\" algorithm fails, then we fall back to PARI (NumPy will\n",
" fail if some coefficient is infinite, for instance).\n",
"\n",
" If L is \"SR\" (or one of its subrings), then the roots will be\n",
" radical expressions, computed as the solutions of a symbolic\n",
" polynomial expression. At the moment this delegates to\n",
" \"sage.symbolic.expression.Expression.solve()\" which in turn uses\n",
" Maxima to find radical solutions. Some solutions may be lost in\n",
" this approach. Once https://github.com/sagemath/sage/issues/17516\n",
" gets implemented, all possible radical solutions should become\n",
" available.\n",
"\n",
" If L is \"AA\" or \"RIF\", and K is \"ZZ\", \"QQ\", or \"AA\", then the root\n",
" isolation algorithm \"sage.rings.polynomial.real_roots.real_roots()\"\n",
" is used. (You can call \"real_roots()\" directly to get more control\n",
" than this method gives.)\n",
"\n",
" If L is \"QQbar\" or \"CIF\", and K is \"ZZ\", \"QQ\", \"AA\", \"QQbar\", or\n",
" the Gaussian rationals, then the root isolation algorithm\n",
" \"sage.rings.polynomial.complex_roots.complex_roots()\" is used. (You\n",
" can call \"complex_roots()\" directly to get more control than this\n",
" method gives.)\n",
"\n",
" If L is \"AA\" and K is \"QQbar\" or the Gaussian rationals, then\n",
" \"complex_roots()\" is used (as above) to find roots in \"QQbar\", then\n",
" these roots are filtered to select only the real roots.\n",
"\n",
" If L is floating-point and K is not, then we attempt to change the\n",
" polynomial ring to L (using \"change_ring()\") (or, if L is complex\n",
" and K is not, to the corresponding real field). Then we use either\n",
" PARI or NumPy as specified above.\n",
"\n",
" For all other cases where K is different from L, we attempt to use\n",
" \".change_ring(L)\". When that fails but L is a subring of K, we also\n",
" attempt to compute the roots over K and filter the ones belonging\n",
" to L.\n",
"\n",
" The next method, which is used if K is an integral domain, is to\n",
" attempt to factor the polynomial. If this succeeds, then for every\n",
" degree-one factor ax+b, we add -b/a as a root (as long as this\n",
" quotient is actually in the desired ring).\n",
"\n",
" If factoring over K is not implemented (or K is not an integral\n",
" domain), and K is finite, then we find the roots by enumerating all\n",
" elements of K and checking whether the polynomial evaluates to zero\n",
" at that value.\n",
"\n",
" Note:\n",
"\n",
" We mentioned above that polynomials with multiple roots are\n",
" always ill-conditioned; if your input is given to n bits of\n",
" precision, you should not expect more than n/k good bits for a\n",
" k-fold root. (You can get solutions that make the polynomial\n",
" evaluate to a number very close to zero; basically the problem is\n",
" that with a multiple root, there are many such numbers, and it's\n",
" difficult to choose between them.)To see why this is true,\n",
" consider the naive floating-point error analysis model where you\n",
" just pretend that all floating-point numbers are somewhat\n",
" imprecise - a little 'fuzzy', if you will. Then the graph of a\n",
" floating-point polynomial will be a fuzzy line. Consider the\n",
" graph of (x-1)^3; this will be a fuzzy line with a horizontal\n",
" tangent at x=1, y=0. If the fuzziness extends up and down by\n",
" about j, then it will extend left and right by about\n",
" cube_root(j).\n",
"\u001b[0;31mInit docstring:\u001b[0m Initialize self. See help(type(self)) for accurate signature.\n",
"\u001b[0;31mFile:\u001b[0m ~/sage/src/sage/rings/polynomial/polynomial_element.pyx\n",
"\u001b[0;31mType:\u001b[0m builtin_function_or_method"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"p.roots?"
]
},
{
"cell_type": "markdown",
"id": "e06599db-f840-4311-ae56-2249e8419050",
"metadata": {},
"source": [
"Beyond these basic features, there are also a number of more advanced topics that are provided within SageMath by default. We will have later a combinatorics tutorial, so instead we will focus on some other areas of mathematics (non-exhaustive; biased by the author's preferences):\n",
"\n",
"- Commutative algebra\n",
"- Field extensions\n",
"- Group theory\n",
"- Representation theory"
]
},
{
"cell_type": "code",
"execution_count": 40,
"id": "27a1c703-d2e1-4f75-8dda-28e28a366a8f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[z^3, y^2 + y*z + z^2, x + y + z]"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"R. = QQ[]\n",
"I = R.ideal([x + y + z, x*y + x*z + y*z, x*y*z])\n",
"I.groebner_basis()"
]
},
{
"cell_type": "code",
"execution_count": 41,
"id": "0d8b93e3-9a84-42b4-97ee-830f40f67f3e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"I.dimension()"
]
},
{
"cell_type": "code",
"execution_count": 42,
"id": "e7b7a636-68db-400a-9012-7a37d462ca88",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[y*z^2, z^2, y*z, z, y, 1]"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"I.normal_basis()"
]
},
{
"cell_type": "code",
"execution_count": 43,
"id": "e5b44e2c-54c3-4241-a04f-b526e38d79b3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(t + 1)/(t^2 - 2*t + 1)"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"J = R.ideal([x*y, x*y*z])\n",
"J.hilbert_series()"
]
},
{
"cell_type": "code",
"execution_count": 44,
"id": "036ff794-4d6d-465a-8963-be556ac77123",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Quotient of Multivariate Polynomial Ring in x, y, z over Rational Field by the ideal (x*y, x*y*z)"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Q = R.quotient(J)\n",
"Q"
]
},
{
"cell_type": "code",
"execution_count": 45,
"id": "4afaebb1-fbeb-4410-9501-42487676b24c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(xbar, ybar, zbar)"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Q.gens()"
]
},
{
"cell_type": "code",
"execution_count": 46,
"id": "ce5820de-5d9e-4f72-83c6-5d5230c7b191",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Q.is_integral_domain()"
]
},
{
"cell_type": "code",
"execution_count": 47,
"id": "b0b4a9b3-c4f0-4795-9f3b-834c8d552093",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"xb,yb,zb = Q.gens()\n",
"xb * yb"
]
},
{
"cell_type": "code",
"execution_count": 48,
"id": "a376df15-706e-49cc-9014-38d2a541564c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"J.is_prime()"
]
},
{
"cell_type": "code",
"execution_count": 49,
"id": "7ca86861-c156-4d5f-acc9-bed82afa221e",
"metadata": {},
"outputs": [],
"source": [
"R. = QQ[]\n",
"S5. = QQ.extension(a^2-5)"
]
},
{
"cell_type": "code",
"execution_count": 50,
"id": "c58f3662-6f78-4d3f-bc75-eac8055e61ab",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 50,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sq5^2"
]
},
{
"cell_type": "code",
"execution_count": 51,
"id": "02ae4c7d-1159-406b-b6c9-af0f7a78f755",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"S5.is_field()"
]
},
{
"cell_type": "code",
"execution_count": 52,
"id": "060eca8c-c0b5-4f95-95e3-4224f29c5202",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Number Field in t with defining polynomial a^2 - 6 over its base field"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"S56. = S5.extension(a^2-6)\n",
"S56"
]
},
{
"cell_type": "code",
"execution_count": 53,
"id": "3fc034d9-59f6-43bd-bf9a-2e665be91128",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/tscrim/sage/src/sage/rings/number_field/number_field.py:6296: DeprecationWarning: Use .absolute_field().galois_group() if you want the Galois group of the absolute field\n",
"See https://github.com/sagemath/sage/issues/28782 for details.\n",
" return GaloisGroup_v2(self, algorithm=algorithm, names=names, gc_numbering=gc_numbering, _type=type)\n"
]
},
{
"data": {
"text/plain": [
"Galois group 4T2 (2[x]2) with order 4 of a^2 - 6"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"S56.galois_group()"
]
},
{
"cell_type": "code",
"execution_count": 54,
"id": "e20a8e51-2223-4cd5-820d-f45d823d0bdd",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Number Field in x with defining polynomial x^4 - 22*x^2 + 1"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"A = S56.absolute_field('x')\n",
"A"
]
},
{
"cell_type": "code",
"execution_count": 55,
"id": "ad16f5de-8114-47f6-9c98-02c76d701cbd",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Galois group 4T2 (2[x]2) with order 4 of x^4 - 22*x^2 + 1"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"A.galois_group()"
]
},
{
"cell_type": "code",
"execution_count": 56,
"id": "8a1057b9-e8c3-4f4c-b7dd-b86b0b584631",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Dihedral group of order 10 as a permutation group"
]
},
"execution_count": 56,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"D5 = groups.permutation.Dihedral(5)\n",
"D5"
]
},
{
"cell_type": "code",
"execution_count": 57,
"id": "88d86a03-896d-4daf-b2a3-83b63e06b95f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"10"
]
},
"execution_count": 57,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"D5.order()"
]
},
{
"cell_type": "code",
"execution_count": 58,
"id": "e347dac5-3fe6-4141-8f1c-41eb0cdea3d8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[ 1 1 1 1]\n",
"[ 1 -1 1 1]\n",
"[ 2 0 zeta5^3 + zeta5^2 -zeta5^3 - zeta5^2 - 1]\n",
"[ 2 0 -zeta5^3 - zeta5^2 - 1 zeta5^3 + zeta5^2]"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"D5.character_table()"
]
},
{
"cell_type": "code",
"execution_count": 59,
"id": "97a1843d-0714-443e-bc9f-957a3495dd19",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[Subgroup generated by [(1,2,3,4,5), (1,5)(2,4)] of (Dihedral group of order 10 as a permutation group),\n",
" Subgroup generated by [(1,2,3,4,5)] of (Dihedral group of order 10 as a permutation group),\n",
" Subgroup generated by [()] of (Dihedral group of order 10 as a permutation group)]"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"D5.normal_subgroups()"
]
},
{
"cell_type": "code",
"execution_count": 60,
"id": "87ed985b-29c2-4713-92d6-a12ad8d589dc",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Permutation Group with generators [(1,2)]"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"N = D5.normal_subgroups()[1]\n",
"Q = D5.quotient(N)\n",
"Q"
]
},
{
"cell_type": "code",
"execution_count": 61,
"id": "e9845002-4f5d-46c2-b308-fda6b5466c8c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Algebra of Dihedral group of order 10 as a permutation group over Rational Field"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"AD5 = D5.algebra(QQ)\n",
"AD5"
]
},
{
"cell_type": "code",
"execution_count": 62,
"id": "e85f4dba-af6b-4c83-b47b-feb776eb3f5f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"() + (2,5)(3,4) + (1,2)(3,5) + (1,2,3,4,5) + (1,3)(4,5) + (1,3,5,2,4) + (1,4)(2,3) + (1,4,2,5,3) + (1,5,4,3,2) + (1,5)(2,4)"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum(AD5.basis())"
]
},
{
"cell_type": "code",
"execution_count": 63,
"id": "bc922aaa-0d9d-44df-9055-4b70d4798b51",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 63,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"AD5 in Algebras(QQ).Semisimple()"
]
},
{
"cell_type": "code",
"execution_count": 64,
"id": "1e4b4d34-f656-44f6-bcb0-94ff4deffbe7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Algebra of Dihedral group of order 10 as a permutation group over Finite Field of size 5"
]
},
"execution_count": 64,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"AD5 = D5.algebra(GF(5))\n",
"AD5"
]
},
{
"cell_type": "code",
"execution_count": 65,
"id": "b5ad789d-50ca-4269-a631-0d6e11d0fd37",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 65,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"AD5 in Algebras(GF(5)).Semisimple()"
]
},
{
"cell_type": "code",
"execution_count": 66,
"id": "74928087-7446-41a5-92f4-b2e97d0814dc",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[3 2]\n",
"[2 3]"
]
},
"execution_count": 66,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"AD5.cartan_invariants_matrix()"
]
},
{
"cell_type": "code",
"execution_count": 67,
"id": "61934eb4-3c90-4d65-9eee-5c7a896f4c67",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Left Regular Representation of Dihedral group of order 10 as a permutation group over Finite Field of size 5"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Reg = AD5.regular_representation()\n",
"Reg"
]
},
{
"cell_type": "code",
"execution_count": 68,
"id": "1aa66617-7dcd-4a27-96a6-1149a6b880d9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(10, 0)"
]
},
"execution_count": 68,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Reg.brauer_character()"
]
},
{
"cell_type": "code",
"execution_count": 69,
"id": "4fafd10b-85f2-4699-836a-374b9e18a220",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 69,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"AD5.semisimple_quotient().dimension()"
]
},
{
"cell_type": "code",
"execution_count": 70,
"id": "904e68d5-f30b-427e-9e78-8718bf94f304",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(3*() + 2*(2,5)(3,4) + 2*(1,2)(3,5) + 3*(1,2,3,4,5) + 2*(1,3)(4,5) + 3*(1,3,5,2,4) + 3*(1,4)(2,3) + 2*(1,4,2,5,3) + 2*(1,5,4,3,2) + 3*(1,5)(2,4),\n",
" 3*() + 3*(2,5)(3,4) + 3*(1,2)(3,5) + 2*(1,2,3,4,5) + 3*(1,3)(4,5) + 2*(1,3,5,2,4) + 2*(1,4)(2,3) + 3*(1,4,2,5,3) + 3*(1,5,4,3,2) + 2*(1,5)(2,4))"
]
},
"execution_count": 70,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"AD5.orthogonal_idempotents_central_mod_radical()"
]
},
{
"cell_type": "code",
"execution_count": 71,
"id": "cb1d3b52-2c3c-4410-8f46-371b9850be54",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[[Free module generated by {0, 1, 2} over Finite Field of size 5,\n",
" Free module generated by {0, 1} over Finite Field of size 5],\n",
" [Free module generated by {0, 1} over Finite Field of size 5,\n",
" Free module generated by {0, 1, 2} over Finite Field of size 5]]"
]
},
"execution_count": 71,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"AD5.peirce_decomposition()"
]
},
{
"cell_type": "code",
"execution_count": 72,
"id": "d8aaaa36-06dc-492f-a532-9d4f1973571e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1/3*() + 1/3*(1,2,3) + 1/3*(1,3,2),\n",
" 1/3*() - (1/3*zeta3+1/3)*(1,2,3) - (-1/3*zeta3)*(1,3,2),\n",
" 1/3*() - (-1/3*zeta3)*(1,2,3) - (1/3*zeta3+1/3)*(1,3,2))"
]
},
"execution_count": 72,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"A3 = AlternatingGroup(3).algebra(CyclotomicField(3))\n",
"A3.central_orthogonal_idempotents()"
]
},
{
"cell_type": "code",
"execution_count": 73,
"id": "5a46c0a9-b8fe-47af-9a93-7c68d5bd0824",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[ 1 1 1]\n",
"[ 1 zeta3 -zeta3 - 1]\n",
"[ 1 -zeta3 - 1 zeta3]"
]
},
"execution_count": 73,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"AlternatingGroup(3).character_table()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8b8858ba-f6af-40a1-abe6-b25023f0c570",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "SageMath 10.6.beta9",
"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.12.5"
}
},
"nbformat": 4,
"nbformat_minor": 5
}