edcd7626cd
All checks were successful
Build Typst PDFs (Docker) / build-typst (push) Successful in 40s
868 lines
30 KiB
Typst
868 lines
30 KiB
Typst
#import "@preview/biceps:0.0.1" : *
|
|
#import "@preview/mannot:0.3.1"
|
|
#import "@preview/fletcher:0.5.8"
|
|
#import "@preview/cetz:0.4.2"
|
|
|
|
#import "../lib/styles.typ" : *
|
|
#import "../lib/common_rewrite.typ" : *
|
|
#import "../lib/mathExpressions.typ" : *
|
|
|
|
#set page(
|
|
paper: "a4",
|
|
margin: (
|
|
bottom: 10mm,
|
|
top: 5mm,
|
|
left: 5mm,
|
|
right: 5mm
|
|
),
|
|
flipped:true,
|
|
numbering: "— 1 —",
|
|
number-align: center
|
|
)
|
|
|
|
#set text(size: 6pt)
|
|
|
|
#place(top+center, scope: "parent", float: true, heading(
|
|
[Linear Algebra EI]
|
|
))
|
|
|
|
#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
|
|
#let colorMatrixVerfahren = color.hsl(330.19deg, 100%, 68.43%)
|
|
#let colorMatrix = color.hsl(202.05deg, 92.13%, 75.1%)
|
|
#let colorVR = color.hsl(280deg, 92.13%, 75.1%)
|
|
#let colorAbbildungen = color.hsl(356.92deg, 92.13%, 75.1%)
|
|
#let colorGruppen = color.hsl(34.87deg, 92.13%, 75.1%)
|
|
|
|
#let MathAlignLeft(e) = {
|
|
align(left, block(e))
|
|
}
|
|
#columns(5, gutter: 2mm)[
|
|
|
|
|
|
#bgBlock(fill: colorGruppen)[
|
|
#subHeading(fill: colorGruppen)[Gruppen]
|
|
|
|
*Halbgruppe:* $(M, compose): M times M arrow M$
|
|
- Assoziativgesetz: $a dot (b dot c) = (a dot b) dot c$ \
|
|
z.B. Komposition von Funktionen
|
|
- Abgeschlossenheit
|
|
*Monoid* Halbgruppe $M$ mit:
|
|
- Neutrales-/Identäts-Element: $e in M : a e = e a = a$
|
|
*Kommutativ/abelsch:* Halbgruppe/Monoid mit
|
|
- Kommutativgesetz $a dot b = b dot a$
|
|
|
|
#SeperatorLine
|
|
|
|
*Gruppe:* Monoid mit
|
|
- Inverse: $forall a in G : exists space a a^(-1) = a^(-1)a = e$
|
|
- Eindeutig Lösung für Gleichungen
|
|
Zusatz:
|
|
- Inverseregel: $(a dot b)^(-1) = b^(-1) dot a^(-1)$
|
|
- Wenn $a = a^(-1) =>$ Gruppe kommutativ
|
|
|
|
|
|
|
|
*Untergruppe:*
|
|
- Gruppe: $(G, dot)$, $U subset G$
|
|
- $a,b in U <=> a dot b in U$
|
|
- $a in U <=> a^(-1) in U$
|
|
- $e in U$ (Neutrales Element)
|
|
|
|
*Direktes Produkt:*\
|
|
$(G_1,dot_1) times (G_2,dot_2) times ... $ \
|
|
$(a_1,b_1,...)(a_2,b_2,...)= (a_1 dot_1 b_1, a_2 dot_2 b_2, ...)$
|
|
|
|
|
|
#SeperatorLine
|
|
|
|
*Ring:* (auch Schiefkörper) Menge $R$ mit:
|
|
- $(R, +)$ kommutativ Gruppe
|
|
- $(R, dot)$ Halbgruppe
|
|
- $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
|
|
|
|
*Körper:* Menge $K$ mit:
|
|
- $(K, +), (K without {0} , dot)$ kommutativ Gruppe \
|
|
($0$ ist Neutrales Element von $+$)
|
|
- $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
|
|
_Beweiß durch Überprüfung der Eigneschaften_
|
|
|
|
#SeperatorLine
|
|
|
|
$S_n$: Symetrisch Gruppe (Permutation von element) \
|
|
$(S_n, compose)$ ist Gruppe, aber nicht kommutativ
|
|
]
|
|
|
|
#bgBlock(fill: colorAllgemein)[
|
|
#subHeading(fill: colorAllgemein)[Komplexe Zahlen]
|
|
|
|
#ComplexNumbersSection()
|
|
]
|
|
|
|
// Matrix Typen
|
|
#bgBlock(fill: colorMatrix)[
|
|
#let colred(x) = text(fill: red, $#x$)
|
|
#let colblue(x) = text(fill: blue, $#x$)
|
|
#subHeading(fill: colorMatrix)[Matrix Typen]
|
|
#align(center, scale($colred(m "Zeilen") colblue(n "Splate") A in KK^(colred(m) times colblue(n))$, 110%)) #grid(columns: (1fr, 1fr),
|
|
$quad mat(
|
|
a_11, a_12, ..., a_(1n);
|
|
a_21, a_22, ..., a_(2n);
|
|
dots.v, dots.v, dots.down, dots.v;
|
|
a_(m 1), a_(m 2), ..., a_(m n)
|
|
)
|
|
$,
|
|
|
|
cetz.canvas({
|
|
import cetz.draw : *
|
|
let scale = 0.76;
|
|
|
|
rect((0, 0), (1*scale, 1*scale), fill: rgb("#9292926b"))
|
|
|
|
set-style(mark: (end: (symbol: "straight")))
|
|
line((0, -0.2*scale), (1*scale, -0.2*scale), stroke: (paint: blue, thickness: 0.3mm))
|
|
line((-0.2*scale, 1*scale), (-0.2*scale, 0), stroke: (paint: red, thickness: 0.3mm))
|
|
|
|
content((-0.45*scale, 0.5*scale), $colred(bold(m))$)
|
|
content((0.5*scale, -0.35*scale), $colblue(bold(n))$)
|
|
content((0.5*scale, 0.5*scale), $A$)
|
|
})
|
|
)
|
|
]
|
|
|
|
// Vektorräume
|
|
#bgBlock(fill: colorVR)[
|
|
#subHeading(fill: colorVR)[Vektorräume (VR)]
|
|
Bsp: $KK^n$ ($RR^n, CC^n$) \
|
|
$(V, plus.o, dot.o)$ ist ein über Körper $K (V, +, dot)$ \
|
|
$(V, +), (V, dot)$ kommutativ Gruppe
|
|
- Vektor-Addition $+: V times V -> V, (v,w) -> v + w$
|
|
- Scalar-Multiplikation $dot: K times V -> V, (lambda,v) -> lambda v$
|
|
Es gilt: $lambda,mu in K, space v,w in V "über" K$
|
|
- Linearität $(lambda mu)v = lambda (mu v)$ \
|
|
$lambda(v + w) = lambda v + lambda w$\
|
|
$(lambda + mu)v = lambda v + mu v$
|
|
- Neutrales Element für $dot.o : 1v = v$
|
|
- Neutrales Element für $plus.o : arrow(0) in V$
|
|
|
|
*Untervektorraum: (UVR)* $U subset V$ \
|
|
#grid(columns: (1fr, 1fr, 1fr),
|
|
align(center, $forall v,w : v + w in U$),
|
|
align(center, $arrow(0) in U$),
|
|
align(center, $forall v,lambda : lambda v in U$)
|
|
)
|
|
]
|
|
|
|
// Spann Erzeugendessystem ect
|
|
#bgBlock(fill: colorVR)[
|
|
#subHeading(fill: colorVR)[Spann, Erzeugendensystem, Basis, Dim]
|
|
$"Sei" V "ein" KK"-VR"\ M = {ve(v_1), ve(v)_2, ve(v)_3, ...}, ve(v_i) in V "Menge von Vektoren"$
|
|
|
|
*Spann:* UVR von $V quad quad spann(M) subset V$
|
|
- UVR $= op("spann")(M) = limits(inter)_(M subset U) U$ \
|
|
$spann(M)$ ist der Durchschnitt aller Untervektorräume $U subset.eq V$ , die M enthalten:
|
|
- $op("spann")(M) = $ Alle lin. Kombindation von $ve(v_1), ve(v_2), ... in M$ \
|
|
$lambda_1 ve(v_1) + lambda_2 ve(v_2) + ... = ve(v) in spann(M)$
|
|
- Linear Abbildung $Phi : op("spann")(Phi(M)) = Phi(op("spann")(M))$
|
|
|
|
*Erzeugendensystem* \
|
|
Menge $M = {ve(v_1), ve(v)_2, ve(v)_3, ...}$ ist Erzeugendensystem von UVR $U$ wenn $spann(M) = U$
|
|
|
|
#SeperatorLine
|
|
|
|
*Basis:* #underline("kleinstmögliches") Erzeugendensystem \
|
|
- Immer linear unabhänige Menge $B$ an $v in V$, sodass $op("spann")(v_1, ..., v_n) = op("spann")(V)$
|
|
- Jede Basis $B$ ist Erzeugerssystem (ABER NICHT ungekehrt)
|
|
- Endliche Erzeugerssystem: \
|
|
$B_1, B_2, ...$ Erzeugerssystem vom gleichen $V$ \
|
|
$=> abs(B_1)=abs(B_2)...$
|
|
|
|
|
|
Vektor dratstellung durch Basis Vektoren: \
|
|
$ve(v) = lambda_1 ve(b_1) + lambda_2 ve(b_2) + ...$
|
|
- $lambda_1, lambda_2, ...$ beschreiben ein #underline[eindeutig] Punk
|
|
|
|
*Basisergänzungssatz:* Sei $M = {ve(v_1), ... ve(v_n)}, ve(v_i) in V$ lin. unabhänig aber $M$ kein Basis des $V$. Dann $exists v_(n+1)$ sodass $M union {ve(v_(n+1))}$ lin unabhänig (aber evt. eine Basis ist)
|
|
|
|
#SeperatorLine
|
|
|
|
*Linear unabhänige:* \
|
|
- $v$ ist linear unabhänig wenn \ $spann(M) != spann(M without {ve(v)})$
|
|
- $M$ besteht nur aus linear unabhänig Vektoren wenn \
|
|
$lambda_0 = 0, ..., lambda_n = 0$ die EINZIEGE Lösung für \ $lambda_0 ve(v_0) + ... + lambda_1 ve(v_1) = ve(0)$ \
|
|
$->$ Bei Matrizen: $A ve(v) = ve(0)$ lösen \
|
|
- Überprüfung by Inspection
|
|
- Überprüfung: Spalten Vekotren ein Matrix $A : A ve(v) = ve(0)$
|
|
- $ve(v)$ Nur $ve(0)$ als Lösung $<=>$ Linearunabhänig
|
|
- $kern(A) = {ve(0)} <=>$ Linerarunabhänig
|
|
|
|
#SeperatorLine
|
|
|
|
*Dimension:*
|
|
- $dim V = \#$Vektoren der Basis (#underline[linear unabhänigs] Erzeugendensystem)
|
|
- $dim V = infinity$, wenn $V$ nicht endlich erzeugt ist
|
|
- $dim {ve(0)} = 0$
|
|
|
|
$U "UVR von "V => dim U <= dim V$
|
|
- Kodimension: $dim V - dim U$
|
|
- Wenn $dim U = dim V <=> U = V "(Kodimension"=0")"$
|
|
- Kodimension $= 1$ Hyperebend
|
|
]
|
|
|
|
// Darstellungs Matrix
|
|
#bgBlock(fill: colorVR)[
|
|
#subHeading([Darstellungs Matrix], fill: colorVR)
|
|
*Vektorraum Isomorphismus*
|
|
- $V tilde.equiv W <=> dim(V) = dim(W)$
|
|
- $V tilde.equiv W <=> exists f: V -> W, f "bijektiv (umkehrbar)"$
|
|
|
|
*Koordinatensystem* Ein bestimmte Wahl von Basisvektoren/Basis $ve(b_1), ve(b_2), ...$
|
|
|
|
#SeperatorLine
|
|
#grid(
|
|
columns: (auto, 1fr),
|
|
column-gutter: 2mm,
|
|
image("../images/linAlg/BasisWechsel.jpg", height: 1.3cm),
|
|
|
|
[
|
|
Vektorraum $V tilde.equiv KK^n$ (in Basis $A$)\
|
|
Vektorraum $V tilde.equiv KK^n$ (in Basis $B$)\
|
|
|
|
$Phi_A, Phi_B$ Bijektiv Mappings zwischen $V$ und dem $KK^n_A slash KK^n_B$
|
|
]
|
|
)
|
|
|
|
$space_A T_B$: Basiswechsel: $K^n$ (in Basis $A$) $->$ $K^n$ (in Basis $B$)
|
|
$space_B T_A$: Basiswechsel: $K^n$ (in Basis $B$) $->$ $K^n$ (in Basis $A$)
|
|
|
|
Wenn $V, KK^n "(in Basis A/B)"$ ein $RR^n slash CC^n$ \ ist $Phi_(A slash B) = mat(|, |; ve(b_1), ve(b_2), ...; |, |,)$, $ve(b_1), ve(b_2), ...$ \ Basisvektoren der Basis von $A slash B$
|
|
|
|
#SeperatorLine
|
|
*Darstellungs-Matrix*
|
|
|
|
Idee: Wir führen Abbildung $f$ nicht $V -> W$ sonderem in $KK^n -> KK^m$ durch $-->$ Darstellungs-Matrix $D$
|
|
|
|
#grid(
|
|
columns: (auto, 1fr),
|
|
column-gutter: 2mm,
|
|
image("../images/linAlg/DarstellungsMatrix.jpg", height: 1.6cm),
|
|
[
|
|
$f: V -> W$ Orignal Abbildung \
|
|
Vektorraum $V tilde.equiv KK^n$ (in Basis $A$)\
|
|
Vektorraum $W tilde.equiv KK^m$ (in Basis $B$)\
|
|
|
|
$Phi_A, Phi_B$ Bijektiv Mappings zwischen $V,W$ und dem $KK^n, KK^m$
|
|
],
|
|
)
|
|
|
|
#grid(columns: (1fr, 1fr),
|
|
$D = Phi_C compose f compose Phi_B$,
|
|
$$
|
|
)
|
|
|
|
#SeperatorLine
|
|
|
|
Normalweiße alle Abbildung/Matrizen in Kannoischer Basis $hat(e)_1 = vec(1, 0, dots.v), hat(e)_2 = vec(0, 1, dots.v), ...$
|
|
]
|
|
|
|
// Matrix Basics
|
|
#bgBlock(fill: colorMatrix)[
|
|
#subHeading(fill: colorMatrix)[Matrix Basics]
|
|
Linera Abbildung $equiv$ EINER eindeutige Matrix \
|
|
|
|
- Sclar/Matrix: $lambda dot A$
|
|
- Matrix/Matrix: $A + B$
|
|
- Matrix-Matrix: $A dot B = Phi_A compose Phi_B = Phi_A (Phi_B (ve(x)))$ \
|
|
$c_(j i) = sum^n_(s=1) a_(j s) b_(s i)$
|
|
|
|
$(KK^(n times n), +)$ sind Gruppe, $(KK^(n times n), dot)$ sind Monoid,
|
|
|
|
#image("../images/linAlg/matMul.jpg")
|
|
|
|
#SeperatorLine
|
|
|
|
#grid(columns: (1fr, 1fr, 1fr),
|
|
row-gutter: 2mm,
|
|
align(center, $(lambda mu) A = lambda (mu A)$),
|
|
grid.cell(colspan: 2, align(center, $(lambda + mu) A = lambda A + mu A$)),
|
|
align(center, $$),
|
|
grid.cell(colspan: 2, align(center, $lambda (A + B) = lambda A + lambda B$)),
|
|
)
|
|
|
|
*Transponieren*
|
|
|
|
#grid(columns: (1fr, 1fr),
|
|
row-gutter: 2mm,
|
|
$(A + B)^T = A^T + B^T$,
|
|
$(lambda A)^T = lambda A^T$,
|
|
$(A^T)^T = A$,
|
|
$(A dot B)^T = B^T dot A^T$
|
|
)
|
|
]
|
|
|
|
|
|
#colbreak()
|
|
#bgBlock(fill: colorAbbildungen)[
|
|
#subHeading([Abbildungen], fill: colorAbbildungen)
|
|
|
|
$f(x)=y, f: A -> B$
|
|
|
|
*Linear Abbildung:* $Phi: M -> N$
|
|
- $Phi(0) = 0 quad quad Phi(lambda v + w) = lambda Phi(v) + Phi(w)$
|
|
- Menge aller linearen Abbildung: $L(M,N), space "Mengen" M,N$
|
|
- $spann(Phi(M)) = Phi(spann(M))$
|
|
- $Phi_1 compose Phi_2 = Phi_1 (Phi_2(x)) = Phi$ wieder linerar
|
|
|
|
*Vektorraum-Homomorphismus:* linear Abbildung zwischen VR,
|
|
Bsp. jede Matrix
|
|
|
|
*Injectiv (Monomorphismus):*\
|
|
_one to one_ \
|
|
$f(x) = f(y) <=> x = y$ \
|
|
Gilt immer: $x = y => f(x) = f(y)$
|
|
|
|
Injektiv zweigen: Beweiß durch Wiederspruch. \
|
|
Angnomen $x != y, f(x) = f(y) -"Umstellen"--> x = y$
|
|
|
|
Nicht Injektiv: Gegenbeispiel finden
|
|
|
|
|
|
|
|
*Surjectiv (Epimorhismus):* \
|
|
_Output space coverered_ \
|
|
- Zeigen das $f(f^(-1)(x)) = x$ für $x in DD$
|
|
- $forall y in B: exists x in A : f(x) = y$
|
|
NICHT surjektiv wenn $abs(A) < abs(B)$
|
|
|
|
*Bijektiv (Isomorphismus):* \
|
|
_Injectiv und Surjectiv_ \
|
|
- $<=>$ Umkehrbar
|
|
- In einer Gruppe ist $f(x) = x c$ für $c,x in G$ bijektiv
|
|
- isomorph: $V,W$ VRs, $f$ bijektiv $f(V) = W => V tilde.equiv W$
|
|
|
|
Beweiß durch Wiederspruch \
|
|
für Gegenbeweiß
|
|
|
|
*Endomorphismus:* $A -> B$ mit $A, B subset.eq C$ \
|
|
Endomorphismus: $KK^n -> KK^n$ \
|
|
KEIN Endomorphismus: $KK^n -> KK^m, m != n$ \
|
|
Bsp. #underline("Qudratische") Matrix
|
|
|
|
*Automorphismus:* Endomorphismus und Bijektiv (Isomorphismus) \
|
|
Bsp. #underline("Invertierbare") Matrix, $f(x) = x$
|
|
]
|
|
|
|
// Spann und Bild, Kern
|
|
#bgBlock(fill: colorAbbildungen)[
|
|
#subHeading(fill: colorAbbildungen)[Spann und Bild]
|
|
$f: A -> B$
|
|
|
|
*Urbild:* $f^(-1)(I subset B) subset.eq A$
|
|
|
|
*Bild:* Wertemenge $WW$
|
|
- $f(I subset A) = B$ (Oft $I = A$)
|
|
- Bei Matrix: $Bild(M) = spann("Spalten Vektoren")$
|
|
- $op("Bild") Phi := {Phi in W | v in V}$
|
|
|
|
*Rang:*
|
|
$op("Rang") f := dim op("Bild") f$
|
|
- Bei Matrizen: \ $Rang(f) <= min(n, m) equiv min("#Spalten", "#Zeilen")$
|
|
- $Rang("Zeilen Vektoren") = Rang("Spalten Rang")$
|
|
- $Rang(A) = Rang(A^T)$
|
|
- $"#Linear unabhäniger Spalten/Zeilen"$
|
|
|
|
*Nullraum/Kern:* \
|
|
$kern(Phi) := {v in V | Phi(v) = 0}$
|
|
- $A ve(x) = ve(0)$ (Lösung des Homogenen Gleichungssystem)
|
|
|
|
*Dimensionssatz:* Sei $A$ lineare Abbildung \
|
|
$dim(V) = dim(kern(A)) + dim(Bild(A))$ \
|
|
$dim(V) = dim(kern(A)) + Rang(A)$
|
|
|
|
#linebreak()
|
|
|
|
$"Wenn" dim(V) = dim(Bild(A)) "oder" dim(kern(A)) = 0 \ <=> A "bijektiv" <=> "invertierbar"$
|
|
|
|
#SeperatorLine
|
|
|
|
- Homogense Lineares Gleichungsystem: $A ve(x) = ve(0) $ Lösungsmenge: $LL = kern(A)$, immer: $ve(0) in L$ \
|
|
|
|
- In-Homogense LGS: $A ve(x) = ve(b) $<<
|
|
|
|
#SeperatorLine
|
|
|
|
*Gaußalgorithmus*
|
|
|
|
#grid(columns: (auto, 1fr),
|
|
row-gutter: 1mm,
|
|
column-gutter: 2mm,
|
|
|
|
image("../images/linAlg/Gauss1a.jpg", width: 2cm),
|
|
[
|
|
Gleichungssystem: $A ve(x) = b$ \
|
|
$A in KK^(m times n)$
|
|
In Zeilenstufenform Bringen, Operationen:
|
|
- Zeile $dot lambda$ ($x in CC$ mit $dot i$)
|
|
- Zeile vertauschen
|
|
- Zeile $+$ Zeile
|
|
],
|
|
)
|
|
|
|
#grid(columns: (auto, 1fr),
|
|
row-gutter: 3mm,
|
|
column-gutter: 2mm,
|
|
image("../images/linAlg/Gauss2.jpg", width: 2cm),
|
|
[
|
|
*Eindeutige Lösung* $-->$ Normale Rückeinsetzung
|
|
|
|
Nur bei $A in RR^(n times n)$ möglich
|
|
|
|
Bei qudratischen $A:$ \ $n equiv "#Spalten" equiv dim ve(x)$
|
|
|
|
$Rang(A) = n$
|
|
],
|
|
|
|
image("../images/linAlg/Gauss1.jpg", width: 2cm),
|
|
[
|
|
*Nullzeile*:
|
|
Pro Nullzeile eine frei Var $t, s, ...$
|
|
|
|
Bei qudratischen $A:$ \ $Rang(A) = n - "#Nullzeilen"$
|
|
],
|
|
|
|
image("../images/linAlg/Gauss3.jpg", width: 2cm),
|
|
[
|
|
*Wiederspruch*: Keine Lösung
|
|
]
|
|
)
|
|
|
|
$kern(A) = dim ve(x) - Rang(A)$ (Dimensionssatz)
|
|
|
|
#SeperatorLine
|
|
*Matrix Invertieren*
|
|
#image("../images/linAlg/InverseMatrix.jpg")
|
|
|
|
$KK^(2 times 2): A = mat(a, b; c, d) \ A^(-1) = 1/det(A) mat(d, -b; -c, a) = 1/(a d - b c) mat(d, -b; -c, a) $
|
|
]
|
|
|
|
|
|
#colbreak()
|
|
|
|
#bgBlock(fill: colorAbbildungen)[
|
|
#subHeading(fill: colorAbbildungen)[Linearform]
|
|
|
|
- Sclar-Produkt $ip(ve(a), ve(b))$ ist Bi-Linearform
|
|
- Symetrisch
|
|
- Determinante einer Matrix: $det(A in RR^(m times n))$ ist $n$-Linearform (sogar alternierend)
|
|
|
|
*$k$-Linearform:* Lineare $f: KK^n times KK^n times ... -> KK$
|
|
- Für $k=2 : $ Bi-Linerform
|
|
- Linearität: (in beiden Argumente) \
|
|
$f(ve(v)_1, lambda ve(v)_2) = lambda f(ve(v)_1, ve(v)_2) \
|
|
f(ve(v)_1, ve(x) + ve(y)) = f(ve(v)_1, ve(x)) + f(ve(v)_1, ve(y))
|
|
$
|
|
- *Symetrisch* wenn: $f(ve(v)_1, ve(v)_2) = f(ve(v)_2, ve(v)_1), space space forall ve(v)_1, ve(v)_2 in KK^n$
|
|
|
|
- *Alternierend* wenn: $f(ve(v), ve(v)) = 0, space space forall ve(v) in KK^n$
|
|
- $f(ve(v)_1, ... #text(red, $ve(v)_i$), #text(blue, $ve(v)_j$), ... ve(v)_k) = -f(ve(v)_1, ... #text(blue, $ve(v)_j$), #text(red, $ve(v)_i$), ... ve(v)_k) $
|
|
- Tauschung von Argumenten $->$ Vorzeichen Flip
|
|
- $ve(v)_1, ... "linear abhänig" <=> f(ve(v)_1, ...) = 0$
|
|
- $ve(v)_1, ... "linear unabhänig" <=> f(ve(v)_1, ...) != 0$, eindeutig
|
|
]
|
|
|
|
#bgBlock(fill: colorAbbildungen)[
|
|
#subHeading(fill: colorAbbildungen)[Determinante]
|
|
|
|
*Determinaten Form* \
|
|
Nicht tiviale ($f(...) = 0$) alternierende n-Linearform auf einem VR.
|
|
$exists$ Immer, in jeder Scalierung
|
|
|
|
Speziell für Martizen $in KK^(n times n)$ \ (Qudratische, Endomorphismus)
|
|
|
|
*Herleitung:*
|
|
Für die $det equiv delta$: $delta(ve(e)_1, ve(e)_2, ve(e)_3, ...) = 1$, alternierend und n-Linearform
|
|
|
|
1. Mit Linearität zerlegen
|
|
2. Mit Alterniered, Element tauschen: $delta(ve(e)_1, ve(e)_2, ve(e)_3, ...) dot ...$
|
|
|
|
*Leibniz-Formel*
|
|
|
|
$det(A) = limits(sum)_(sigma in S_n) sign(sigma)( a_(sigma(1)1) dot a_(sigma(2)2) dot dots dot a_(sigma(n)n))$
|
|
|
|
$S_n := "Alle Permutation von n Element" $ \
|
|
$sign(sigma) = (-1)^"#Vertauschungen"$ \
|
|
Anzahl der Vertauschungen, die nötig sind um $sigma$ von $(1, 2, 3, ...)$ zu erzeugen \
|
|
$sigma(n): n$-te Element aus der Tupel $sigma$
|
|
|
|
*Bsp:* $A in KK^(n times n)$
|
|
#grid(
|
|
columns: 9,
|
|
row-gutter: 1mm,
|
|
$S_3 =$, ${$, $(1,2,3),$, $(1,3,2),$, $(2,1,3),$, $(2,3,1),$, $(3,1,2),$, $(3,2,1)$, $}$,
|
|
"#Vert.", $$,
|
|
align(center, $0$),
|
|
align(center, $1$),
|
|
align(center, $1$),
|
|
align(center, $2$),
|
|
align(center, $2$),
|
|
align(center, $1$), $$,
|
|
$sign(sigma)$, $$,
|
|
align(center, $1$),
|
|
align(center, $-1$),
|
|
align(center, $-1$),
|
|
align(center, $1$),
|
|
align(center, $1$),
|
|
align(center, $-1$),
|
|
)
|
|
|
|
$det(A) = &(a_11 a_22 a_33) - (a_11 a_23 a_32) - (a_12 a_21 a_33) + \
|
|
&(a_12 a_23 a_31) + (a_13 a_21 a_32) - (a_13 a_22 a_31) + \
|
|
$
|
|
|
|
#SeperatorLine
|
|
|
|
*Regel von Saurus*
|
|
#grid(
|
|
columns: (auto, 1fr),
|
|
image("../images/linAlg/saurus.png", height: 1cm),
|
|
align(center+horizon, $= a_11 a_22 a_33 + a_12 a_23 a_31 + a_13 a_21 a_32 \
|
|
- a_13 a_22 a_31 - a_12 a_21 a_33 - a_11 a_23 a_32
|
|
$)
|
|
)
|
|
|
|
*Laplace Entwicklung*
|
|
|
|
#grid(
|
|
columns: (auto, 1fr),
|
|
column-gutter: 2mm,
|
|
image("../images/linAlg/laplace.jpg", height: 2cm),
|
|
[
|
|
- Nach Spalte oder Zeile Entwicklung
|
|
- #underline([Auf Vorzeichen Achten!!!])
|
|
- Zeilen mit vielen Nuller wählen
|
|
]
|
|
)
|
|
|
|
*Determinate Tricke-Kiste*
|
|
|
|
- Orthogonal-Matrix: $det(A) = 1$
|
|
- Diagonal-/Oberdreiecks-/Unterdreick-Matrix: \ $det(A) = product a_(i i)$
|
|
- $det(A) = product lambda_(i i) "(Eigenwerte)"$
|
|
|
|
- Partionen: $mat(A, B; 0, C) slash mat(A, 0; B, C) -> det(A) = det(A) dot det(C)$
|
|
|
|
#grid(
|
|
columns: (1fr, 1fr),
|
|
column-gutter: 2mm,
|
|
row-gutter: 2mm,
|
|
$A,B in KK^(n times n) :$, $$,
|
|
$det(A dot B) = det A dot det B$,
|
|
$det(A^(-1)) = 1/det(A)$,
|
|
$det(A) = det(A^T)$,
|
|
$det(lambda A) = lambda^n det(A)$,
|
|
$det mat(a, b; c, d) = a d - b c$,
|
|
)
|
|
|
|
Elementare (Gauß) Zeilen Umfohrungen kann man machen
|
|
|
|
NICHT Qudratischen Matrizen $det(D)$ nicht definiert, Nur für Endomorphisen
|
|
|
|
$det(A) = 0 <=> "invertierbar" <=> "bijektiv"$
|
|
|
|
|
|
]
|
|
|
|
#bgBlock(fill: colorVR)[
|
|
#subHeading(fill: colorVR)[Eukldische VRs]
|
|
|
|
- *Skalarprodukt:* Positiv definite symetrisch Bilinearform
|
|
- $equiv$ Skalarprodukt $ip(dot, dot)$ in $RR$
|
|
- $f(ve(v)_1, ve(v)_2) = f(ve(v)_2, ve(v)_1), space space forall ve(v)_1, ve(v)_2 in KK^n$
|
|
- Linear in beiden Argument: \
|
|
$ip(lambda ve(x), ve(y)) = lambda ip(ve(x), ve(y))$\
|
|
$ip(ve(x) + ve(a), ve(y)) = ip(ve(x), ve(y)) + ip(ve(a), ve(y))$
|
|
- $f(ve(v), ve(v)) > 0, v in V without {ve(0)}$
|
|
|
|
*Kannonische Scalar Produkt* $ip(ve(x), ve(y)) := limits(sum)_(i=1)^n x_i y_i$
|
|
- Positiv definit: $ip(ve(x), ve(x)) > 0$
|
|
|
|
#SeperatorLine
|
|
|
|
*Norm*
|
|
- $norm(ve(v)) = 0 <=> ve(v) = ve(0)$
|
|
- $norm(lambda ve(v)) = abs(lambda) norm(ve(v))$
|
|
- Dreieckesungleichung: $norm(x + y) <= norm(x) + norm(y)$
|
|
|
|
*Generisch/$L_p$-Norm*: $|| v ||_p = root(p, sum_(k=1)^n (x_k)^p)$
|
|
|
|
*Induzierte Norm:* $norm(ve(v)) = sqrt(ip(ve(v), ve(v)))$ (Bliebiges $ip(dot, dot)$)
|
|
|
|
*Eukldische Norm:*
|
|
- $L_2$-Norm/kannoische Norm: $norm(ve(v)) = sqrt(ip(ve(v), ve(v)))$
|
|
|
|
*Cauchy-Schwarz-Ungleichung:* $abs(ip(v, w)) <= norm(v) norm(w)$
|
|
- Gilt in Eukldische Vektoraum
|
|
- Gilt nur mit aus Eukldischer Norm
|
|
|
|
*Euklidsche Vektorraum:* $ = (RR^n"-VR", ip(dot, dot))$, (Irgendeine Skalarprodukt
|
|
- Eigenschaften:
|
|
- Polarisation: $ip(v, w) = 1/4 (norm(v + w)^2 - norm(v -w )^2)$
|
|
- Parallelogrammgleichung: \
|
|
$2 (norm(v)^2 + norm(w)^2) = norm(v + w)^2 + norm(v - w)^2$
|
|
- Winkel: $cos alpha = ip(v, w)/(norm(v) norm(w))$
|
|
|
|
*Orthogonal Vektoren:* $ip(v, w) = 0$ \
|
|
*Ortho#text(red)[normal] Vektoren:* $ip(v, w) = 0$ UND $norm(v),norm(w) = 1$
|
|
|
|
#SeperatorLine
|
|
*Orthogonal Projektion* $pi_U(v) = limits(sum)_(i=1)^k ip(v, u_i) u_i$
|
|
|
|
$U subset V$ Untervektorraum eines Eukldische VRs $V$, \ $U$ in orthogo#text(red)[normal] Basis:
|
|
|
|
]
|
|
|
|
#colbreak()
|
|
|
|
#bgBlock(fill: colorMatrixVerfahren)[
|
|
|
|
#subHeading(fill: colorMatrixVerfahren)[Eigenwert und Eigenvektoren ]
|
|
|
|
$A in CC^(n times n):$ $n$ Complexe Eigenwerte \
|
|
$A in RR^(n times n)$
|
|
|
|
*1. Eigentwete bestimmen*
|
|
|
|
$A v = lambda v => det(A-E lambda) = 0$
|
|
|
|
$0 = det mat(#mannot.markhl($x_11 - lambda_1$, color: red), x_12, ..., x_(1n);
|
|
x_21, #mannot.markhl($x_22 - lambda_2$, color: red), ..., x_(2n);
|
|
dots.v, dots.v, dots.down, dots.v;
|
|
x_(n 1), x_(n 2), ..., #mannot.markhl($x_(n n) -lambda_n$, color: red)
|
|
)$
|
|
|
|
$--> chi_A = (lambda_0 - lambda)^(n_0) dot (lambda_1 - lambda)^(n_1) ... $
|
|
|
|
|
|
$lambda_0, lambda_1, ... = $ Nst von $chi_A$
|
|
|
|
|
|
*2. Eigenvektor bestimmen*
|
|
|
|
$Eig(lambda_k) = kern(A - lambda_k E)$
|
|
|
|
$mat(#mannot.markhl($x_11 - lambda_k$, color: red), x_12, ..., x_(1n);
|
|
x_21, #mannot.markhl($x_22 - lambda_k$, color: red), ..., x_(2n);
|
|
dots.v, dots.v, dots.down, dots.v;
|
|
x_(n 1), x_(n 2), ..., #mannot.markhl($x_(n n) -lambda_k$, color: red)
|
|
) vec(v_1, v_2, dots.v, v_n) = vec(0, 0, dots.v, 0)$
|
|
|
|
|
|
|
|
*Algebrasche Vielfacheit:* $alg(lambda) = n_0 + n_1 + ...$ \
|
|
*Geometrische Vielfacheit:* $geo(lambda) = dim("Eig"_A (lambda))$ \
|
|
|
|
$1 <= geo(lambda) <= alg(lambda)$
|
|
|
|
]
|
|
|
|
#bgBlock(fill: colorMatrixVerfahren)[
|
|
#subHeading(fill: colorMatrixVerfahren)[Gram-Schmit ONB]
|
|
|
|
Idee: $ip("Orth"#text(red)[normal] ve(v), ve(x)) = "Anteil von" ve(x) "an" ve(v)$ \
|
|
Ziel: Basis $W -->$ Orthogonal Basis $V$
|
|
|
|
1. $v_1 = 1/norm(w_1)$
|
|
2. $hat(v)_(j+1) = w_(j+1) -ip(w_(j+1), v_1)v_1 - ip(w_(j+2), v_2)v_2 ... $
|
|
|
|
3. $v_(j+1) = hat(v)_(j+1)/norm(hat(v)_(j+1))$
|
|
4. Repeat for $w_1, w_2, w_3, ...$
|
|
|
|
|
|
]
|
|
|
|
#bgBlock(fill: colorMatrixVerfahren)[
|
|
#subHeading(fill: colorMatrixVerfahren)[Diagonalisierung]
|
|
$A = R D R^(-1)$
|
|
|
|
*Rezept Diagonalisierung*
|
|
|
|
1. EW bestimmen: $det(A - lambda I) = 0$ \
|
|
$=> chi_A = (lambda_1 - lambda)^(m 1) (lambda_2 - lambda)^(m 2) ...$
|
|
2. EV bestimmen: $spann(kern(A - lambda_i I))$: $r_0, r_1, ...$
|
|
3. \
|
|
#grid(columns: (1fr, 1fr),
|
|
[
|
|
Diagnoalmatrix: $D$
|
|
$mat(
|
|
lambda_1, 0, 0,...;
|
|
0, lambda_1, 0, ...;
|
|
0, 0, lambda_2, ...;
|
|
dots.v, dots.v, dots.v, dots.down
|
|
)
|
|
$
|
|
],
|
|
[
|
|
Basiswechselmatrix: $R$
|
|
$mat(
|
|
|, | , ..., |;
|
|
r_0, r_1, ..., r_n;
|
|
|, |, ..., |
|
|
)$
|
|
]
|
|
)
|
|
]
|
|
|
|
|
|
#bgBlock(fill: colorMatrixVerfahren)[
|
|
#subHeading(fill: colorMatrixVerfahren)[Schur-Zerlegung]
|
|
Wenn dsa charakteristische Polynom $chi_A "von" A in CC^(n times n) slash RR^(n times n) "in" chi_A(lambda) = (lambda_1 - lambda)(lambda_2 - lambda)... "zerfällt"$ dann ist Schur-Zerlegung möglich
|
|
- Gilt für $CC^(n times n)$ immer
|
|
|
|
#grid(
|
|
columns: (1fr, 3fr),
|
|
$R = B^* A B$,
|
|
[
|
|
$B:$ orthogonal/unitair $KK^(n times n)$ \
|
|
$R:$ Oberedreiecks Matrix $KK^(n times n)$ \
|
|
$B^* = B^T "für" RR, B^* = B^(-T) "für" CC$
|
|
]
|
|
)
|
|
|
|
- $A,R$ haben die selben Eigenwerte
|
|
- Schur-Zerlegung ist nicht eindeutig, (Diagnoal elemen bis auf die Reihnfolge schon)
|
|
- Wenn $A$ diagonaliserbar $=>$ $R$ Dignoalmatrix
|
|
]
|
|
|
|
#bgBlock(fill: colorMatrixVerfahren)[
|
|
#subHeading(fill: colorMatrixVerfahren)[SVD]
|
|
|
|
$A in RR^(m times n)$ zerlegbar in $A = L S R^T$ \
|
|
|
|
|
|
$L in RR^(m times m)$ Orthogonal \
|
|
$S in RR^(m times n)$ Diagonal \
|
|
$R in RR^(n times n)$ Orthogonal
|
|
|
|
|
|
1. $A A^T$ berechnen $A A^T in RR^(m times m)$
|
|
|
|
2. $A A^T$ diagonalisieren in $R$, $D$ (dabei EWs, EVs berechen)
|
|
|
|
3. Singulärwerte berechen: $sigma_i = sqrt(lambda_i) $
|
|
|
|
4. $l_i = 1/sigma_i A v_(lambda i) quad quad L = mat( |, |, ..., |; l_0, l_1, ..., l_m; |, |, ..., |)$ \
|
|
(Evt. zu ONB ergenze mit Gram-Schmit/Kreuzprodukt)
|
|
|
|
5. $S in RR^(n times m)$ (wie $A$): \
|
|
$S = mat(sigma_0, 0; 0, sigma_1; dots.v, dots.v; 0, 0) quad quad quad S = mat(sigma_0, 0, dots, 0; 0, sigma_1, ..., 0)$
|
|
]
|
|
|
|
#bgBlock(fill: colorMatrix)[
|
|
#subHeading(fill: colorMatrix)[Matrix Normen]
|
|
|
|
$|| dot ||_M$ Matrix Norm, $|| dot ||_V$ Vektornorm
|
|
|
|
- submultiplikativ: $||A B||_"M" <= ||A||||B||$
|
|
- verträglich mit einer Vektornorm: $||A v||_"V" <= ||A||_"M" ||v||_"V"$
|
|
|
|
*Frobenius-Norm* $||A||_"M" = sqrt(sum_(i=1)^m sum_(j=1)^n a_(m n)^2)$
|
|
|
|
*Induzierte Norm* \
|
|
$||A||_"M" = sup_(v in V without {0}) (||A v||_V)/(||v||_V) = sup_(||v|| = 1) ||A v||_V$
|
|
- submultiplikativ
|
|
- verträglich mit einer Vektornorm $||dot||_V$
|
|
|
|
*maximale Spaltensumme* $||A||_r = max_(1<= i <= n) sum_(j=1)^n |a_(j)|$
|
|
]
|
|
|
|
#bgBlock(fill: colorMatrix)[
|
|
#subHeading(fill: colorMatrix)[Rekursive Folgen]
|
|
|
|
E.g: $a_1 x_(n-1) + a_2 x_(n) = x_(n+1)$
|
|
|
|
1. Als Matrix Schreiben $F: vec(x_(n-1), x_(n)) = vec(x_n, x_(n+1))$ \
|
|
$F s_(n-1) = s_(n)$
|
|
|
|
2. Diagonaliseren: $F = R D R^(-1) $ \
|
|
3. Wiederholte Anwendung: $F^n = R D^n R^(-1)$
|
|
|
|
]
|
|
|
|
#bgBlock(fill: colorMatrix)[
|
|
#subHeading(fill: colorMatrix)[Lineare Differenzialgleichungen]
|
|
|
|
$y'_1(t) &= alpha_11 &dot y_1(t) + alpha_12 dot y_2(t) + ...\
|
|
y'_1(t) &= alpha_11 &dot y_1(t) + alpha_12 dot y_2(t) + ... \
|
|
&dots.v &dots.v\
|
|
y'_1(t) &= alpha_11 &dot y_1(t) + alpha_12 dot y_2(t) + ...
|
|
$
|
|
]
|
|
|
|
#colbreak()
|
|
|
|
|
|
#sinTable
|
|
]
|
|
|
|
#columns(2)[
|
|
#table(
|
|
columns: (auto, 1fr),
|
|
inset: 2mm,
|
|
fill: (x, y) => if (calc.rem(y, 2) == 0) { tableFillLow } else { tableFillHigh },
|
|
[*Einheits Matrix*\ $I,E$], [
|
|
$det(E) = 1$
|
|
],
|
|
[*Diagonalmatrix* \ $Sigma,D$], [
|
|
Nur Einträger auf Hauptdiagonalen \
|
|
$det(D) = d_00 dot d_11 dot d_22 dot ...$
|
|
],
|
|
[*Symetrisch*\ $S$], [
|
|
$S = S^T$, $S in KK^(n times n)$\
|
|
$A A^T$, $A^T A$ ist symetrisch \
|
|
$S$ immer diagonaliserbar \
|
|
EW immer $in RR$, EV orthogonal
|
|
],
|
|
[*Invertierbar*], [
|
|
$exists A^(-1) : A A^(-1) = A^(-1) A = E$ \
|
|
|
|
*Invertierbar wenn:* \
|
|
$A$ bijektiv, $det(A) = 0$ \
|
|
$"Spalten Vekoren lin. unabhänig"$ \
|
|
$Rang(A) = n, A in KK^(n times n)$ \
|
|
$det(A) = 0$ \
|
|
|
|
*Nicht Invertierbar wenn:*\
|
|
$exists$ EW $!= 0 => not "invertierbar"$
|
|
Keine Qudratische Matrix
|
|
],
|
|
[*Orthogonal*], [
|
|
#grid(
|
|
columns: (1fr, 1fr),
|
|
[
|
|
- Immer Bijektiv
|
|
- $det (A) = plus.minus 1$
|
|
$O^T = O^(-1) quad quad O^T O = O O^T = I$ \
|
|
$ip(O v, O w) = ip(v, w)$
|
|
]
|
|
)
|
|
|
|
],
|
|
[*Unitair* $equiv$ Orthogonal $in CC$], [
|
|
- Immer Bijektiv
|
|
$V = V^*$
|
|
|
|
],
|
|
[*Diagonaliserbar*], [
|
|
$exists A = B D B^(-1)$, $D$ diagonal,
|
|
|
|
$B$: Splaten sind EV von $A$
|
|
|
|
- Selbst-Adujunkte ($$) diagonalisierbar
|
|
- Symetrisch Matrix
|
|
- $A in KK^(n times n) "UND" alg(lambda) = geo(lambda)$
|
|
],
|
|
[*postiv-semi-definit*], [
|
|
$forall$ EW $>= 0$
|
|
],
|
|
)
|
|
]
|