scritti/Geometria/Notebook/1. Forma canonica di Jordan/Algoritmo di estrazione della forma canonica di Jordan.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algoritmo di estrazione della forma canonica di Jordan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo scopo di questo notebook è illustrare un breve e semplice algoritmo di estrazione della forma canonica di Jordan di una matrice $A \\in M(n, \\mathbb{C})$ qualsiasi. Si ricorda che la forma canonica di Jordan è un invariante completo per similitudine\n",
    "di una matrice e che è una matrice a blocchi diagonale composta da più blocchi, detti per l'appunto di Jordan, della seguente forma:\n",
    "\n",
    "$$ J_{\\lambda, m} = \\begin{bmatrix}\n",
    "\\lambda & 1            & \\;     & \\;  \\\\\n",
    "\\;        & \\lambda    & \\ddots & \\;  \\\\\n",
    "\\;        & \\;           & \\ddots & 1   \\\\\n",
    "\\;        & \\;           & \\;     & \\lambda      \n",
    "\\end{bmatrix} \\in M(m, \\mathbb{C}). $$\n",
    "\n",
    "Innanzitutto si sceglie un $n \\in \\mathbb{N}^+$ che rappresenta la taglia della matrice quadrata data in esame all'algoritmo e si crea la matrice $I = I_n$, ossia la matrice identità di taglia $n$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%display latex\n",
    "from IPython.display import display, Markdown, Latex\n",
    "\n",
    "n = 10\n",
    "I = matrix.identity(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si definisce adesso una funzione $\\operatorname{jordan}(A)$ che prende in ingresso una matrice $A \\in M(n, \\mathbb{C})$ senza restituire alcun risultato. Tale funzione illustra passo passo in output l'algoritmo di estrazione della forma canonica di Jordan della matrice $A$ nei seguenti passi:\n",
    "\n",
    "   - Calcola il polinomio caratteristico $p_A(x)$ di $A$ e lo fattorizza;\n",
    "   - Ne deduce lo spettro $\\operatorname{sp}(A)$ e si riduce a studiare i blocchi relativi a ciascun autovalore;\n",
    "   - Per ogni autovalore $\\lambda$, calcola le dimensioni dei kernel delle potenze di $B = A - \\lambda I$ fino a che non viene raggiunta la molteplicità algebrica di $\\lambda$;\n",
    "   - Infine, per l'autovalore $\\lambda$, calcola il numero di blocchi $b_i$ di taglia $i$ secondo la formula $b_i = 2 \\dim \\ker B^i - \\dim \\ker B^{i-1} - \\dim \\ker B^{i+1}$;\n",
    "   - Compone tutti i blocchi in una matrice a blocchi diagonale, ossia la forma canonica di Jordan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def jordan(A):\n",
    "    display(Latex(r\"Innanzitutto, si calcola il polinomio caratteristico di $A$, che risulta essere $p_A(x) = \" + latex(factor(charpoly(A)(SR('x')))) + \"$.\"))\n",
    "    eig = set(A.eigenvalues())\n",
    "    sp = \", \".join(map(latex, eig))\n",
    "\n",
    "    display(Latex(r\"Allora, calcolandone le radici, si ricava $\\operatorname{sp}(A) = \\{\" + sp + r\"\\}$.\"))\n",
    "    display(Markdown(\"---\"))\n",
    "\n",
    "    Js = []\n",
    "\n",
    "    for i, t in enumerate(eig, start=1):\n",
    "        B = A - t*I\n",
    "        r = rank(B)\n",
    "        k = n - r\n",
    "\n",
    "        display(Latex(f\"({i}) \" + r\"Consideriamo $\\lambda = \" + latex(t) + r\"$ e $B=A-\\lambda I=\" + latex(B) + r\".$\"))\n",
    "        display(Latex(r\"$B$ ha rango $\" + str(r) + r\"$ e quindi $\\mu_g(\\lambda) = \" + str(k) + r\"$.\"))\n",
    "\n",
    "        if k == 1:\n",
    "            display(Latex(r\"Allora a $\\lambda$ sarà dedicato esattamente un blocco nella forma canonica di Jordan.\"))\n",
    "        else:\n",
    "            display(Latex(r\"Allora a $\\lambda$ saranno dedicati esattamente $\" + str(k) + \"$ blocchi nella forma canonica di Jordan.\"))\n",
    "\n",
    "        K = [k]\n",
    "        k_1 = k\n",
    "        k_2 = n-rank(B^2)\n",
    "\n",
    "        i = 3\n",
    "        while k_1 != k_2:\n",
    "            K.append(k_2)\n",
    "            k_1 = k_2\n",
    "            k_2 = n-rank(B^i)\n",
    "            i += 1\n",
    "\n",
    "        display(Latex(r\"Si calcolano adesso le dimensioni dei kernel fino a quando non viene raggiunta la molteplicità algebrica $\\mu_a(\\lambda) = \" + str(K[-1]) + \"$:\"))\n",
    "\n",
    "        for i, k in enumerate(K, start=1):\n",
    "            if i == 1:\n",
    "                if i == len(K):\n",
    "                    display(Latex(r\"‎ ‎ ‎ ‎ • $\\dim \\ker B = \" + str(k) + \"$.\"))\n",
    "                else:\n",
    "                    display(Latex(r\"‎ ‎ ‎ ‎ • $\\dim \\ker B = \" + str(k) + \"$;\"))\n",
    "            else:\n",
    "                if i == len(K):\n",
    "                    display(Latex(r\"‎ ‎ ‎ ‎ • $\\dim \\ker B^\" + str(i) + r\" = \" + str(k) + \"$.\"))\n",
    "                else:\n",
    "                    display(Latex(r\"‎ ‎ ‎ ‎ • $\\dim \\ker B^\" + str(i) + r\" = \" + str(k) + \"$;\"))\n",
    "\n",
    "        display(Latex(r\"Pertanto a $\\lambda$ sono assegnati i seguenti blocchi (dove $b_n$ indica il numero di blocchi di taglia $n$):\"))\n",
    "\n",
    "        b = {}\n",
    "\n",
    "        for i, k in enumerate(K, start=1):\n",
    "            if i == len(K):\n",
    "                if i == 2:\n",
    "                    b[i] = k - K[0]\n",
    "                    display(Latex(r\"‎ ‎ ‎ ‎ • $b_2 = \\dim \\ker B^2 - \\dim \\ker B = \" + str(b[i]) + \"$.\"))\n",
    "                elif i == 1:\n",
    "                    b[i] = k\n",
    "                    display(Latex(r\"‎ ‎ ‎ ‎ • $b_1 = \\dim \\ker B = \" + str(b[i]) + \"$.\"))\n",
    "                else:\n",
    "                    b[i] = k - K[i-2]\n",
    "                    display(Latex(r\"‎ ‎ ‎ ‎ • $b_\" + str(i) + r\" = \\dim \\ker B^\" + str(i) + r\" - \\dim \\ker B^\" + str(i-1) + \" = \" + str(b[i]) + \"$.\"))\n",
    "            elif i == 1:\n",
    "                b[i] = 2*k - K[1]\n",
    "                display(Latex(r\"‎ ‎ ‎ ‎ • $b_1 = 2 \\dim \\ker B - \\dim \\ker B^2 = \" + str(b[i]) + \"$;\"))\n",
    "            else:\n",
    "                if i != 2:\n",
    "                    b[i] = 2*k - K[i-2] - K[i]\n",
    "                    display(Latex(r\"‎ ‎ ‎ ‎ • $b_\" + str(i) + r\" = 2 \\dim \\ker B^\" + str(i) + r\" - \\dim \\ker B^\" + str(i-1) + r\" - \\dim \\ker B^\" + str(i+1) + \" = \" + str(b[i]) + \"$;\"))\n",
    "                else:\n",
    "                    b[i] = 2*k - K[0] - K[2]\n",
    "                    display(Latex(r\"‎ ‎ ‎ ‎ • $b_\" + str(i) + r\" = 2 \\dim \\ker B^2 - \\dim \\ker B - \\dim \\ker B^3 = \" + str(b[i]) + \"$;\"))\n",
    "        \n",
    "        JBs = [jordan_block(t, N) for N, j in b.items() for _ in range(j)]\n",
    "        Js.extend(JBs)\n",
    "        \n",
    "        display(Latex(r\"Allora l'insieme di tutti i blocchi relativi a $\\lambda$ sarà rappresentato dalla seguente matrice: $J_{\\lambda} = \" + latex(block_diagonal_matrix(JBs)) + \"$.\"))\n",
    "        display(Markdown(\"---\"))\n",
    "            \n",
    "    JNF = block_diagonal_matrix(Js)\n",
    "    \n",
    "    display(Latex(r\"La forma canonica di Jordan di $A$ sarà allora $J = \" + latex(JNF) + \"$.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si sceglie adesso una matrice $A \\in M(n, \\mathbb{C})$ di cui si vuole calcolare la forma canonica di Jordan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<html><script type=\"math/tex; mode=display\">\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrrrrrrr}\n",
       "1 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 1 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 1 & 1 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 2 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 2 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 2 & 1 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 3 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 3 & 1 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 3\n",
       "\\end{array}\\right)</script></html>"
      ],
      "text/latex": [
       "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\left(\\begin{array}{rrrrrrrrrr}\n",
       "1 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 1 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 1 & 1 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 2 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 2 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 2 & 1 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 3 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 3 & 1 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 3\n",
       "\\end{array}\\right)$$"
      ],
      "text/plain": [
       "[1 1 0 0 0 0 1 0 1 0]\n",
       "[0 1 1 0 0 0 1 0 1 0]\n",
       "[0 0 1 1 0 0 1 0 1 0]\n",
       "[0 0 0 1 1 0 1 0 1 0]\n",
       "[0 0 0 0 2 0 1 0 1 0]\n",
       "[0 0 0 0 0 2 1 0 1 0]\n",
       "[0 0 0 0 0 0 2 1 1 0]\n",
       "[0 0 0 0 0 0 0 3 1 0]\n",
       "[0 0 0 0 0 0 0 0 3 1]\n",
       "[0 0 0 0 0 0 0 0 0 3]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A deve avere esattamente n^2 elementi, essendo n x n...\n",
    "A = matrix(SR, n, [1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3])\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si calcola infine la forma canonica di Jordan della matrice $A$ mediante la funzione $\\operatorname{jordan}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "Innanzitutto, si calcola il polinomio caratteristico di $A$, che risulta essere $p_A(x) = {\\left(x - 1\\right)}^{4} {\\left(x - 2\\right)}^{3} {\\left(x - 3\\right)}^{3} $."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Allora, calcolandone le radici, si ricava $\\operatorname{sp}(A) = \\{1, 2, 3\\}$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "(1) Consideriamo $\\lambda = 1 $ e $B=A-\\lambda I= \\left(\\begin{array}{rrrrrrrrrr}\n",
       "0 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 1 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 1 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 2 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 2 & 1 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 2\n",
       "\\end{array}\\right) .$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$B$ ha rango $9$ e quindi $\\mu_g(\\lambda) = 1$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Allora a $\\lambda$ sarà dedicato esattamente un blocco nella forma canonica di Jordan."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Si calcolano adesso le dimensioni dei kernel fino a quando non viene raggiunta la molteplicità algebrica $\\mu_a(\\lambda) = 4$:"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $\\dim \\ker B = 1$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $\\dim \\ker B^2 = 2$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $\\dim \\ker B^3 = 3$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $\\dim \\ker B^4 = 4$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Pertanto a $\\lambda$ sono assegnati i seguenti blocchi (dove $b_n$ indica il numero di blocchi di taglia $n$):"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $b_1 = 2 \\dim \\ker B - \\dim \\ker B^2 = 0$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $b_2 = 2 \\dim \\ker B^2 - \\dim \\ker B - \\dim \\ker B^3 = 0$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $b_3 = 2 \\dim \\ker B^3 - \\dim \\ker B^2 - \\dim \\ker B^4 = 0$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $b_4 = \\dim \\ker B^4 - \\dim \\ker B^3 = 1$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Allora l'insieme di tutti i blocchi relativi a $\\lambda$ sarà rappresentato dalla seguente matrice: $J_{\\lambda} = \\left(\\begin{array}{rrrr}\n",
       "1 & 1 & 0 & 0 \\\\\n",
       "0 & 1 & 1 & 0 \\\\\n",
       "0 & 0 & 1 & 1 \\\\\n",
       "0 & 0 & 0 & 1\n",
       "\\end{array}\\right) $."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "(2) Consideriamo $\\lambda = 2 $ e $B=A-\\lambda I= \\left(\\begin{array}{rrrrrrrrrr}\n",
       "-1 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & -1 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & -1 & 1 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & -1 & 1 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n",
       "\\end{array}\\right) .$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$B$ ha rango $8$ e quindi $\\mu_g(\\lambda) = 2$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Allora a $\\lambda$ saranno dedicati esattamente $2$ blocchi nella forma canonica di Jordan."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Si calcolano adesso le dimensioni dei kernel fino a quando non viene raggiunta la molteplicità algebrica $\\mu_a(\\lambda) = 3$:"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $\\dim \\ker B = 2$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $\\dim \\ker B^2 = 3$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Pertanto a $\\lambda$ sono assegnati i seguenti blocchi (dove $b_n$ indica il numero di blocchi di taglia $n$):"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $b_1 = 2 \\dim \\ker B - \\dim \\ker B^2 = 1$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $b_2 = \\dim \\ker B^2 - \\dim \\ker B = 1$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Allora l'insieme di tutti i blocchi relativi a $\\lambda$ sarà rappresentato dalla seguente matrice: $J_{\\lambda} = \\left(\\begin{array}{r|rr}\n",
       "2 & 0 & 0 \\\\\n",
       "\\hline\n",
       " 0 & 2 & 1 \\\\\n",
       "0 & 0 & 2\n",
       "\\end{array}\\right) $."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "(3) Consideriamo $\\lambda = 3 $ e $B=A-\\lambda I= \\left(\\begin{array}{rrrrrrrrrr}\n",
       "-2 & 1 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & -2 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & -2 & 1 & 0 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & -2 & 1 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & -1 & 0 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & -1 & 1 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & -1 & 1 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\n",
       "\\end{array}\\right) .$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "$B$ ha rango $9$ e quindi $\\mu_g(\\lambda) = 1$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Allora a $\\lambda$ sarà dedicato esattamente un blocco nella forma canonica di Jordan."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Si calcolano adesso le dimensioni dei kernel fino a quando non viene raggiunta la molteplicità algebrica $\\mu_a(\\lambda) = 3$:"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $\\dim \\ker B = 1$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $\\dim \\ker B^2 = 2$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $\\dim \\ker B^3 = 3$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Pertanto a $\\lambda$ sono assegnati i seguenti blocchi (dove $b_n$ indica il numero di blocchi di taglia $n$):"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $b_1 = 2 \\dim \\ker B - \\dim \\ker B^2 = 0$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $b_2 = 2 \\dim \\ker B^2 - \\dim \\ker B - \\dim \\ker B^3 = 0$;"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "‎ ‎ ‎ ‎ • $b_3 = \\dim \\ker B^3 - \\dim \\ker B^2 = 1$."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "Allora l'insieme di tutti i blocchi relativi a $\\lambda$ sarà rappresentato dalla seguente matrice: $J_{\\lambda} = \\left(\\begin{array}{rrr}\n",
       "3 & 1 & 0 \\\\\n",
       "0 & 3 & 1 \\\\\n",
       "0 & 0 & 3\n",
       "\\end{array}\\right) $."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/latex": [
       "La forma canonica di Jordan di $A$ sarà allora $J = \\left(\\begin{array}{rrrr|r|rr|rrr}\n",
       "1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
       "0 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
       "0 & 0 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
       "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
       "\\hline\n",
       " 0 & 0 & 0 & 0 & 2 & 0 & 0 & 0 & 0 & 0 \\\\\n",
       "\\hline\n",
       " 0 & 0 & 0 & 0 & 0 & 2 & 1 & 0 & 0 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 2 & 0 & 0 & 0 \\\\\n",
       "\\hline\n",
       " 0 & 0 & 0 & 0 & 0 & 0 & 0 & 3 & 1 & 0 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 3 & 1 \\\\\n",
       "0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 3\n",
       "\\end{array}\\right) $."
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "jordan(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "(c) 2023, [~videtta](https://poisson.phc.dm.unipi.it/~videtta/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.3",
   "language": "sage",
   "name": "sagemath"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}