diff --git a/correction.bib b/correction.bib
index 7cfafff..600245a 100644
--- a/correction.bib
+++ b/correction.bib
@@ -5,4 +5,45 @@
   url = "https://en.wikipedia.org/w/index.php?title=Signal-to-noise_ratio&oldid=1334458479",
   note = "[Online; accessed 16-February-2026]"
 }
-
+  @misc{ enwiki:convolutional,
+    author = "{Wikipedia contributors}",
+    title = "Convolutional code --- {Wikipedia}{,} The Free Encyclopedia",
+    year = "2026",
+    url = "https://en.wikipedia.org/w/index.php?title=Convolutional_code&oldid=1353119167",
+    note = "[Online; accessed 6-July-2026]"
+  }
+@misc{ enwiki:gilbert-varshamov,
+  author = "{Wikipedia contributors}",
+  title = "Gilbert–Varshamov bound --- {Wikipedia}{,} The Free Encyclopedia",
+  year = "2025",
+  url = "https://en.wikipedia.org/w/index.php?title=Gilbert%E2%80%93Varshamov_bound&oldid=1329330572",
+  note = "[Online; accessed 7-July-2026]"
+}
+@misc{ enwiki:hamming-distance,
+  author = "{Wikipedia contributors}",
+  title = "Hamming distance --- {Wikipedia}{,} The Free Encyclopedia",
+  year = "2025",
+  url = "https://en.wikipedia.org/w/index.php?title=Hamming_distance&oldid=1320319980",
+  note = "[Online; accessed 7-July-2026]"
+}
+@misc{ enwiki:cyclic,
+  author = "{Wikipedia contributors}",
+  title = "Cyclic code --- {Wikipedia}{,} The Free Encyclopedia",
+  year = "2026",
+  url = "https://en.wikipedia.org/w/index.php?title=Cyclic_code&oldid=1362628486",
+  note = "[Online; accessed 7-July-2026]"
+}
+@misc{ enwiki:crc,
+  author = "{Wikipedia contributors}",
+  title = "Cyclic redundancy check --- {Wikipedia}{,} The Free Encyclopedia",
+  year = "2026",
+  url = "https://en.wikipedia.org/w/index.php?title=Cyclic_redundancy_check&oldid=1360762341",
+  note = "[Online; accessed 7-July-2026]"
+}
+@misc{ enwiki:reed-solomon,
+  author = "{Wikipedia contributors}",
+  title = "Reed–Solomon error correction --- {Wikipedia}{,} The Free Encyclopedia",
+  year = "2026",
+  url = "https://en.wikipedia.org/w/index.php?title=Reed%E2%80%93Solomon_error_correction&oldid=1360527569",
+  note = "[Online; accessed 7-July-2026]"
+}
diff --git a/correction.tex b/correction.tex
index 14de523..e65ff35 100644
--- a/correction.tex
+++ b/correction.tex
@@ -18,7 +18,9 @@
 \usepackage[style=ieee, backend=biber, maxnames=1, minnames=1]{biblatex}
 \addbibresource{correction.bib}
 
