Vorlesung vom 22.12.2022
© 2022 Prof. Dr. Rüdiger W. Braun
from sympy import *
init_printing()
A = Matrix(3,3,range(1,10))
A
b = Matrix([6,15,24])
b
x_var = symbols('x1:4')
x = Matrix(x_var)
x
glg = Eq(A*x, b)
glg
lsg = solve(glg)
lsg
lsg = solve(glg, {x[1],x[2]})
lsg
Also $$ \{ x \in \mathbb R^3 \mid Ax = b \} = \left\{ \left. \begin{pmatrix} x_1 \\ 3 - 2x_1 \\ x_1 \end{pmatrix} \right| x_1 \in \mathbb R \right\} $$
A.det()
Probe:
v = x.subs(lsg)
v
A * v - b
Konkrete Lösung
v.subs(x[0], 0)
Gleichung ohne Lösung
b = Matrix([0,2,3])
glg = Eq(A*x, b)
solve(glg)
Kern von $A$
glg = Eq(A*x, 0)
glg
glg = Eq(A*x, 0, evaluate=False)
glg
#solve(glg) # TypeError
null = Matrix([0,0,0])
glg = Eq(A*x, null)
glg
solve(glg)
A.nullspace()
Basis des Kerns
A
A.eigenvals()
A.eigenvects(simplify=True)
Die Tripel enthalten: Eigenwert, arithmetische Vielfachheit, Basis des Eigenraums
B = Matrix([[1,0,1], [0,1,0], [0,0,1]])
B
B.eigenvals()
B.eigenvects()
arithmetische > geometrische Vielfachheit $\Rightarrow$ Matrix nicht diagonalisierbar
B
T, J = B.jordan_form()
T, J
T * J * T**(-1)
C = Matrix(3, 3, [-4, -2, -3, 5, 3, 3, 5, 2, 4])
C
T, J = C.jordan_form()
T, J
C.eigenvects()
w1 = C.eigenvects()[0][2][0]
w1
w2 = C.eigenvects()[0][2][1]
w2
5*w1 + 5*w2, T.col(0)
T * J * T**(-1) == C
True
Die Jordansche Normalform hängt unstetig von den Daten ab
delta = Symbol('delta')
C[0,0] += delta
C
Te, Je = C.jordan_form()
Je
Je.limit(delta, 0), J
v = Matrix([1,2,3])
v.norm()
a, b, c, d = symbols("a b c d", real=True)
w = Matrix([a, b, c])
w.norm()
v.norm(oo)
w.norm(oo)
v.norm(Rational(8,7))
w.norm(Rational(8,7))
A
A.norm()
M = Matrix(2,2,[a,b,c,d])
M
M.norm()
Das ist die Frobeniusnorm. Sie keine Matrixnorm, aber submultiplikativ, erfüllt also $\Vert AB \Vert \le \Vert A \Vert \, \Vert B \Vert$.
A.norm(2)
B = A.T*A
B
B.eigenvals()
Das ist eine Matrixnorm.
M.norm(1)
Spaltensummennorm
M.norm(oo)
Zeilensummennorm
Das sind auch Matrixnormen.
x, y, z = symbols('x y z')
variablen = [x,y,z]
f = exp(x**2 + 2*y**2 + 3*z**2)
f
J = Matrix([f]).jacobian(variablen)
J
Das ist die Jacobi-Matrix
nabla_f = J.T
nabla_f
Das ist der Gradient
A = Matrix([f, f**2, f**3])
A
A.jacobian(variablen)
H = hessian(f, variablen)
H
H == H.T
True
x = Symbol("x")
H1 = H.subs({x:1, y:0, z:-1})
H1
H1.is_positive_definite
True
H1.is_indefinite
False
M = Matrix(2,2,[x,0,0,1])
M
M.is_positive_definite # kann man ohne Kenntnis von $x$ nicht wissen
print(M.is_positive_definite)
None
x = Symbol("x", positive=True)
M = Matrix([[0,x], [x,0]])
M
M.is_indefinite
True
Dreiwertige Logik
x = Symbol("x")
f = -x**4/2 - x**2*y**2 - y**4/2 + x**3 - 3*x*y**2
f
gr = Matrix([f]).jacobian([x,y])
gr
lsg = solve(gr)
lsg
kritische Punkte
H = hessian(f, [x,y])
H
H1 = H.subs(lsg[0])
H1
H1.is_negative_definite
True
H2 = H.subs(lsg[1])
H2
H2.is_negative_definite
True
H3 = H.subs(lsg[2])
H3
H3.is_positive_semidefinite
True
H3.is_negative_semidefinite
True
verschieben wir auf später
H4 = H.subs(lsg[3])
H4
Direkt zu sehen: negativ definit
zurück zu
lsg[2]
f_x = f.subs(y, lsg[2][y])
f_x
Diese Funktion hat in $0$ einen Sattelpunkt