diff --git a/lecture.cls b/lecture.cls index fe2af32..262a1fb 100644 --- a/lecture.cls +++ b/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} diff --git a/ws2019/ana/lectures/analysis.pdf b/ws2019/ana/lectures/analysis.pdf index 527f985..4674da8 100644 Binary files a/ws2019/ana/lectures/analysis.pdf and b/ws2019/ana/lectures/analysis.pdf differ diff --git a/ws2019/ana/lectures/analysis.tex b/ws2019/ana/lectures/analysis.tex index d3e1cce..342ec09 100644 --- a/ws2019/ana/lectures/analysis.tex +++ b/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} diff --git a/ws2019/ana/lectures/analysis1-2.tex b/ws2019/ana/lectures/analysis1-2.tex index 7c34a55..eaf522e 100644 --- a/ws2019/ana/lectures/analysis1-2.tex +++ b/ws2019/ana/lectures/analysis1-2.tex @@ -2,12 +2,6 @@ \begin{document} -\maketitle - -\newpage -\tableofcontents -\newpage - \section{Grundlagen} \subsection{Mengen und Aussagen} diff --git a/ws2019/ana/lectures/analysis14.tex b/ws2019/ana/lectures/analysis14.tex index 21c1b99..76e8576 100644 --- a/ws2019/ana/lectures/analysis14.tex +++ b/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] diff --git a/ws2019/ana/lectures/analysis15.pdf b/ws2019/ana/lectures/analysis15.pdf index 481d962..9ab150b 100644 Binary files a/ws2019/ana/lectures/analysis15.pdf and b/ws2019/ana/lectures/analysis15.pdf differ diff --git a/ws2019/ana/lectures/analysis15.tex b/ws2019/ana/lectures/analysis15.tex index e8bd302..9b3859c 100644 --- a/ws2019/ana/lectures/analysis15.tex +++ b/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) diff --git a/ws2019/ana/lectures/analysis16.tex b/ws2019/ana/lectures/analysis16.tex index 2e0f10b..6f849b3 100644 --- a/ws2019/ana/lectures/analysis16.tex +++ b/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\} $ \\ diff --git a/ws2019/ipi/uebungen/ipi8.pdf b/ws2019/ipi/uebungen/ipi8.pdf new file mode 100644 index 0000000..3f3ba5d Binary files /dev/null and b/ws2019/ipi/uebungen/ipi8.pdf differ diff --git a/ws2019/ipi/uebungen/ipi8.tex b/ws2019/ipi/uebungen/ipi8.tex new file mode 100644 index 0000000..ed695ca --- /dev/null +++ b/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 + +// 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} diff --git a/ws2019/ipi/uebungen/listclass.cpp b/ws2019/ipi/uebungen/listclass.cpp new file mode 100644 index 0000000..78a7dc8 --- /dev/null +++ b/ws2019/ipi/uebungen/listclass.cpp @@ -0,0 +1,210 @@ +#include + +// 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; +} diff --git a/ws2019/la/uebungen/la9.pdf b/ws2019/la/uebungen/la9.pdf new file mode 100644 index 0000000..f736429 Binary files /dev/null and b/ws2019/la/uebungen/la9.pdf differ diff --git a/ws2019/la/uebungen/la9.tex b/ws2019/la/uebungen/la9.tex new file mode 100644 index 0000000..7572256 --- /dev/null +++ b/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}