g.videtta
/
scritti
mirror of https://github.com/hearot/scritti
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
main
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'de77ee70b5'
${ noResults }
scritti/Geometria/Notebook/1. Forma canonica di Jordan/Algoritmo di estrazione del...

841 lines
26 KiB
Plaintext
Raw Blame History Unescape Escape

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden characters.

{
"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
}
Reference in New Issue View Git Blame Copy Permalink