From a701958755bc708196896d5c36a1b0e2a31546c6 Mon Sep 17 00:00:00 2001
From: Jonas Hahn <jonas@hahn1.one>
Date: Sat, 14 Feb 2026 16:40:27 +0100
Subject: [PATCH] Testing llm

---
 GPT.md | 297 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 297 insertions(+)
 create mode 100644 GPT.md

diff --git a/GPT.md b/GPT.md
new file mode 100644
index 0000000..32385cf
--- /dev/null
+++ b/GPT.md
@@ -0,0 +1,297 @@
+### 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.
+
+```prompt
+<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:
+
+1. Iteriere über Spalten (k = 1, ..., n)
+2. Bestimme (v), sodass alle Einträge unterhalb der Diagonale in Spalte (k) verschwinden
+3. 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)
+
+```python
+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:
+
+1. (y = Q^T b)
+2. Löse (Sx = y) per Rückwärtseinsetzen
+
+### Code:
+
+```python
+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
+
+```python
+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
+
+```python
+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
+
+```python
+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.