Added files

9 files changed, 5579 insertions, 0 deletions

diff --git a/src/Lecture5/notebook/.ipynb_checkpoints/7-SageAlgebra-checkpoint.ipynb b/src/Lecture5/notebook/.ipynb_checkpoints/7-SageAlgebra-checkpoint.ipynb
new file mode 100644
index 0000000..59ea033
--- /dev/null
+++ b/src/Lecture5/notebook/.ipynb_checkpoints/7-SageAlgebra-checkpoint.ipynb
@@ -0,0 +1,1046 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This lecture's notes are in a different format: the presentations for the $\\LaTeX$ part were made with $\\LaTeX$, so this one is made with Sage, or rather with the [Jupyter Notebook](https://jupyter.org/).\n",
+    "\n",
+    "# The Jupyter Notebook\n",
+    "**Reference:** [[1](https://jupyter.org/documentation)]\n",
+    "\n",
+    "The Jupyter Notebook is one of the default interfaces for SageMath, along with the command line interface. You can access it via web browser, but it is running locally on your device (notice the strange url: `http://localhost:8888/notebooks...`).\n",
+    "\n",
+    "You can create a new notebook by clicking on `New > SageMath 9.2`. You can also create a Python 3 notebook to write Python code.\n",
+    "\n",
+    "Jupyter saves and reads files in the `.ipynb` format. If you download the file for this lecture you can open it and follow the examples interactively.\n",
+    "\n",
+    "## Cells\n",
+    "\n",
+    "The notebook contains one or more *interactive cells* that you can run, like this one below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2/5"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Exercise: modify this cell to use the print() command\n",
+    "2+2\n",
+    "2/5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you are reading this from Jupyter rather than from the pdf file, you can edit the cell above and run it again. You can also add more cells by selecting `Insert` from the menu bar.\n",
+    "\n",
+    "Notice that only the last statement produces an output. You can force anything to be written as output with the `print()` command, which works like in Python. As an exercise, try to modify the cell above to provide more output!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Markdown\n",
+    "\n",
+    "[Markdown](https://en.wikipedia.org/wiki/Markdown) is a simple markup language - think of LaTeX or html, but much simpler.\n",
+    "You can add text to your notebook with Markdown cells by selecting `Cell > Cell Type > Markdown`.\n",
+    "\n",
+    "You can also include some LaTeX code in Markdown cells, with dollar signs $ or align environments:\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\frac{(x+y)^2}{x+1} = \\frac{x^2+y^2}{x+1}\n",
+    "\\end{align*}\n",
+    "\n",
+    "When you are done writing a Markdown cell, you can run it to see the well-formatted text. To edit the text again, double-click on the cell. Try doing it now to fix the formula above!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Symbolic expressions\n",
+    "\n",
+    "**Reference:** [[2](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html)]\n",
+    "\n",
+    "Now, let's get started with Sage. One thing you might want to do is manipulating symbolic expressions, like the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[x == -sqrt(6) - 1, x == sqrt(6) - 1]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f =  x^2 + 2*x - 5 == 0\n",
+    "solve(f,x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice that the single `=` is part of an assignment, as in Python: we are *assigning* to the variable `f` the value `x^2 + 2*x - 5 >= 0`, which in this case is an equation, so it contains the symbol `==`. Keep in mind the difference between the two!\n",
+    "\n",
+    "**Exercise:** change the code above to solve the corresponding inequality $x^2+2x-5\\geq 0$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mathematical variables\n",
+    "\n",
+    "Last time we saw what *variables* are in Python, and that they are a little bit different from the *Mathematical variables* that you use in Mathematics. In Sage, both concepts are present, but they are still distinct. For example in the cell above `f` is a variable in the sense of computer science, while `x` is a Mathematical variable.\n",
+    "\n",
+    "If you want to use Mathematical variables other than `x`, you first need to *declare* them with the `var()` command:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[y == -1/2*x - 1/2*sqrt(x^2 + 2*x + 9) - 1/2, y == -1/2*x + 1/2*sqrt(x^2 + 2*x + 9) - 1/2]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "var('y')\n",
+    "solve(y^2 + (x+1)*y - 2 == 0, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Try removing the first line in the cell above and see what error you get!\n",
+    "\n",
+    "Here is another example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[x == -1/2*a - 1/2*sqrt(a^2 - 4*b), x == -1/2*a + 1/2*sqrt(a^2 - 4*b)]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "var('a', 'b')\n",
+    "f = x^2+a*x+b\n",
+    "solve(f,x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Some common constants are [already defined](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html) in Sage:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-1"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "e^(pi*I)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will study symbolic expressions more in detail next time, in the context of calculus/analysis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Basic rings and fields\n",
+    "\n",
+    "**References:** [[3](https://doc.sagemath.org/html/en/reference/rings_standard/index.html)]\n",
+    "[[4](https://doc.sagemath.org/html/en/reference/rings_numerical/index.html)]\n",
+    "[[5](https://doc.sagemath.org/html/en/reference/finite_rings/index.html)]\n",
+    "\n",
+    "As you should know, a *field* is a Mathematical structure with two operations, addition and multiplication, which respect certain rules (distributivity, associativity, commutativity...). Some examples of fields are the Rational numbers $\\mathbb Q$, the Real numbers $\\mathbb R$ and the Complex numbers $\\mathbb C$, but there are many more. As you should also know, a *(commutative) ring* is like a field, except not all elements different from $0$ need have a multiplicative inverse. For example the integers $\\mathbb Z = \\{ \\dots, -1, 0, 1, 2, \\dots\\}$ are a ring, but not a field.\n",
+    "\n",
+    "These structures are already implemented in Sage. Some of the most common are listed in the following table:\n",
+    "\n",
+    "|Mathematical object|Math symbol|Sage name|\n",
+    "|------------------:|:---------:|:--------|\n",
+    "|Integers|$\\mathbb Z$|`ZZ`|\n",
+    "|Rational numbers|$\\mathbb Q$|`QQ`|\n",
+    "|Real numbers|$\\mathbb R$|`RR`|\n",
+    "|Complex numbers|$\\mathbb C$|`CC`|\n",
+    "|Integers modulo $n$|$\\mathbb Z/n\\mathbb Z$|`Integers(n)`|\n",
+    "|Finite fields|$\\mathbb F_p$|GF(p)|\n",
+    "|$\\dots$|$\\dots$|$\\dots$|"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you write a number or an expression, Sage will figure out where it \"lives\", choosing the most restrictive interpretation possible. For example `3` will be interpreted to be an integer, even if it is also a rational number, a real number and a complex number."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parents and coercion\n",
+    "**Reference:** [[6](https://doc.sagemath.org/html/en/tutorial/tour_coercion.html)]\n",
+    "\n",
+    "You can check where an object \"lives\" with the `parent()` command. It works more or less like the Python command `type()`, but it gives a more Mathematically inclined answer. Check the reference link [6] above if you want more details."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Rational Field"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Edit this cell to find out the type of other objects that we used\n",
+    "parent(3/5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sometimes Sage does not give you the best possible interpretation, so you can force something to be interpreted as living in a smaller ring as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Symbolic Ring\n",
+      "Integer Ring\n"
+     ]
+    }
+   ],
+   "source": [
+    "minus_one = e^(pi*I)\n",
+    "minus_one_coerced = ZZ(e^(pi*I))  # coercion\n",
+    "print(parent(minus_one))\n",
+    "print(parent(minus_one_coerced))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Remark.** Notice that there is a fundamental difference between the rings `RR` and `CC` and all the others in the table above: the real and complex numbers are *approximated*."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n",
+      "3.00000000000000\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(QQ(3))\n",
+    "print(RR(3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also choose the precision of this approximation using the alternative name `RealField`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Real Field with 53 bits of precision\n",
+      "Real Field with 1000 bits of precision\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(RR)\n",
+    "print(RealField(prec=1000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Polynomial rings\n",
+    "\n",
+    "**Reference:** [[7](https://doc.sagemath.org/html/en/reference/polynomial_rings/index.html)]\n",
+    "\n",
+    "If you want to work with polynomials over a certain ring it is better to use this specific construction, rather than the symbolic expressions introduced above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Multivariate Polynomial Ring in x, y, z over Real Field with 53 bits of precision"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "polring.<x,y,z> = RR[]  # Alternative: polring.<x,y,z> = PolynomialRing(RR)\n",
+    "polring"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can use as many variables as you like, and you can replace `RR` with any ring. In the example above `polring` is just the name of the variable (in the computer science sense) associated with this polynomial ring.\n",
+    "\n",
+    "## Operations on polynomials\n",
+    "\n",
+    "The usual Mathematical operations are available on polynomial rings, including Euclidean division `//` and remainder `%`. There is also the single-slash division `/`, but the result may not be a polynomial anymore.\n",
+    "\n",
+    "**Exercise:** use the `parent()` command to find out what the quotient of two polynomials is.\n",
+    "\n",
+    "**Question:** what happens if you remove the first line in the cell below? What if we used the variable `y` instead of `x`?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "x + 1\n",
+      "-4\n",
+      "(x^2 + 2*x - 3)/(x + 1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "polring.<x> = QQ[]\n",
+    "p = x^2 + 2*x - 3   # Don't forget * for multiplication!\n",
+    "q = p // (x+1)\n",
+    "r = p %  (x+1)\n",
+    "f = p /  (x+1)\n",
+    "print(q)\n",
+    "print(r)\n",
+    "print(f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can do more complex operations. Try out `roots()` and `factor` in the cell below.\n",
+    "\n",
+    "**Remark.** Notice how the result can change substantially if you change the base ring.\n",
+    "\n",
+    "**Remark.** [Factorizations](https://doc.sagemath.org/html/en/reference/structure/sage/structure/factorization.html) are a particular object in Sage. They are kinda like a list, but not really. You can get a list of pairs (factor, power) with `list(factor(f))`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(t + 1) * (t^2 - 3) * (t^2 + 1)\n",
+      "[(-1, 1)]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(y + 1) * x"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "polring_onevar.<t> = QQ[]\n",
+    "\n",
+    "f = t^5 + t^4 - 2*t^3 - 2*t^2 - 3*t - 3\n",
+    "print(factor(f))\n",
+    "print(f.roots())  # Result: list of pairs (root,multiplicity)\n",
+    "\n",
+    "polring_manyvar.<x,y,z> = QQ[]\n",
+    "factor(x*y+x)\n",
+    "\n",
+    "# The following line gives an error, because the polynomial\n",
+    "# is understood to possibly have many variables:\n",
+    "#(x^2-1).roots()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Matrices and vectors\n",
+    "\n",
+    "**References:** [[8](https://doc.sagemath.org/html/en/reference/matrices/index.html)], but in particular the subections [[9](https://doc.sagemath.org/html/en/reference/matrices/sage/matrix/docs.html)] and [[10](https://doc.sagemath.org/html/en/reference/matrices/sage/matrix/matrix2.html)]\n",
+    "\n",
+    "In Sage you can easily manipulate matrices and vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[   1    2    3]\n",
+      "[   0    0    1]\n",
+      "[   4   -3 22/7] \n",
+      "\n",
+      "[1/2   0   0]\n",
+      "[  7   0   0]\n",
+      "[  1   1   1] \n",
+      "\n",
+      "(3/2, 21, 6) \n",
+      "\n",
+      "[  -7/2    -10   80/7]\n",
+      "[    17     -4   15/7]\n",
+      "[ 241/7  -18/7 869/49] \n",
+      "\n",
+      "Rank of A = 3\n",
+      "Rank of B = 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "A = matrix([[1,2,3],[0,0,1],[4,-3,22/7]])\n",
+    "B = matrix([[1/2,0,0],[7,0,0],[1,1,1]])\n",
+    "v = vector([3,4,-1])\n",
+    "\n",
+    "print(A, \"\\n\")  # \\n just means \"newline\"\n",
+    "print(B, \"\\n\")\n",
+    "print(B*v, \"\\n\")\n",
+    "print(A^2 + 2*B - A*B, \"\\n\")\n",
+    "\n",
+    "print(\"Rank of A =\", rank(A)) # You can also use A.rank()\n",
+    "print(\"Rank of B =\", rank(B))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** in the cell above, compute the determinant, inverse and characteristic polynomial of the matrix `A`. *Hint: look at the reference [10] above (the functions are listed in alphabetic order).*\n",
+    "\n",
+    "As for polynomials, you can specify where a matrix or a vector lives"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Full MatrixSpace of 2 by 2 dense matrices over Complex Field with 53 bits of precision"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "M = matrix(CC, [[0,1],[1,0]])\n",
+    "parent(M)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also solve linear systems and compute eigenvalues and eigenvectors of a matrix\n",
+    "\n",
+    "**Warning.** In linear algebra there are distinct concepts of *left* and *right* eigenvalues (and eigenvector). The one you know is probably that of **right** eigen-{value,vector}, that is an element $\\lambda$ of the base field and a non-zero vector $\\mathbf v$ with $A\\mathbf v=\\lambda\\mathbf v$. The other concept corresponds to the equality $\\mathbf v^TA=\\lambda \\mathbf v$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.289916349448506, 0.0241596957873755)"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A = Matrix(RR, [[sqrt(59),32],[-1/4,3]])\n",
+    "v = vector(RR, [3,0])\n",
+    "A.solve_right(v) # Solve Ax=v. Alternative: A \\ v"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[\n",
+       "(-0.3722813232690144?, Vector space of degree 2 and dimension 1 over Algebraic Field\n",
+       "User basis matrix:\n",
+       "[                   1 -0.6861406616345072?]),\n",
+       "(5.372281323269015?, Vector space of degree 2 and dimension 1 over Algebraic Field\n",
+       "User basis matrix:\n",
+       "[                 1 2.186140661634508?])\n",
+       "]"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A = Matrix(QQ, [[1,2],[3,4]])\n",
+    "A.eigenspaces_right() # Also: A.eigenvalues(), A.eigenvectors_right()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also extract a specific submatrix by selecting only some rows and columns, with a syntax similar to that of Python's lists. Check out more examples in the reference [9] above, and try them in the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[-14   2   0  -1   1  -2  -1]\n",
+      "[  0  -8   0   9  -2  11   1]\n",
+      "[  0   3   1  -1   1   1 221]\n",
+      "[ -1   2   1 -25 -10   4   0]\n",
+      "[ -3   0   0   2  16  -1  -2]\n",
+      "[  1  -3   3 -41   1   0   0]\n",
+      "[ -2   1   0   0  -6   2  12] \n",
+      "\n",
+      "[ 0  9 -2]\n",
+      "[ 1 -1  1] \n",
+      "\n",
+      "[-14   2   0  -1   1  -2  -1] \n",
+      "\n",
+      "[-14   2   0  -1   1]\n",
+      "[  1  -3   3 -41   1]\n",
+      "[  0   3   1  -1   1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "A = MatrixSpace(ZZ, 7).random_element()\n",
+    "print(A, \"\\n\")\n",
+    "print(A[1:3,2:5], \"\\n\") # Rows from 1 to 3, columns from 2 to 5\n",
+    "print(A[0,0:], \"\\n\")    # First row, all columns\n",
+    "print(A[[0,5,2],0:5])   # Rows 0, 5 and 2 (in this order) and columns 0 to 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** write a sage function that computes the determinant of an $n\\times n$ matrix $A=(a_{ij})$ using Laplace's rule by the first row, that is \n",
+    "\\begin{align*}\n",
+    "    \\operatorname{det}A = \\sum_{j=1}^n (-1)^ja_{0j}M_{0j}\n",
+    "\\end{align*}\n",
+    "where $M_{0j}$ is the determinant of the $(n-1)\\times(n-1)$ matrix obtained by removing the $0$-th row and the $j$-th column from $A$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def my_det(A):\n",
+    "    if not A.is_square():\n",
+    "        print(\"Error: matrix is not square\")\n",
+    "    \n",
+    "    n = A.nrows()  # size of the matrix\n",
+    "    \n",
+    "    # Continue from here!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Number Theory\n",
+    "\n",
+    "**Reference:** [[11](https://doc.sagemath.org/html/en/reference/rings_standard/sage/rings/integer.html)]\n",
+    "\n",
+    "Sage includes a large library of functions for computing with the integers, see the link above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3^2 * 3607 * 3803\n",
+      "True\n",
+      "True\n",
+      "619703040\n",
+      "9\n",
+      "13548070123626141\n"
+     ]
+    }
+   ],
+   "source": [
+    "n = 123456789\n",
+    "m = 987654321\n",
+    "p = 3607\n",
+    "\n",
+    "print(factor(n))\n",
+    "print(is_prime(p))\n",
+    "print(p.divides(n))\n",
+    "print(euler_phi(m))\n",
+    "print(gcd(n, m))\n",
+    "print(lcm(n, m))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Primes\n",
+    "\n",
+    "**Reference:** [[12](https://doc.sagemath.org/html/en/reference/sets/sage/sets/primes.html)]\n",
+    "\n",
+    "The set of prime numbers is called `Primes()`. It is like an infinite list: for example you can get the one-millionth prime number or you can use this list to create other lists. You can also check what the first prime number larger than a given number is."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Set of all prime numbers: 2, 3, 5, 7, ...\n",
+      "31 15485867\n",
+      "47\n",
+      "[79, 83, 89, 97]\n"
+     ]
+    }
+   ],
+   "source": [
+    "PP = Primes()\n",
+    "print(PP)\n",
+    "print(PP[10], PP[10^6])\n",
+    "print(PP.next(44))\n",
+    "\n",
+    "First_Thousand_Primes = PP[0:1000]\n",
+    "print([p for p in First_Thousand_Primes if p < 100 and p > 75])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The Chinese remainder theorem (CRT)\n",
+    "\n",
+    "We say that two integers $a$ and $b$ are *congruent* modulo another integer $n>0$ if they have the same remainder when divided by $n$. We denote this by $a\\equiv b\\pmod n$, or in Python/Sage syntax `a % n == b % n`.\n",
+    "\n",
+    "The Chinese remainder theorem states that if $a,b\\in\\mathbb Z$ and $n,m\\in \\mathbb Z_{>0}$ are such that $\\gcd(n,m)=1$ then the system of congruences\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\begin{cases}\n",
+    "    x \\equiv a \\pmod n\\\\\n",
+    "    x \\equiv b \\pmod m\n",
+    "\\end{cases}\n",
+    "\\end{align*}\n",
+    "\n",
+    "has exactly one solution modulo $mn$. This means that there is one and only one number $x$ with $0\\leq x<mn$ such that $x\\equiv a\\pmod n$ and $x\\equiv b\\pmod m$.\n",
+    "\n",
+    "The procedure to find such a number is not too hard to describe (you might see it in an algebra or number theory course), but it can be a bit long. Luckily, Sage can do this for you:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "74306 2 798\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = 2\n",
+    "b = -1\n",
+    "n = 172\n",
+    "m = 799\n",
+    "\n",
+    "if gcd(n,m) != 1:\n",
+    "    print(\"The numbers are not comprime, I can't solve this!\")\n",
+    "else:\n",
+    "    x = crt(a, b, n, m)\n",
+    "    print(x, x%n, x%m)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise.** There is a more general version of the Chinese remainder theorem which says that if $a_0, a_1, \\dots, a_k\\in\\mathbb Z$ and $n_0, n_2, \\dots, n_k\\in\\mathbb Z_{>0}$ are such that $\\gcd(n_i, n_j)=1$ for $i\\neq j$, then the system of congruences\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\begin{cases}\n",
+    "    x \\equiv a_0 \\pmod {n_0}\\\\\n",
+    "    x \\equiv a_1 \\pmod {n_1}\\\\\n",
+    "    \\dots \\\\\n",
+    "    x \\equiv a_k \\pmod {n_k}\n",
+    "\\end{cases}\n",
+    "\\end{align*}\n",
+    "\n",
+    "has exactly one solution modulo $\\prod_{i=0}^kn_i$. Use the `crt()` function to find a solution to such a system.\n",
+    "*Hint: start by running the command `help(crt)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 127,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#help(crt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cryptography: RSA\n",
+    "\n",
+    "[Cryptography](https://en.wikipedia.org/wiki/Cryptography) is the discipline that studies methods to communicate secrets in such a way that any unauthorized listener would not be able to understand the message.\n",
+    "\n",
+    "A simple cryptographic protocol could be changing every letter of your text following a fixed scheme (or *cypher*), for example by turning every A into a B, every B into a C and so on. However this is not a very secure method, for many reasons. One of them is that at some point the people who want to communicate need to agree on what method to use, and anyone listening to that conversation would be able to decypher every subsequent conversation. A public-key cryptographic protocol solves this problem.\n",
+    "\n",
+    "## Public-key cryptography\n",
+    "\n",
+    "Public-key cryptographic protocols, such as RSA, work like this: there are two keys, a *private* key that is only known to person A (traditionally called Alice in every example), and a *public* key that does not need to be secret.\n",
+    "\n",
+    "The public key is used to *encrypt* the message (that is to \"lock\" it, or \"hyde\" it), but one needs the private key to *decrypt* it. Imagine having two keys for your door, but one can only be used to lock it, while the other only to open it.\n",
+    "\n",
+    "The message exchange works like this: suppose that person B (Bob) wants to send a secret message to Alice. Then Alice secretely generates a private and a public key and sends only the public one to Bob. Now Bob encrypts the message and sends it to Alice, who can use her private key to decrypt it. Even if Eve (short for *eavesdropper*, an unauthorized listener) listens to every message exchanged, she won't be able to decypher the secret: the private key has never left Alice's house!\n",
+    "\n",
+    "Notice that such a protocol is *asymmetric*: if Alice wanted to send a secret to Bob in reply, Bob would need to generate a pair of keys of his own.\n",
+    "\n",
+    "Let's see how we can do this in practice, using number theory!\n",
+    "\n",
+    "## RSA\n",
+    "\n",
+    "As many other cryptography protocols, RSA is based on a Mathematical process that is easy to do in one direction, but very hard to invert. In this case the hard process is integer factorization, that is decomposing an integer number as a product of primes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True True False\n"
+     ]
+    }
+   ],
+   "source": [
+    "p = 100003100019100043100057100069\n",
+    "q = 100144655312449572059845328443\n",
+    "n = p*q\n",
+    "print(is_prime(p), is_prime(q), is_prime(p*q))\n",
+    "\n",
+    "# Use the command below to see how long it takes\n",
+    "#timeit(\"factor(n)\", number=1, repeat=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In order to generate the keys, Alice picks a number $n$ which is the product of two large primes $p$ and $q$ of more or less the same size. Finding such primes is relatively easy compared to factoring the number $n$ she obtained. Then she computes the Euler totient $\\varphi(n)=(p-1)(q-1)$ of $n$, which she can do because she knows that $n=pq$ - it would be impossible otherwise!\n",
+    "\n",
+    "Then Alice can compute two integers $(d,e)$ such that $de\\equiv 1\\pmod{\\varphi(n)}$. She will send the numbers $n$ and $d$ to Bob and keep $e$ secret. In this case the public key is the pair $(n,d)$, while $e$ is the private key.\n",
+    "\n",
+    "Of course, she does all of this using Sage!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(419199544978969, 235530823946467, 80799425863927)"
+      ]
+     },
+     "execution_count": 105,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def two_large_primes():\n",
+    "    p, q = 0, 0\n",
+    "    # We make sure that they are different\n",
+    "    while p == q:\n",
+    "        p = Primes()[randint(10^6, 2*10^6)]\n",
+    "        q = Primes()[randint(10^6, 2*10^6)]\n",
+    "    return p, q\n",
+    "\n",
+    "def random_unit_mod(N):\n",
+    "    R = Integers(N)\n",
+    "    d = R(0)\n",
+    "    # We make sure that it is invertible\n",
+    "    while not d.is_unit():\n",
+    "        d = R.random_element()\n",
+    "    return d\n",
+    "\n",
+    "def Alice_generate_keys():\n",
+    "    p, q = two_large_primes()\n",
+    "    n = p*q\n",
+    "    phi_n = (p-1)*(q-1) # euler_phi(n) is slow!\n",
+    "    \n",
+    "    d = random_unit_mod(phi_n)\n",
+    "    e = d^-1\n",
+    "    return n, d, e\n",
+    "\n",
+    "Alice_generate_keys()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, how does Bob encrypt his message? Let's say he wants to send to Alice the number $m$ with $1<m<n$ (In practice he would like to send her some text with emojis, or maybe a voice message; but for computers everything is a number, and there are different ways to translate any sort of information to a number. He just chooses one of the many standard methods that already exist, no cryptography is needed in this step. If the message $m$ is too long, he can split it up in some pieces and repeat the process multiple times.)\n",
+    "\n",
+    "Now he computes $m^d\\pmod n$ and sends it back to Alice."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "149461597163501"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def Bob_encrypt(m, n, d):\n",
+    "    R = Integers(n)\n",
+    "    return R(m)^d  # Assume that n is large enough\n",
+    "    \n",
+    "message = 42424242\n",
+    "Bob_encrypt(message, 419199544978969, 235530823946467)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since $de\\equiv 1\\pmod{\\varphi(n)}$, it follows that $(m^d)^e\\equiv m\\pmod n$ (see [Wikipedia: Euler's theorem](https://en.wikipedia.org/wiki/Euler%27s_theorem)). So for Alice it is very easy to get back the original message:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "42424242"
+      ]
+     },
+     "execution_count": 108,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def Alice_decrypt(m_encrypted, n, e):\n",
+    "    R = Integers(n)\n",
+    "    return R(m_encrypted)^e\n",
+    "\n",
+    "Alice_decrypt(149461597163501, 419199544978969, 80799425863927)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Another assumption on which RSA relies is that even if one knows $M=m^e$ and $e$, extracting the $e$-th root of $M$ modulo $n$ (and thus obtaining $m$) is very hard. Currently the best known way to do this is by factorizing $n$ first, which is considered to be a very hard problem. However, there is no proof that faster algorithms can't be devised.\n",
+    "\n",
+    "Moreover, one day we will overcome the current technological difficulties and quantum computers will be available. Quantum computers are not just \"more powerful\" than classical hardware, but they work based on completely different logical foundations and they make the factorization problem much easier to solve: for example [Shor's algorithm](https://en.wikipedia.org/wiki/Shor%27s_algorithm) takes advantage of this different logic and can factorize numbers quickly, if run on a quantum computer.\n",
+    "\n",
+    "To this day the largest number factorized with a quantum computer is $21=3\\times 7$. Nonetheless, quantum-safe cryptography protocols (i.e. based on problems that are hard to solve also with quantum computers) have already been developed."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SageMath 9.2",
+   "language": "sage",
+   "name": "sagemath"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture5/notebook/.ipynb_checkpoints/7-SageAlgebra-modified+solutions-checkpoint.ipynb b/src/Lecture5/notebook/.ipynb_checkpoints/7-SageAlgebra-modified+solutions-checkpoint.ipynb
new file mode 100644
index 0000000..f4e39b2
--- /dev/null
+++ b/src/Lecture5/notebook/.ipynb_checkpoints/7-SageAlgebra-modified+solutions-checkpoint.ipynb
@@ -0,0 +1,1099 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This lecture's notes are in a different format: the presentations for the $\\LaTeX$ part were made with $\\LaTeX$, so this one is made with Sage, or rather with the [Jupyter Notebook](https://jupyter.org/).\n",
+    "\n",
+    "# The Jupyter Notebook\n",
+    "**Reference:** [[1](https://jupyter.org/documentation)]\n",
+    "\n",
+    "The Jupyter Notebook is one of the default interfaces for SageMath, along with the command line interface. You can access it via web browser, but it is running locally on your device (notice the strange url: `http://localhost:8888/notebooks...`).\n",
+    "\n",
+    "You can create a new notebook by clicking on `New > SageMath 9.2`. You can also create a Python 3 notebook to write Python code.\n",
+    "\n",
+    "Jupyter saves and reads files in the `.ipynb` format. If you download the file for this lecture you can open it and follow the examples interactively.\n",
+    "\n",
+    "## Cells\n",
+    "\n",
+    "The notebook contains one or more *interactive cells* that you can run, like this one below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Exercise: modify this cell to use the print() command\n",
+    "\n",
+    "a = 34*102\n",
+    "\n",
+    "print(2+2)\n",
+    "print(\"hello\")\n",
+    "print(a-1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you are reading this from Jupyter rather than from the pdf file, you can edit the cell above and run it again. You can also add more cells by selecting `Insert` from the menu bar.\n",
+    "\n",
+    "Notice that only the last statement produces an output. You can force anything to be written as output with the `print()` command, which works like in Python. As an exercise, try to modify the cell above to provide more output!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "text *hello*\n",
+    "* this\n",
+    "* is\n",
+    "* a list"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Markdown\n",
+    "\n",
+    "[Markdown](https://en.wikipedia.org/wiki/Markdown) is a simple markup language - think of LaTeX or html, but much simpler.\n",
+    "You can add text to your notebook with Markdown cells by selecting `Cell > Cell Type > Markdown`.\n",
+    "\n",
+    "You can also include some LaTeX code in Markdown cells, with dollar signs $ or align environments:\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\frac{(x+y)^2}{x+1} = \\frac{x^2+2xy+y^2}{x+1}\n",
+    "\\end{align*}\n",
+    "\n",
+    "When you are done writing a Markdown cell, you can run it to see the well-formatted text. To edit the text again, double-click on the cell. Try doing it now to fix the formula above!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Symbolic expressions\n",
+    "\n",
+    "**Reference:** [[2](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html)]\n",
+    "\n",
+    "Now, let's get started with Sage. One thing you might want to do is manipulating symbolic expressions, like the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[\n",
+      "x == -1/2*(I*sqrt(3) + 1)*(1/2*I*sqrt(3) - 1/2)^(1/3) + (1/2*I*sqrt(3) - 1/2)^(2/3) - 1,\n",
+      "x == (1/2*I*sqrt(3) - 1/2)^(4/3) - 1/2*(I*sqrt(3) + 1)/(1/2*I*sqrt(3) - 1/2)^(1/3) - 1,\n",
+      "x == (1/2*I*sqrt(3) - 1/2)^(1/3) + 1/(1/2*I*sqrt(3) - 1/2)^(1/3) - 1\n",
+      "]\n"
+     ]
+    }
+   ],
+   "source": [
+    "f =  (x^2 + 2*x - 5 >= 0)\n",
+    "solve(f,x)\n",
+    "\n",
+    "g =  x^3 + 3*x^2-1\n",
+    "print(solve(g==0, x))\n",
+    "\n",
+    "h = x^2 +3*x -1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice that the single `=` is part of an assignment, as in Python: we are *assigning* to the variable `f` the value `x^2 + 2*x - 5 >= 0`, which in this case is an equation, so it contains the symbol `==`. Keep in mind the difference between the two!\n",
+    "\n",
+    "**Exercise:** change the code above to solve the corresponding inequality $x^2+2x-5\\geq 0$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mathematical variables\n",
+    "\n",
+    "Last time we saw what *variables* are in Python, and that they are a little bit different from the *Mathematical variables* that you use in Mathematics. In Sage, both concepts are present, but they are still distinct. For example in the cell above `f` is a variable in the sense of computer science, while `x` is a Mathematical variable.\n",
+    "\n",
+    "If you want to use Mathematical variables other than `x`, you first need to *declare* them with the `var()` command:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "var('z')\n",
+    "solve(z^2 + z - 2 == 0, z)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Try removing the first line in the cell above and see what error you get!\n",
+    "\n",
+    "Here is another example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "var('a', 'b')\n",
+    "f = x^2+a*x+b == 0\n",
+    "solve(f,a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Some common constants are [already defined](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html) in Sage:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "e^(pi*I)\n",
+    "print(N(pi), N(e))\n",
+    "e = 42\n",
+    "print(e)\n",
+    "reset('e')\n",
+    "print(N(e))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will study symbolic expressions more in detail next time, in the context of calculus/analysis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Basic rings and fields\n",
+    "\n",
+    "**References:** [[3](https://doc.sagemath.org/html/en/reference/rings_standard/index.html)]\n",
+    "[[4](https://doc.sagemath.org/html/en/reference/rings_numerical/index.html)]\n",
+    "[[5](https://doc.sagemath.org/html/en/reference/finite_rings/index.html)]\n",
+    "\n",
+    "As you should know, a *field* is a Mathematical structure with two operations, addition and multiplication, which respect certain rules (distributivity, associativity, commutativity...). Some examples of fields are the Rational numbers $\\mathbb Q$, the Real numbers $\\mathbb R$ and the Complex numbers $\\mathbb C$, but there are many more. As you should also know, a *(commutative) ring* is like a field, except not all elements different from $0$ need have a multiplicative inverse. For example the integers $\\mathbb Z = \\{ \\dots, -1, 0, 1, 2, \\dots\\}$ are a ring, but not a field.\n",
+    "\n",
+    "These structures are already implemented in Sage. Some of the most common are listed in the following table:\n",
+    "\n",
+    "|Mathematical object|Math symbol|Sage name|\n",
+    "|------------------:|:---------:|:--------|\n",
+    "|Integers|$\\mathbb Z$|`ZZ`|\n",
+    "|Rational numbers|$\\mathbb Q$|`QQ`|\n",
+    "|Real numbers|$\\mathbb R$|`RR`|\n",
+    "|Complex numbers|$\\mathbb C$|`CC`|\n",
+    "|Integers modulo $n$|$\\mathbb Z/n\\mathbb Z$|`Integers(n)`|\n",
+    "|Finite fields|$\\mathbb F_p$|GF(p)|\n",
+    "|$\\dots$|$\\dots$|$\\dots$|"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you write a number or an expression, Sage will figure out where it \"lives\", choosing the most restrictive interpretation possible. For example `3` will be interpreted to be an integer, even if it is also a rational number, a real number and a complex number."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parents and coercion\n",
+    "**Reference:** [[6](https://doc.sagemath.org/html/en/tutorial/tour_coercion.html)]\n",
+    "\n",
+    "You can check where an object \"lives\" with the `parent()` command. It works more or less like the Python command `type()`, but it gives a more Mathematically inclined answer. Check the reference link [6] above if you want more details."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Edit this cell to find out the type of other objects that we used\n",
+    "print(parent(3/5))\n",
+    "print(QQ)\n",
+    "print(type(3/5))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sometimes Sage does not give you the best possible interpretation, so you can force something to be interpreted as living in a smaller ring as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "minus_one = e^(pi*I)\n",
+    "print(minus_one)\n",
+    "minus_one_coerced = ZZ(e^(pi*I))  # coercion\n",
+    "#print(ZZ(1/2))\n",
+    "print(parent(minus_one))\n",
+    "print(parent(x^2))\n",
+    "print(parent(minus_one_coerced))\n",
+    "print(parent(5.2))\n",
+    "print(parent(QQ(5.2)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Remark.** Notice that there is a fundamental difference between the rings `RR` and `CC` and all the others in the table above: the real and complex numbers are *approximated*."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(QQ(3))\n",
+    "print(RR(3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also choose the precision of this approximation using the alternative name `RealField`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(RR)\n",
+    "print(RealField(prec=1000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Polynomial rings\n",
+    "\n",
+    "**Reference:** [[7](https://doc.sagemath.org/html/en/reference/polynomial_rings/index.html)]\n",
+    "\n",
+    "If you want to work with polynomials over a certain ring it is better to use this specific construction, rather than the symbolic expressions introduced above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Univariate Polynomial Ring in x over Rational Field\n",
+      "[]\n",
+      "[(-2, 2)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "polring.<x> = QQ[]  # Alternative: polring.<x,y,z> = PolynomialRing(RR)\n",
+    "polring\n",
+    "print(parent(x))\n",
+    "g =  x^3 + 3*x^2-1\n",
+    "print(g.roots())\n",
+    "print((x^2+4*x+4).roots())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can use as many variables as you like, and you can replace `RR` with any ring. In the example above `polring` is just the name of the variable (in the computer science sense) associated with this polynomial ring.\n",
+    "\n",
+    "## Operations on polynomials\n",
+    "\n",
+    "The usual Mathematical operations are available on polynomial rings, including Euclidean division `//` and remainder `%`. There is also the single-slash division `/`, but the result may not be a polynomial anymore.\n",
+    "\n",
+    "**Exercise:** use the `parent()` command to find out what the quotient of two polynomials is.\n",
+    "\n",
+    "**Question:** what happens if you remove the first line in the cell below? What if we used the variable `y` instead of `x`?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "x + 1\n",
+      "-4\n",
+      "(x^2 + 2*x - 3)/(x + 1)\n",
+      "Fraction Field of Univariate Polynomial Ring in x over Rational Field\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "x^4 + 2*x^3 - 4*x^2 - 2*x + 3"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "polring.<x> = QQ[]\n",
+    "p = x^2 + 2*x - 3   # Don't forget * for multiplication!\n",
+    "q = p // (x+1)\n",
+    "r = p %  (x+1)\n",
+    "f = p /  (x+1)\n",
+    "print(q)\n",
+    "print(r)\n",
+    "print(f)\n",
+    "print(parent(f))\n",
+    "p*(x^2-1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can do more complex operations. Try out `roots()` and `factor` in the cell below.\n",
+    "\n",
+    "**Remark.** Notice how the result can change substantially if you change the base ring.\n",
+    "\n",
+    "**Remark.** [Factorizations](https://doc.sagemath.org/html/en/reference/structure/sage/structure/factorization.html) are a particular object in Sage. They are kinda like a list, but not really. You can get a list of pairs (factor, power) with `list(factor(f))`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(t + 1) * (t^2 - 3) * (t^2 + 1)\n",
+      "[(t + 1, 1), (t^2 - 3, 1), (t^2 + 1, 1)]\n",
+      "t^5 + t^4 - 2*t^3 - 2*t^2 - 3*t - 3\n",
+      "t^2 - 1\n",
+      "[(-1, 1)]\n",
+      "Multivariate Polynomial Ring in x, y, z over Rational Field\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Multivariate Polynomial Ring in x, y, z over Rational Field"
+      ]
+     },
+     "execution_count": 76,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "polring_onevar.<t> = QQ[]\n",
+    "\n",
+    "f = t^5 + t^4 - 2*t^3 - 2*t^2 - 3*t - 3\n",
+    "fact = factor(f)\n",
+    "print(factor(f))\n",
+    "print(list(fact))\n",
+    "print((t + 1) * (t^2 - 3) * (t^2 + 1))\n",
+    "print((t+1)*(t-1))\n",
+    "print(f.roots())  # Result: list of pairs (root,multiplicity)\n",
+    "\n",
+    "polring_manyvar.<x,y,z> = QQ[]\n",
+    "factor(x*y+x)\n",
+    "\n",
+    "# The following line gives an error, because the polynomial\n",
+    "# is understood to possibly have many variables:\n",
+    "print(parent(x))\n",
+    "(QQ['x'](x^2-1)).roots()\n",
+    "parent(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Matrices and vectors\n",
+    "\n",
+    "**References:** [[8](https://doc.sagemath.org/html/en/reference/matrices/index.html)], but in particular the subections [[9](https://doc.sagemath.org/html/en/reference/matrices/sage/matrix/docs.html)] and [[10](https://doc.sagemath.org/html/en/reference/matrices/sage/matrix/matrix2.html)]\n",
+    "\n",
+    "In Sage you can easily manipulate matrices and vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[   1    2    3]\n",
+      "[   0    0    1]\n",
+      "[   4   -3 22/7] \n",
+      "\n",
+      "[1/2   0   0]\n",
+      "[  7   0   0]\n",
+      "[  1   1   1] \n",
+      "\n",
+      "[1 0]\n",
+      "[0 1] \n",
+      "\n",
+      "(3/2, 21, 6) \n",
+      "\n",
+      "[  -7/2    -10   80/7]\n",
+      "[    17     -4   15/7]\n",
+      "[ 241/7  -18/7 869/49] \n",
+      "\n",
+      "Rank of A = 3\n",
+      "Rank of B = 2\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "11"
+      ]
+     },
+     "execution_count": 94,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A = matrix([[1,2,3],[0,0,1],[4,-3,22/7]])\n",
+    "B = matrix([[1/2,0,0],[7,0,0],[1,1,1]])\n",
+    "C = matrix([[1,0],[0,1]])\n",
+    "v = vector([3,4,-1])\n",
+    "\n",
+    "print(A, \"\\n\")  # \\n just means \"newline\"\n",
+    "print(B, \"\\n\")\n",
+    "print(C, \"\\n\")\n",
+    "#print(A*C) Error!\n",
+    "print(B*v, \"\\n\")\n",
+    "print(A^2 + 2*B - A*B, \"\\n\")\n",
+    "\n",
+    "print(\"Rank of A =\", rank(A)) # You can also use A.rank()\n",
+    "print(\"Rank of B =\", rank(B))\n",
+    "A.determinant()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** in the cell above, compute the determinant, inverse and characteristic polynomial of the matrix `A`. *Hint: look at the reference [10] above (the functions are listed in alphabetic order).*\n",
+    "\n",
+    "As for polynomials, you can specify where a matrix or a vector lives"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Full MatrixSpace of 2 by 2 dense matrices over Complex Field with 53 bits of precision"
+      ]
+     },
+     "execution_count": 97,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "M = matrix(CC, [[0,1/2],[1,0]])\n",
+    "parent(M)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also solve linear systems and compute eigenvalues and eigenvectors of a matrix\n",
+    "\n",
+    "**Warning.** In linear algebra there are distinct concepts of *left* and *right* eigenvalues (and eigenvector). The one you know is probably that of **right** eigen-{value,vector}, that is an element $\\lambda$ of the base field and a non-zero vector $\\mathbf v$ with $A\\mathbf v=\\lambda\\mathbf v$. The other concept corresponds to the equality $\\mathbf v^TA=\\lambda \\mathbf v$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "A = Matrix(RR, [[sqrt(59),32],[-1/4,3]])\n",
+    "v = vector(RR, [3,0])\n",
+    "A.solve_right(v) # Solve Ax=v. Alternative: A \\ v"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<ipython-input-103-d1ccc4990851>:2: UserWarning: Using generic algorithm for an inexact ring, which will probably give incorrect results due to numerical precision issues.\n",
+      "  A.eigenvalues() # Also: A.eigenvalues(), A.eigenvectors_right()\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[5.37228132326901, -0.372281323269014]"
+      ]
+     },
+     "execution_count": 103,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A = Matrix(RR, [[1,2],[3,4]])\n",
+    "A.eigenvalues() # Also: A.eigenvalues(), A.eigenvectors_right()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also extract a specific submatrix by selecting only some rows and columns, with a syntax similar to that of Python's lists. Check out more examples in the reference [9] above, and try them in the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[ -3 -25  -5  -3  61   0  -1]\n",
+      "[ 23   0  -1   1   0   1  -1]\n",
+      "[286   2   7   0 -21  -1   0]\n",
+      "[  2  -1  -2   0  -1   4   0]\n",
+      "[  1  -1   1   0   2  -2   7]\n",
+      "[  0  15  -1   0  -3   1  -1]\n",
+      "[ -1   1  -2   0   2   1   1] \n",
+      "\n",
+      "[ -1   1   0]\n",
+      "[  7   0 -21] \n",
+      "\n",
+      "[ -3 -25  -5  -3  61   0  -1] \n",
+      "\n",
+      "[ -3 -25  -5  -3  61]\n",
+      "[  0  15  -1   0  -3]\n",
+      "[286   2   7   0 -21]\n",
+      "-25\n"
+     ]
+    }
+   ],
+   "source": [
+    "A = MatrixSpace(ZZ, 7).random_element()\n",
+    "print(A, \"\\n\")\n",
+    "print(A[1:3,2:5], \"\\n\") # Rows from 1 to 3, columns from 2 to 5\n",
+    "print(A[0,0:], \"\\n\")    # First row, all columns\n",
+    "print(A[[0,5,2],0:5])   # Rows 0, 5 and 2 (in this order) and columns 0 to 5\n",
+    "print(A[0,1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** write a sage function that computes the determinant of an $n\\times n$ matrix $A=(a_{ij})$ using Laplace's rule by the first row, that is \n",
+    "\\begin{align*}\n",
+    "    \\operatorname{det}A = \\sum_{j=1}^n (-1)^ja_{0j}M_{0j}\n",
+    "\\end{align*}\n",
+    "where $M_{0j}$ is the determinant of the $(n-1)\\times(n-1)$ matrix obtained by removing the $0$-th row and the $j$-th column from $A$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[ -1  -3  -1  11   2  -1  -5]\n",
+      "[  1   0   0  -6  -1   0   1]\n",
+      "[  1   0  -1   0   1  -1   0]\n",
+      "[-24   1  -2  -7   4   0   1]\n",
+      "[ -3   0  -1   0   6  -1   0]\n",
+      "[-17  -1   1   0  28   1   0]\n",
+      "[  1  -4   1   1  -2  -6  -2]\n",
+      "Sage determinant:  13578\n",
+      "my_det:  13578\n"
+     ]
+    }
+   ],
+   "source": [
+    "def my_det(A):\n",
+    "    if not A.is_square():\n",
+    "        print(\"Error: matrix is not square\")\n",
+    "    \n",
+    "    n = A.nrows()  # size of the matrix\n",
+    "    \n",
+    "    if n == 1:\n",
+    "        return A[0,0]\n",
+    "    \n",
+    "    my_sum = 0\n",
+    "    for j in range(0,n):\n",
+    "        rows = range(1,n)\n",
+    "        columns = [element for element in range(0,n) if element != j]\n",
+    "        submatrix = A[rows,columns]\n",
+    "        my_sum += (-1)^j * A[0,j] * my_det(submatrix)\n",
+    "    \n",
+    "    return my_sum\n",
+    "\n",
+    "A = MatrixSpace(ZZ, 7).random_element()\n",
+    "print(A)\n",
+    "print(\"Sage determinant: \", A.determinant())\n",
+    "print(\"my_det: \", my_det(A))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Number Theory\n",
+    "\n",
+    "**Reference:** [[11](https://doc.sagemath.org/html/en/reference/rings_standard/sage/rings/integer.html)]\n",
+    "\n",
+    "Sage includes a large library of functions for computing with the integers, see the link above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3^2 * 3607 * 3803\n",
+      "[(3, 2), (3607, 1), (3803, 1)]\n",
+      "True\n",
+      "True\n",
+      "619703040\n",
+      "9\n",
+      "13548070123626141\n"
+     ]
+    }
+   ],
+   "source": [
+    "n = 123456789\n",
+    "m = 987654321\n",
+    "p = 3607\n",
+    "\n",
+    "print(factor(n))\n",
+    "print(list(factor(n)))\n",
+    "print(is_prime(p))\n",
+    "print(p.divides(n))\n",
+    "print(euler_phi(m))\n",
+    "print(gcd(n, m))\n",
+    "print(lcm(n, m))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Primes\n",
+    "\n",
+    "**Reference:** [[12](https://doc.sagemath.org/html/en/reference/sets/sage/sets/primes.html)]\n",
+    "\n",
+    "The set of prime numbers is called `Primes()`. It is like an infinite list: for example you can get the one-millionth prime number or you can use this list to create other lists. You can also check what the first prime number larger than a given number is."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Set of all prime numbers: 2, 3, 5, 7, ...\n",
+      "31 252097800629\n",
+      "47\n",
+      "[79, 83, 89, 97]\n"
+     ]
+    }
+   ],
+   "source": [
+    "PP = Primes()\n",
+    "print(PP)\n",
+    "print(PP[10], PP[10^10])\n",
+    "print(PP.next(44))\n",
+    "\n",
+    "First_Thousand_Primes = PP[0:1000]\n",
+    "print([p for p in First_Thousand_Primes if p < 100 and p > 75])\n",
+    "#print([p for p in PP if p < 100 and p > 75])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The Chinese remainder theorem (CRT)\n",
+    "\n",
+    "We say that two integers $a$ and $b$ are *congruent* modulo another integer $n>0$ if they have the same remainder when divided by $n$. We denote this by $a\\equiv b\\pmod n$, or in Python/Sage syntax `a % n == b % n`.\n",
+    "\n",
+    "The Chinese remainder theorem states that if $a,b\\in\\mathbb Z$ and $n,m\\in \\mathbb Z_{>0}$ are such that $\\gcd(n,m)=1$ then the system of congruences\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\begin{cases}\n",
+    "    x \\equiv a \\pmod n\\\\\n",
+    "    x \\equiv b \\pmod m\n",
+    "\\end{cases}\n",
+    "\\end{align*}\n",
+    "\n",
+    "\n",
+    "has exactly one solution modulo $mn$. This means that there is one and only one number $x$ with $0\\leq x<mn$ such that $x\\equiv a\\pmod n$ and $x\\equiv b\\pmod m$.\n",
+    "\n",
+    "\n",
+    "For example:\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\begin{cases}\n",
+    "    x \\equiv 1 \\pmod 3\\\\\n",
+    "    x \\equiv 2 \\pmod 5\n",
+    "\\end{cases}\n",
+    "\\end{align*}\n",
+    "\n",
+    "Solution: $x=7$ (any other solution is congruent to $7$ modulo $15$; for example $22=15+7$ is also a solution).\n",
+    "\n",
+    "The procedure to find such a number is not too hard to describe (you might see it in an algebra or number theory course), but it can be a bit long. Luckily, Sage can do this for you:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "74306 2 798\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = 2\n",
+    "b = -1\n",
+    "n = 172\n",
+    "m = 799\n",
+    "\n",
+    "if gcd(n,m) != 1:\n",
+    "    print(\"The numbers are not comprime, I can't solve this!\")\n",
+    "else:\n",
+    "    x = crt(a, b, n, m)\n",
+    "    print(x, x%n, x%m)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise.** There is a more general version of the Chinese remainder theorem which says that if $a_0, a_1, \\dots, a_k\\in\\mathbb Z$ and $n_0, n_2, \\dots, n_k\\in\\mathbb Z_{>0}$ are such that $\\gcd(n_i, n_j)=1$ for $i\\neq j$, then the system of congruences\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\begin{cases}\n",
+    "    x \\equiv a_0 \\pmod {n_0}\\\\\n",
+    "    x \\equiv a_1 \\pmod {n_1}\\\\\n",
+    "    \\dots \\\\\n",
+    "    x \\equiv a_k \\pmod {n_k}\n",
+    "\\end{cases}\n",
+    "\\end{align*}\n",
+    "\n",
+    "has exactly one solution modulo $\\prod_{i=0}^kn_i$. Use the `crt()` function to find a solution to such a system.\n",
+    "*Hint: start by running the command `help(crt)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#help(crt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cryptography: RSA\n",
+    "\n",
+    "[Cryptography](https://en.wikipedia.org/wiki/Cryptography) is the discipline that studies methods to communicate secrets in such a way that any unauthorized listener would not be able to understand the message.\n",
+    "\n",
+    "A simple cryptographic protocol could be changing every letter of your text following a fixed scheme (or *cypher*), for example by turning every A into a B, every B into a C and so on. However this is not a very secure method, for many reasons. One of them is that at some point the people who want to communicate need to agree on what method to use, and anyone listening to that conversation would be able to decypher every subsequent conversation. A public-key cryptographic protocol solves this problem.\n",
+    "\n",
+    "## Public-key cryptography\n",
+    "\n",
+    "Public-key cryptographic protocols, such as RSA, work like this: there are two keys, a *private* key that is only known to person A (traditionally called Alice in every example), and a *public* key that does not need to be secret.\n",
+    "\n",
+    "The public key is used to *encrypt* the message (that is to \"lock\" it, or \"hyde\" it), but one needs the private key to *decrypt* it. Imagine having two keys for your door, but one can only be used to lock it, while the other only to open it.\n",
+    "\n",
+    "The message exchange works like this: suppose that person B (Bob) wants to send a secret message to Alice. Then Alice secretely generates a private and a public key and sends only the public one to Bob. Now Bob encrypts the message and sends it to Alice, who can use her private key to decrypt it. Even if Eve (short for *eavesdropper*, an unauthorized listener) listens to every message exchanged, she won't be able to decypher the secret: the private key has never left Alice's house!\n",
+    "\n",
+    "Notice that such a protocol is *asymmetric*: if Alice wanted to send a secret to Bob in reply, Bob would need to generate a pair of keys of his own.\n",
+    "\n",
+    "Let's see how we can do this in practice, using number theory!\n",
+    "\n",
+    "## RSA\n",
+    "\n",
+    "As many other cryptography protocols, RSA is based on a Mathematical process that is easy to do in one direction, but very hard to invert. In this case the hard process is integer factorization, that is decomposing an integer number as a product of primes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True True False\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "1 loop, best of 1: 9.06 s per loop"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "p = 100003100019100043100057100069\n",
+    "q = 100144655312449572059845328443\n",
+    "n = p*q\n",
+    "print(is_prime(p), is_prime(q), is_prime(p*q))\n",
+    "\n",
+    "# Use the command below to see how long it takes\n",
+    "timeit(\"factor(n)\", number=1, repeat=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In order to generate the keys, Alice picks a number $n$ which is the product of two large primes $p$ and $q$ of more or less the same size. Finding such primes is relatively easy compared to factoring the number $n$ she obtained. Then she computes the Euler totient $\\varphi(n)=(p-1)(q-1)$ of $n$, which she can do because she knows that $n=pq$ - it would be impossible otherwise!\n",
+    "\n",
+    "Then Alice can compute two integers $(d,e)$ such that $de\\equiv 1\\pmod{\\varphi(n)}$. She will send the numbers $n$ and $d$ to Bob and keep $e$ secret. In this case the public key is the pair $(n,d)$, while $e$ is the private key.\n",
+    "\n",
+    "Of course, she does all of this using Sage!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(338547806707501, 141995674537431, 107165393087271)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def two_large_primes():\n",
+    "    p, q = 0, 0\n",
+    "    # We make sure that they are different\n",
+    "    while p == q:\n",
+    "        p = Primes()[randint(10^6, 2*10^6)]\n",
+    "        q = Primes()[randint(10^6, 2*10^6)]\n",
+    "    return p, q\n",
+    "\n",
+    "def random_unit_mod(N):\n",
+    "    R = Integers(N)\n",
+    "    d = R(0)\n",
+    "    # We make sure that it is invertible\n",
+    "    while not d.is_unit():\n",
+    "        d = R.random_element()\n",
+    "    return d\n",
+    "\n",
+    "def Alice_generate_keys():\n",
+    "    p, q = two_large_primes()\n",
+    "    n = p*q\n",
+    "    phi_n = (p-1)*(q-1) # euler_phi(n) is slow!\n",
+    "    \n",
+    "    d = random_unit_mod(phi_n)\n",
+    "    e = d^-1\n",
+    "    return n, d, e\n",
+    "\n",
+    "Alice_generate_keys()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, how does Bob encrypt his message? Let's say he wants to send to Alice the number $m$ with $1<m<n$ (In practice he would like to send her some text with emojis, or maybe a voice message; but for computers everything is a number, and there are different ways to translate any sort of information to a number. He just chooses one of the many standard methods that already exist, no cryptography is needed in this step. If the message $m$ is too long, he can split it up in some pieces and repeat the process multiple times.)\n",
+    "\n",
+    "Now he computes $m^d\\pmod n$ and sends it back to Alice."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "177776139844621"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def Bob_encrypt(m, n, d):\n",
+    "    R = Integers(n)\n",
+    "    return R(m)^d  # Assume that n is large enough\n",
+    "    \n",
+    "message = 42424242\n",
+    "Bob_encrypt(message, 338547806707501, 141995674537431)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since $de\\equiv 1\\pmod{\\varphi(n)}$, it follows that $(m^d)^e\\equiv m\\pmod n$ (see [Wikipedia: Euler's theorem](https://en.wikipedia.org/wiki/Euler%27s_theorem)). So for Alice it is very easy to get back the original message:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "42424242"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def Alice_decrypt(m_encrypted, n, e):\n",
+    "    R = Integers(n)\n",
+    "    return R(m_encrypted)^e\n",
+    "\n",
+    "Alice_decrypt(177776139844621, 338547806707501, 107165393087271)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Another assumption on which RSA relies is that even if one knows $M=m^e$ and $e$, extracting the $e$-th root of $M$ modulo $n$ (and thus obtaining $m$) is very hard. Currently the best known way to do this is by factorizing $n$ first, which is considered to be a very hard problem. However, there is no proof that faster algorithms can't be devised.\n",
+    "\n",
+    "Moreover, one day we will overcome the current technological difficulties and quantum computers will be available. Quantum computers are not just \"more powerful\" than classical hardware, but they work based on completely different logical foundations and they make the factorization problem much easier to solve: for example [Shor's algorithm](https://en.wikipedia.org/wiki/Shor%27s_algorithm) takes advantage of this different logic and can factorize numbers quickly, if run on a quantum computer.\n",
+    "\n",
+    "To this day the largest number factorized with a quantum computer is $21=3\\times 7$. Nonetheless, quantum-safe cryptography protocols (i.e. based on problems that are hard to solve also with quantum computers) have already been developed."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SageMath 9.2",
+   "language": "sage",
+   "name": "sagemath"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture5/notebook/.ipynb_checkpoints/scratchpad-checkpoint.ipynb b/src/Lecture5/notebook/.ipynb_checkpoints/scratchpad-checkpoint.ipynb
new file mode 100644
index 0000000..5232819
--- /dev/null
+++ b/src/Lecture5/notebook/.ipynb_checkpoints/scratchpad-checkpoint.ipynb
@@ -0,0 +1,52 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "9"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gcd(36,27)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SageMath 9.2",
+   "language": "sage",
+   "name": "sagemath"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture5/notebook/7-SageAlgebra.aux b/src/Lecture5/notebook/7-SageAlgebra.aux
new file mode 100644
index 0000000..a3f33b6
--- /dev/null
+++ b/src/Lecture5/notebook/7-SageAlgebra.aux
@@ -0,0 +1,56 @@
+\relax 
+\providecommand\hyper@newdestlabel[2]{}
+\providecommand\HyperFirstAtBeginDocument{\AtBeginDocument}
+\HyperFirstAtBeginDocument{\ifx\hyper@anchor\@undefined
+\global\let\oldcontentsline\contentsline
+\gdef\contentsline#1#2#3#4{\oldcontentsline{#1}{#2}{#3}}
+\global\let\oldnewlabel\newlabel
+\gdef\newlabel#1#2{\newlabelxx{#1}#2}
+\gdef\newlabelxx#1#2#3#4#5#6{\oldnewlabel{#1}{{#2}{#3}}}
+\AtEndDocument{\ifx\hyper@anchor\@undefined
+\let\contentsline\oldcontentsline
+\let\newlabel\oldnewlabel
+\fi}
+\fi}
+\global\let\hyper@last\relax 
+\gdef\HyperFirstAtBeginDocument#1{#1}
+\providecommand\HyField@AuxAddToFields[1]{}
+\providecommand\HyField@AuxAddToCoFields[2]{}
+\providecommand \oddpage@label [2]{}
+\@writefile{toc}{\contentsline {section}{\numberline {1}The Jupyter Notebook}{1}{section.1}\protected@file@percent }
+\newlabel{the-jupyter-notebook}{{1}{1}{The Jupyter Notebook}{section.1}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {1.1}Cells}{1}{subsection.1.1}\protected@file@percent }
+\newlabel{cells}{{1.1}{1}{Cells}{subsection.1.1}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {1.2}Markdown}{1}{subsection.1.2}\protected@file@percent }
+\newlabel{markdown}{{1.2}{1}{Markdown}{subsection.1.2}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {2}Symbolic expressions}{2}{section.2}\protected@file@percent }
+\newlabel{symbolic-expressions}{{2}{2}{Symbolic expressions}{section.2}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Mathematical variables}{2}{subsection.2.1}\protected@file@percent }
+\newlabel{mathematical-variables}{{2.1}{2}{Mathematical variables}{subsection.2.1}{}}
+\gdef \LT@i {\LT@entry 
+    {1}{103.45363pt}\LT@entry 
+    {1}{76.13344pt}\LT@entry 
+    {2}{68.2421pt}}
+\@writefile{toc}{\contentsline {section}{\numberline {3}Basic rings and fields}{3}{section.3}\protected@file@percent }
+\newlabel{basic-rings-and-fields}{{3}{3}{Basic rings and fields}{section.3}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.1}Parents and coercion}{3}{subsection.3.1}\protected@file@percent }
+\newlabel{parents-and-coercion}{{3.1}{3}{Parents and coercion}{subsection.3.1}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {4}Polynomial rings}{4}{section.4}\protected@file@percent }
+\newlabel{polynomial-rings}{{4}{4}{Polynomial rings}{section.4}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1}Operations on polynomials}{4}{subsection.4.1}\protected@file@percent }
+\newlabel{operations-on-polynomials}{{4.1}{4}{Operations on polynomials}{subsection.4.1}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {5}Matrices and vectors}{5}{section.5}\protected@file@percent }
+\newlabel{matrices-and-vectors}{{5}{5}{Matrices and vectors}{section.5}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {6}Number Theory}{8}{section.6}\protected@file@percent }
+\newlabel{number-theory}{{6}{8}{Number Theory}{section.6}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {6.1}Primes}{8}{subsection.6.1}\protected@file@percent }
+\newlabel{primes}{{6.1}{8}{Primes}{subsection.6.1}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {6.2}The Chinese remainder theorem (CRT)}{9}{subsection.6.2}\protected@file@percent }
+\newlabel{the-chinese-remainder-theorem-crt}{{6.2}{9}{The Chinese remainder theorem (CRT)}{subsection.6.2}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {7}Cryptography: RSA}{10}{section.7}\protected@file@percent }
+\newlabel{cryptography-rsa}{{7}{10}{Cryptography: RSA}{section.7}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {7.1}Public-key cryptography}{10}{subsection.7.1}\protected@file@percent }
+\newlabel{public-key-cryptography}{{7.1}{10}{Public-key cryptography}{subsection.7.1}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {7.2}RSA}{10}{subsection.7.2}\protected@file@percent }
+\newlabel{rsa}{{7.2}{10}{RSA}{subsection.7.2}{}}
+\gdef \@abspage@last{12}
diff --git a/src/Lecture5/notebook/7-SageAlgebra.ipynb b/src/Lecture5/notebook/7-SageAlgebra.ipynb
new file mode 100644
index 0000000..59ea033
--- /dev/null
+++ b/src/Lecture5/notebook/7-SageAlgebra.ipynb
@@ -0,0 +1,1046 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This lecture's notes are in a different format: the presentations for the $\\LaTeX$ part were made with $\\LaTeX$, so this one is made with Sage, or rather with the [Jupyter Notebook](https://jupyter.org/).\n",
+    "\n",
+    "# The Jupyter Notebook\n",
+    "**Reference:** [[1](https://jupyter.org/documentation)]\n",
+    "\n",
+    "The Jupyter Notebook is one of the default interfaces for SageMath, along with the command line interface. You can access it via web browser, but it is running locally on your device (notice the strange url: `http://localhost:8888/notebooks...`).\n",
+    "\n",
+    "You can create a new notebook by clicking on `New > SageMath 9.2`. You can also create a Python 3 notebook to write Python code.\n",
+    "\n",
+    "Jupyter saves and reads files in the `.ipynb` format. If you download the file for this lecture you can open it and follow the examples interactively.\n",
+    "\n",
+    "## Cells\n",
+    "\n",
+    "The notebook contains one or more *interactive cells* that you can run, like this one below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2/5"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Exercise: modify this cell to use the print() command\n",
+    "2+2\n",
+    "2/5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you are reading this from Jupyter rather than from the pdf file, you can edit the cell above and run it again. You can also add more cells by selecting `Insert` from the menu bar.\n",
+    "\n",
+    "Notice that only the last statement produces an output. You can force anything to be written as output with the `print()` command, which works like in Python. As an exercise, try to modify the cell above to provide more output!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Markdown\n",
+    "\n",
+    "[Markdown](https://en.wikipedia.org/wiki/Markdown) is a simple markup language - think of LaTeX or html, but much simpler.\n",
+    "You can add text to your notebook with Markdown cells by selecting `Cell > Cell Type > Markdown`.\n",
+    "\n",
+    "You can also include some LaTeX code in Markdown cells, with dollar signs $ or align environments:\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\frac{(x+y)^2}{x+1} = \\frac{x^2+y^2}{x+1}\n",
+    "\\end{align*}\n",
+    "\n",
+    "When you are done writing a Markdown cell, you can run it to see the well-formatted text. To edit the text again, double-click on the cell. Try doing it now to fix the formula above!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Symbolic expressions\n",
+    "\n",
+    "**Reference:** [[2](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html)]\n",
+    "\n",
+    "Now, let's get started with Sage. One thing you might want to do is manipulating symbolic expressions, like the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[x == -sqrt(6) - 1, x == sqrt(6) - 1]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f =  x^2 + 2*x - 5 == 0\n",
+    "solve(f,x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice that the single `=` is part of an assignment, as in Python: we are *assigning* to the variable `f` the value `x^2 + 2*x - 5 >= 0`, which in this case is an equation, so it contains the symbol `==`. Keep in mind the difference between the two!\n",
+    "\n",
+    "**Exercise:** change the code above to solve the corresponding inequality $x^2+2x-5\\geq 0$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mathematical variables\n",
+    "\n",
+    "Last time we saw what *variables* are in Python, and that they are a little bit different from the *Mathematical variables* that you use in Mathematics. In Sage, both concepts are present, but they are still distinct. For example in the cell above `f` is a variable in the sense of computer science, while `x` is a Mathematical variable.\n",
+    "\n",
+    "If you want to use Mathematical variables other than `x`, you first need to *declare* them with the `var()` command:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[y == -1/2*x - 1/2*sqrt(x^2 + 2*x + 9) - 1/2, y == -1/2*x + 1/2*sqrt(x^2 + 2*x + 9) - 1/2]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "var('y')\n",
+    "solve(y^2 + (x+1)*y - 2 == 0, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Try removing the first line in the cell above and see what error you get!\n",
+    "\n",
+    "Here is another example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[x == -1/2*a - 1/2*sqrt(a^2 - 4*b), x == -1/2*a + 1/2*sqrt(a^2 - 4*b)]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "var('a', 'b')\n",
+    "f = x^2+a*x+b\n",
+    "solve(f,x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Some common constants are [already defined](https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html) in Sage:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-1"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "e^(pi*I)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will study symbolic expressions more in detail next time, in the context of calculus/analysis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Basic rings and fields\n",
+    "\n",
+    "**References:** [[3](https://doc.sagemath.org/html/en/reference/rings_standard/index.html)]\n",
+    "[[4](https://doc.sagemath.org/html/en/reference/rings_numerical/index.html)]\n",
+    "[[5](https://doc.sagemath.org/html/en/reference/finite_rings/index.html)]\n",
+    "\n",
+    "As you should know, a *field* is a Mathematical structure with two operations, addition and multiplication, which respect certain rules (distributivity, associativity, commutativity...). Some examples of fields are the Rational numbers $\\mathbb Q$, the Real numbers $\\mathbb R$ and the Complex numbers $\\mathbb C$, but there are many more. As you should also know, a *(commutative) ring* is like a field, except not all elements different from $0$ need have a multiplicative inverse. For example the integers $\\mathbb Z = \\{ \\dots, -1, 0, 1, 2, \\dots\\}$ are a ring, but not a field.\n",
+    "\n",
+    "These structures are already implemented in Sage. Some of the most common are listed in the following table:\n",
+    "\n",
+    "|Mathematical object|Math symbol|Sage name|\n",
+    "|------------------:|:---------:|:--------|\n",
+    "|Integers|$\\mathbb Z$|`ZZ`|\n",
+    "|Rational numbers|$\\mathbb Q$|`QQ`|\n",
+    "|Real numbers|$\\mathbb R$|`RR`|\n",
+    "|Complex numbers|$\\mathbb C$|`CC`|\n",
+    "|Integers modulo $n$|$\\mathbb Z/n\\mathbb Z$|`Integers(n)`|\n",
+    "|Finite fields|$\\mathbb F_p$|GF(p)|\n",
+    "|$\\dots$|$\\dots$|$\\dots$|"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you write a number or an expression, Sage will figure out where it \"lives\", choosing the most restrictive interpretation possible. For example `3` will be interpreted to be an integer, even if it is also a rational number, a real number and a complex number."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parents and coercion\n",
+    "**Reference:** [[6](https://doc.sagemath.org/html/en/tutorial/tour_coercion.html)]\n",
+    "\n",
+    "You can check where an object \"lives\" with the `parent()` command. It works more or less like the Python command `type()`, but it gives a more Mathematically inclined answer. Check the reference link [6] above if you want more details."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Rational Field"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Edit this cell to find out the type of other objects that we used\n",
+    "parent(3/5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sometimes Sage does not give you the best possible interpretation, so you can force something to be interpreted as living in a smaller ring as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Symbolic Ring\n",
+      "Integer Ring\n"
+     ]
+    }
+   ],
+   "source": [
+    "minus_one = e^(pi*I)\n",
+    "minus_one_coerced = ZZ(e^(pi*I))  # coercion\n",
+    "print(parent(minus_one))\n",
+    "print(parent(minus_one_coerced))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Remark.** Notice that there is a fundamental difference between the rings `RR` and `CC` and all the others in the table above: the real and complex numbers are *approximated*."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n",
+      "3.00000000000000\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(QQ(3))\n",
+    "print(RR(3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also choose the precision of this approximation using the alternative name `RealField`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Real Field with 53 bits of precision\n",
+      "Real Field with 1000 bits of precision\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(RR)\n",
+    "print(RealField(prec=1000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Polynomial rings\n",
+    "\n",
+    "**Reference:** [[7](https://doc.sagemath.org/html/en/reference/polynomial_rings/index.html)]\n",
+    "\n",
+    "If you want to work with polynomials over a certain ring it is better to use this specific construction, rather than the symbolic expressions introduced above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Multivariate Polynomial Ring in x, y, z over Real Field with 53 bits of precision"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "polring.<x,y,z> = RR[]  # Alternative: polring.<x,y,z> = PolynomialRing(RR)\n",
+    "polring"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can use as many variables as you like, and you can replace `RR` with any ring. In the example above `polring` is just the name of the variable (in the computer science sense) associated with this polynomial ring.\n",
+    "\n",
+    "## Operations on polynomials\n",
+    "\n",
+    "The usual Mathematical operations are available on polynomial rings, including Euclidean division `//` and remainder `%`. There is also the single-slash division `/`, but the result may not be a polynomial anymore.\n",
+    "\n",
+    "**Exercise:** use the `parent()` command to find out what the quotient of two polynomials is.\n",
+    "\n",
+    "**Question:** what happens if you remove the first line in the cell below? What if we used the variable `y` instead of `x`?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "x + 1\n",
+      "-4\n",
+      "(x^2 + 2*x - 3)/(x + 1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "polring.<x> = QQ[]\n",
+    "p = x^2 + 2*x - 3   # Don't forget * for multiplication!\n",
+    "q = p // (x+1)\n",
+    "r = p %  (x+1)\n",
+    "f = p /  (x+1)\n",
+    "print(q)\n",
+    "print(r)\n",
+    "print(f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can do more complex operations. Try out `roots()` and `factor` in the cell below.\n",
+    "\n",
+    "**Remark.** Notice how the result can change substantially if you change the base ring.\n",
+    "\n",
+    "**Remark.** [Factorizations](https://doc.sagemath.org/html/en/reference/structure/sage/structure/factorization.html) are a particular object in Sage. They are kinda like a list, but not really. You can get a list of pairs (factor, power) with `list(factor(f))`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(t + 1) * (t^2 - 3) * (t^2 + 1)\n",
+      "[(-1, 1)]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(y + 1) * x"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "polring_onevar.<t> = QQ[]\n",
+    "\n",
+    "f = t^5 + t^4 - 2*t^3 - 2*t^2 - 3*t - 3\n",
+    "print(factor(f))\n",
+    "print(f.roots())  # Result: list of pairs (root,multiplicity)\n",
+    "\n",
+    "polring_manyvar.<x,y,z> = QQ[]\n",
+    "factor(x*y+x)\n",
+    "\n",
+    "# The following line gives an error, because the polynomial\n",
+    "# is understood to possibly have many variables:\n",
+    "#(x^2-1).roots()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Matrices and vectors\n",
+    "\n",
+    "**References:** [[8](https://doc.sagemath.org/html/en/reference/matrices/index.html)], but in particular the subections [[9](https://doc.sagemath.org/html/en/reference/matrices/sage/matrix/docs.html)] and [[10](https://doc.sagemath.org/html/en/reference/matrices/sage/matrix/matrix2.html)]\n",
+    "\n",
+    "In Sage you can easily manipulate matrices and vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[   1    2    3]\n",
+      "[   0    0    1]\n",
+      "[   4   -3 22/7] \n",
+      "\n",
+      "[1/2   0   0]\n",
+      "[  7   0   0]\n",
+      "[  1   1   1] \n",
+      "\n",
+      "(3/2, 21, 6) \n",
+      "\n",
+      "[  -7/2    -10   80/7]\n",
+      "[    17     -4   15/7]\n",
+      "[ 241/7  -18/7 869/49] \n",
+      "\n",
+      "Rank of A = 3\n",
+      "Rank of B = 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "A = matrix([[1,2,3],[0,0,1],[4,-3,22/7]])\n",
+    "B = matrix([[1/2,0,0],[7,0,0],[1,1,1]])\n",
+    "v = vector([3,4,-1])\n",
+    "\n",
+    "print(A, \"\\n\")  # \\n just means \"newline\"\n",
+    "print(B, \"\\n\")\n",
+    "print(B*v, \"\\n\")\n",
+    "print(A^2 + 2*B - A*B, \"\\n\")\n",
+    "\n",
+    "print(\"Rank of A =\", rank(A)) # You can also use A.rank()\n",
+    "print(\"Rank of B =\", rank(B))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** in the cell above, compute the determinant, inverse and characteristic polynomial of the matrix `A`. *Hint: look at the reference [10] above (the functions are listed in alphabetic order).*\n",
+    "\n",
+    "As for polynomials, you can specify where a matrix or a vector lives"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Full MatrixSpace of 2 by 2 dense matrices over Complex Field with 53 bits of precision"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "M = matrix(CC, [[0,1],[1,0]])\n",
+    "parent(M)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also solve linear systems and compute eigenvalues and eigenvectors of a matrix\n",
+    "\n",
+    "**Warning.** In linear algebra there are distinct concepts of *left* and *right* eigenvalues (and eigenvector). The one you know is probably that of **right** eigen-{value,vector}, that is an element $\\lambda$ of the base field and a non-zero vector $\\mathbf v$ with $A\\mathbf v=\\lambda\\mathbf v$. The other concept corresponds to the equality $\\mathbf v^TA=\\lambda \\mathbf v$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.289916349448506, 0.0241596957873755)"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A = Matrix(RR, [[sqrt(59),32],[-1/4,3]])\n",
+    "v = vector(RR, [3,0])\n",
+    "A.solve_right(v) # Solve Ax=v. Alternative: A \\ v"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[\n",
+       "(-0.3722813232690144?, Vector space of degree 2 and dimension 1 over Algebraic Field\n",
+       "User basis matrix:\n",
+       "[                   1 -0.6861406616345072?]),\n",
+       "(5.372281323269015?, Vector space of degree 2 and dimension 1 over Algebraic Field\n",
+       "User basis matrix:\n",
+       "[                 1 2.186140661634508?])\n",
+       "]"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A = Matrix(QQ, [[1,2],[3,4]])\n",
+    "A.eigenspaces_right() # Also: A.eigenvalues(), A.eigenvectors_right()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also extract a specific submatrix by selecting only some rows and columns, with a syntax similar to that of Python's lists. Check out more examples in the reference [9] above, and try them in the cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[-14   2   0  -1   1  -2  -1]\n",
+      "[  0  -8   0   9  -2  11   1]\n",
+      "[  0   3   1  -1   1   1 221]\n",
+      "[ -1   2   1 -25 -10   4   0]\n",
+      "[ -3   0   0   2  16  -1  -2]\n",
+      "[  1  -3   3 -41   1   0   0]\n",
+      "[ -2   1   0   0  -6   2  12] \n",
+      "\n",
+      "[ 0  9 -2]\n",
+      "[ 1 -1  1] \n",
+      "\n",
+      "[-14   2   0  -1   1  -2  -1] \n",
+      "\n",
+      "[-14   2   0  -1   1]\n",
+      "[  1  -3   3 -41   1]\n",
+      "[  0   3   1  -1   1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "A = MatrixSpace(ZZ, 7).random_element()\n",
+    "print(A, \"\\n\")\n",
+    "print(A[1:3,2:5], \"\\n\") # Rows from 1 to 3, columns from 2 to 5\n",
+    "print(A[0,0:], \"\\n\")    # First row, all columns\n",
+    "print(A[[0,5,2],0:5])   # Rows 0, 5 and 2 (in this order) and columns 0 to 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise:** write a sage function that computes the determinant of an $n\\times n$ matrix $A=(a_{ij})$ using Laplace's rule by the first row, that is \n",
+    "\\begin{align*}\n",
+    "    \\operatorname{det}A = \\sum_{j=1}^n (-1)^ja_{0j}M_{0j}\n",
+    "\\end{align*}\n",
+    "where $M_{0j}$ is the determinant of the $(n-1)\\times(n-1)$ matrix obtained by removing the $0$-th row and the $j$-th column from $A$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def my_det(A):\n",
+    "    if not A.is_square():\n",
+    "        print(\"Error: matrix is not square\")\n",
+    "    \n",
+    "    n = A.nrows()  # size of the matrix\n",
+    "    \n",
+    "    # Continue from here!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Number Theory\n",
+    "\n",
+    "**Reference:** [[11](https://doc.sagemath.org/html/en/reference/rings_standard/sage/rings/integer.html)]\n",
+    "\n",
+    "Sage includes a large library of functions for computing with the integers, see the link above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3^2 * 3607 * 3803\n",
+      "True\n",
+      "True\n",
+      "619703040\n",
+      "9\n",
+      "13548070123626141\n"
+     ]
+    }
+   ],
+   "source": [
+    "n = 123456789\n",
+    "m = 987654321\n",
+    "p = 3607\n",
+    "\n",
+    "print(factor(n))\n",
+    "print(is_prime(p))\n",
+    "print(p.divides(n))\n",
+    "print(euler_phi(m))\n",
+    "print(gcd(n, m))\n",
+    "print(lcm(n, m))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Primes\n",
+    "\n",
+    "**Reference:** [[12](https://doc.sagemath.org/html/en/reference/sets/sage/sets/primes.html)]\n",
+    "\n",
+    "The set of prime numbers is called `Primes()`. It is like an infinite list: for example you can get the one-millionth prime number or you can use this list to create other lists. You can also check what the first prime number larger than a given number is."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Set of all prime numbers: 2, 3, 5, 7, ...\n",
+      "31 15485867\n",
+      "47\n",
+      "[79, 83, 89, 97]\n"
+     ]
+    }
+   ],
+   "source": [
+    "PP = Primes()\n",
+    "print(PP)\n",
+    "print(PP[10], PP[10^6])\n",
+    "print(PP.next(44))\n",
+    "\n",
+    "First_Thousand_Primes = PP[0:1000]\n",
+    "print([p for p in First_Thousand_Primes if p < 100 and p > 75])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The Chinese remainder theorem (CRT)\n",
+    "\n",
+    "We say that two integers $a$ and $b$ are *congruent* modulo another integer $n>0$ if they have the same remainder when divided by $n$. We denote this by $a\\equiv b\\pmod n$, or in Python/Sage syntax `a % n == b % n`.\n",
+    "\n",
+    "The Chinese remainder theorem states that if $a,b\\in\\mathbb Z$ and $n,m\\in \\mathbb Z_{>0}$ are such that $\\gcd(n,m)=1$ then the system of congruences\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\begin{cases}\n",
+    "    x \\equiv a \\pmod n\\\\\n",
+    "    x \\equiv b \\pmod m\n",
+    "\\end{cases}\n",
+    "\\end{align*}\n",
+    "\n",
+    "has exactly one solution modulo $mn$. This means that there is one and only one number $x$ with $0\\leq x<mn$ such that $x\\equiv a\\pmod n$ and $x\\equiv b\\pmod m$.\n",
+    "\n",
+    "The procedure to find such a number is not too hard to describe (you might see it in an algebra or number theory course), but it can be a bit long. Luckily, Sage can do this for you:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "74306 2 798\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = 2\n",
+    "b = -1\n",
+    "n = 172\n",
+    "m = 799\n",
+    "\n",
+    "if gcd(n,m) != 1:\n",
+    "    print(\"The numbers are not comprime, I can't solve this!\")\n",
+    "else:\n",
+    "    x = crt(a, b, n, m)\n",
+    "    print(x, x%n, x%m)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Exercise.** There is a more general version of the Chinese remainder theorem which says that if $a_0, a_1, \\dots, a_k\\in\\mathbb Z$ and $n_0, n_2, \\dots, n_k\\in\\mathbb Z_{>0}$ are such that $\\gcd(n_i, n_j)=1$ for $i\\neq j$, then the system of congruences\n",
+    "\n",
+    "\\begin{align*}\n",
+    "\\begin{cases}\n",
+    "    x \\equiv a_0 \\pmod {n_0}\\\\\n",
+    "    x \\equiv a_1 \\pmod {n_1}\\\\\n",
+    "    \\dots \\\\\n",
+    "    x \\equiv a_k \\pmod {n_k}\n",
+    "\\end{cases}\n",
+    "\\end{align*}\n",
+    "\n",
+    "has exactly one solution modulo $\\prod_{i=0}^kn_i$. Use the `crt()` function to find a solution to such a system.\n",
+    "*Hint: start by running the command `help(crt)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 127,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#help(crt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cryptography: RSA\n",
+    "\n",
+    "[Cryptography](https://en.wikipedia.org/wiki/Cryptography) is the discipline that studies methods to communicate secrets in such a way that any unauthorized listener would not be able to understand the message.\n",
+    "\n",
+    "A simple cryptographic protocol could be changing every letter of your text following a fixed scheme (or *cypher*), for example by turning every A into a B, every B into a C and so on. However this is not a very secure method, for many reasons. One of them is that at some point the people who want to communicate need to agree on what method to use, and anyone listening to that conversation would be able to decypher every subsequent conversation. A public-key cryptographic protocol solves this problem.\n",
+    "\n",
+    "## Public-key cryptography\n",
+    "\n",
+    "Public-key cryptographic protocols, such as RSA, work like this: there are two keys, a *private* key that is only known to person A (traditionally called Alice in every example), and a *public* key that does not need to be secret.\n",
+    "\n",
+    "The public key is used to *encrypt* the message (that is to \"lock\" it, or \"hyde\" it), but one needs the private key to *decrypt* it. Imagine having two keys for your door, but one can only be used to lock it, while the other only to open it.\n",
+    "\n",
+    "The message exchange works like this: suppose that person B (Bob) wants to send a secret message to Alice. Then Alice secretely generates a private and a public key and sends only the public one to Bob. Now Bob encrypts the message and sends it to Alice, who can use her private key to decrypt it. Even if Eve (short for *eavesdropper*, an unauthorized listener) listens to every message exchanged, she won't be able to decypher the secret: the private key has never left Alice's house!\n",
+    "\n",
+    "Notice that such a protocol is *asymmetric*: if Alice wanted to send a secret to Bob in reply, Bob would need to generate a pair of keys of his own.\n",
+    "\n",
+    "Let's see how we can do this in practice, using number theory!\n",
+    "\n",
+    "## RSA\n",
+    "\n",
+    "As many other cryptography protocols, RSA is based on a Mathematical process that is easy to do in one direction, but very hard to invert. In this case the hard process is integer factorization, that is decomposing an integer number as a product of primes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True True False\n"
+     ]
+    }
+   ],
+   "source": [
+    "p = 100003100019100043100057100069\n",
+    "q = 100144655312449572059845328443\n",
+    "n = p*q\n",
+    "print(is_prime(p), is_prime(q), is_prime(p*q))\n",
+    "\n",
+    "# Use the command below to see how long it takes\n",
+    "#timeit(\"factor(n)\", number=1, repeat=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In order to generate the keys, Alice picks a number $n$ which is the product of two large primes $p$ and $q$ of more or less the same size. Finding such primes is relatively easy compared to factoring the number $n$ she obtained. Then she computes the Euler totient $\\varphi(n)=(p-1)(q-1)$ of $n$, which she can do because she knows that $n=pq$ - it would be impossible otherwise!\n",
+    "\n",
+    "Then Alice can compute two integers $(d,e)$ such that $de\\equiv 1\\pmod{\\varphi(n)}$. She will send the numbers $n$ and $d$ to Bob and keep $e$ secret. In this case the public key is the pair $(n,d)$, while $e$ is the private key.\n",
+    "\n",
+    "Of course, she does all of this using Sage!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(419199544978969, 235530823946467, 80799425863927)"
+      ]
+     },
+     "execution_count": 105,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def two_large_primes():\n",
+    "    p, q = 0, 0\n",
+    "    # We make sure that they are different\n",
+    "    while p == q:\n",
+    "        p = Primes()[randint(10^6, 2*10^6)]\n",
+    "        q = Primes()[randint(10^6, 2*10^6)]\n",
+    "    return p, q\n",
+    "\n",
+    "def random_unit_mod(N):\n",
+    "    R = Integers(N)\n",
+    "    d = R(0)\n",
+    "    # We make sure that it is invertible\n",
+    "    while not d.is_unit():\n",
+    "        d = R.random_element()\n",
+    "    return d\n",
+    "\n",
+    "def Alice_generate_keys():\n",
+    "    p, q = two_large_primes()\n",
+    "    n = p*q\n",
+    "    phi_n = (p-1)*(q-1) # euler_phi(n) is slow!\n",
+    "    \n",
+    "    d = random_unit_mod(phi_n)\n",
+    "    e = d^-1\n",
+    "    return n, d, e\n",
+    "\n",
+    "Alice_generate_keys()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, how does Bob encrypt his message? Let's say he wants to send to Alice the number $m$ with $1<m<n$ (In practice he would like to send her some text with emojis, or maybe a voice message; but for computers everything is a number, and there are different ways to translate any sort of information to a number. He just chooses one of the many standard methods that already exist, no cryptography is needed in this step. If the message $m$ is too long, he can split it up in some pieces and repeat the process multiple times.)\n",
+    "\n",
+    "Now he computes $m^d\\pmod n$ and sends it back to Alice."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "149461597163501"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def Bob_encrypt(m, n, d):\n",
+    "    R = Integers(n)\n",
+    "    return R(m)^d  # Assume that n is large enough\n",
+    "    \n",
+    "message = 42424242\n",
+    "Bob_encrypt(message, 419199544978969, 235530823946467)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since $de\\equiv 1\\pmod{\\varphi(n)}$, it follows that $(m^d)^e\\equiv m\\pmod n$ (see [Wikipedia: Euler's theorem](https://en.wikipedia.org/wiki/Euler%27s_theorem)). So for Alice it is very easy to get back the original message:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "42424242"
+      ]
+     },
+     "execution_count": 108,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def Alice_decrypt(m_encrypted, n, e):\n",
+    "    R = Integers(n)\n",
+    "    return R(m_encrypted)^e\n",
+    "\n",
+    "Alice_decrypt(149461597163501, 419199544978969, 80799425863927)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Another assumption on which RSA relies is that even if one knows $M=m^e$ and $e$, extracting the $e$-th root of $M$ modulo $n$ (and thus obtaining $m$) is very hard. Currently the best known way to do this is by factorizing $n$ first, which is considered to be a very hard problem. However, there is no proof that faster algorithms can't be devised.\n",
+    "\n",
+    "Moreover, one day we will overcome the current technological difficulties and quantum computers will be available. Quantum computers are not just \"more powerful\" than classical hardware, but they work based on completely different logical foundations and they make the factorization problem much easier to solve: for example [Shor's algorithm](https://en.wikipedia.org/wiki/Shor%27s_algorithm) takes advantage of this different logic and can factorize numbers quickly, if run on a quantum computer.\n",
+    "\n",
+    "To this day the largest number factorized with a quantum computer is $21=3\\times 7$. Nonetheless, quantum-safe cryptography protocols (i.e. based on problems that are hard to solve also with quantum computers) have already been developed."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SageMath 9.2",
+   "language": "sage",
+   "name": "sagemath"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/Lecture5/notebook/7-SageAlgebra.log b/src/Lecture5/notebook/7-SageAlgebra.log
new file mode 100644
index 0000000..615d65f
--- /dev/null
+++ b/src/Lecture5/notebook/7-SageAlgebra.log
@@ -0,0 +1,967 @@
+This is pdfTeX, Version 3.14159265-2.6-1.40.21 (TeX Live 2020/VoidLinux) (preloaded format=pdflatex 2021.4.20)  22 APR 2021 15:19
+entering extended mode
+ \write18 enabled.
+ %&-line parsing enabled.
+**7-SageAlgebra.tex
+(./7-SageAlgebra.tex
+LaTeX2e <2020-10-01> patch level 2
+L3 programming layer <2020-12-03> xparse <2020-03-03>
+(/usr/share/texmf-dist/tex/latex/base/article.cls
+Document Class: article 2020/04/10 v1.4m Standard LaTeX document class
+(/usr/share/texmf-dist/tex/latex/base/size11.clo
+File: size11.clo 2020/04/10 v1.4m Standard LaTeX file (size option)
+)
+\c@part=\count177
+\c@section=\count178
+\c@subsection=\count179
+\c@subsubsection=\count180
+\c@paragraph=\count181
+\c@subparagraph=\count182
+\c@figure=\count183
+\c@table=\count184
+\abovecaptionskip=\skip47
+\belowcaptionskip=\skip48
+\bibindent=\dimen138
+)
+(/usr/share/texmf-dist/tex/latex/tcolorbox/tcolorbox.sty
+Package: tcolorbox 2020/10/09 version 4.42 text color boxes
+
+(/usr/share/texmf-dist/tex/latex/pgf/basiclayer/pgf.sty
+(/usr/share/texmf-dist/tex/latex/pgf/utilities/pgfrcs.sty
+(/usr/share/texmf-dist/tex/generic/pgf/utilities/pgfutil-common.tex
+\pgfutil@everybye=\toks15
+\pgfutil@tempdima=\dimen139
+\pgfutil@tempdimb=\dimen140
+
+(/usr/share/texmf-dist/tex/generic/pgf/utilities/pgfutil-common-lists.tex))
+(/usr/share/texmf-dist/tex/generic/pgf/utilities/pgfutil-latex.def
+\pgfutil@abb=\box47
+)
+(/usr/share/texmf-dist/tex/generic/pgf/utilities/pgfrcs.code.tex
+(/usr/share/texmf-dist/tex/generic/pgf/pgf.revision.tex)
+Package: pgfrcs 2020/12/01 v3.1.7a (3.1.7a)
+))
+Package: pgf 2020/12/01 v3.1.7a (3.1.7a)
+
+(/usr/share/texmf-dist/tex/latex/pgf/basiclayer/pgfcore.sty
+(/usr/share/texmf-dist/tex/latex/graphics/graphicx.sty
+Package: graphicx 2020/09/09 v1.2b Enhanced LaTeX Graphics (DPC,SPQR)
+
+(/usr/share/texmf-dist/tex/latex/graphics/keyval.sty
+Package: keyval 2014/10/28 v1.15 key=value parser (DPC)
+\KV@toks@=\toks16
+)
+(/usr/share/texmf-dist/tex/latex/graphics/graphics.sty
+Package: graphics 2020/08/30 v1.4c Standard LaTeX Graphics (DPC,SPQR)
+
+(/usr/share/texmf-dist/tex/latex/graphics/trig.sty
+Package: trig 2016/01/03 v1.10 sin cos tan (DPC)
+)
+(/usr/share/texmf-dist/tex/latex/graphics-cfg/graphics.cfg
+File: graphics.cfg 2016/06/04 v1.11 sample graphics configuration
+)
+Package graphics Info: Driver file: pdftex.def on input line 105.
+
+(/usr/share/texmf-dist/tex/latex/graphics-def/pdftex.def
+File: pdftex.def 2020/10/05 v1.2a Graphics/color driver for pdftex
+))
+\Gin@req@height=\dimen141
+\Gin@req@width=\dimen142
+)
+(/usr/share/texmf-dist/tex/latex/pgf/systemlayer/pgfsys.sty
+(/usr/share/texmf-dist/tex/generic/pgf/systemlayer/pgfsys.code.tex
+Package: pgfsys 2020/12/01 v3.1.7a (3.1.7a)
+
+(/usr/share/texmf-dist/tex/generic/pgf/utilities/pgfkeys.code.tex
+\pgfkeys@pathtoks=\toks17
+\pgfkeys@temptoks=\toks18
+
+(/usr/share/texmf-dist/tex/generic/pgf/utilities/pgfkeysfiltered.code.tex
+\pgfkeys@tmptoks=\toks19
+))
+\pgf@x=\dimen143
+\pgf@y=\dimen144
+\pgf@xa=\dimen145
+\pgf@ya=\dimen146
+\pgf@xb=\dimen147
+\pgf@yb=\dimen148
+\pgf@xc=\dimen149
+\pgf@yc=\dimen150
+\pgf@xd=\dimen151
+\pgf@yd=\dimen152
+\w@pgf@writea=\write3
+\r@pgf@reada=\read2
+\c@pgf@counta=\count185
+\c@pgf@countb=\count186
+\c@pgf@countc=\count187
+\c@pgf@countd=\count188
+\t@pgf@toka=\toks20
+\t@pgf@tokb=\toks21
+\t@pgf@tokc=\toks22
+\pgf@sys@id@count=\count189
+
+(/usr/share/texmf-dist/tex/generic/pgf/systemlayer/pgf.cfg
+File: pgf.cfg 2020/12/01 v3.1.7a (3.1.7a)
+)
+Driver file for pgf: pgfsys-pdftex.def
+
+(/usr/share/texmf-dist/tex/generic/pgf/systemlayer/pgfsys-pdftex.def
+File: pgfsys-pdftex.def 2020/12/01 v3.1.7a (3.1.7a)
+
+(/usr/share/texmf-dist/tex/generic/pgf/systemlayer/pgfsys-common-pdf.def
+File: pgfsys-common-pdf.def 2020/12/01 v3.1.7a (3.1.7a)
+)))
+(/usr/share/texmf-dist/tex/generic/pgf/systemlayer/pgfsyssoftpath.code.tex
+File: pgfsyssoftpath.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgfsyssoftpath@smallbuffer@items=\count190
+\pgfsyssoftpath@bigbuffer@items=\count191
+)
+(/usr/share/texmf-dist/tex/generic/pgf/systemlayer/pgfsysprotocol.code.tex
+File: pgfsysprotocol.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+))
+(/usr/share/texmf-dist/tex/latex/xcolor/xcolor.sty
+Package: xcolor 2016/05/11 v2.12 LaTeX color extensions (UK)
+
+(/usr/share/texmf-dist/tex/latex/graphics-cfg/color.cfg
+File: color.cfg 2016/01/02 v1.6 sample color configuration
+)
+Package xcolor Info: Driver file: pdftex.def on input line 225.
+Package xcolor Info: Model `cmy' substituted by `cmy0' on input line 1348.
+Package xcolor Info: Model `hsb' substituted by `rgb' on input line 1352.
+Package xcolor Info: Model `RGB' extended on input line 1364.
+Package xcolor Info: Model `HTML' substituted by `rgb' on input line 1366.
+Package xcolor Info: Model `Hsb' substituted by `hsb' on input line 1367.
+Package xcolor Info: Model `tHsb' substituted by `hsb' on input line 1368.
+Package xcolor Info: Model `HSB' substituted by `hsb' on input line 1369.
+Package xcolor Info: Model `Gray' substituted by `gray' on input line 1370.
+Package xcolor Info: Model `wave' substituted by `hsb' on input line 1371.
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcore.code.tex
+Package: pgfcore 2020/12/01 v3.1.7a (3.1.7a)
+
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmath.code.tex
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathcalc.code.tex
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathutil.code.tex)
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathparser.code.tex
+\pgfmath@dimen=\dimen153
+\pgfmath@count=\count192
+\pgfmath@box=\box48
+\pgfmath@toks=\toks23
+\pgfmath@stack@operand=\toks24
+\pgfmath@stack@operation=\toks25
+)
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.code.tex
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.basic.code.tex)
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.trigonometric.code
+.tex)
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.random.code.tex)
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.comparison.code.te
+x) (/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.base.code.tex)
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.round.code.tex)
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.misc.code.tex)
+(/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfunctions.integerarithmetics
+.code.tex))) (/usr/share/texmf-dist/tex/generic/pgf/math/pgfmathfloat.code.tex
+\c@pgfmathroundto@lastzeros=\count193
+)) (/usr/share/texmf-dist/tex/generic/pgf/math/pgfint.code.tex)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepoints.code.tex
+File: pgfcorepoints.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgf@picminx=\dimen154
+\pgf@picmaxx=\dimen155
+\pgf@picminy=\dimen156
+\pgf@picmaxy=\dimen157
+\pgf@pathminx=\dimen158
+\pgf@pathmaxx=\dimen159
+\pgf@pathminy=\dimen160
+\pgf@pathmaxy=\dimen161
+\pgf@xx=\dimen162
+\pgf@xy=\dimen163
+\pgf@yx=\dimen164
+\pgf@yy=\dimen165
+\pgf@zx=\dimen166
+\pgf@zy=\dimen167
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepathconstruct.code.tex
+File: pgfcorepathconstruct.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgf@path@lastx=\dimen168
+\pgf@path@lasty=\dimen169
+) (/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepathusage.code.tex
+File: pgfcorepathusage.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgf@shorten@end@additional=\dimen170
+\pgf@shorten@start@additional=\dimen171
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorescopes.code.tex
+File: pgfcorescopes.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgfpic=\box49
+\pgf@hbox=\box50
+\pgf@layerbox@main=\box51
+\pgf@picture@serial@count=\count194
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcoregraphicstate.code.tex
+File: pgfcoregraphicstate.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgflinewidth=\dimen172
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcoretransformations.code.t
+ex
+File: pgfcoretransformations.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgf@pt@x=\dimen173
+\pgf@pt@y=\dimen174
+\pgf@pt@temp=\dimen175
+) (/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorequick.code.tex
+File: pgfcorequick.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreobjects.code.tex
+File: pgfcoreobjects.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepathprocessing.code.te
+x
+File: pgfcorepathprocessing.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+) (/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorearrows.code.tex
+File: pgfcorearrows.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgfarrowsep=\dimen176
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreshade.code.tex
+File: pgfcoreshade.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgf@max=\dimen177
+\pgf@sys@shading@range@num=\count195
+\pgf@shadingcount=\count196
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreimage.code.tex
+File: pgfcoreimage.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcoreexternal.code.tex
+File: pgfcoreexternal.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgfexternal@startupbox=\box52
+))
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorelayers.code.tex
+File: pgfcorelayers.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcoretransparency.code.tex
+File: pgfcoretransparency.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+) (/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorepatterns.code.tex
+File: pgfcorepatterns.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+)
+(/usr/share/texmf-dist/tex/generic/pgf/basiclayer/pgfcorerdf.code.tex
+File: pgfcorerdf.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+)))
+(/usr/share/texmf-dist/tex/generic/pgf/modules/pgfmoduleshapes.code.tex
+File: pgfmoduleshapes.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+\pgfnodeparttextbox=\box53
+)
+(/usr/share/texmf-dist/tex/generic/pgf/modules/pgfmoduleplot.code.tex
+File: pgfmoduleplot.code.tex 2020/12/01 v3.1.7a (3.1.7a)
+)
+(/usr/share/texmf-dist/tex/latex/pgf/compatibility/pgfcomp-version-0-65.sty
+Package: pgfcomp-version-0-65 2020/12/01 v3.1.7a (3.1.7a)
+\pgf@nodesepstart=\dimen178
+\pgf@nodesepend=\dimen179
+)
+(/usr/share/texmf-dist/tex/latex/pgf/compatibility/pgfcomp-version-1-18.sty
+Package: pgfcomp-version-1-18 2020/12/01 v3.1.7a (3.1.7a)
+))
+(/usr/share/texmf-dist/tex/latex/tools/verbatim.sty
+Package: verbatim 2020-07-07 v1.5u LaTeX2e package for verbatim enhancements
+\every@verbatim=\toks26
+\verbatim@line=\toks27
+\verbatim@in@stream=\read3
+)
+(/usr/share/texmf-dist/tex/latex/environ/environ.sty
+Package: environ 2014/05/04 v0.3 A new way to define environments
+
+(/usr/share/texmf-dist/tex/latex/trimspaces/trimspaces.sty
+Package: trimspaces 2009/09/17 v1.1 Trim spaces around a token list
+)
+\@envbody=\toks28
+)
+(/usr/share/texmf-dist/tex/latex/etoolbox/etoolbox.sty
+Package: etoolbox 2020/10/05 v2.5k e-TeX tools for LaTeX (JAW)
+\etb@tempcnta=\count197
+)
+\tcb@titlebox=\box54
+\tcb@upperbox=\box55
+\tcb@lowerbox=\box56
+\tcb@phantombox=\box57
+\c@tcbbreakpart=\count198
+\c@tcblayer=\count199
+\c@tcolorbox@number=\count266
+\tcb@temp=\box58
+\tcb@temp=\box59
+\tcb@temp=\box60
+\tcb@temp=\box61
+\tcb@out=\write4
+\tcb@record@out=\write5
+
+(/usr/share/texmf-dist/tex/latex/tcolorbox/tcbbreakable.code.tex
+Library (tcolorbox): 'tcbbreakable.code.tex' version '4.42'
+(/usr/share/texmf-dist/tex/generic/oberdiek/pdfcol.sty
+Package: pdfcol 2019/12/29 v1.6 Handle new color stacks for pdfTeX (HO)
+
+(/usr/share/texmf-dist/tex/generic/ltxcmds/ltxcmds.sty
+Package: ltxcmds 2020-05-10 v1.25 LaTeX kernel commands for general use (HO)
+)
+(/usr/share/texmf-dist/tex/generic/infwarerr/infwarerr.sty
+Package: infwarerr 2019/12/03 v1.5 Providing info/warning/error messages (HO)
+)
+(/usr/share/texmf-dist/tex/generic/iftex/iftex.sty
+Package: iftex 2020/03/06 v1.0d TeX engine tests
+))
+Package pdfcol Info: New color stack `tcb@breakable' = 1 on input line 23.
+\tcb@testbox=\box62
+\tcb@totalupperbox=\box63
+\tcb@totallowerbox=\box64
+))
+(/usr/share/texmf-dist/tex/latex/parskip/parskip.sty
+Package: parskip 2020-06-15 v2.0f non-zero parskip adjustments
+
+(/usr/share/texmf-dist/tex/latex/kvoptions/kvoptions.sty
+Package: kvoptions 2020-10-07 v3.14 Key value format for package options (HO)
+
+(/usr/share/texmf-dist/tex/generic/kvsetkeys/kvsetkeys.sty
+Package: kvsetkeys 2019/12/15 v1.18 Key value parser (HO)
+)))
+(/usr/share/texmf-dist/tex/latex/base/fontenc.sty
+Package: fontenc 2020/08/10 v2.0s Standard LaTeX package
+)
+(/usr/share/texmf-dist/tex/latex/psnfss/mathpazo.sty
+Package: mathpazo 2020/03/25 PSNFSS-v9.3 Palatino w/ Pazo Math (D.Puga, WaS) 
+\symupright=\mathgroup4
+)
+(/usr/share/texmf-dist/tex/latex/caption/caption.sty
+Package: caption 2020/10/26 v3.5g Customizing captions (AR)
+
+(/usr/share/texmf-dist/tex/latex/caption/caption3.sty
+Package: caption3 2020/10/21 v2.2e caption3 kernel (AR)
+\captionmargin=\dimen180
+\captionmargin@=\dimen181
+\captionwidth=\dimen182
+\caption@tempdima=\dimen183
+\caption@indent=\dimen184
+\caption@parindent=\dimen185
+\caption@hangindent=\dimen186
+Package caption Info: Standard document class detected.
+)
+\c@caption@flags=\count267
+\c@continuedfloat=\count268
+)
+(/usr/share/texmf-dist/tex/latex/adjustbox/adjustbox.sty
+Package: adjustbox 2020/08/19 v1.3 Adjusting TeX boxes (trim, clip, ...)
+
+(/usr/share/texmf-dist/tex/latex/xkeyval/xkeyval.sty
+Package: xkeyval 2020/11/20 v2.8 package option processing (HA)
+
+(/usr/share/texmf-dist/tex/generic/xkeyval/xkeyval.tex
+(/usr/share/texmf-dist/tex/generic/xkeyval/xkvutils.tex
+\XKV@toks=\toks29
+\XKV@tempa@toks=\toks30
+)
+\XKV@depth=\count269
+File: xkeyval.tex 2014/12/03 v2.7a key=value parser (HA)
+))
+(/usr/share/texmf-dist/tex/latex/adjustbox/adjcalc.sty
+Package: adjcalc 2012/05/16 v1.1 Provides advanced setlength with multiple back
+-ends (calc, etex, pgfmath)
+)
+(/usr/share/texmf-dist/tex/latex/adjustbox/trimclip.sty
+Package: trimclip 2020/08/19 v1.2 Trim and clip general TeX material
+
+(/usr/share/texmf-dist/tex/latex/collectbox/collectbox.sty
+Package: collectbox 2012/05/17 v0.4b Collect macro arguments as boxes
+\collectedbox=\box65
+)
+\tc@llx=\dimen187
+\tc@lly=\dimen188
+\tc@urx=\dimen189
+\tc@ury=\dimen190
+Package trimclip Info: Using driver 'tc-pdftex.def'.
+
+(/usr/share/texmf-dist/tex/latex/adjustbox/tc-pdftex.def
+File: tc-pdftex.def 2019/01/04 v2.2 Clipping driver for pdftex
+))
+\adjbox@Width=\dimen191
+\adjbox@Height=\dimen192
+\adjbox@Depth=\dimen193
+\adjbox@Totalheight=\dimen194
+\adjbox@pwidth=\dimen195
+\adjbox@pheight=\dimen196
+\adjbox@pdepth=\dimen197
+\adjbox@ptotalheight=\dimen198
+
+(/usr/share/texmf-dist/tex/latex/ifoddpage/ifoddpage.sty
+Package: ifoddpage 2016/04/23 v1.1 Conditionals for odd/even page detection
+\c@checkoddpage=\count270
+)
+(/usr/share/texmf-dist/tex/latex/varwidth/varwidth.sty
+Package: varwidth 2009/03/30 ver 0.92;  Variable-width minipages
+\@vwid@box=\box66
+\sift@deathcycles=\count271
+\@vwid@loff=\dimen199
+\@vwid@roff=\dimen256
+))
+(/usr/share/texmf-dist/tex/latex/float/float.sty
+Package: float 2001/11/08 v1.3d Float enhancements (AL)
+\c@float@type=\count272
+\float@exts=\toks31
+\float@box=\box67
+\@float@everytoks=\toks32
+\@floatcapt=\box68
+)
+(/usr/share/texmf-dist/tex/latex/tools/enumerate.sty
+Package: enumerate 2015/07/23 v3.00 enumerate extensions (DPC)
+\@enLab=\toks33
+)
+(/usr/share/texmf-dist/tex/latex/geometry/geometry.sty
+Package: geometry 2020/01/02 v5.9 Page Geometry
+
+(/usr/share/texmf-dist/tex/generic/iftex/ifvtex.sty
+Package: ifvtex 2019/10/25 v1.7 ifvtex legacy package. Use iftex instead.
+)
+\Gm@cnth=\count273
+\Gm@cntv=\count274
+\c@Gm@tempcnt=\count275
+\Gm@bindingoffset=\dimen257
+\Gm@wd@mp=\dimen258
+\Gm@odd@mp=\dimen259
+\Gm@even@mp=\dimen260
+\Gm@layoutwidth=\dimen261
+\Gm@layoutheight=\dimen262
+\Gm@layouthoffset=\dimen263
+\Gm@layoutvoffset=\dimen264
+\Gm@dimlist=\toks34
+)
+(/usr/share/texmf-dist/tex/latex/amsmath/amsmath.sty
+Package: amsmath 2020/09/23 v2.17i AMS math features
+\@mathmargin=\skip49
+
+For additional information on amsmath, use the `?' option.
+(/usr/share/texmf-dist/tex/latex/amsmath/amstext.sty
+Package: amstext 2000/06/29 v2.01 AMS text
+
+(/usr/share/texmf-dist/tex/latex/amsmath/amsgen.sty
+File: amsgen.sty 1999/11/30 v2.0 generic functions
+\@emptytoks=\toks35
+\ex@=\dimen265
+))
+(/usr/share/texmf-dist/tex/latex/amsmath/amsbsy.sty
+Package: amsbsy 1999/11/29 v1.2d Bold Symbols
+\pmbraise@=\dimen266
+)
+(/usr/share/texmf-dist/tex/latex/amsmath/amsopn.sty
+Package: amsopn 2016/03/08 v2.02 operator names
+)
+\inf@bad=\count276
+LaTeX Info: Redefining \frac on input line 234.
+\uproot@=\count277
+\leftroot@=\count278
+LaTeX Info: Redefining \overline on input line 399.
+\classnum@=\count279
+\DOTSCASE@=\count280
+LaTeX Info: Redefining \ldots on input line 496.
+LaTeX Info: Redefining \dots on input line 499.
+LaTeX Info: Redefining \cdots on input line 620.
+\Mathstrutbox@=\box69
+\strutbox@=\box70
+\big@size=\dimen267
+LaTeX Font Info:    Redeclaring font encoding OML on input line 743.
+LaTeX Font Info:    Redeclaring font encoding OMS on input line 744.
+\macc@depth=\count281
+\c@MaxMatrixCols=\count282
+\dotsspace@=\muskip16
+\c@parentequation=\count283
+\dspbrk@lvl=\count284
+\tag@help=\toks36
+\row@=\count285
+\column@=\count286
+\maxfields@=\count287
+\andhelp@=\toks37
+\eqnshift@=\dimen268
+\alignsep@=\dimen269
+\tagshift@=\dimen270
+\tagwidth@=\dimen271
+\totwidth@=\dimen272
+\lineht@=\dimen273
+\@envbody=\toks38
+\multlinegap=\skip50
+\multlinetaggap=\skip51
+\mathdisplay@stack=\toks39
+LaTeX Info: Redefining \[ on input line 2923.
+LaTeX Info: Redefining \] on input line 2924.
+)
+(/usr/share/texmf-dist/tex/latex/amsfonts/amssymb.sty
+Package: amssymb 2013/01/14 v3.01 AMS font symbols
+
+(/usr/share/texmf-dist/tex/latex/amsfonts/amsfonts.sty
+Package: amsfonts 2013/01/14 v3.01 Basic AMSFonts support
+\symAMSa=\mathgroup5
+\symAMSb=\mathgroup6
+LaTeX Font Info:    Redeclaring math symbol \hbar on input line 98.
+LaTeX Font Info:    Overwriting math alphabet `\mathfrak' in version `bold'
+(Font)                  U/euf/m/n --> U/euf/b/n on input line 106.
+))
+(/usr/share/texmf-dist/tex/latex/base/textcomp.sty
+Package: textcomp 2020/02/02 v2.0n Standard LaTeX package
+)
+(/usr/share/texmf-dist/tex/latex/upquote/upquote.sty
+Package: upquote 2012/04/19 v1.3 upright-quote and grave-accent glyphs in verba
+tim
+)
+(/usr/share/texmf-dist/tex/latex/eurosym/eurosym.sty
+Package: eurosym 1998/08/06 v1.1 European currency symbol ``Euro''
+\@eurobox=\box71
+)
+(/usr/share/texmf-dist/tex/latex/ucs/ucs.sty
+Package: ucs 2013/05/11 v2.2 UCS: Unicode input support
+
+(/usr/share/texmf-dist/tex/latex/ucs/data/uni-global.def
+File: uni-global.def 2013/05/13 UCS: Unicode global data
+)
+\uc@secondtry=\count288
+\uc@combtoks=\toks40
+\uc@combtoksb=\toks41
+\uc@temptokena=\toks42
+)
+(/usr/share/texmf-dist/tex/latex/fancyvrb/fancyvrb.sty
+Package: fancyvrb 2020/05/03 v3.6 verbatim text (tvz,hv)
+\FV@CodeLineNo=\count289
+\FV@InFile=\read4
+\FV@TabBox=\box72
+\c@FancyVerbLine=\count290
+\FV@StepNumber=\count291
+\FV@OutFile=\write6
+)
+(/usr/share/texmf-dist/tex/latex/grffile/grffile.sty
+Package: grffile 2019/11/11 v2.1 Extended file name support for graphics (legac
+y)
+Package grffile Info: This package is an empty stub for compatibility on input 
+line 40.
+)
+(/usr/share/texmf-dist/tex/latex/hyperref/hyperref.sty
+Package: hyperref 2020-05-15 v7.00e Hypertext links for LaTeX
+
+(/usr/share/texmf-dist/tex/generic/pdftexcmds/pdftexcmds.sty
+Package: pdftexcmds 2020-06-27 v0.33 Utility functions of pdfTeX for LuaTeX (HO
+)
+Package pdftexcmds Info: \pdf@primitive is available.
+Package pdftexcmds Info: \pdf@ifprimitive is available.
+Package pdftexcmds Info: \pdfdraftmode found.
+)
+(/usr/share/texmf-dist/tex/generic/kvdefinekeys/kvdefinekeys.sty
+Package: kvdefinekeys 2019-12-19 v1.6 Define keys (HO)
+)
+(/usr/share/texmf-dist/tex/generic/pdfescape/pdfescape.sty
+Package: pdfescape 2019/12/09 v1.15 Implements pdfTeX's escape features (HO)
+)
+(/usr/share/texmf-dist/tex/latex/hycolor/hycolor.sty
+Package: hycolor 2020-01-27 v1.10 Color options for hyperref/bookmark (HO)
+)
+(/usr/share/texmf-dist/tex/latex/letltxmacro/letltxmacro.sty
+Package: letltxmacro 2019/12/03 v1.6 Let assignment for LaTeX macros (HO)
+)
+(/usr/share/texmf-dist/tex/latex/auxhook/auxhook.sty
+Package: auxhook 2019-12-17 v1.6 Hooks for auxiliary files (HO)
+)
+\@linkdim=\dimen274
+\Hy@linkcounter=\count292
+\Hy@pagecounter=\count293
+
+(/usr/share/texmf-dist/tex/latex/hyperref/pd1enc.def
+File: pd1enc.def 2020-05-15 v7.00e Hyperref: PDFDocEncoding definition (HO)
+Now handling font encoding PD1 ...
+... no UTF-8 mapping file for font encoding PD1
+)
+(/usr/share/texmf-dist/tex/generic/intcalc/intcalc.sty
+Package: intcalc 2019/12/15 v1.3 Expandable calculations with integers (HO)
+)
+(/usr/share/texmf-dist/tex/generic/etexcmds/etexcmds.sty
+Package: etexcmds 2019/12/15 v1.7 Avoid name clashes with e-TeX commands (HO)
+)
+\Hy@SavedSpaceFactor=\count294
+Package hyperref Info: Hyper figures OFF on input line 4464.
+Package hyperref Info: Link nesting OFF on input line 4469.
+Package hyperref Info: Hyper index ON on input line 4472.
+Package hyperref Info: Plain pages OFF on input line 4479.
+Package hyperref Info: Backreferencing OFF on input line 4484.
+Package hyperref Info: Implicit mode ON; LaTeX internals redefined.
+Package hyperref Info: Bookmarks ON on input line 4717.
+\c@Hy@tempcnt=\count295
+
+(/usr/share/texmf-dist/tex/latex/url/url.sty
+\Urlmuskip=\muskip17
+Package: url 2013/09/16  ver 3.4  Verb mode for urls, etc.
+)
+LaTeX Info: Redefining \url on input line 5076.
+\XeTeXLinkMargin=\dimen275
+
+(/usr/share/texmf-dist/tex/generic/bitset/bitset.sty
+Package: bitset 2019/12/09 v1.3 Handle bit-vector datatype (HO)
+
+(/usr/share/texmf-dist/tex/generic/bigintcalc/bigintcalc.sty
+Package: bigintcalc 2019/12/15 v1.5 Expandable calculations on big integers (HO
+)
+))
+\Fld@menulength=\count296
+\Field@Width=\dimen276
+\Fld@charsize=\dimen277
+Package hyperref Info: Hyper figures OFF on input line 6347.
+Package hyperref Info: Link nesting OFF on input line 6352.
+Package hyperref Info: Hyper index ON on input line 6355.
+Package hyperref Info: backreferencing OFF on input line 6362.
+Package hyperref Info: Link coloring OFF on input line 6367.
+Package hyperref Info: Link coloring with OCG OFF on input line 6372.
+Package hyperref Info: PDF/A mode OFF on input line 6377.
+LaTeX Info: Redefining \ref on input line 6417.
+LaTeX Info: Redefining \pageref on input line 6421.
+
+(/usr/share/texmf-dist/tex/latex/base/atbegshi-ltx.sty
+Package: atbegshi-ltx 2020/08/17 v1.0a Emulation of the original atbegshi packa
+ge
+with kernel methods
+)
+\Hy@abspage=\count297
+\c@Item=\count298
+\c@Hfootnote=\count299
+)
+Package hyperref Info: Driver (autodetected): hpdftex.
+
+(/usr/share/texmf-dist/tex/latex/hyperref/hpdftex.def
+File: hpdftex.def 2020-05-15 v7.00e Hyperref driver for pdfTeX
+
+(/usr/share/texmf-dist/tex/latex/base/atveryend-ltx.sty
+Package: atveryend-ltx 2020/08/19 v1.0a Emulation of the original atvery packag
+e
+with kernel methods
+)
+\Fld@listcount=\count300
+\c@bookmark@seq@number=\count301
+
+(/usr/share/texmf-dist/tex/latex/rerunfilecheck/rerunfilecheck.sty
+Package: rerunfilecheck 2019/12/05 v1.9 Rerun checks for auxiliary files (HO)
+
+(/usr/share/texmf-dist/tex/generic/uniquecounter/uniquecounter.sty
+Package: uniquecounter 2019/12/15 v1.4 Provide unlimited unique counter (HO)
+)
+Package uniquecounter Info: New unique counter `rerunfilecheck' on input line 2
+86.
+)
+\Hy@SectionHShift=\skip52
+)
+(/usr/share/texmf-dist/tex/latex/titling/titling.sty
+Package: titling 2009/09/04 v2.1d maketitle typesetting
+\thanksmarkwidth=\skip53
+\thanksmargin=\skip54
+\droptitle=\skip55
+)
+(/usr/share/texmf-dist/tex/latex/tools/longtable.sty
+Package: longtable 2020/01/07 v4.13 Multi-page Table package (DPC)
+\LTleft=\skip56
+\LTright=\skip57
+\LTpre=\skip58
+\LTpost=\skip59
+\LTchunksize=\count302
+\LTcapwidth=\dimen278
+\LT@head=\box73
+\LT@firsthead=\box74
+\LT@foot=\box75
+\LT@lastfoot=\box76
+\LT@cols=\count303
+\LT@rows=\count304
+\c@LT@tables=\count305
+\c@LT@chunks=\count306
+\LT@p@ftn=\toks43
+)
+(/usr/share/texmf-dist/tex/latex/booktabs/booktabs.sty
+Package: booktabs 2020/01/12 v1.61803398 Publication quality tables
+\heavyrulewidth=\dimen279
+\lightrulewidth=\dimen280
+\cmidrulewidth=\dimen281
+\belowrulesep=\dimen282
+\belowbottomsep=\dimen283
+\aboverulesep=\dimen284
+\abovetopsep=\dimen285
+\cmidrulesep=\dimen286
+\cmidrulekern=\dimen287
+\defaultaddspace=\dimen288
+\@cmidla=\count307
+\@cmidlb=\count308
+\@aboverulesep=\dimen289
+\@belowrulesep=\dimen290
+\@thisruleclass=\count309
+\@lastruleclass=\count310
+\@thisrulewidth=\dimen291
+)
+(/usr/share/texmf-dist/tex/latex/enumitem/enumitem.sty
+Package: enumitem 2019/06/20 v3.9 Customized lists
+\labelindent=\skip60
+\enit@outerparindent=\dimen292
+\enit@toks=\toks44
+\enit@inbox=\box77
+\enit@count@id=\count311
+\enitdp@description=\count312
+)
+(/usr/share/texmf-dist/tex/generic/ulem/ulem.sty
+\UL@box=\box78
+\UL@hyphenbox=\box79
+\UL@skip=\skip61
+\UL@hook=\toks45
+\UL@height=\dimen293
+\UL@pe=\count313
+\UL@pixel=\dimen294
+\ULC@box=\box80
+Package: ulem 2019/11/18
+\ULdepth=\dimen295
+)
+(/usr/share/texmf-dist/tex/latex/jknapltx/mathrsfs.sty
+Package: mathrsfs 1996/01/01 Math RSFS package v1.0 (jk)
+\symrsfs=\mathgroup7
+)
+\Wrappedcontinuationbox=\box81
+\Wrappedvisiblespacebox=\box82
+Package hyperref Info: Option `breaklinks' set `true' on input line 361.
+Package hyperref Info: Option `colorlinks' set `true' on input line 361.
+LaTeX Font Info:    Trying to load font information for T1+ppl on input line 36
+8.
+
+(/usr/share/texmf-dist/tex/latex/psnfss/t1ppl.fd
+File: t1ppl.fd 2001/06/04 font definitions for T1/ppl.
+)
+(/usr/share/texmf-dist/tex/latex/l3backend/l3backend-pdftex.def
+File: l3backend-pdftex.def 2020-09-24 L3 backend support: PDF output (pdfTeX)
+\l__kernel_color_stack_int=\count314
+\l__pdf_internal_box=\box83
+)
+No file 7-SageAlgebra.aux.
+\openout1 = `7-SageAlgebra.aux'.
+
+LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 368.
+LaTeX Font Info:    ... okay on input line 368.
+LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 368.
+LaTeX Font Info:    ... okay on input line 368.
+LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 368.
+LaTeX Font Info:    ... okay on input line 368.
+LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 368.
+LaTeX Font Info:    ... okay on input line 368.
+LaTeX Font Info:    Checking defaults for TS1/cmr/m/n on input line 368.
+LaTeX Font Info:    ... okay on input line 368.
+LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 368.
+LaTeX Font Info:    ... okay on input line 368.
+LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 368.
+LaTeX Font Info:    ... okay on input line 368.
+LaTeX Font Info:    Checking defaults for PD1/pdf/m/n on input line 368.
+LaTeX Font Info:    ... okay on input line 368.
+(/usr/share/texmf-dist/tex/context/base/mkii/supp-pdf.mkii
+[Loading MPS to PDF converter (version 2006.09.02).]
+\scratchcounter=\count315
+\scratchdimen=\dimen296
+\scratchbox=\box84
+\nofMPsegments=\count316
+\nofMParguments=\count317
+\everyMPshowfont=\toks46
+\MPscratchCnt=\count318
+\MPscratchDim=\dimen297
+\MPnumerator=\count319
+\makeMPintoPDFobject=\count320
+\everyMPtoPDFconversion=\toks47
+) (/usr/share/texmf-dist/tex/latex/epstopdf-pkg/epstopdf-base.sty
+Package: epstopdf-base 2020-01-24 v2.11 Base part for package epstopdf
+Package epstopdf-base Info: Redefining graphics rule for `.eps' on input line 4
+85.
+
+(/usr/share/texmf-dist/tex/latex/latexconfig/epstopdf-sys.cfg
+File: epstopdf-sys.cfg 2010/07/13 v1.3 Configuration of (r)epstopdf for TeX Liv
+e
+))
+Package caption Info: Begin \AtBeginDocument code.
+Package caption Info: float package is loaded.
+Package caption Info: hyperref package is loaded.
+Package caption Info: longtable package is loaded.
+
+(/usr/share/texmf-dist/tex/latex/caption/ltcaption.sty
+Package: ltcaption 2020/05/30 v1.4b longtable captions (AR)
+)
+Package caption Info: End \AtBeginDocument code.
+
+*geometry* driver: auto-detecting
+*geometry* detected driver: pdftex
+*geometry* verbose mode - [ preamble ] result:
+* driver: pdftex
+* paper: <default>
+* layout: <same size as paper>
+* layoutoffset:(h,v)=(0.0pt,0.0pt)
+* modes: 
+* h-part:(L,W,R)=(72.26999pt, 469.75502pt, 72.26999pt)
+* v-part:(T,H,B)=(72.26999pt, 650.43001pt, 72.26999pt)
+* \paperwidth=614.295pt
+* \paperheight=794.96999pt
+* \textwidth=469.75502pt
+* \textheight=650.43001pt
+* \oddsidemargin=0.0pt
+* \evensidemargin=0.0pt
+* \topmargin=-37.0pt
+* \headheight=12.0pt
+* \headsep=25.0pt
+* \topskip=11.0pt
+* \footskip=30.0pt
+* \marginparwidth=59.0pt
+* \marginparsep=10.0pt
+* \columnsep=10.0pt
+* \skip\footins=10.0pt plus 4.0pt minus 2.0pt
+* \hoffset=0.0pt
+* \voffset=0.0pt
+* \mag=1000
+* \@twocolumnfalse
+* \@twosidefalse
+* \@mparswitchfalse
+* \@reversemarginfalse
+* (1in=72.27pt=25.4mm, 1cm=28.453pt)
+
+(/usr/share/texmf-dist/tex/latex/ucs/ucsencs.def
+File: ucsencs.def 2011/01/21 Fixes to fontencodings LGR, T3
+)
+Package hyperref Info: Link coloring ON on input line 368.
+
+(/usr/share/texmf-dist/tex/latex/hyperref/nameref.sty
+Package: nameref 2019/09/16 v2.46 Cross-referencing by name of section
+
+(/usr/share/texmf-dist/tex/latex/refcount/refcount.sty
+Package: refcount 2019/12/15 v3.6 Data extraction from label references (HO)
+)
+(/usr/share/texmf-dist/tex/generic/gettitlestring/gettitlestring.sty
+Package: gettitlestring 2019/12/15 v1.6 Cleanup title references (HO)
+)
+\c@section@level=\count321
+)
+LaTeX Info: Redefining \ref on input line 368.
+LaTeX Info: Redefining \pageref on input line 368.
+LaTeX Info: Redefining \nameref on input line 368.
+\@outlinefile=\write7
+\openout7 = `7-SageAlgebra.out'.
+
+LaTeX Font Info:    Trying to load font information for OT1+ppl on input line 3
+70.
+
+(/usr/share/texmf-dist/tex/latex/psnfss/ot1ppl.fd
+File: ot1ppl.fd 2001/06/04 font definitions for OT1/ppl.
+)
+LaTeX Font Info:    Trying to load font information for OML+zplm on input line 
+370.
+
+(/usr/share/texmf-dist/tex/latex/psnfss/omlzplm.fd
+File: omlzplm.fd 2002/09/08 Fontinst v1.914 font definitions for OML/zplm.
+)
+LaTeX Font Info:    Trying to load font information for OMS+zplm on input line 
+370.
+
+(/usr/share/texmf-dist/tex/latex/psnfss/omszplm.fd
+File: omszplm.fd 2002/09/08 Fontinst v1.914 font definitions for OMS/zplm.
+)
+LaTeX Font Info:    Trying to load font information for OMX+zplm on input line 
+370.
+
+(/usr/share/texmf-dist/tex/latex/psnfss/omxzplm.fd
+File: omxzplm.fd 2002/09/08 Fontinst v1.914 font definitions for OMX/zplm.
+)
+LaTeX Font Info:    Trying to load font information for OT1+zplm on input line 
+370.
+
+(/usr/share/texmf-dist/tex/latex/psnfss/ot1zplm.fd
+File: ot1zplm.fd 2002/09/08 Fontinst v1.914 font definitions for OT1/zplm.
+)
+LaTeX Font Info:    Font shape `U/msa/m/n' will be
+(Font)              scaled to size 12.50409pt on input line 370.
+LaTeX Font Info:    Font shape `U/msa/m/n' will be
+(Font)              scaled to size 9.37807pt on input line 370.
+LaTeX Font Info:    Font shape `U/msa/m/n' will be
+(Font)              scaled to size 7.29405pt on input line 370.
+LaTeX Font Info:    Font shape `U/msb/m/n' will be
+(Font)              scaled to size 12.50409pt on input line 370.
+LaTeX Font Info:    Font shape `U/msb/m/n' will be
+(Font)              scaled to size 9.37807pt on input line 370.
+LaTeX Font Info:    Font shape `U/msb/m/n' will be
+(Font)              scaled to size 7.29405pt on input line 370.
+LaTeX Font Info:    Trying to load font information for U+rsfs on input line 37
+0.
+
+(/usr/share/texmf-dist/tex/latex/jknapltx/ursfs.fd
+File: ursfs.fd 1998/03/24 rsfs font definition file (jk)
+)
+LaTeX Font Info:    Trying to load font information for T1+cmtt on input line 3
+70.
+
+(/usr/share/texmf-dist/tex/latex/base/t1cmtt.fd
+File: t1cmtt.fd 2019/12/16 v2.5j Standard LaTeX font definitions
+)
+LaTeX Font Info:    Font shape `U/msa/m/n' will be
+(Font)              scaled to size 11.40997pt on input line 376.
+LaTeX Font Info:    Font shape `U/msa/m/n' will be
+(Font)              scaled to size 8.33606pt on input line 376.
+LaTeX Font Info:    Font shape `U/msa/m/n' will be
+(Font)              scaled to size 6.25204pt on input line 376.
+LaTeX Font Info:    Font shape `U/msb/m/n' will be
+(Font)              scaled to size 11.40997pt on input line 376.
+LaTeX Font Info:    Font shape `U/msb/m/n' will be
+(Font)              scaled to size 8.33606pt on input line 376.
+LaTeX Font Info:    Font shape `U/msb/m/n' will be
+(Font)              scaled to size 6.25204pt on input line 376.
+ [1
+
+{/usr/share/texmf-var/fonts/map/pdftex/updmap/pdftex.map}]
+LaTeX Font Info:    Trying to load font information for TS1+cmtt on input line 
+496.
+ (/usr/share/texmf-dist/tex/latex/base/ts1cmtt.fd
+File: ts1cmtt.fd 2019/12/16 v2.5j Standard LaTeX font definitions
+) [2]
+LaTeX Font Info:    Trying to load font information for U+fplmbb on input line 
+562.
+ (/usr/share/texmf-dist/tex/latex/psnfss/ufplmbb.fd
+File: ufplmbb.fd 2003/10/30 Fontinst v1.914 font definitions for U/fplmbb.
+)
+
+Package longtable Warning: Column widths have changed
+(longtable)                in table 1 on input line 587.
+
+[3] [4]
+LaTeX Font Info:    Font shape `T1/cmtt/bx/n' in size <10.95> not available
+(Font)              Font shape `T1/cmtt/m/n' tried instead on input line 798.
+ [5] [6] [7] [8] [9] [10] [11] [12]
+
+Package longtable Warning: Table widths have changed. Rerun LaTeX.
+
+(./7-SageAlgebra.aux)
+
+Package rerunfilecheck Warning: File `7-SageAlgebra.out' has changed.
+(rerunfilecheck)                Rerun to get outlines right
+(rerunfilecheck)                or use package `bookmark'.
+
+Package rerunfilecheck Info: Checksums for `7-SageAlgebra.out':
+(rerunfilecheck)             Before: <no file>
+(rerunfilecheck)             After:  961D93ACE9582C324C6D1EA7B5DE7C92;970.
+
+LaTeX Warning: Label(s) may have changed. Rerun to get cross-references right.
+
+ ) 
+Here is how much of TeX's memory you used:
+ 21321 strings out of 479383
+ 388521 string characters out of 5875798
+ 751012 words of memory out of 5000000
+ 37920 multiletter control sequences out of 15000+600000
+ 445530 words of font info for 135 fonts, out of 8000000 for 9000
+ 1141 hyphenation exceptions out of 8191
+ 107i,14n,111p,506b,616s stack positions out of 5000i,500n,10000p,200000b,80000s
+{/usr/share/texmf-dist/fonts/enc/dvips/cm-super/cm-super-ts1.enc}{/usr/share/
+texmf-dist/fonts/enc/dvips/cm-super/cm-super-t1.enc}{/usr/share/texmf-dist/font
+s/enc/dvips/base/8r.enc}</usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/c
+mex10.pfb></usr/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmmi10.pfb></us
+r/share/texmf-dist/fonts/type1/public/amsfonts/cm/cmr10.pfb></usr/share/texmf-d
+ist/fonts/type1/public/amsfonts/cm/cmsy10.pfb></usr/share/texmf-dist/fonts/type
+1/public/mathpazo/fplmbb.pfb></usr/share/texmf-dist/fonts/type1/public/mathpazo
+/fplmr.pfb></usr/share/texmf-dist/fonts/type1/public/mathpazo/fplmri.pfb></usr/
+share/texmf-dist/fonts/type1/public/cm-super/sfit1095.pfb></usr/share/texmf-dis
+t/fonts/type1/public/cm-super/sftt1095.pfb></usr/share/texmf-dist/fonts/type1/p
+ublic/cm-super/sftt1200.pfb></usr/share/texmf-dist/fonts/type1/urw/palatino/upl
+b8a.pfb></usr/share/texmf-dist/fonts/type1/urw/palatino/uplr8a.pfb></usr/share/
+texmf-dist/fonts/type1/urw/palatino/uplri8a.pfb>
+Output written on 7-SageAlgebra.pdf (12 pages, 226346 bytes).
+PDF statistics:
+ 184 PDF objects out of 1000 (max. 8388607)
+ 155 compressed objects within 2 object streams
+ 46 named destinations out of 1000 (max. 500000)
+ 13 words of extra memory for PDF output out of 10000 (max. 10000000)
+
diff --git a/src/Lecture5/notebook/7-SageAlgebra.out b/src/Lecture5/notebook/7-SageAlgebra.out
new file mode 100644
index 0000000..a3ec270
--- /dev/null
+++ b/src/Lecture5/notebook/7-SageAlgebra.out
@@ -0,0 +1,16 @@
+\BOOKMARK [1][-]{section.1}{The Jupyter Notebook}{}% 1
+\BOOKMARK [2][-]{subsection.1.1}{Cells}{section.1}% 2
+\BOOKMARK [2][-]{subsection.1.2}{Markdown}{section.1}% 3
+\BOOKMARK [1][-]{section.2}{Symbolic expressions}{}% 4
+\BOOKMARK [2][-]{subsection.2.1}{Mathematical variables}{section.2}% 5
+\BOOKMARK [1][-]{section.3}{Basic rings and fields}{}% 6
+\BOOKMARK [2][-]{subsection.3.1}{Parents and coercion}{section.3}% 7
+\BOOKMARK [1][-]{section.4}{Polynomial rings}{}% 8
+\BOOKMARK [2][-]{subsection.4.1}{Operations on polynomials}{section.4}% 9
+\BOOKMARK [1][-]{section.5}{Matrices and vectors}{}% 10
+\BOOKMARK [1][-]{section.6}{Number Theory}{}% 11
+\BOOKMARK [2][-]{subsection.6.1}{Primes}{section.6}% 12
+\BOOKMARK [2][-]{subsection.6.2}{The Chinese remainder theorem \(CRT\)}{section.6}% 13
+\BOOKMARK [1][-]{section.7}{Cryptography: RSA}{}% 14
+\BOOKMARK [2][-]{subsection.7.1}{Public-key cryptography}{section.7}% 15
+\BOOKMARK [2][-]{subsection.7.2}{RSA}{section.7}% 16
diff --git a/src/Lecture5/notebook/7-SageAlgebra.pdf b/src/Lecture5/notebook/7-SageAlgebra.pdf
new file mode 100644
index 0000000..3b9d17c
--- /dev/null
+++ b/src/Lecture5/notebook/7-SageAlgebra.pdf
diff --git a/src/Lecture5/notebook/7-SageAlgebra.tex b/src/Lecture5/notebook/7-SageAlgebra.tex
new file mode 100644
index 0000000..a9c6c72
--- /dev/null
+++ b/src/Lecture5/notebook/7-SageAlgebra.tex
@@ -0,0 +1,1297 @@
+\documentclass[11pt]{article}
+
+    \usepackage[breakable]{tcolorbox}
+    \usepackage{parskip} % Stop auto-indenting (to mimic markdown behaviour)
+    
+    \usepackage{iftex}
+    \ifPDFTeX
+        \usepackage[T1]{fontenc}
+        \usepackage{mathpazo}
+    \else
+        \usepackage{fontspec}
+    \fi
+
+    % Basic figure setup, for now with no caption control since it's done
+    % automatically by Pandoc (which extracts ![](path) syntax from Markdown).
+    \usepackage{graphicx}
+    % Maintain compatibility with old templates. Remove in nbconvert 6.0
+    \let\Oldincludegraphics\includegraphics
+    % Ensure that by default, figures have no caption (until we provide a
+    % proper Figure object with a Caption API and a way to capture that
+    % in the conversion process - todo).
+    \usepackage{caption}
+    \DeclareCaptionFormat{nocaption}{}
+    \captionsetup{format=nocaption,aboveskip=0pt,belowskip=0pt}
+
+    \usepackage[Export]{adjustbox} % Used to constrain images to a maximum size
+    \adjustboxset{max size={0.9\linewidth}{0.9\paperheight}}
+    \usepackage{float}
+    \floatplacement{figure}{H} % forces figures to be placed at the correct location
+    \usepackage{xcolor} % Allow colors to be defined
+    \usepackage{enumerate} % Needed for markdown enumerations to work
+    \usepackage{geometry} % Used to adjust the document margins
+    \usepackage{amsmath} % Equations
+    \usepackage{amssymb} % Equations
+    \usepackage{textcomp} % defines textquotesingle
+    % Hack from http://tex.stackexchange.com/a/47451/13684:
+    \AtBeginDocument{%
+        \def\PYZsq{\textquotesingle}% Upright quotes in Pygmentized code
+    }
+    \usepackage{upquote} % Upright quotes for verbatim code
+    \usepackage{eurosym} % defines \euro
+    \usepackage[mathletters]{ucs} % Extended unicode (utf-8) support
+    \usepackage{fancyvrb} % verbatim replacement that allows latex
+    \usepackage{grffile} % extends the file name processing of package graphics 
+                         % to support a larger range
+    \makeatletter % fix for grffile with XeLaTeX
+    \def\Gread@@xetex#1{%
+      \IfFileExists{"\Gin@base".bb}%
+      {\Gread@eps{\Gin@base.bb}}%
+      {\Gread@@xetex@aux#1}%
+    }
+    \makeatother
+
+    % The hyperref package gives us a pdf with properly built
+    % internal navigation ('pdf bookmarks' for the table of contents,
+    % internal cross-reference links, web links for URLs, etc.)
+    \usepackage{hyperref}
+    % The default LaTeX title has an obnoxious amount of whitespace. By default,
+    % titling removes some of it. It also provides customization options.
+    \usepackage{titling}
+    \usepackage{longtable} % longtable support required by pandoc >1.10
+    \usepackage{booktabs}  % table support for pandoc > 1.12.2
+    \usepackage[inline]{enumitem} % IRkernel/repr support (it uses the enumerate* environment)
+    \usepackage[normalem]{ulem} % ulem is needed to support strikethroughs (\sout)
+                                % normalem makes italics be italics, not underlines
+    \usepackage{mathrsfs}
+    
+
+    
+    % Colors for the hyperref package
+    \definecolor{urlcolor}{rgb}{0,.145,.698}
+    \definecolor{linkcolor}{rgb}{.71,0.21,0.01}
+    \definecolor{citecolor}{rgb}{.12,.54,.11}
+
+    % ANSI colors
+    \definecolor{ansi-black}{HTML}{3E424D}
+    \definecolor{ansi-black-intense}{HTML}{282C36}
+    \definecolor{ansi-red}{HTML}{E75C58}
+    \definecolor{ansi-red-intense}{HTML}{B22B31}
+    \definecolor{ansi-green}{HTML}{00A250}
+    \definecolor{ansi-green-intense}{HTML}{007427}
+    \definecolor{ansi-yellow}{HTML}{DDB62B}
+    \definecolor{ansi-yellow-intense}{HTML}{B27D12}
+    \definecolor{ansi-blue}{HTML}{208FFB}
+    \definecolor{ansi-blue-intense}{HTML}{0065CA}
+    \definecolor{ansi-magenta}{HTML}{D160C4}
+    \definecolor{ansi-magenta-intense}{HTML}{A03196}
+    \definecolor{ansi-cyan}{HTML}{60C6C8}
+    \definecolor{ansi-cyan-intense}{HTML}{258F8F}
+    \definecolor{ansi-white}{HTML}{C5C1B4}
+    \definecolor{ansi-white-intense}{HTML}{A1A6B2}
+    \definecolor{ansi-default-inverse-fg}{HTML}{FFFFFF}
+    \definecolor{ansi-default-inverse-bg}{HTML}{000000}
+
+    % commands and environments needed by pandoc snippets
+    % extracted from the output of `pandoc -s`
+    \providecommand{\tightlist}{%
+      \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
+    \DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}}
+    % Add ',fontsize=\small' for more characters per line
+    \newenvironment{Shaded}{}{}
+    \newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{{#1}}}}
+    \newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.56,0.13,0.00}{{#1}}}
+    \newcommand{\DecValTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}}
+    \newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}}
+    \newcommand{\FloatTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{{#1}}}
+    \newcommand{\CharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}}
+    \newcommand{\StringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}}
+    \newcommand{\CommentTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textit{{#1}}}}
+    \newcommand{\OtherTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{{#1}}}
+    \newcommand{\AlertTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{{#1}}}}
+    \newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.02,0.16,0.49}{{#1}}}
+    \newcommand{\RegionMarkerTok}[1]{{#1}}
+    \newcommand{\ErrorTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{{#1}}}}
+    \newcommand{\NormalTok}[1]{{#1}}
+    
+    % Additional commands for more recent versions of Pandoc
+    \newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.53,0.00,0.00}{{#1}}}
+    \newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}}
+    \newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{{#1}}}
+    \newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.73,0.40,0.53}{{#1}}}
+    \newcommand{\ImportTok}[1]{{#1}}
+    \newcommand{\DocumentationTok}[1]{\textcolor[rgb]{0.73,0.13,0.13}{\textit{{#1}}}}
+    \newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{{#1}}}}}
+    \newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{{#1}}}}}
+    \newcommand{\VariableTok}[1]{\textcolor[rgb]{0.10,0.09,0.49}{{#1}}}
+    \newcommand{\ControlFlowTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{{#1}}}}
+    \newcommand{\OperatorTok}[1]{\textcolor[rgb]{0.40,0.40,0.40}{{#1}}}
+    \newcommand{\BuiltInTok}[1]{{#1}}
+    \newcommand{\ExtensionTok}[1]{{#1}}
+    \newcommand{\PreprocessorTok}[1]{\textcolor[rgb]{0.74,0.48,0.00}{{#1}}}
+    \newcommand{\AttributeTok}[1]{\textcolor[rgb]{0.49,0.56,0.16}{{#1}}}
+    \newcommand{\InformationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{{#1}}}}}
+    \newcommand{\WarningTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{{#1}}}}}
+    
+    
+    % Define a nice break command that doesn't care if a line doesn't already
+    % exist.
+    \def\br{\hspace*{\fill} \\* }
+    % Math Jax compatibility definitions
+    \def\gt{>}
+    \def\lt{<}
+    \let\Oldtex\TeX
+    \let\Oldlatex\LaTeX
+    \renewcommand{\TeX}{\textrm{\Oldtex}}
+    \renewcommand{\LaTeX}{\textrm{\Oldlatex}}
+    % Document parameters
+    % Document title
+    \title{Algebra and Cryptography with SageMath}
+    \date{2021-04-23}
+    \author{Sebastiano Tronto - \texttt{sebastiano.tronto@uni.lu}}
+    
+    
+    
+    
+    
+% Pygments definitions
+\makeatletter
+\def\PY@reset{\let\PY@it=\relax \let\PY@bf=\relax%
+    \let\PY@ul=\relax \let\PY@tc=\relax%
+    \let\PY@bc=\relax \let\PY@ff=\relax}
+\def\PY@tok#1{\csname PY@tok@#1\endcsname}
+\def\PY@toks#1+{\ifx\relax#1\empty\else%
+    \PY@tok{#1}\expandafter\PY@toks\fi}
+\def\PY@do#1{\PY@bc{\PY@tc{\PY@ul{%
+    \PY@it{\PY@bf{\PY@ff{#1}}}}}}}
+\def\PY#1#2{\PY@reset\PY@toks#1+\relax+\PY@do{#2}}
+
+\expandafter\def\csname PY@tok@w\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.73,0.73}{##1}}}
+\expandafter\def\csname PY@tok@c\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@cp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.74,0.48,0.00}{##1}}}
+\expandafter\def\csname PY@tok@k\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@kp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@kt\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.69,0.00,0.25}{##1}}}
+\expandafter\def\csname PY@tok@o\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@ow\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
+\expandafter\def\csname PY@tok@nb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@nf\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@nc\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@nn\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@ne\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.82,0.25,0.23}{##1}}}
+\expandafter\def\csname PY@tok@nv\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@no\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.53,0.00,0.00}{##1}}}
+\expandafter\def\csname PY@tok@nl\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.63,0.63,0.00}{##1}}}
+\expandafter\def\csname PY@tok@ni\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.60,0.60,0.60}{##1}}}
+\expandafter\def\csname PY@tok@na\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.49,0.56,0.16}{##1}}}
+\expandafter\def\csname PY@tok@nt\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@nd\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
+\expandafter\def\csname PY@tok@s\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@sd\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@si\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.53}{##1}}}
+\expandafter\def\csname PY@tok@se\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.13}{##1}}}
+\expandafter\def\csname PY@tok@sr\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.40,0.53}{##1}}}
+\expandafter\def\csname PY@tok@ss\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@sx\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@m\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@gh\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
+\expandafter\def\csname PY@tok@gu\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.50,0.00,0.50}{##1}}}
+\expandafter\def\csname PY@tok@gd\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.63,0.00,0.00}{##1}}}
+\expandafter\def\csname PY@tok@gi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.63,0.00}{##1}}}
+\expandafter\def\csname PY@tok@gr\endcsname{\def\PY@tc##1{\textcolor[rgb]{1.00,0.00,0.00}{##1}}}
+\expandafter\def\csname PY@tok@ge\endcsname{\let\PY@it=\textit}
+\expandafter\def\csname PY@tok@gs\endcsname{\let\PY@bf=\textbf}
+\expandafter\def\csname PY@tok@gp\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
+\expandafter\def\csname PY@tok@go\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
+\expandafter\def\csname PY@tok@gt\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.27,0.87}{##1}}}
+\expandafter\def\csname PY@tok@err\endcsname{\def\PY@bc##1{\setlength{\fboxsep}{0pt}\fcolorbox[rgb]{1.00,0.00,0.00}{1,1,1}{\strut ##1}}}
+\expandafter\def\csname PY@tok@kc\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@kd\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@kn\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@kr\endcsname{\let\PY@bf=\textbf\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@bp\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
+\expandafter\def\csname PY@tok@fm\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
+\expandafter\def\csname PY@tok@vc\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@vg\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@vi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@vm\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
+\expandafter\def\csname PY@tok@sa\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@sb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@sc\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@dl\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@s2\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@sh\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@s1\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
+\expandafter\def\csname PY@tok@mb\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@mf\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@mh\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@mi\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@il\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@mo\endcsname{\def\PY@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
+\expandafter\def\csname PY@tok@ch\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@cm\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@cpf\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@c1\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+\expandafter\def\csname PY@tok@cs\endcsname{\let\PY@it=\textit\def\PY@tc##1{\textcolor[rgb]{0.25,0.50,0.50}{##1}}}
+
+\def\PYZbs{\char`\\}
+\def\PYZus{\char`\_}
+\def\PYZob{\char`\{}
+\def\PYZcb{\char`\}}
+\def\PYZca{\char`\^}
+\def\PYZam{\char`\&}
+\def\PYZlt{\char`\<}
+\def\PYZgt{\char`\>}
+\def\PYZsh{\char`\#}
+\def\PYZpc{\char`\%}
+\def\PYZdl{\char`\$}
+\def\PYZhy{\char`\-}
+\def\PYZsq{\char`\'}
+\def\PYZdq{\char`\"}
+\def\PYZti{\char`\~}
+% for compatibility with earlier versions
+\def\PYZat{@}
+\def\PYZlb{[}
+\def\PYZrb{]}
+\makeatother
+
+
+    % For linebreaks inside Verbatim environment from package fancyvrb. 
+    \makeatletter
+        \newbox\Wrappedcontinuationbox 
+        \newbox\Wrappedvisiblespacebox 
+        \newcommand*\Wrappedvisiblespace {\textcolor{red}{\textvisiblespace}} 
+        \newcommand*\Wrappedcontinuationsymbol {\textcolor{red}{\llap{\tiny$\m@th\hookrightarrow$}}} 
+        \newcommand*\Wrappedcontinuationindent {3ex } 
+        \newcommand*\Wrappedafterbreak {\kern\Wrappedcontinuationindent\copy\Wrappedcontinuationbox} 
+        % Take advantage of the already applied Pygments mark-up to insert 
+        % potential linebreaks for TeX processing. 
+        %        {, <, #, %, $, ' and ": go to next line. 
+        %        _, }, ^, &, >, - and ~: stay at end of broken line. 
+        % Use of \textquotesingle for straight quote. 
+        \newcommand*\Wrappedbreaksatspecials {% 
+            \def\PYGZus{\discretionary{\char`\_}{\Wrappedafterbreak}{\char`\_}}% 
+            \def\PYGZob{\discretionary{}{\Wrappedafterbreak\char`\{}{\char`\{}}% 
+            \def\PYGZcb{\discretionary{\char`\}}{\Wrappedafterbreak}{\char`\}}}% 
+            \def\PYGZca{\discretionary{\char`\^}{\Wrappedafterbreak}{\char`\^}}% 
+            \def\PYGZam{\discretionary{\char`\&}{\Wrappedafterbreak}{\char`\&}}% 
+            \def\PYGZlt{\discretionary{}{\Wrappedafterbreak\char`\<}{\char`\<}}% 
+            \def\PYGZgt{\discretionary{\char`\>}{\Wrappedafterbreak}{\char`\>}}% 
+            \def\PYGZsh{\discretionary{}{\Wrappedafterbreak\char`\#}{\char`\#}}% 
+            \def\PYGZpc{\discretionary{}{\Wrappedafterbreak\char`\%}{\char`\%}}% 
+            \def\PYGZdl{\discretionary{}{\Wrappedafterbreak\char`\$}{\char`\$}}% 
+            \def\PYGZhy{\discretionary{\char`\-}{\Wrappedafterbreak}{\char`\-}}% 
+            \def\PYGZsq{\discretionary{}{\Wrappedafterbreak\textquotesingle}{\textquotesingle}}% 
+            \def\PYGZdq{\discretionary{}{\Wrappedafterbreak\char`\"}{\char`\"}}% 
+            \def\PYGZti{\discretionary{\char`\~}{\Wrappedafterbreak}{\char`\~}}% 
+        } 
+        % Some characters . , ; ? ! / are not pygmentized. 
+        % This macro makes them "active" and they will insert potential linebreaks 
+        \newcommand*\Wrappedbreaksatpunct {% 
+            \lccode`\~`\.\lowercase{\def~}{\discretionary{\hbox{\char`\.}}{\Wrappedafterbreak}{\hbox{\char`\.}}}% 
+            \lccode`\~`\,\lowercase{\def~}{\discretionary{\hbox{\char`\,}}{\Wrappedafterbreak}{\hbox{\char`\,}}}% 
+            \lccode`\~`\;\lowercase{\def~}{\discretionary{\hbox{\char`\;}}{\Wrappedafterbreak}{\hbox{\char`\;}}}% 
+            \lccode`\~`\:\lowercase{\def~}{\discretionary{\hbox{\char`\:}}{\Wrappedafterbreak}{\hbox{\char`\:}}}% 
+            \lccode`\~`\?\lowercase{\def~}{\discretionary{\hbox{\char`\?}}{\Wrappedafterbreak}{\hbox{\char`\?}}}% 
+            \lccode`\~`\!\lowercase{\def~}{\discretionary{\hbox{\char`\!}}{\Wrappedafterbreak}{\hbox{\char`\!}}}% 
+            \lccode`\~`\/\lowercase{\def~}{\discretionary{\hbox{\char`\/}}{\Wrappedafterbreak}{\hbox{\char`\/}}}% 
+            \catcode`\.\active
+            \catcode`\,\active 
+            \catcode`\;\active
+            \catcode`\:\active
+            \catcode`\?\active
+            \catcode`\!\active
+            \catcode`\/\active 
+            \lccode`\~`\~       
+        }
+    \makeatother
+
+    \let\OriginalVerbatim=\Verbatim
+    \makeatletter
+    \renewcommand{\Verbatim}[1][1]{%
+        %\parskip\z@skip
+        \sbox\Wrappedcontinuationbox {\Wrappedcontinuationsymbol}%
+        \sbox\Wrappedvisiblespacebox {\FV@SetupFont\Wrappedvisiblespace}%
+        \def\FancyVerbFormatLine ##1{\hsize\linewidth
+            \vtop{\raggedright\hyphenpenalty\z@\exhyphenpenalty\z@
+                \doublehyphendemerits\z@\finalhyphendemerits\z@
+                \strut ##1\strut}%
+        }%
+        % If the linebreak is at a space, the latter will be displayed as visible
+        % space at end of first line, and a continuation symbol starts next line.
+        % Stretch/shrink are however usually zero for typewriter font.
+        \def\FV@Space {%
+            \nobreak\hskip\z@ plus\fontdimen3\font minus\fontdimen4\font
+            \discretionary{\copy\Wrappedvisiblespacebox}{\Wrappedafterbreak}
+            {\kern\fontdimen2\font}%
+        }%
+        
+        % Allow breaks at special characters using \PYG... macros.
+        \Wrappedbreaksatspecials
+        % Breaks at punctuation characters . , ; ? ! and / need catcode=\active         
+        \OriginalVerbatim[#1,codes*=\Wrappedbreaksatpunct]%
+    }
+    \makeatother
+
+    % Exact colors from NB
+    \definecolor{incolor}{HTML}{303F9F}
+    \definecolor{outcolor}{HTML}{D84315}
+    \definecolor{cellborder}{HTML}{CFCFCF}
+    \definecolor{cellbackground}{HTML}{F7F7F7}
+    
+    % prompt
+    \makeatletter
+    \newcommand{\boxspacing}{\kern\kvtcb@left@rule\kern\kvtcb@boxsep}
+    \makeatother
+    \newcommand{\prompt}[4]{
+        \ttfamily\llap{{\color{#2}[#3]:\hspace{3pt}#4}}\vspace{-\baselineskip}
+    }
+    
+
+    
+    % Prevent overflowing lines due to hard-to-break entities
+    \sloppy 
+    % Setup hyperref package
+    \hypersetup{
+      breaklinks=true,  % so long urls are correctly broken across lines
+      colorlinks=true,
+      urlcolor=urlcolor,
+      linkcolor=linkcolor,
+      citecolor=citecolor,
+      }
+    % Slightly bigger margins than the latex defaults
+    
+    \geometry{verbose,tmargin=1in,bmargin=1in,lmargin=1in,rmargin=1in}
+    
+    
+
+\begin{document}
+    
+    \maketitle
+    
+    
+
+    
+    This lecture's notes are in a different format: the presentations for
+the \(\LaTeX\) part were made with \(\LaTeX\), so this one is made with
+Sage, or rather with the \href{https://jupyter.org/}{Jupyter Notebook}.
+
+\hypertarget{the-jupyter-notebook}{%
+\section{The Jupyter Notebook}\label{the-jupyter-notebook}}
+
+\textbf{Reference:} {[}\href{https://jupyter.org/documentation}{1}{]}
+
+The Jupyter Notebook is one of the default interfaces for SageMath,
+along with the command line interface. You can access it via web
+browser, but it is running locally on your device (notice the strange
+url: \texttt{http://localhost:8888/notebooks...}).
+
+You can create a new notebook by clicking on
+\texttt{New\ \textgreater{}\ SageMath\ 9.2}. You can also create a
+Python 3 notebook to write Python code.
+
+Jupyter saves and reads files in the \texttt{.ipynb} format. If you
+download the file for this lecture you can open it and follow the
+examples interactively.
+
+\hypertarget{cells}{%
+\subsection{Cells}\label{cells}}
+
+The notebook contains one or more \emph{interactive cells} that you can
+run, like this one below:
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{2}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{c+c1}{\PYZsh{} Exercise: modify this cell to use the print() command}
+\PY{l+m+mi}{2}\PY{o}{+}\PY{l+m+mi}{2}
+\PY{l+m+mi}{2}\PY{o}{/}\PY{l+m+mi}{5}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{2}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+2/5
+\end{Verbatim}
+\end{tcolorbox}
+        
+    If you are reading this from Jupyter rather than from the pdf file, you
+can edit the cell above and run it again. You can also add more cells by
+selecting \texttt{Insert} from the menu bar.
+
+Notice that only the last statement produces an output. You can force
+anything to be written as output with the \texttt{print()} command,
+which works like in Python. As an exercise, try to modify the cell above
+to provide more output!
+
+    \hypertarget{markdown}{%
+\subsection{Markdown}\label{markdown}}
+
+\href{https://en.wikipedia.org/wiki/Markdown}{Markdown} is a simple
+markup language - think of LaTeX or html, but much simpler. You can add
+text to your notebook with Markdown cells by selecting
+\texttt{Cell\ \textgreater{}\ Cell\ Type\ \textgreater{}\ Markdown}.
+
+You can also include some LaTeX code in Markdown cells, with dollar
+signs \$ or align environments:
+
+\begin{align*}
+\frac{(x+y)^2}{x+1} = \frac{x^2+y^2}{x+1}
+\end{align*}
+
+When you are done writing a Markdown cell, you can run it to see the
+well-formatted text. To edit the text again, double-click on the cell.
+Try doing it now to fix the formula above!
+
+    \hypertarget{symbolic-expressions}{%
+\section{Symbolic expressions}\label{symbolic-expressions}}
+
+\textbf{Reference:}
+{[}\href{https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html}{2}{]}
+
+Now, let's get started with Sage. One thing you might want to do is
+manipulating symbolic expressions, like the following:
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{3}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{f} \PY{o}{=}  \PY{n}{x}\PY{o}{\PYZca{}}\PY{l+m+mi}{2} \PY{o}{+} \PY{l+m+mi}{2}\PY{o}{*}\PY{n}{x} \PY{o}{\PYZhy{}} \PY{l+m+mi}{5} \PY{o}{==} \PY{l+m+mi}{0}
+\PY{n}{solve}\PY{p}{(}\PY{n}{f}\PY{p}{,}\PY{n}{x}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{3}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+[x == -sqrt(6) - 1, x == sqrt(6) - 1]
+\end{Verbatim}
+\end{tcolorbox}
+        
+    Notice that the single \texttt{=} is part of an assignment, as in
+Python: we are \emph{assigning} to the variable \texttt{f} the value
+\texttt{x\^{}2\ +\ 2*x\ -\ 5\ \textgreater{}=\ 0}, which in this case is
+an equation, so it contains the symbol \texttt{==}. Keep in mind the
+difference between the two!
+
+\textbf{Exercise:} change the code above to solve the corresponding
+inequality \(x^2+2x-5\geq 0\).
+
+    \hypertarget{mathematical-variables}{%
+\subsection{Mathematical variables}\label{mathematical-variables}}
+
+Last time we saw what \emph{variables} are in Python, and that they are
+a little bit different from the \emph{Mathematical variables} that you
+use in Mathematics. In Sage, both concepts are present, but they are
+still distinct. For example in the cell above \texttt{f} is a variable
+in the sense of computer science, while \texttt{x} is a Mathematical
+variable.
+
+If you want to use Mathematical variables other than \texttt{x}, you
+first need to \emph{declare} them with the \texttt{var()} command:
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{14}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{var}\PY{p}{(}\PY{l+s+s1}{\PYZsq{}}\PY{l+s+s1}{y}\PY{l+s+s1}{\PYZsq{}}\PY{p}{)}
+\PY{n}{solve}\PY{p}{(}\PY{n}{y}\PY{o}{\PYZca{}}\PY{l+m+mi}{2} \PY{o}{+} \PY{p}{(}\PY{n}{x}\PY{o}{+}\PY{l+m+mi}{1}\PY{p}{)}\PY{o}{*}\PY{n}{y} \PY{o}{\PYZhy{}} \PY{l+m+mi}{2} \PY{o}{==} \PY{l+m+mi}{0}\PY{p}{,} \PY{n}{y}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{14}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+[y == -1/2*x - 1/2*sqrt(x\^{}2 + 2*x + 9) - 1/2, y == -1/2*x + 1/2*sqrt(x\^{}2 + 2*x +
+9) - 1/2]
+\end{Verbatim}
+\end{tcolorbox}
+        
+    Try removing the first line in the cell above and see what error you
+get!
+
+Here is another example:
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{16}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{var}\PY{p}{(}\PY{l+s+s1}{\PYZsq{}}\PY{l+s+s1}{a}\PY{l+s+s1}{\PYZsq{}}\PY{p}{,} \PY{l+s+s1}{\PYZsq{}}\PY{l+s+s1}{b}\PY{l+s+s1}{\PYZsq{}}\PY{p}{)}
+\PY{n}{f} \PY{o}{=} \PY{n}{x}\PY{o}{\PYZca{}}\PY{l+m+mi}{2}\PY{o}{+}\PY{n}{a}\PY{o}{*}\PY{n}{x}\PY{o}{+}\PY{n}{b}
+\PY{n}{solve}\PY{p}{(}\PY{n}{f}\PY{p}{,}\PY{n}{x}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{16}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+[x == -1/2*a - 1/2*sqrt(a\^{}2 - 4*b), x == -1/2*a + 1/2*sqrt(a\^{}2 - 4*b)]
+\end{Verbatim}
+\end{tcolorbox}
+        
+    Some common constants are
+\href{https://doc.sagemath.org/html/en/reference/calculus/sage/symbolic/expression.html}{already
+defined} in Sage:
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{17}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{e}\PY{o}{\PYZca{}}\PY{p}{(}\PY{n}{pi}\PY{o}{*}\PY{n}{I}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{17}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+-1
+\end{Verbatim}
+\end{tcolorbox}
+        
+    We will study symbolic expressions more in detail next time, in the
+context of calculus/analysis.
+
+    \hypertarget{basic-rings-and-fields}{%
+\section{Basic rings and fields}\label{basic-rings-and-fields}}
+
+\textbf{References:}
+{[}\href{https://doc.sagemath.org/html/en/reference/rings_standard/index.html}{3}{]}
+{[}\href{https://doc.sagemath.org/html/en/reference/rings_numerical/index.html}{4}{]}
+{[}\href{https://doc.sagemath.org/html/en/reference/finite_rings/index.html}{5}{]}
+
+As you should know, a \emph{field} is a Mathematical structure with two
+operations, addition and multiplication, which respect certain rules
+(distributivity, associativity, commutativity\ldots). Some examples of
+fields are the Rational numbers \(\mathbb Q\), the Real numbers
+\(\mathbb R\) and the Complex numbers \(\mathbb C\), but there are many
+more. As you should also know, a \emph{(commutative) ring} is like a
+field, except not all elements different from \(0\) need have a
+multiplicative inverse. For example the integers
+\(\mathbb Z = \{ \dots, -1, 0, 1, 2, \dots\}\) are a ring, but not a
+field.
+
+These structures are already implemented in Sage. Some of the most
+common are listed in the following table:
+
+\begin{longtable}[]{@{}rcl@{}}
+\toprule
+Mathematical object & Math symbol & Sage name \\
+\midrule
+\endhead
+Integers & \(\mathbb Z\) & \texttt{ZZ} \\
+Rational numbers & \(\mathbb Q\) & \texttt{QQ} \\
+Real numbers & \(\mathbb R\) & \texttt{RR} \\
+Complex numbers & \(\mathbb C\) & \texttt{CC} \\
+Integers modulo \(n\) & \(\mathbb Z/n\mathbb Z\) &
+\texttt{Integers(n)} \\
+Finite fields & \(\mathbb F_p\) & GF(p) \\
+\(\dots\) & \(\dots\) & \(\dots\) \\
+\bottomrule
+\end{longtable}
+
+    If you write a number or an expression, Sage will figure out where it
+``lives'', choosing the most restrictive interpretation possible. For
+example \texttt{3} will be interpreted to be an integer, even if it is
+also a rational number, a real number and a complex number.
+
+    \hypertarget{parents-and-coercion}{%
+\subsection{Parents and coercion}\label{parents-and-coercion}}
+
+\textbf{Reference:}
+{[}\href{https://doc.sagemath.org/html/en/tutorial/tour_coercion.html}{6}{]}
+
+You can check where an object ``lives'' with the \texttt{parent()}
+command. It works more or less like the Python command \texttt{type()},
+but it gives a more Mathematically inclined answer. Check the reference
+link {[}6{]} above if you want more details.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{18}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{c+c1}{\PYZsh{}Edit this cell to find out the type of other objects that we used}
+\PY{n}{parent}\PY{p}{(}\PY{l+m+mi}{3}\PY{o}{/}\PY{l+m+mi}{5}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{18}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+Rational Field
+\end{Verbatim}
+\end{tcolorbox}
+        
+    Sometimes Sage does not give you the best possible interpretation, so
+you can force something to be interpreted as living in a smaller ring as
+follows:
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{4}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{minus\PYZus{}one} \PY{o}{=} \PY{n}{e}\PY{o}{\PYZca{}}\PY{p}{(}\PY{n}{pi}\PY{o}{*}\PY{n}{I}\PY{p}{)}
+\PY{n}{minus\PYZus{}one\PYZus{}coerced} \PY{o}{=} \PY{n}{ZZ}\PY{p}{(}\PY{n}{e}\PY{o}{\PYZca{}}\PY{p}{(}\PY{n}{pi}\PY{o}{*}\PY{n}{I}\PY{p}{)}\PY{p}{)}  \PY{c+c1}{\PYZsh{} coercion}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{parent}\PY{p}{(}\PY{n}{minus\PYZus{}one}\PY{p}{)}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{parent}\PY{p}{(}\PY{n}{minus\PYZus{}one\PYZus{}coerced}\PY{p}{)}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+Symbolic Ring
+Integer Ring
+    \end{Verbatim}
+
+    \textbf{Remark.} Notice that there is a fundamental difference between
+the rings \texttt{RR} and \texttt{CC} and all the others in the table
+above: the real and complex numbers are \emph{approximated}.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{1}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{QQ}\PY{p}{(}\PY{l+m+mi}{3}\PY{p}{)}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{RR}\PY{p}{(}\PY{l+m+mi}{3}\PY{p}{)}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+3
+3.00000000000000
+    \end{Verbatim}
+
+    You can also choose the precision of this approximation using the
+alternative name \texttt{RealField}.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{4}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{RR}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{RealField}\PY{p}{(}\PY{n}{prec}\PY{o}{=}\PY{l+m+mi}{1000}\PY{p}{)}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+Real Field with 53 bits of precision
+Real Field with 1000 bits of precision
+    \end{Verbatim}
+
+    \hypertarget{polynomial-rings}{%
+\section{Polynomial rings}\label{polynomial-rings}}
+
+\textbf{Reference:}
+{[}\href{https://doc.sagemath.org/html/en/reference/polynomial_rings/index.html}{7}{]}
+
+If you want to work with polynomials over a certain ring it is better to
+use this specific construction, rather than the symbolic expressions
+introduced above.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{5}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{polring}\PY{o}{.}\PY{o}{\PYZlt{}}\PY{n}{x}\PY{p}{,}\PY{n}{y}\PY{p}{,}\PY{n}{z}\PY{o}{\PYZgt{}} \PY{o}{=} \PY{n}{RR}\PY{p}{[}\PY{p}{]}  \PY{c+c1}{\PYZsh{} Alternative: polring.\PYZlt{}x,y,z\PYZgt{} = PolynomialRing(RR)}
+\PY{n}{polring}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{5}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+Multivariate Polynomial Ring in x, y, z over Real Field with 53 bits of
+precision
+\end{Verbatim}
+\end{tcolorbox}
+        
+    You can use as many variables as you like, and you can replace
+\texttt{RR} with any ring. In the example above \texttt{polring} is just
+the name of the variable (in the computer science sense) associated with
+this polynomial ring.
+
+\hypertarget{operations-on-polynomials}{%
+\subsection{Operations on polynomials}\label{operations-on-polynomials}}
+
+The usual Mathematical operations are available on polynomial rings,
+including Euclidean division \texttt{//} and remainder \texttt{\%}.
+There is also the single-slash division \texttt{/}, but the result may
+not be a polynomial anymore.
+
+\textbf{Exercise:} use the \texttt{parent()} command to find out what
+the quotient of two polynomials is.
+
+\textbf{Question:} what happens if you remove the first line in the cell
+below? What if we used the variable \texttt{y} instead of \texttt{x}?
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{6}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{polring}\PY{o}{.}\PY{o}{\PYZlt{}}\PY{n}{x}\PY{o}{\PYZgt{}} \PY{o}{=} \PY{n}{QQ}\PY{p}{[}\PY{p}{]}
+\PY{n}{p} \PY{o}{=} \PY{n}{x}\PY{o}{\PYZca{}}\PY{l+m+mi}{2} \PY{o}{+} \PY{l+m+mi}{2}\PY{o}{*}\PY{n}{x} \PY{o}{\PYZhy{}} \PY{l+m+mi}{3}   \PY{c+c1}{\PYZsh{} Don\PYZsq{}t forget * for multiplication!}
+\PY{n}{q} \PY{o}{=} \PY{n}{p} \PY{o}{/}\PY{o}{/} \PY{p}{(}\PY{n}{x}\PY{o}{+}\PY{l+m+mi}{1}\PY{p}{)}
+\PY{n}{r} \PY{o}{=} \PY{n}{p} \PY{o}{\PYZpc{}}  \PY{p}{(}\PY{n}{x}\PY{o}{+}\PY{l+m+mi}{1}\PY{p}{)}
+\PY{n}{f} \PY{o}{=} \PY{n}{p} \PY{o}{/}  \PY{p}{(}\PY{n}{x}\PY{o}{+}\PY{l+m+mi}{1}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{q}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{r}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{f}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+x + 1
+-4
+(x\^{}2 + 2*x - 3)/(x + 1)
+    \end{Verbatim}
+
+    You can do more complex operations. Try out \texttt{roots()} and
+\texttt{factor} in the cell below.
+
+\textbf{Remark.} Notice how the result can change substantially if you
+change the base ring.
+
+\textbf{Remark.}
+\href{https://doc.sagemath.org/html/en/reference/structure/sage/structure/factorization.html}{Factorizations}
+are a particular object in Sage. They are kinda like a list, but not
+really. You can get a list of pairs (factor, power) with
+\texttt{list(factor(f))}.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{7}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{polring\PYZus{}onevar}\PY{o}{.}\PY{o}{\PYZlt{}}\PY{n}{t}\PY{o}{\PYZgt{}} \PY{o}{=} \PY{n}{QQ}\PY{p}{[}\PY{p}{]}
+
+\PY{n}{f} \PY{o}{=} \PY{n}{t}\PY{o}{\PYZca{}}\PY{l+m+mi}{5} \PY{o}{+} \PY{n}{t}\PY{o}{\PYZca{}}\PY{l+m+mi}{4} \PY{o}{\PYZhy{}} \PY{l+m+mi}{2}\PY{o}{*}\PY{n}{t}\PY{o}{\PYZca{}}\PY{l+m+mi}{3} \PY{o}{\PYZhy{}} \PY{l+m+mi}{2}\PY{o}{*}\PY{n}{t}\PY{o}{\PYZca{}}\PY{l+m+mi}{2} \PY{o}{\PYZhy{}} \PY{l+m+mi}{3}\PY{o}{*}\PY{n}{t} \PY{o}{\PYZhy{}} \PY{l+m+mi}{3}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{factor}\PY{p}{(}\PY{n}{f}\PY{p}{)}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{f}\PY{o}{.}\PY{n}{roots}\PY{p}{(}\PY{p}{)}\PY{p}{)}  \PY{c+c1}{\PYZsh{} Result: list of pairs (root,multiplicity)}
+
+\PY{n}{polring\PYZus{}manyvar}\PY{o}{.}\PY{o}{\PYZlt{}}\PY{n}{x}\PY{p}{,}\PY{n}{y}\PY{p}{,}\PY{n}{z}\PY{o}{\PYZgt{}} \PY{o}{=} \PY{n}{QQ}\PY{p}{[}\PY{p}{]}
+\PY{n}{factor}\PY{p}{(}\PY{n}{x}\PY{o}{*}\PY{n}{y}\PY{o}{+}\PY{n}{x}\PY{p}{)}
+
+\PY{c+c1}{\PYZsh{} The following line gives an error, because the polynomial}
+\PY{c+c1}{\PYZsh{} is understood to possibly have many variables:}
+\PY{c+c1}{\PYZsh{}(x\PYZca{}2\PYZhy{}1).roots()}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+(t + 1) * (t\^{}2 - 3) * (t\^{}2 + 1)
+[(-1, 1)]
+    \end{Verbatim}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{7}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+(y + 1) * x
+\end{Verbatim}
+\end{tcolorbox}
+        
+    \hypertarget{matrices-and-vectors}{%
+\section{Matrices and vectors}\label{matrices-and-vectors}}
+
+\textbf{References:}
+{[}\href{https://doc.sagemath.org/html/en/reference/matrices/index.html}{8}{]},
+but in particular the subections
+{[}\href{https://doc.sagemath.org/html/en/reference/matrices/sage/matrix/docs.html}{9}{]}
+and
+{[}\href{https://doc.sagemath.org/html/en/reference/matrices/sage/matrix/matrix2.html}{10}{]}
+
+In Sage you can easily manipulate matrices and vectors
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{77}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{A} \PY{o}{=} \PY{n}{matrix}\PY{p}{(}\PY{p}{[}\PY{p}{[}\PY{l+m+mi}{1}\PY{p}{,}\PY{l+m+mi}{2}\PY{p}{,}\PY{l+m+mi}{3}\PY{p}{]}\PY{p}{,}\PY{p}{[}\PY{l+m+mi}{0}\PY{p}{,}\PY{l+m+mi}{0}\PY{p}{,}\PY{l+m+mi}{1}\PY{p}{]}\PY{p}{,}\PY{p}{[}\PY{l+m+mi}{4}\PY{p}{,}\PY{o}{\PYZhy{}}\PY{l+m+mi}{3}\PY{p}{,}\PY{l+m+mi}{22}\PY{o}{/}\PY{l+m+mi}{7}\PY{p}{]}\PY{p}{]}\PY{p}{)}
+\PY{n}{B} \PY{o}{=} \PY{n}{matrix}\PY{p}{(}\PY{p}{[}\PY{p}{[}\PY{l+m+mi}{1}\PY{o}{/}\PY{l+m+mi}{2}\PY{p}{,}\PY{l+m+mi}{0}\PY{p}{,}\PY{l+m+mi}{0}\PY{p}{]}\PY{p}{,}\PY{p}{[}\PY{l+m+mi}{7}\PY{p}{,}\PY{l+m+mi}{0}\PY{p}{,}\PY{l+m+mi}{0}\PY{p}{]}\PY{p}{,}\PY{p}{[}\PY{l+m+mi}{1}\PY{p}{,}\PY{l+m+mi}{1}\PY{p}{,}\PY{l+m+mi}{1}\PY{p}{]}\PY{p}{]}\PY{p}{)}
+\PY{n}{v} \PY{o}{=} \PY{n}{vector}\PY{p}{(}\PY{p}{[}\PY{l+m+mi}{3}\PY{p}{,}\PY{l+m+mi}{4}\PY{p}{,}\PY{o}{\PYZhy{}}\PY{l+m+mi}{1}\PY{p}{]}\PY{p}{)}
+
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{A}\PY{p}{,} \PY{l+s+s2}{\PYZdq{}}\PY{l+s+se}{\PYZbs{}n}\PY{l+s+s2}{\PYZdq{}}\PY{p}{)}  \PY{c+c1}{\PYZsh{} \PYZbs{}n just means \PYZdq{}newline\PYZdq{}}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{B}\PY{p}{,} \PY{l+s+s2}{\PYZdq{}}\PY{l+s+se}{\PYZbs{}n}\PY{l+s+s2}{\PYZdq{}}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{B}\PY{o}{*}\PY{n}{v}\PY{p}{,} \PY{l+s+s2}{\PYZdq{}}\PY{l+s+se}{\PYZbs{}n}\PY{l+s+s2}{\PYZdq{}}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{A}\PY{o}{\PYZca{}}\PY{l+m+mi}{2} \PY{o}{+} \PY{l+m+mi}{2}\PY{o}{*}\PY{n}{B} \PY{o}{\PYZhy{}} \PY{n}{A}\PY{o}{*}\PY{n}{B}\PY{p}{,} \PY{l+s+s2}{\PYZdq{}}\PY{l+s+se}{\PYZbs{}n}\PY{l+s+s2}{\PYZdq{}}\PY{p}{)}
+
+\PY{n+nb}{print}\PY{p}{(}\PY{l+s+s2}{\PYZdq{}}\PY{l+s+s2}{Rank of A =}\PY{l+s+s2}{\PYZdq{}}\PY{p}{,} \PY{n}{rank}\PY{p}{(}\PY{n}{A}\PY{p}{)}\PY{p}{)} \PY{c+c1}{\PYZsh{} You can also use A.rank()}
+\PY{n+nb}{print}\PY{p}{(}\PY{l+s+s2}{\PYZdq{}}\PY{l+s+s2}{Rank of B =}\PY{l+s+s2}{\PYZdq{}}\PY{p}{,} \PY{n}{rank}\PY{p}{(}\PY{n}{B}\PY{p}{)}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+[   1    2    3]
+[   0    0    1]
+[   4   -3 22/7]
+
+[1/2   0   0]
+[  7   0   0]
+[  1   1   1]
+
+(3/2, 21, 6)
+
+[  -7/2    -10   80/7]
+[    17     -4   15/7]
+[ 241/7  -18/7 869/49]
+
+Rank of A = 3
+Rank of B = 2
+    \end{Verbatim}
+
+    \textbf{Exercise:} in the cell above, compute the determinant, inverse
+and characteristic polynomial of the matrix \texttt{A}. \emph{Hint: look
+at the reference {[}10{]} above (the functions are listed in alphabetic
+order).}
+
+As for polynomials, you can specify where a matrix or a vector lives
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{57}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{M} \PY{o}{=} \PY{n}{matrix}\PY{p}{(}\PY{n}{CC}\PY{p}{,} \PY{p}{[}\PY{p}{[}\PY{l+m+mi}{0}\PY{p}{,}\PY{l+m+mi}{1}\PY{p}{]}\PY{p}{,}\PY{p}{[}\PY{l+m+mi}{1}\PY{p}{,}\PY{l+m+mi}{0}\PY{p}{]}\PY{p}{]}\PY{p}{)}
+\PY{n}{parent}\PY{p}{(}\PY{n}{M}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{57}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+Full MatrixSpace of 2 by 2 dense matrices over Complex Field with 53 bits of
+precision
+\end{Verbatim}
+\end{tcolorbox}
+        
+    You can also solve linear systems and compute eigenvalues and
+eigenvectors of a matrix
+
+\textbf{Warning.} In linear algebra there are distinct concepts of
+\emph{left} and \emph{right} eigenvalues (and eigenvector). The one you
+know is probably that of \textbf{right} eigen-\{value,vector\}, that is
+an element \(\lambda\) of the base field and a non-zero vector
+\(\mathbf v\) with \(A\mathbf v=\lambda\mathbf v\). The other concept
+corresponds to the equality \(\mathbf v^TA=\lambda \mathbf v\).
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{60}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{A} \PY{o}{=} \PY{n}{Matrix}\PY{p}{(}\PY{n}{RR}\PY{p}{,} \PY{p}{[}\PY{p}{[}\PY{n}{sqrt}\PY{p}{(}\PY{l+m+mi}{59}\PY{p}{)}\PY{p}{,}\PY{l+m+mi}{32}\PY{p}{]}\PY{p}{,}\PY{p}{[}\PY{o}{\PYZhy{}}\PY{l+m+mi}{1}\PY{o}{/}\PY{l+m+mi}{4}\PY{p}{,}\PY{l+m+mi}{3}\PY{p}{]}\PY{p}{]}\PY{p}{)}
+\PY{n}{v} \PY{o}{=} \PY{n}{vector}\PY{p}{(}\PY{n}{RR}\PY{p}{,} \PY{p}{[}\PY{l+m+mi}{3}\PY{p}{,}\PY{l+m+mi}{0}\PY{p}{]}\PY{p}{)}
+\PY{n}{A}\PY{o}{.}\PY{n}{solve\PYZus{}right}\PY{p}{(}\PY{n}{v}\PY{p}{)} \PY{c+c1}{\PYZsh{} Solve Ax=v. Alternative: A \PYZbs{} v}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{60}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+(0.289916349448506, 0.0241596957873755)
+\end{Verbatim}
+\end{tcolorbox}
+        
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{64}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{A} \PY{o}{=} \PY{n}{Matrix}\PY{p}{(}\PY{n}{QQ}\PY{p}{,} \PY{p}{[}\PY{p}{[}\PY{l+m+mi}{1}\PY{p}{,}\PY{l+m+mi}{2}\PY{p}{]}\PY{p}{,}\PY{p}{[}\PY{l+m+mi}{3}\PY{p}{,}\PY{l+m+mi}{4}\PY{p}{]}\PY{p}{]}\PY{p}{)}
+\PY{n}{A}\PY{o}{.}\PY{n}{eigenspaces\PYZus{}right}\PY{p}{(}\PY{p}{)} \PY{c+c1}{\PYZsh{} Also: A.eigenvalues(), A.eigenvectors\PYZus{}right()}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{64}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+[
+(-0.3722813232690144?, Vector space of degree 2 and dimension 1 over Algebraic
+Field
+User basis matrix:
+[                   1 -0.6861406616345072?]),
+(5.372281323269015?, Vector space of degree 2 and dimension 1 over Algebraic
+Field
+User basis matrix:
+[                 1 2.186140661634508?])
+]
+\end{Verbatim}
+\end{tcolorbox}
+        
+    We can also extract a specific submatrix by selecting only some rows and
+columns, with a syntax similar to that of Python's lists. Check out more
+examples in the reference {[}9{]} above, and try them in the cell below.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{94}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{A} \PY{o}{=} \PY{n}{MatrixSpace}\PY{p}{(}\PY{n}{ZZ}\PY{p}{,} \PY{l+m+mi}{7}\PY{p}{)}\PY{o}{.}\PY{n}{random\PYZus{}element}\PY{p}{(}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{A}\PY{p}{,} \PY{l+s+s2}{\PYZdq{}}\PY{l+s+se}{\PYZbs{}n}\PY{l+s+s2}{\PYZdq{}}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{A}\PY{p}{[}\PY{l+m+mi}{1}\PY{p}{:}\PY{l+m+mi}{3}\PY{p}{,}\PY{l+m+mi}{2}\PY{p}{:}\PY{l+m+mi}{5}\PY{p}{]}\PY{p}{,} \PY{l+s+s2}{\PYZdq{}}\PY{l+s+se}{\PYZbs{}n}\PY{l+s+s2}{\PYZdq{}}\PY{p}{)} \PY{c+c1}{\PYZsh{} Rows from 1 to 3, columns from 2 to 5}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{A}\PY{p}{[}\PY{l+m+mi}{0}\PY{p}{,}\PY{l+m+mi}{0}\PY{p}{:}\PY{p}{]}\PY{p}{,} \PY{l+s+s2}{\PYZdq{}}\PY{l+s+se}{\PYZbs{}n}\PY{l+s+s2}{\PYZdq{}}\PY{p}{)}    \PY{c+c1}{\PYZsh{} First row, all columns}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{A}\PY{p}{[}\PY{p}{[}\PY{l+m+mi}{0}\PY{p}{,}\PY{l+m+mi}{5}\PY{p}{,}\PY{l+m+mi}{2}\PY{p}{]}\PY{p}{,}\PY{l+m+mi}{0}\PY{p}{:}\PY{l+m+mi}{5}\PY{p}{]}\PY{p}{)}   \PY{c+c1}{\PYZsh{} Rows 0, 5 and 2 (in this order) and columns 0 to 5}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+[-14   2   0  -1   1  -2  -1]
+[  0  -8   0   9  -2  11   1]
+[  0   3   1  -1   1   1 221]
+[ -1   2   1 -25 -10   4   0]
+[ -3   0   0   2  16  -1  -2]
+[  1  -3   3 -41   1   0   0]
+[ -2   1   0   0  -6   2  12]
+
+[ 0  9 -2]
+[ 1 -1  1]
+
+[-14   2   0  -1   1  -2  -1]
+
+[-14   2   0  -1   1]
+[  1  -3   3 -41   1]
+[  0   3   1  -1   1]
+    \end{Verbatim}
+
+    \textbf{Exercise:} write a sage function that computes the determinant
+of an \(n\times n\) matrix \(A=(a_{ij})\) using Laplace's rule by the
+first row, that is \begin{align*}
+    \operatorname{det}A = \sum_{j=1}^n (-1)^ja_{0j}M_{0j}
+\end{align*} where \(M_{0j}\) is the determinant of the
+\((n-1)\times(n-1)\) matrix obtained by removing the \(0\)-th row and
+the \(j\)-th column from \(A\).
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{91}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{k}{def} \PY{n+nf}{my\PYZus{}det}\PY{p}{(}\PY{n}{A}\PY{p}{)}\PY{p}{:}
+    \PY{k}{if} \PY{o+ow}{not} \PY{n}{A}\PY{o}{.}\PY{n}{is\PYZus{}square}\PY{p}{(}\PY{p}{)}\PY{p}{:}
+        \PY{n+nb}{print}\PY{p}{(}\PY{l+s+s2}{\PYZdq{}}\PY{l+s+s2}{Error: matrix is not square}\PY{l+s+s2}{\PYZdq{}}\PY{p}{)}
+    
+    \PY{n}{n} \PY{o}{=} \PY{n}{A}\PY{o}{.}\PY{n}{nrows}\PY{p}{(}\PY{p}{)}  \PY{c+c1}{\PYZsh{} size of the matrix}
+    
+    \PY{c+c1}{\PYZsh{} Continue from here!}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \hypertarget{number-theory}{%
+\section{Number Theory}\label{number-theory}}
+
+\textbf{Reference:}
+{[}\href{https://doc.sagemath.org/html/en/reference/rings_standard/sage/rings/integer.html}{11}{]}
+
+Sage includes a large library of functions for computing with the
+integers, see the link above.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{8}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{n} \PY{o}{=} \PY{l+m+mi}{123456789}
+\PY{n}{m} \PY{o}{=} \PY{l+m+mi}{987654321}
+\PY{n}{p} \PY{o}{=} \PY{l+m+mi}{3607}
+
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{factor}\PY{p}{(}\PY{n}{n}\PY{p}{)}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{is\PYZus{}prime}\PY{p}{(}\PY{n}{p}\PY{p}{)}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{p}\PY{o}{.}\PY{n}{divides}\PY{p}{(}\PY{n}{n}\PY{p}{)}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{euler\PYZus{}phi}\PY{p}{(}\PY{n}{m}\PY{p}{)}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{gcd}\PY{p}{(}\PY{n}{n}\PY{p}{,} \PY{n}{m}\PY{p}{)}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{lcm}\PY{p}{(}\PY{n}{n}\PY{p}{,} \PY{n}{m}\PY{p}{)}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+3\^{}2 * 3607 * 3803
+True
+True
+619703040
+9
+13548070123626141
+    \end{Verbatim}
+
+    \hypertarget{primes}{%
+\subsection{Primes}\label{primes}}
+
+\textbf{Reference:}
+{[}\href{https://doc.sagemath.org/html/en/reference/sets/sage/sets/primes.html}{12}{]}
+
+The set of prime numbers is called \texttt{Primes()}. It is like an
+infinite list: for example you can get the one-millionth prime number or
+you can use this list to create other lists. You can also check what the
+first prime number larger than a given number is.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{9}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{PP} \PY{o}{=} \PY{n}{Primes}\PY{p}{(}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{PP}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{PP}\PY{p}{[}\PY{l+m+mi}{10}\PY{p}{]}\PY{p}{,} \PY{n}{PP}\PY{p}{[}\PY{l+m+mi}{10}\PY{o}{\PYZca{}}\PY{l+m+mi}{6}\PY{p}{]}\PY{p}{)}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{PP}\PY{o}{.}\PY{n}{next}\PY{p}{(}\PY{l+m+mi}{44}\PY{p}{)}\PY{p}{)}
+
+\PY{n}{First\PYZus{}Thousand\PYZus{}Primes} \PY{o}{=} \PY{n}{PP}\PY{p}{[}\PY{l+m+mi}{0}\PY{p}{:}\PY{l+m+mi}{1000}\PY{p}{]}
+\PY{n+nb}{print}\PY{p}{(}\PY{p}{[}\PY{n}{p} \PY{k}{for} \PY{n}{p} \PY{o+ow}{in} \PY{n}{First\PYZus{}Thousand\PYZus{}Primes} \PY{k}{if} \PY{n}{p} \PY{o}{\PYZlt{}} \PY{l+m+mi}{100} \PY{o+ow}{and} \PY{n}{p} \PY{o}{\PYZgt{}} \PY{l+m+mi}{75}\PY{p}{]}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+Set of all prime numbers: 2, 3, 5, 7, {\ldots}
+31 15485867
+47
+[79, 83, 89, 97]
+    \end{Verbatim}
+
+    \hypertarget{the-chinese-remainder-theorem-crt}{%
+\subsection{The Chinese remainder theorem
+(CRT)}\label{the-chinese-remainder-theorem-crt}}
+
+We say that two integers \(a\) and \(b\) are \emph{congruent} modulo
+another integer \(n>0\) if they have the same remainder when divided by
+\(n\). We denote this by \(a\equiv b\pmod n\), or in Python/Sage syntax
+\texttt{a\ \%\ n\ ==\ b\ \%\ n}.
+
+The Chinese remainder theorem states that if \(a,b\in\mathbb Z\) and
+\(n,m\in \mathbb Z_{>0}\) are such that \(\gcd(n,m)=1\) then the system
+of congruences
+
+\begin{align*}
+\begin{cases}
+    x \equiv a \pmod n\\
+    x \equiv b \pmod m
+\end{cases}
+\end{align*}
+
+has exactly one solution modulo \(mn\). This means that there is one and
+only one number \(x\) with \(0\leq x<mn\) such that \(x\equiv a\pmod n\)
+and \(x\equiv b\pmod m\).
+
+The procedure to find such a number is not too hard to describe (you
+might see it in an algebra or number theory course), but it can be a bit
+long. Luckily, Sage can do this for you:
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{10}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{a} \PY{o}{=} \PY{l+m+mi}{2}
+\PY{n}{b} \PY{o}{=} \PY{o}{\PYZhy{}}\PY{l+m+mi}{1}
+\PY{n}{n} \PY{o}{=} \PY{l+m+mi}{172}
+\PY{n}{m} \PY{o}{=} \PY{l+m+mi}{799}
+
+\PY{k}{if} \PY{n}{gcd}\PY{p}{(}\PY{n}{n}\PY{p}{,}\PY{n}{m}\PY{p}{)} \PY{o}{!=} \PY{l+m+mi}{1}\PY{p}{:}
+    \PY{n+nb}{print}\PY{p}{(}\PY{l+s+s2}{\PYZdq{}}\PY{l+s+s2}{The numbers are not comprime, I can}\PY{l+s+s2}{\PYZsq{}}\PY{l+s+s2}{t solve this!}\PY{l+s+s2}{\PYZdq{}}\PY{p}{)}
+\PY{k}{else}\PY{p}{:}
+    \PY{n}{x} \PY{o}{=} \PY{n}{crt}\PY{p}{(}\PY{n}{a}\PY{p}{,} \PY{n}{b}\PY{p}{,} \PY{n}{n}\PY{p}{,} \PY{n}{m}\PY{p}{)}
+    \PY{n+nb}{print}\PY{p}{(}\PY{n}{x}\PY{p}{,} \PY{n}{x}\PY{o}{\PYZpc{}}\PY{k}{n}, x\PYZpc{}m)
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+74306 2 798
+    \end{Verbatim}
+
+    \textbf{Exercise.} There is a more general version of the Chinese
+remainder theorem which says that if
+\(a_0, a_1, \dots, a_k\in\mathbb Z\) and
+\(n_0, n_2, \dots, n_k\in\mathbb Z_{>0}\) are such that
+\(\gcd(n_i, n_j)=1\) for \(i\neq j\), then the system of congruences
+
+\begin{align*}
+\begin{cases}
+    x \equiv a_0 \pmod {n_0}\\
+    x \equiv a_1 \pmod {n_1}\\
+    \dots \\
+    x \equiv a_k \pmod {n_k}
+\end{cases}
+\end{align*}
+
+has exactly one solution modulo \(\prod_{i=0}^kn_i\). Use the
+\texttt{crt()} function to find a solution to such a system. *Hint:
+start by running the command \texttt{help(crt)}.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{127}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{c+c1}{\PYZsh{}help(crt)}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \hypertarget{cryptography-rsa}{%
+\section{Cryptography: RSA}\label{cryptography-rsa}}
+
+\href{https://en.wikipedia.org/wiki/Cryptography}{Cryptography} is the
+discipline that studies methods to communicate secrets in such a way
+that any unauthorized listener would not be able to understand the
+message.
+
+A simple cryptographic protocol could be changing every letter of your
+text following a fixed scheme (or \emph{cypher}), for example by turning
+every A into a B, every B into a C and so on. However this is not a very
+secure method, for many reasons. One of them is that at some point the
+people who want to communicate need to agree on what method to use, and
+anyone listening to that conversation would be able to decypher every
+subsequent conversation. A public-key cryptographic protocol solves this
+problem.
+
+\hypertarget{public-key-cryptography}{%
+\subsection{Public-key cryptography}\label{public-key-cryptography}}
+
+Public-key cryptographic protocols, such as RSA, work like this: there
+are two keys, a \emph{private} key that is only known to person A
+(traditionally called Alice in every example), and a \emph{public} key
+that does not need to be secret.
+
+The public key is used to \emph{encrypt} the message (that is to
+``lock'' it, or ``hyde'' it), but one needs the private key to
+\emph{decrypt} it. Imagine having two keys for your door, but one can
+only be used to lock it, while the other only to open it.
+
+The message exchange works like this: suppose that person B (Bob) wants
+to send a secret message to Alice. Then Alice secretely generates a
+private and a public key and sends only the public one to Bob. Now Bob
+encrypts the message and sends it to Alice, who can use her private key
+to decrypt it. Even if Eve (short for \emph{eavesdropper}, an
+unauthorized listener) listens to every message exchanged, she won't be
+able to decypher the secret: the private key has never left Alice's
+house!
+
+Notice that such a protocol is \emph{asymmetric}: if Alice wanted to
+send a secret to Bob in reply, Bob would need to generate a pair of keys
+of his own.
+
+Let's see how we can do this in practice, using number theory!
+
+\hypertarget{rsa}{%
+\subsection{RSA}\label{rsa}}
+
+As many other cryptography protocols, RSA is based on a Mathematical
+process that is easy to do in one direction, but very hard to invert. In
+this case the hard process is integer factorization, that is decomposing
+an integer number as a product of primes.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{2}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{n}{p} \PY{o}{=} \PY{l+m+mi}{100003100019100043100057100069}
+\PY{n}{q} \PY{o}{=} \PY{l+m+mi}{100144655312449572059845328443}
+\PY{n}{n} \PY{o}{=} \PY{n}{p}\PY{o}{*}\PY{n}{q}
+\PY{n+nb}{print}\PY{p}{(}\PY{n}{is\PYZus{}prime}\PY{p}{(}\PY{n}{p}\PY{p}{)}\PY{p}{,} \PY{n}{is\PYZus{}prime}\PY{p}{(}\PY{n}{q}\PY{p}{)}\PY{p}{,} \PY{n}{is\PYZus{}prime}\PY{p}{(}\PY{n}{p}\PY{o}{*}\PY{n}{q}\PY{p}{)}\PY{p}{)}
+
+\PY{c+c1}{\PYZsh{} Use the command below to see how long it takes}
+\PY{c+c1}{\PYZsh{}timeit(\PYZdq{}factor(n)\PYZdq{}, number=1, repeat=1)}
+\end{Verbatim}
+\end{tcolorbox}
+
+    \begin{Verbatim}[commandchars=\\\{\}]
+True True False
+    \end{Verbatim}
+
+    In order to generate the keys, Alice picks a number \(n\) which is the
+product of two large primes \(p\) and \(q\) of more or less the same
+size. Finding such primes is relatively easy compared to factoring the
+number \(n\) she obtained. Then she computes the Euler totient
+\(\varphi(n)=(p-1)(q-1)\) of \(n\), which she can do because she knows
+that \(n=pq\) - it would be impossible otherwise!
+
+Then Alice can compute two integers \((d,e)\) such that
+\(de\equiv 1\pmod{\varphi(n)}\). She will send the numbers \(n\) and
+\(d\) to Bob and keep \(e\) secret. In this case the public key is the
+pair \((n,d)\), while \(e\) is the private key.
+
+Of course, she does all of this using Sage!
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{105}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{k}{def} \PY{n+nf}{two\PYZus{}large\PYZus{}primes}\PY{p}{(}\PY{p}{)}\PY{p}{:}
+    \PY{n}{p}\PY{p}{,} \PY{n}{q} \PY{o}{=} \PY{l+m+mi}{0}\PY{p}{,} \PY{l+m+mi}{0}
+    \PY{c+c1}{\PYZsh{} We make sure that they are different}
+    \PY{k}{while} \PY{n}{p} \PY{o}{==} \PY{n}{q}\PY{p}{:}
+        \PY{n}{p} \PY{o}{=} \PY{n}{Primes}\PY{p}{(}\PY{p}{)}\PY{p}{[}\PY{n}{randint}\PY{p}{(}\PY{l+m+mi}{10}\PY{o}{\PYZca{}}\PY{l+m+mi}{6}\PY{p}{,} \PY{l+m+mi}{2}\PY{o}{*}\PY{l+m+mi}{10}\PY{o}{\PYZca{}}\PY{l+m+mi}{6}\PY{p}{)}\PY{p}{]}
+        \PY{n}{q} \PY{o}{=} \PY{n}{Primes}\PY{p}{(}\PY{p}{)}\PY{p}{[}\PY{n}{randint}\PY{p}{(}\PY{l+m+mi}{10}\PY{o}{\PYZca{}}\PY{l+m+mi}{6}\PY{p}{,} \PY{l+m+mi}{2}\PY{o}{*}\PY{l+m+mi}{10}\PY{o}{\PYZca{}}\PY{l+m+mi}{6}\PY{p}{)}\PY{p}{]}
+    \PY{k}{return} \PY{n}{p}\PY{p}{,} \PY{n}{q}
+
+\PY{k}{def} \PY{n+nf}{random\PYZus{}unit\PYZus{}mod}\PY{p}{(}\PY{n}{N}\PY{p}{)}\PY{p}{:}
+    \PY{n}{R} \PY{o}{=} \PY{n}{Integers}\PY{p}{(}\PY{n}{N}\PY{p}{)}
+    \PY{n}{d} \PY{o}{=} \PY{n}{R}\PY{p}{(}\PY{l+m+mi}{0}\PY{p}{)}
+    \PY{c+c1}{\PYZsh{} We make sure that it is invertible}
+    \PY{k}{while} \PY{o+ow}{not} \PY{n}{d}\PY{o}{.}\PY{n}{is\PYZus{}unit}\PY{p}{(}\PY{p}{)}\PY{p}{:}
+        \PY{n}{d} \PY{o}{=} \PY{n}{R}\PY{o}{.}\PY{n}{random\PYZus{}element}\PY{p}{(}\PY{p}{)}
+    \PY{k}{return} \PY{n}{d}
+
+\PY{k}{def} \PY{n+nf}{Alice\PYZus{}generate\PYZus{}keys}\PY{p}{(}\PY{p}{)}\PY{p}{:}
+    \PY{n}{p}\PY{p}{,} \PY{n}{q} \PY{o}{=} \PY{n}{two\PYZus{}large\PYZus{}primes}\PY{p}{(}\PY{p}{)}
+    \PY{n}{n} \PY{o}{=} \PY{n}{p}\PY{o}{*}\PY{n}{q}
+    \PY{n}{phi\PYZus{}n} \PY{o}{=} \PY{p}{(}\PY{n}{p}\PY{o}{\PYZhy{}}\PY{l+m+mi}{1}\PY{p}{)}\PY{o}{*}\PY{p}{(}\PY{n}{q}\PY{o}{\PYZhy{}}\PY{l+m+mi}{1}\PY{p}{)} \PY{c+c1}{\PYZsh{} euler\PYZus{}phi(n) is slow!}
+    
+    \PY{n}{d} \PY{o}{=} \PY{n}{random\PYZus{}unit\PYZus{}mod}\PY{p}{(}\PY{n}{phi\PYZus{}n}\PY{p}{)}
+    \PY{n}{e} \PY{o}{=} \PY{n}{d}\PY{o}{\PYZca{}}\PY{o}{\PYZhy{}}\PY{l+m+mi}{1}
+    \PY{k}{return} \PY{n}{n}\PY{p}{,} \PY{n}{d}\PY{p}{,} \PY{n}{e}
+
+\PY{n}{Alice\PYZus{}generate\PYZus{}keys}\PY{p}{(}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{105}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+(419199544978969, 235530823946467, 80799425863927)
+\end{Verbatim}
+\end{tcolorbox}
+        
+    Now, how does Bob encrypt his message? Let's say he wants to send to
+Alice the number \(m\) with \(1<m<n\) (In practice he would like to send
+her some text with emojis, or maybe a voice message; but for computers
+everything is a number, and there are different ways to translate any
+sort of information to a number. He just chooses one of the many
+standard methods that already exist, no cryptography is needed in this
+step. If the message \(m\) is too long, he can split it up in some
+pieces and repeat the process multiple times.)
+
+Now he computes \(m^d\pmod n\) and sends it back to Alice.
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{3}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{k}{def} \PY{n+nf}{Bob\PYZus{}encrypt}\PY{p}{(}\PY{n}{m}\PY{p}{,} \PY{n}{n}\PY{p}{,} \PY{n}{d}\PY{p}{)}\PY{p}{:}
+    \PY{n}{R} \PY{o}{=} \PY{n}{Integers}\PY{p}{(}\PY{n}{n}\PY{p}{)}
+    \PY{k}{return} \PY{n}{R}\PY{p}{(}\PY{n}{m}\PY{p}{)}\PY{o}{\PYZca{}}\PY{n}{d}  \PY{c+c1}{\PYZsh{} Assume that n is large enough}
+    
+\PY{n}{message} \PY{o}{=} \PY{l+m+mi}{42424242}
+\PY{n}{Bob\PYZus{}encrypt}\PY{p}{(}\PY{n}{message}\PY{p}{,} \PY{l+m+mi}{419199544978969}\PY{p}{,} \PY{l+m+mi}{235530823946467}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{3}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+149461597163501
+\end{Verbatim}
+\end{tcolorbox}
+        
+    Since \(de\equiv 1\pmod{\varphi(n)}\), it follows that
+\((m^d)^e\equiv m\pmod n\) (see
+\href{https://en.wikipedia.org/wiki/Euler\%27s_theorem}{Wikipedia:
+Euler's theorem}). So for Alice it is very easy to get back the original
+message:
+
+    \begin{tcolorbox}[breakable, size=fbox, boxrule=1pt, pad at break*=1mm,colback=cellbackground, colframe=cellborder]
+\prompt{In}{incolor}{108}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+\PY{k}{def} \PY{n+nf}{Alice\PYZus{}decrypt}\PY{p}{(}\PY{n}{m\PYZus{}encrypted}\PY{p}{,} \PY{n}{n}\PY{p}{,} \PY{n}{e}\PY{p}{)}\PY{p}{:}
+    \PY{n}{R} \PY{o}{=} \PY{n}{Integers}\PY{p}{(}\PY{n}{n}\PY{p}{)}
+    \PY{k}{return} \PY{n}{R}\PY{p}{(}\PY{n}{m\PYZus{}encrypted}\PY{p}{)}\PY{o}{\PYZca{}}\PY{n}{e}
+
+\PY{n}{Alice\PYZus{}decrypt}\PY{p}{(}\PY{l+m+mi}{149461597163501}\PY{p}{,} \PY{l+m+mi}{419199544978969}\PY{p}{,} \PY{l+m+mi}{80799425863927}\PY{p}{)}
+\end{Verbatim}
+\end{tcolorbox}
+
+            \begin{tcolorbox}[breakable, size=fbox, boxrule=.5pt, pad at break*=1mm, opacityfill=0]
+\prompt{Out}{outcolor}{108}{\boxspacing}
+\begin{Verbatim}[commandchars=\\\{\}]
+42424242
+\end{Verbatim}
+\end{tcolorbox}
+        
+    Another assumption on which RSA relies is that even if one knows
+\(M=m^e\) and \(e\), extracting the \(e\)-th root of \(M\) modulo \(n\)
+(and thus obtaining \(m\)) is very hard. Currently the best known way to
+do this is by factorizing \(n\) first, which is considered to be a very
+hard problem. However, there is no proof that faster algorithms can't be
+devised.
+
+Moreover, one day we will overcome the current technological
+difficulties and quantum computers will be available. Quantum computers
+are not just ``more powerful'' than classical hardware, but they work
+based on completely different logical foundations and they make the
+factorization problem much easier to solve: for example
+\href{https://en.wikipedia.org/wiki/Shor\%27s_algorithm}{Shor's
+algorithm} takes advantage of this different logic and can factorize
+numbers quickly, if run on a quantum computer.
+
+To this day the largest number factorized with a quantum computer is
+\(21=3\times 7\). Nonetheless, quantum-safe cryptography protocols
+(i.e.~based on problems that are hard to solve also with quantum
+computers) have already been developed.
+
+
+    % Add a bibliography block to the postdoc
+    
+    
+    
+\end{document}