gMerge branch 'master' of gitea:christian/uni

lecture.cls

@@ -1,5 +1,5 @@
 \ProvidesClass{lecture}
-\LoadClass[a4paper]{article}
+\LoadClass[a4paper, titlepage]{article}
 
 \RequirePackage[utf8]{inputenc}
 \RequirePackage[T1]{fontenc}
@@ -20,6 +20,7 @@
 
 \usetikzlibrary{quotes, angles}
 
+\DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}
 \DeclareOption{uebung}{
     \makeatletter
     \lhead{\@title}

ws2019/ana/lectures/analysis.tex

@@ -1,4 +1,4 @@
-\documentclass{../../../lecture}
+\documentclass[titlepage]{../../../lecture}
 
 \usepackage{standalone}
 \usepackage{tikz}
@@ -9,6 +9,11 @@
 
 \begin{document}
 
+\maketitle
+
+\tableofcontents
+\newpage
+
 \input{analysis1-2.tex}
 \input{analysis3.tex}
 \input{analysis4.tex}
@@ -22,7 +27,7 @@
 \input{analysis12.tex}
 \input{analysis13.tex}
 \input{analysis14.tex}
-\input{analysis14.tex}
 \input{analysis15.tex}
+\input{analysis16.tex}
 
 \end{document}

ws2019/ana/lectures/analysis1-2.tex

@@ -2,12 +2,6 @@
 
 \begin{document}
 
-\maketitle
-
-\newpage
-\tableofcontents
-\newpage
-
 \section{Grundlagen}
 
 \subsection{Mengen und Aussagen}

ws2019/ana/lectures/analysis14.tex

@@ -305,7 +305,7 @@ Kostina glaubt, dass das so stimmt, aber offensichtlich ist sie sich nicht siche
     definiert durch
     \[
         \sum_{n=0}^{\infty} a_n (z - z_0)^{n}, z \in \mathbb{C}
-    .\] $a_n \in \mathbb{C}, \forall n \in N_0$
+    .\] $a_n \in \mathbb{C}, \forall n \in \N_0$
 \end{definition}
 
 \begin{bsp}[Exponentialreihe]

ws2019/ana/lectures/analysis15.tex

@@ -22,7 +22,7 @@
 \subsection{Grenzwerte bei Funktionen}
 
 \begin{definition}[Berührpunkt]
