4.3 KiB
Disclaimer
Dieser LLM-generierte Output dient als Überblick über die Aufgabe und zur Einschätzung, wie gut die aktuelle ChatGPT-Version solche Aufgaben bearbeiten kann. Er wird nicht direkt übernommen; die Inhalte werden selbst geprüft und eigenständig ausgearbeitet.
Disclaimer
Prompt to ChatGPT
Ausgefuehrt am 14.02.2026 auf der freien Version.
<Contents of ./TASK.md>
solve in detail
Answer from ChatGPT
1. Householder-Verfahren (kurz erklärt)
Die Householder-Transformation ist eine orthogonale Spiegelung, mit der man gezielt Einträge unterhalb der Diagonale auf 0 bringt.
Grundidee:
- Für eine Spalte (k) von (A) konstruiert man einen Vektor (v), sodass eine Spiegelung (H_k) den Teilvektor (a_k) auf eine Vielfache des Einheitsvektors (e_1) abbildet.
- Die Householder-Matrix ist: [ H_k = I - 2 \frac{v v^T}{v^T v} ]
- Diese ist orthogonal: (H_k^T = H_k^{-1})
Vorgehen:
- Iteriere über Spalten (k = 1, ..., n)
- Bestimme (v), sodass alle Einträge unterhalb der Diagonale in Spalte (k) verschwinden
- Wende (H_k) auf die Restmatrix an
Am Ende: [ Q = H_1 H_2 \cdots H_n,\quad S = Q^T A ]
Eigenschaften:
- numerisch stabil
- keine Verschlechterung der Kondition
- besser als Gram-Schmidt in der Praxis
2. QS-Zerlegung für
[
A =
\begin{pmatrix}
0 & 1
0 & 0
1 & 1
\end{pmatrix}
]
Schritt 1: erste Spalte
[ a_1 = (0,0,1)^T,\quad |a_1| = 1 ]
Wähle: [ v = a_1 + |a_1| e_1 = (1,0,1)^T ]
Norm: [ v^T v = 2 ]
Householder: [ H_1 = I - 2 \frac{vv^T}{v^T v} = I - \frac{vv^T}{1} ]
[
vv^T =
\begin{pmatrix}
1 & 0 & 1
0 & 0 & 0
1 & 0 & 1
\end{pmatrix}
]
[
H_1 =
\begin{pmatrix}
0 & 0 & -1
0 & 1 & 0
-1 & 0 & 0
\end{pmatrix}
]
Schritt 2: transformiere A
[
S = H_1 A =
\begin{pmatrix}
-1 & -1
0 & 0
0 & 1
\end{pmatrix}
]
Schritt 3: zweite Spalte (unterer Block)
Betrachte: [ (0,1)^T \Rightarrow v = (1,1)^T ]
Ergibt:
[
H_2 =
\begin{pmatrix}
1 & 0 & 0
0 & 0 & -1
0 & -1 & 0
\end{pmatrix}
]
Endergebnis:
[
S =
\begin{pmatrix}
-1 & -1
0 & -1
0 & 0
\end{pmatrix}
]
[ Q = H_1 H_2 ]
3. Python-Implementierung (Householder)
import numpy as np
def householder_qs(A):
A = A.astype(float)
m, n = A.shape
Q = np.eye(m)
S = A.copy()
for k in range(n):
# Teilvektor
x = S[k:, k]
# Norm
norm_x = np.linalg.norm(x)
if norm_x == 0:
continue
# Householder-Vektor
e1 = np.zeros_like(x)
e1[0] = 1
v = x + np.sign(x[0]) * norm_x * e1
v = v / np.linalg.norm(v)
# Transformation
H_k = np.eye(m)
H_k[k:, k:] -= 2.0 * np.outer(v, v)
# Anwenden
S = H_k @ S
Q = Q @ H_k
return Q, S
4. Lösen von (Ax = b) mit QS
Gegeben: [ A = QS ]
Dann: [ Ax = b \Rightarrow QSx = b ]
Multipliziere mit (Q^T): [ Sx = Q^T b ]
Vorgehen:
- (y = Q^T b)
- Löse (Sx = y) per Rückwärtseinsetzen
Code:
def back_substitution(R, b):
n = len(b)
x = np.zeros(n)
for i in reversed(range(n)):
x[i] = (b[i] - np.dot(R[i, i+1:], x[i+1:])) / R[i, i]
return x
def solve_qs(A, b):
Q, S = householder_qs(A)
y = Q.T @ b
x = back_substitution(S, y)
return x
5. Anwendung für (n=20, d=0.1)
Matrix A erzeugen
def build_A(n, d):
A = np.zeros((n, n))
for i in range(n):
for j in range(n):
if i == j:
A[i, j] = d
elif j == n-1:
A[i, j] = 1
elif i > j:
A[i, j] = -1
return A
Vektor b
def build_b(n, d):
b = np.zeros(n)
for i in range(n):
b[i] = (i+1) - n + d
b[0] = 1 + d
return b
Ausführung
n = 20
d = 0.1
A = build_A(n, d)
b = build_b(n, d)
x = solve_qs(A, b)
print(x)
Erwartetes Verhalten
- Lösung existiert eindeutig (A regulär)
- Numerisch stabil durch Householder
- Ergebnis: Vektor (x \in \mathbb{R}^{20})
Wichtige Punkte für die Abgabe
-
Householder statt Gram-Schmidt → Stabilität
-
Kein Gebrauch von
np.linalg.qr -
Rückwärtseinsetzen selbst implementiert
-
Code kommentieren:
- Bedeutung von v
- warum Norm + Vorzeichen
- Struktur von H
Wenn gewünscht: kompakte Version für Portfolio (≤15.000 Zeichen) oder Latex-Ausarbeitung.