+\newcommand{\red}[1]{\textcolor{red}{#1}}
 \newacronym{snr}{SNR}{signal-to-noise ratio}
+\newacronym{crc}{CRC}{Cyclic Redundancy Check}
 
 
 
@@ -39,7 +41,7 @@ i.e. more errors per intended information will require more effort to retain the
 \[ \mathrm{SNR} = \frac{P_{signal}}{P_{noise}} \]
 In an analog system, one might attempt to simply increase transmission power $P_{signal}$
 as is done for example in professional audio equipment.
-This would however require the modification of the transmission channel itself, which is not possible for e.g. wireless transmissions.
+This would however require the modification of the transmission channel itself, which is only feasible to a certain degree.
 
 In a digital system, we could understand \acrshort{snr} as the probability of a bit being flipped in transit.
 For example, if a binary message is sent electronically, with a 1 being represented by a voltage of one volt
@@ -55,24 +57,24 @@ However, there generally remains a chance that an intended 1 will be received as
 In this digital system, we can improve communication reliability by using a coding scheme that is tolerant of errors.
 As a naive approach, we will simply transmit our message multiple times.
 This is called a \textit{repetition code}, where the receiver will perform a majority vote over the received bits,
-resulting in the following
+resulting in error detection for 2 bits used, and error correction for 3+ bits used.
 
 \begin{figure}[H]
 \begin{minipage}{.5\textwidth}
     \begin{tabular}{c|ccc}
-        recieved & 0 & \textcolor{red}{1} & 2 \\
+        received & 0 & \textcolor{red}{1} & 2 \\
         \hline
         read & 0 & ERR &  1 \\
     \end{tabular}
 
     \begin{tabular}{c|cccccccc}
-        recieved & 0 & \textcolor{red}{1} & \textcolor{red}{2} & 3 \\
+        received & 0 & \textcolor{red}{1} & \textcolor{red}{2} & 3 \\
         \hline
         read & 0 & 0 & 1 & 1  \\
     \end{tabular}
 
     \begin{tabular}{c|cccccccc}
-        recieved & 0 & \textcolor{red}{1} & \textcolor{red}{2} & \textcolor{red}{3} & 4 \\
+        received & 0 & \textcolor{red}{1} & \textcolor{red}{2} & \textcolor{red}{3} & 4 \\
         \hline
         read & 0 & 0 & ERR & 1 & 1 \\
     \end{tabular}
@@ -106,11 +108,99 @@ resulting in the following
 
 
 
-\section{Hamming Condition}
-theorems: Hamming condition, Varsham-Gilbert
-Shannon-Hartley
-Convolutional Code
-Reed-Solomon
-CRC
+\subsection{Mathematical Bounds}
+In general, the amount of errors a code can detect or correct
+is determined by the Hamming distance $h$ defined as the number of positions in which neighboring strings (code words) differ.
+
+"Karolin" and "Kerstin" differ in 3 letters and thus have a Hamming distance of $h=3$, just as the binary example.
+In general, a code is said to have a Hamming distance of $h$ if it is the minimal pairwise distance of all codewords.
+Given a Hamming distance of $h$, $(h-1)$ errors can be detected, to correct $r$ errors a minimum distance of $h\geq 2r+1$ is required.
+This is analogous to the repetition code already shown in \autoref{tab:detection-correction},
+as the length of our repetition code is directly equivalent to the hamming distance.
+
+The Hamming distance of a code is then defined as the minimum pairwise distance between any two code words.
+From it, minimal detection and correction capabilities follow according to the above rules.
+\cite{enwiki:hamming-distance}
+
+Given a $q$-ary code with length $n$ and minimum Hamming distance $d$, the Gilbert-Varshamov bound provides a bound for the size of
+the resulting code, i.e. the number of available code words given the conditions.
+Let $\mathcal{A}_q(n,d)$ be the maximum possible size of said code, then the Gilbert-Varshamov bound consists of
+$q^n$ as the number of total possible code words in a $q$-ary code of length n, divided by
+$\sum_{j=0}^{d-1} \binom{n}{j} (q-1)^j$, the size of a ball created around a code word by the required Hamming distance.
+\cite{enwiki:gilbert-varshamov}
+The ball is the geometric interpretation of the space created around each used code word by requiring a minimal hamming distance,
+i.e. requiring that no code word lie closer within the vector space.
+
+\begin{figure}[h]
+  \begin{minipage}{.3\textwidth}
+    \begin{tabular}{c|c}
+      karolin & 0111 \\
+      k\red{e}r\red{st}in & 0\red{000}
+    \end{tabular} 
+  \end{minipage}
+  \begin{minipage}{.3\textwidth}
+    \[
+    \mathcal{A}_q(n,d) \geq \frac{q^n}{\sum_{j=0}^{d-1} \binom{n}{j} (q-1)^j}
+    \]
+  \end{minipage}
+\end{figure}
+
+
+\section{Block Codes}
+% NOTE fact-check
+Block codes are \textit{memoryless}, meaning that each block is encoded independently using a static dictionary.
+
+\subsection{Cyclic Redundancy Check}
+A \acrfull{crc} is a method of detecting (correcting) errors by interpreting the information to be sent as a polynomial.
+They are particularly suited for the type of burst error common in storage media such as DVDs.
+Typically an $n$-bit \acrshort{crc} can detect any error burst of length $n$,
+with a chance of also detecting longer error bursts of approximately $1-2^{-n}$.
+
+Specification of a \acrshort{crc} code requires definition of a so-called \textit{generator polynomial}.
+It is used as the divisor in a polynomial division taking the message as the dividend.
+The remainder of $n$ bits is then appended to the message, thus requiring a generator polynomial of degree $n$ for the calculation.
+Because the division is calculated in a finite (also known as galois) field, so the operation can be performed
+bitwise-parallel, reducing to a simple bitwise \verb|XOR| in the binary case.
+
+One of the simplest error-detection systems besides a repetition code, the parity bit, is in fact a 1-bit \acrshort{crc}.
+Using the generator polynomial $g=x+1$ of degree 1 results in the well-known pattern of extending the code words to achieve
+an even number of 1s.
+\cite{enwiki:crc}
+
+\begin{figure}[H]
+  
+\begin{minipage}{0.7\textwidth}
+  To calculate the \acrshort{crc}-1, the message $100$ is first extended by $n$ 0s to $1000$.
+  It is then divided by the generator polynomial $g=x+1 \equiv (11_2)$, leaving a remainder of $1$.
+  Thus, the code word that should be transmitted is $1001$.
+  As a result, any 1-bit flip will be detected, allowing the receiver to request retransmission of the message.
+\end{minipage}
+\hspace{1cm}
+\begin{minipage}{0.2\textwidth}
+\begin{verbatim}
+  1000 : 11 = 111
+ :11
+ =010
+  :11
+  =010
+   :11
+    =1
+\end{verbatim}
+\end{minipage}
+\end{figure}
+
+\subsection{Reed-Solomon}
+Similar to \acrshort{crc}, a Reed-Solomon code also interprets the message as a polynomial.
+This polynomial of degree $k-1$ is uniquely identified by $k$ evaluation points.
+By transmitting $n>k$ points, a Reed-Solomon code can detect $t=n-k$ errors or locate and correct up to $\lfloor t/2 \rfloor$ errors.
+
+Formally, the message will be $(a_1,a_2,...,a_k)$ coefficients of a polynomial
+\[
+f(x) = a_1 + a_2 x + a_3 x^2+...+a_k x^{k-1} = \sum_{i=1}^{k} a_i x^{i-1}
+\]
+\cite{enwiki:reed-solomon}
+
+\section{Convolutional Codes}
+
 \printbibliography
 \end{document}