-    Sei $D \in \R$. Ein Punkt $a \in \R$ heißt Berührpunkt von $D$, falls
+    Sei $D \subset  \R$. Ein Punkt $a \in \R$ heißt Berührpunkt von $D$, falls
     in jeder $\delta$-Umgebung von $a$, d.h.
     \[
         U_{\delta}(a) := ]a - \delta, a + \delta[ = (a-\delta, a+\delta)

ws2019/ana/lectures/analysis16.tex

@@ -185,7 +185,7 @@ in dieser Umgebung.
 \end{definition}
 
 \begin{satz}
-    Stetige reelwertige Funktionen nehmen auf kompakten Mengen
+    Stetige reellwertige Funktionen nehmen auf kompakten Mengen
     ihr Minimum und Maximum an, d.h.
     $f\colon D \to \R$ stetig, $D$ kompakt, dann ex. $x_{min}, x_{max} \in D$ mit \\
     $f(x_{min}) = \text{inf } \{f(x)  \mid x \in D\} $ \\

ws2019/ipi/uebungen/ipi8.tex

@@ -0,0 +1,285 @@
+\documentclass[uebung]{../../../lecture}
+
+\title{IPI: Übungsblatt 8}
+\author{Samuel Weidemaier, Christian Merten}
+
+\usepackage[]{listings}
+
+\usepackage{xcolor}
+ 
+\lstdefinestyle{mystyle}{
+    commentstyle=\color{gray},
+    language=C++,
+    keywordstyle=\color{blue},
+    numberstyle=\tiny\color{gray},
+    stringstyle=\color{black},
+    basicstyle=\ttfamily\footnotesize,
+    breakatwhitespace=false,         
+    breaklines=true,                 
+    captionpos=b,                    
+    keepspaces=true,                 
+    numbers=left,                    
+    numbersep=5pt,                  
+    showspaces=false,                
+    showstringspaces=false,
+    showtabs=false,                  
+    tabsize=2
+}
+ 
+\lstset{style=mystyle}
+
+
+\begin{document}
+
+\punkte
+
+\begin{aufgabe} Konstruktoren
+
+\begin{tabular}{llllllllllll}
+    \textbf{37}: & a int-Konstruktor & b int-Konstruktor \\
+    \textbf{38}: & c Copy-Konstruktor & d Konstruktor & e Konstruktor \\
+    \textbf{39}: & d int-Zuweisung \\
+    \textbf{40}: & T Copy-Konstruktor & T Addition & U int-Konstruktor & V Copy-Konstruktor
+    & U Destruktor \\
+    & W Copy-Konstruktor & V Destruktor & d Zuweisung & W Destruktor & T Destruktor\\
+    \textbf{41}: & d Addition & T int-Konstruktor & U Copy-Konstruktor & T Destruktor & U Addition \\
+    & V int-Konstruktor & W Copy-Konstruktor & V Destruktor & e Zuweisung & W Destruktor\\
+    & U Destruktor \\
+    \textbf{42}: & e Destruktor & d Destruktor & c Destruktor & b Destruktor & a Destruktor \\
+\end{tabular}
+
+\end{aufgabe}
+
+\begin{aufgabe}
+    \begin{enumerate}[(a)]
+        \item Der Implementierung liegt weiterhin eine einfach verkettete Liste zu Grunde. Konkret
+            wird die \lstinline{struct IntListElem} verwendet.
+            
+            Es wird ein Zeiger \lstinline{IntListElem* first} auf das erste Listenelement, eine
+            Variable \lstinline{int count}, die die Länge der Liste speichert und zwei Hilfsmethoden,
+            \lstinline{IntListElem* getListElement(int position)}, die einen Zeiger auf das interne
+            Listenelement zurückgibt und \lstinline{void copy(IntList& other)}, die die Listenelemente
+            von einer anderen Liste kopiert, verwendet.
+
+            Der leere Konstruktor setzt \lstinline{first} und \lstinline{count} auf 0, genauso wie
+            der Destruktor. Dies führt zur Initialisierung bzw. Leerung der Liste. Der Copy-Konstruktor
+            bzw. Zuweisungsoperator initialisieren bzw. leeren die Liste ebenfalls zunächst und
+            kopieren dann mithilfe der \lstinline{copy} Methode, die Elemente einer zweiten Liste.
+        \item 
+
+    \begin{lstlisting}[language=C++, title=listclass.cpp, captionpos=b]
+#include<stdio.h>
+
+// a list element
+struct IntListElem {
+    int value; // int value
+    IntListElem* next; // pointer to the next element
+};
+
+// A list of integers
+// Beware: indexing is done starting from 1 as the excercise sheet requests it
+class IntList {
+public:
+    // empty constructor, creates an empty list
+    IntList();
+    
+    // copy constructor, intializes by copying from 'other'
+    IntList(IntList& other);
+
+    // assignment operator, removes own elements and copies from 'other'
+    IntList& operator=(IntList& other);
+
+    // destructor, removes list content
+    ~IntList();
+
+    // returns the number of elements in the list
+    int getCount();
+
+    // returns if the list is empty
+    bool isEmpty();
+
+    // prints the list
+    void print();
+
+    // inserts 'element' in the beginning of the list
+    void insert(int element);
+
+    // inserts 'element' AFTER 'position'
+    void insert(int element, int position);
+
+    // removes the element AFTER 'position'
+    void remove(int position);
+
+    // returns the element AT 'position'
+    int getElement(int position);
+private:
+    // pointer to first element
+    IntListElem* first;    
+    // element count
+    int count;
+
+    // returns the IntListElem AT 'position'
+    IntListElem* getListElement(int position);
+
+    // Kopiert die Liste 'other'
+    void copy(IntList& other);
+};
+
+// creates new empty list
+IntList::IntList() {
+    first = 0;
+    count = 0;
+}
+
+// creates a new list by copying an old one
+IntList::IntList(IntList& list) {
+    copy(list);
+}
+
+// Assignment operator
+IntList& IntList::operator=(IntList& other) {
+    if (this == &other) { // if assigning to the same object
+        return *this; // do nothing
+    }
+    copy(other); // otherwise copy contents
+    return *this; 
+}
+
+// destroys the list
+IntList::~IntList() {
+    first = 0; // remove the connection to the list elements
+    count = 0; // reset list count
+};
+
+// private helper that copies from 'other' list
+void IntList::copy(IntList& other) {
+    // clear and copy elements
+    first = 0;
+    count = 0;
+    // copy element by element from 'other' to this new list
+    for (int i = 1; i <= other.count; i++) {
+        insert(other.getElement(i), i-1);
+    }
+}
+
+// private helper that returns the list element struct AT 'position'
+IntListElem* IntList::getListElement(int position) {
+    IntListElem* current = first;
+    for (int i = 1; i < position; i++) {
+        // if list is not long enough
+        if (current->next == 0) {
+            // return the last element
+            return current;
+        }
+        current = current->next;
+    }
+    return current;
+}
+
+// return element AT 'position'
+int IntList::getElement(int position) {
+    if (position < 1 || position > count) {
+        printf("Error: Index out of Bounds, no element at position %d\n", position);
+        return -1;
+    }
+    return getListElement(position)->value; // return the value of the element
+}
+
+// insert 'element' AFTER 'position'
+void IntList::insert(int element, int position) {
+    if (position < 0 || position > count) { // check for invalid positions
+        printf("Error: Index out of Bounds, can't insert.\n");
+        return;
+    }
+    IntListElem* elem = new IntListElem(); // create a new list element
+    elem->value = element; // with the given value
+    if (position == 0) { // insert in the very beginning
+        elem->next = first; // the successor of elem is the old first, now second element
+        first = elem; // make the new element the new first
+    } else {
+        IntListElem* where = getListElement(position); // find the element to insert after
+        elem->next = where->next; // make the old successor of where now follow elem
+        where->next = elem; // make elem the new successor of where
+    }
+    count += 1;
+    return;
+}
+
+// insert 'element' in the very beginning of the list
+void IntList::insert(int element) {
+    insert(element, 0); // insert AFTER position 0
+}
+
+// remove next element AFTER 'position'
+void IntList::remove(int position) {
+    if (position < 0 || position >= count) { // check for invalid positions
+        printf("Error: Index out of bounds, can't remove after %d\n", position);
+        return;
+    }
+    if (position == 0) { // remove first element
+        first = first->next; // new first is the new element
+    } else {
+        IntListElem* where = getListElement(position); // find the element to remove after
+        where->next = where->next->next; // remove by skipping the next element of where
+    }
+    count -= 1; // reduce element count
+    return;
+}
+
+// check if list is empty
+bool IntList::isEmpty() {
+    return count == 0;
+}
+
+// returns the list's size
+int IntList::getCount() {
+    return count;
+}
+
+// print a list of integers
+void IntList::print() {
+    printf("["); // opening brackets
+    IntListElem* current = first;
+    while (current != 0) { // while not last element
+        printf("%d", current->value); // print value
+        if (current->next != 0) {
+            printf(", "); // if not the last element, append a comma
+        }
+        current = current->next; // go to next
+    }
+    printf("]\n"); // closing brackets
+}
+
+int main() {
+    IntList list;
+    list.insert(30);
+    list.insert(20);
+    list.insert(10);
+    list.print();
+
+    list.remove(2);
+    list.print();
+
+    list.insert(30,2);
+    list.print();
+
+    list.insert(40,3);
+    list.print();
+
+    IntList copy(list);
+    copy.print();
+
+    copy.remove(0);
+    copy.print();
+    list.print();
+
+    copy = list;
+    copy.print();
+
+    return 0;
+}
+    \end{lstlisting}
+    \end{enumerate}
+\end{aufgabe}
+
+\end{document}

ws2019/ipi/uebungen/listclass.cpp

@@ -0,0 +1,210 @@
+#include<stdio.h>
+
+// a list element
+struct IntListElem {
+    int value; // int value
+    IntListElem* next; // pointer to the next element
+};
+
+// A list of integers
+// Beware: indexing is done starting from 1 as the excercise sheet requests it
+class IntList {
+public:
+    // empty constructor, creates an empty list
+    IntList();
+    
+    // copy constructor, intializes by copying from 'other'
+    IntList(IntList& other);
+
+    // assignment operator, removes own elements and copies from 'other'
+    IntList& operator=(IntList& other);
+
+    // destructor, removes list content
+    ~IntList();
+
+    // returns the number of elements in the list
+    int getCount();
+
+    // returns if the list is empty
+    bool isEmpty();
+
+    // prints the list
+    void print();
+
+    // inserts 'element' in the beginning of the list
+    void insert(int element);
+
+    // inserts 'element' AFTER 'position'
+    void insert(int element, int position);
+
+    // removes the element AFTER 'position'
+    void remove(int position);
+
+    // returns the element AT 'position'
+    int getElement(int position);
+private:
+    // pointer to first element
+    IntListElem* first;    
+    // element count
+    int count;
+
+    // returns the IntListElem AT 'position'
+    IntListElem* getListElement(int position);
+
+    // Kopiert die Liste 'other'
+    void copy(IntList& other);
+};
+
+// creates new empty list
+IntList::IntList() {
+    first = 0;
+    count = 0;
+}
+
+// creates a new list by copying an old one
+IntList::IntList(IntList& list) {
+    copy(list);
+}
+
+// Assignment operator
+IntList& IntList::operator=(IntList& other) {
+    if (this == &other) { // if assigning to the same object
+        return *this; // do nothing
+    }
+    copy(other); // otherwise copy contents
+    return *this; 
+}
+
+// destroys the list
+IntList::~IntList() {
+    first = 0; // remove the connection to the list elements
+    count = 0; // reset list count
+};
+
+// private helper that copies from 'other' list
+void IntList::copy(IntList& other) {
+    // clear and copy elements
+    first = 0;
+    count = 0;
+    // copy element by element from 'other' to this new list
+    for (int i = 1; i <= other.count; i++) {
+        insert(other.getElement(i), i-1);
+    }
+}
+
+// private helper that returns the list element struct AT 'position'
+IntListElem* IntList::getListElement(int position) {
+    IntListElem* current = first;
+    for (int i = 1; i < position; i++) {
+        // if list is not long enough
+        if (current->next == 0) {
+            // return the last element
+            return current;
+        }
+        current = current->next;
+    }
+    return current;
+}
+
+// return element AT 'position'
+int IntList::getElement(int position) {
+    if (position < 1 || position > count) {
+        printf("Error: Index out of Bounds, no element at position %d\n", position);
+        return -1;
+    }
+    return getListElement(position)->value; // return the value of the element
+}
+
+// insert 'element' AFTER 'position'
+void IntList::insert(int element, int position) {
+    if (position < 0 || position > count) { // check for invalid positions
+        printf("Error: Index out of Bounds, can't insert.\n");
+        return;
+    }
+    IntListElem* elem = new IntListElem(); // create a new list element
+    elem->value = element; // with the given value
+    if (position == 0) { // insert in the very beginning
+        elem->next = first; // the successor of elem is the old first, now second element
+        first = elem; // make the new element the new first
+    } else {
+        IntListElem* where = getListElement(position); // find the element to insert after
+        elem->next = where->next; // make the old successor of where now follow elem
+        where->next = elem; // make elem the new successor of where
+    }
+    count += 1;
+    return;
+}
+
+// insert 'element' in the very beginning of the list
+void IntList::insert(int element) {
+    insert(element, 0); // insert AFTER position 0
+}
+
+// remove next element AFTER 'position'
+void IntList::remove(int position) {
+    if (position < 0 || position >= count) { // check for invalid positions
+        printf("Error: Index out of bounds, can't remove after %d\n", position);
+        return;
+    }
+    if (position == 0) { // remove first element
+        first = first->next; // new first is the new element
+    } else {
+        IntListElem* where = getListElement(position); // find the element to remove after
+        where->next = where->next->next; // remove by skipping the next element of where
+    }
+    count -= 1; // reduce element count
+    return;
+}
+
+// check if list is empty
+bool IntList::isEmpty() {
+    return count == 0;
+}
+
+// returns the list's size
+int IntList::getCount() {
+    return count;
+}
+
+// print a list of integers
+void IntList::print() {
+    printf("["); // opening brackets
+    IntListElem* current = first;
+    while (current != 0) { // while not last element
+        printf("%d", current->value); // print value
+        if (current->next != 0) {
+            printf(", "); // if not the last element, append a comma
+        }
+        current = current->next; // go to next
+    }
+    printf("]\n"); // closing brackets
+}
+
+int main() {
+    IntList list;
+    list.insert(30);
+    list.insert(20);
+    list.insert(10);
+    list.print();
+
+    list.remove(2);
+    list.print();
+
+    list.insert(30,2);
+    list.print();
+
+    list.insert(40,3);
+    list.print();
+
+    IntList copy(list);
+    copy.print();
+
+    copy.remove(0);
+    copy.print();
+    list.print();
+
+    copy = list;
+    copy.print();
+
+    return 0;
+}

ws2019/la/uebungen/la9.tex

@@ -0,0 +1,378 @@
+\documentclass[uebung]{../../../lecture}
+
+\author{Christian Merten}
+\title{Lineare Algebra 1: Übungsblatt Nr. 9}
+
+\usepackage[]{gauss}
+
+\begin{document}
+
+\punkte
+
+\begin{aufgabe}
+    \begin{enumerate}[(a)]
+        \item Es seien $f\colon V \to W$ und $g: W \to V$ lineare Abbildungen
+            zwischen $V$ und $W$ Vektorräumen.
+
+            Beh.: Es existiert genau dann ein $v \in V \setminus \{0\} $ mit $(g \circ f)(v) = v$, wenn
+            es ein $w \in W \setminus \{0\} $ gibt mit $(f \circ g)(w) = w$.
+            \begin{proof} 
+                ,,$\implies$'' Es sei $w \in W$ mit $(f \circ g)(w) = w$. Dann
+                definiere $v := g(w)$. Wegen  $f(g(w)) = f(v) = w$ folgt  $g(f(v)) = g(w) = v$.
+
+                ,,$\impliedby$'' folgt analog.
+            \end{proof}
+        \item Es sei $A \in M_{n,m}(K)$ und $B \in M_{m,n}(K)$.
+
+            Beh.: $E_n - AB$ invertierbar $\iff$ $E_m - BA$ invertierbar.
+            \begin{proof}
+                ,,$\implies$'' Es seien $a\colon K^{m} \to K^{n}$ und $b\colon K^{n} \to K^{m}$ die
+                zu $A$ und $B$ gehörigen Abbildungen.
+                
+                Da $E_{n} - AB$ invertierbar, folgt $id_{K^{n}} - a \circ b$ ist Automorphismus.
+                Also ist zu zeigen, dass
+                der Endomorphismus $id_{K^{m}} - b \circ a$ bijektiv ist.
+
+                Da $id_{K^{n}} - a \circ b$ bijektiv, insbesondere injektiv ist, folgt
+                \begin{align*}
+                    &\text{ker}(id_{K^{n}} - a \circ b) = \{0\}  \\
+                    \implies & id_{K^{n}}(v) - a(b(v)) \neq 0 \quad \forall v \in V \setminus \{0\} \\
+                    \implies &v \neq a(b(v)) \quad \forall v \in V \setminus \{0\}
+                    \intertext{Sei nun $w \in K^{m}$ mit $id_{K^{m}} - b(a(w)) = 0$.}
+                    \implies & w = b(a(w)) \\
+                    \stackrel{\text{1a)}}{\implies} &w = 0
+                .\end{align*}
+                Damit ist $id_{K^{m}} - b \circ a$ ein injektiver Endomorphismus, also
+                auch bijektiv, also Automorphismus.\\
+                $\implies E_m - BA$ invertierbar.
+
+                ,,$\impliedby$'' folgt analog.
+            \end{proof}
+    \end{enumerate}
+\end{aufgabe}
+
+\begin{aufgabe} Es sei $K$ Körper und $A \in M_{n,m}(K)$ und $B \in M_{m,n}(K)$ mit $ABA = A$.
+    \begin{enumerate}[(a)]
+        \item Beh.: $\text{ker } A = \{x - BAx  \mid x \in K^{m}\} $
+            \begin{proof}
+                Zz.: $\text{ker } A \subset \{x - BAx  \mid x \in K^{m}\} $
+                
+                Sei $x \in \text{ker } A$, d.h. $Ax = 0$, damit:
+                \[
+                    x - BAx = x - B\cdot 0 = x
+                .\] 
+
+                Zz.: $\{x - BAx  \mid x \in K^{m}\} \subset \text{ker } A$
+
+                Sei $r \in K^{m}$, dann $x := r - BAr$. Damit folgt:
+                \begin{align*}
+                    Ax = Ar - ABAr \stackrel{ABA=A}{=} Ar - Ar = 0
+                .\end{align*}
+            \end{proof}
+        \item Beh.: $Ax = b$ hat eine Lösung $\iff ABb = b$
+            \begin{proof}
+                \begin{align*}
+                    & Ax = b \text{ hat eine Lösung} \\
+                    \iff & b \in \text{Bild}(A) \\
+                    \iff & \exists x \in K^{m}\colon Ax = ABAx = AB(Ax) = b \\
+                    \iff & ABb = b
+                .\end{align*}
+            \end{proof}
+
+            Beh.: $L := \{x \in K^{m}  \mid Ax = b\} = \{Bb + x' - BAx'  \mid x' \in K^{m}\} $
+            \begin{proof}
+                \begin{enumerate}[(i)]
+                    \item Zz.: $L \subset \{Bb + x - BAx  \mid x \in K^{m}\} $, 
+
+                        Sei $x \in L$ beliebig, d.h. $Ax = b$. Nun g.z.z
+                        $\exists r \in K^{m}\colon x = Bb + r - BAr$. Wähle $k := x - Bb \in K^{m}$. Damit:
+                        \begin{align*}
+                            &Ak = Ax - ABb \stackrel{ABb = b}{=} b - b = 0 \\
+                            \implies &k \in \text{ker}(A)\\
+                            \stackrel{(a)}{\implies} & \exists r \in K^{m}\colon k = r - BAr. \text{ Fixiere }r \\
+                            \implies & Bb + r - BAr = Bb + k = Bb + x - Bb = x
+                        .\end{align*}
+                    \item Zz.: $\{Bb + x - BAx  \mid x \in K^{m}\} \subset L$.
+
+                        Sei $r \in K^{m}$ beliebig, dann definiere $x := Bb + r - BAr \in K^{m}$.
+                        Nun g.z.z. $Ax = b$.
+                        \begin{align*}
+                            Ax = ABb + Ar - ABAr \stackrel{ABb = b}{=} b + Ar - ABAr
+                            \stackrel{ABA = A}{=} b
+                        .\end{align*}
+                \end{enumerate}
+            \end{proof}
+    \end{enumerate}
+    
+\end{aufgabe}
+
+\begin{aufgabe}
+    \begin{align*}
+        &\begin{gmatrix}[p]
+            1 & 1 & 0 \\ 0 & 1 & 1 \\ 1 & 1 & 0
+            \rowops
+            \add[-1]{0}{2}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p] 1 & 1 & 0 \\ 0 & 1 & 1 \\ 0 & 0 & 0
+            \rowops
+            \add[-1]{1}{0}
+        \end{gmatrix}
+        \to 
+        \begin{pmatrix} 1 & 0 & -1 \\ 0 & 1 & 1 \\ 0 & 0 & 0 \end{pmatrix}
+        \intertext{$\implies$ Rang 2}
+        &\begin{gmatrix}[p]
+            1 & 1 & 0 \\ 2 & 1 & 1 \\ 1 & 1 & 1
+            \rowops
+            \add[-2]{0}{1}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p] 1 & 1 & 0 \\ 0 & -1 & 0 \\ 1 & 1 & 1
+            \rowops
+            \add[-1]{0}{2}
+            \mult{1}{\scriptstyle\cdot-1}
+        \end{gmatrix}
+        \to 
+            \begin{gmatrix}[p] 1 & 1 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1
+            \rowops
+            \add[-1]{1}{0}
+        \end{gmatrix}
+        \to 
+        \begin{gmatrix}[p] 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1
+        \end{gmatrix}
+        \intertext{$\implies$ Rang 3}
+        &\begin{gmatrix}[p]
+            1 & 0 & 2 \\ 1 & 1 & 4
+            \rowops
+            \add[-1]{0}{1}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p] 1 & 0 & 2 \\ 0 & 1 & 2
+            \rowops
+        \end{gmatrix}
+        \intertext{$\implies$ Rang 2}
+        &\begin{gmatrix}[p]
+            1 & 2 & 1 \\ 2 & 4 & 2
+            \rowops
+            \add[-2]{0}{1}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p] 1 & 2 & 1 \\ 0 & 0 & 0
+        \end{gmatrix}
+        \intertext{$\implies$ Rang 1 \vspace{2mm}\newline Für $a = 1$ folgt direkt:}
+        &\begin{gmatrix}[p]
+            a & 1 & a \\ 1 & a & 1 \\ a & 1 & a
+        \end{gmatrix}
+        = 
+        \begin{gmatrix}[p] 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1
+            \rowops
+            \add[-1]{0}{1}
+            \add[-1]{0}{2}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p] 1 & 1 & 1 \\ 0 & 0 & 0 \\ 0 & 0 & 0
+        \end{gmatrix}
+        \intertext{$\implies$ Rang 1 \vspace{2mm}\newline Für $a = -1$ folgt}
+        &\begin{gmatrix}[p]
+            a & 1 & a \\ 1 & a & 1 \\ a & 1 & a
+        \end{gmatrix}
+        = 
+        \begin{gmatrix}[p] -1 & 1 & -1 \\ 1 & -1 & 1 \\ -1 & 1 & -1
+            \rowops
+            \add{0}{1}
+            \add[-1]{0}{2}
+            \mult{0}{\scriptstyle\cdot -1}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p] 1 & -1 & 1 \\ 0 & 0 & 0 \\ 0 & 0 & 0
+        \end{gmatrix}
+        \intertext{$\implies$ Rang 0 \vspace{2mm} \newline
+        Für $a \neq 1 \land a \neq -1 \implies 1 - a^2 \neq 0$, damit:}
+        &\begin{gmatrix}[p]
+            a & 1 & a \\ 1 & a & 1 \\ a & 1 & a
+            \rowops
+            \add[-1]{0}{2}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p] a & 1 & a \\ 1 & a & 1 \\ 0 & 0 & 0
+            \rowops
+            \swap{0}{1}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p] 1 & a & 1 \\ a & 1 & a \\ 0 & 0 & 0
+            \rowops
+            \add[-a]{0}{1}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p] 1 & a & 1 \\ 0 & 1-a^2 & 0 \\ 0 & 0 & 0
+            \rowops
+            \mult{1}{\scriptstyle\cdot \frac{1}{1-a^2}}
+        \end{gmatrix}\\
+        \to
+        &\begin{gmatrix}[p] 1 & a & 1 \\ 0 & 1 & 0 \\ 0 & 0 & 0
+            \rowops
+            \add[-a]{1}{0}
+        \end{gmatrix}
+        \to
+        \begin{gmatrix}[p]
+            1 & 0 & 1 \\ 0 & 1 & 0 \\ 0 & 0 & 0
+        \end{gmatrix}
+    \end{align*}
+    $\implies$ Rang 2
+\end{aufgabe}
+
+\begin{aufgabe}
+    \begin{enumerate}[(a)]
+        \item Beh.: $\underline{v} = \left( (1,2)^{t}, (0, -1)^{t} \right) $ ist Basis von $\Q^{2}$.
+            \begin{proof}
+                Zu zeigen.: $\underline{v}$ ist linear unabhängig
+                
+                Seien $a, b \in \Q$ mit
+                \begin{align*}
+                    &a \cdot \binom{1}{2} + b \binom{0}{-1} = 0 \\
+                    \implies & a = 0 \land 2a -b = 0 \implies b = 0
+                .\end{align*}
+                $\implies$  $\underline{v}$ ist linear unabhängig wegen $\text{dim } \Q^{2} = 2$ eine Basis
+                von $\Q^{2}$.
+            \end{proof}
+            Beh.: $\underline{w} = \left( (1,1)^{t}, (3,2)^{t} \right) $ ist Basis von $\Q^{2}$
+            \begin{proof}
+                Zu zeigen.: $\underline{v}$ ist linear unabhängig
+                
+                Seien $a, b \in \Q$ mit
+                \begin{align*}
+                    &a \cdot \binom{1}{1} + b \binom{3}{2} = 0 \\
+                    \implies & a + 3b = 0 \land a +2b = 0
+                    \implies b = a = 0
+                .\end{align*}
+                $\implies$  $\underline{v}$ ist linear unabhängig wegen $\text{dim } \Q^{2} = 2$ eine Basis
+                von $\Q^{2}$.
+            \end{proof}
+
+            Beh.:
+            \[
+                T = M_{\underline{e}}^{\underline{v}}(\text{id}_V) =
+                \begin{pmatrix} 1 & 2 \\ 0 & -1 \end{pmatrix} 
+            .\] 
+            \begin{proof}
+                Zu Überprüfen für die zwei Basisvektoren aus $\underline{v}$.
+                \begin{enumerate}[(i)]
+                    \item $v_1 = (1,2)^{t}$. $\phi(v_1) = (1,0)^{t}$.
+                        
+                        \begin{align*}
+                            \begin{pmatrix} 1 & 2 \\ 0 & -1 \end{pmatrix}
+                            \cdot \begin{pmatrix} 1 \\ 0 \end{pmatrix}
+                            = \begin{pmatrix} 1 \\ 2 \end{pmatrix}
+                        .\end{align*}
+                    \item $v_2 = (0,-1)^{t}$. $\phi(v_2) = (0,1)^{t}$.
+                        
+                        \begin{align*}
+                            \begin{pmatrix} 1 & 2 \\ 0 & -1 \end{pmatrix}
+                            \cdot \begin{pmatrix} 0 \\ 1 \end{pmatrix}
+                            = \begin{pmatrix} 0 \\ -1 \end{pmatrix}
+                        .\end{align*}
+                \end{enumerate}
+            \end{proof}
+
+            Beh.:
+            \[
+                T = M_{\underline{e}}^{\underline{w}}(\text{id}_V) =
+                \begin{pmatrix} 1 & 1 \\ 3 & 2 \end{pmatrix} 
+            .\] 
+            \begin{proof}
+                Zu Überprüfen für die zwei Basisvektoren aus $\underline{w}$.
+                \begin{enumerate}[(i)]
+                    \item $w_1 = (1,1)^{t}$. $\phi(w_1) = (1,0)^{t}$.
+                        
+                        \begin{align*}
+                            \begin{pmatrix} 1 & 3 \\ 1 & 2 \end{pmatrix}
+                            \cdot \begin{pmatrix} 1 \\ 0 \end{pmatrix}
+                            = \begin{pmatrix} 1 \\ 1 \end{pmatrix}
+                        .\end{align*}
+                    \item $w_2 = (3,2)^{t}$. $\phi(w_2) = (0,1)^{t}$.
+                        
+                        \begin{align*}
+                            \begin{pmatrix} 1 & 3 \\ 1 & 2 \end{pmatrix}
+                            \cdot \begin{pmatrix} 0 \\ 1 \end{pmatrix}
+                            = \begin{pmatrix} 3 \\ 2 \end{pmatrix}
+                        .\end{align*}
+                \end{enumerate}
+            \end{proof}
+        \item
+            \begin{align*}
+                &\begin{gmatrix}[p]
+                    1 & 0 \\ 2 & -1
+                \end{gmatrix}
+                \begin{gmatrix}[p]
+                    1 & 0 \\ 0 & 1
+                    \rowops
+                    \add[-2]{0}{1}
+                    \mult{1}{\scriptstyle\cdot -1}
+                \end{gmatrix}
+                \to 
+                \begin{gmatrix}[p]
+                    1 & 0 \\ 0 & 1
+                \end{gmatrix}
+                \begin{gmatrix}[p]
+                    1 & 0 \\ 2 & -1
+                \end{gmatrix}
+                \intertext{$\implies T = \left(M_{\underline{e}}^{\underline{v}}\right)^{-1} =
+                \begin{pmatrix} 1 & 0 \\ 2 & -1 \end{pmatrix}$ }
+                &\begin{gmatrix}[p]
+                    1 & 3 \\ 1 & 2 
+                \end{gmatrix}
+                \begin{gmatrix}[p]
+                    1 & 0 \\ 0 & 1
+                    \rowops
+                    \add[-1]{0}{1}
+                    \mult{1}{\scriptstyle\cdot -1}
+                \end{gmatrix}
+                \to 
+                \begin{gmatrix}[p]
+                    1 & 3 \\ 0 & 1
+                \end{gmatrix}
+                \begin{gmatrix}[p]
+                    1 & 0 \\ 1 & -1
+                    \rowops
+                    \add[-3]{1}{0}
+                \end{gmatrix}
+                \to 
+                \begin{gmatrix}[p]
+                    1 & 0 \\ 0 & 1
+                \end{gmatrix}
+                \begin{gmatrix}[p]
+                    -2 & 3 \\ 1 & -1
+                \end{gmatrix}
+            .\end{align*}
+                $\implies S = \left(M_{\underline{e}}^{\underline{w}}\right)^{-1} =
+                \begin{pmatrix} -2 & 3 \\ 1 & -1 \end{pmatrix}$
+            \item $M_{\underline{e}}^{\underline{e}}(f) = \begin{pmatrix} 1 & 2 \\ -1 & -1 \end{pmatrix} $
+                durch ablesen, die restlichen Matrizen ergeben sich durch Multiplikation:
+                \begin{align*}
+                    &M_{\underline{v}}^{\underline{v}}(f)
+                    = M_{\underline{v}}^{\underline{e}}(\text{id}_V) \cdot M_{\underline{e}}^{\underline{e}}(f)
+                    \cdot M_{\underline{e}}^{\underline{v}}(\text{id}_V)
+                    = \begin{pmatrix} 5 & -2 \\ -3 & 1 \end{pmatrix}  \\
+                    &M_{\underline{w}}^{\underline{w}}(f)
+                    = M_{\underline{w}}^{\underline{e}}(\text{id}_V) \cdot M_{\underline{e}}^{\underline{e}}(f)
+                    \cdot M_{\underline{e}}^{\underline{w}}(\text{id}_V)
+                    = \begin{pmatrix} -12 & -29 \\ 5 & 12 \end{pmatrix}  \\
+                    &M_{\underline{v}}^{\underline{w}}(\text{id}_{V})
+                    = M_{\underline{v}}^{\underline{e}}(\text{id}_V)
+                    \cdot M_{\underline{e}}^{\underline{w}}(\text{id}_V)
+                    = \begin{pmatrix} 1 & 3 \\ 1 & 4 \end{pmatrix}
+                .\end{align*}
+            \item
+                \begin{align*}
+                    AC - CB = M_{\underline{v}}^{\underline{v}}(f)
+                    \cdot M_{\underline{v}}^{\underline{w}}(\text{id}_V)
+                    - M_{\underline{v}}^{\underline{w}}(\text{id}_V)
+                    \cdot M_{\underline{w}}^{\underline{w}}(f)
+                    = M_{\underline{v}}^{\underline{w}}(f)
+                    - M_{\underline{v}}^{\underline{w}}(f)
+                    = 0
+                .\end{align*}
+    \end{enumerate}
+\end{aufgabe}
+
+\end{document}