From 3c6ef88078fec18da498eae637862539027429de Mon Sep 17 00:00:00 2001
From: Jonas Hahn <jonas@hahn1.one>
Date: Sat, 14 Feb 2026 17:05:05 +0100
Subject: [PATCH] Remove llm

---
 GPT.md | 297 ---------------------------------------------------------
 1 file changed, 297 deletions(-)
 delete mode 100644 GPT.md

diff --git a/GPT.md b/GPT.md
deleted file mode 100644
index 32385cf..0000000
--- a/GPT.md
+++ /dev/null
@@ -1,297 +0,0 @@
-### 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.