## High Frequency Signal

Frequency content of a signal would be symmetric around a target frequency \(f_{c}\), and most of the energy will go from \(f_{c} \pm \frac{1}{T}\). Strictly speaking, you maybe leaking some energy outside the band.

### energy of signal

\begin{equation} \varepsilon_{1} = \frac{1}{T} \int_{0}^{T} y^{2}(t) \dd{t} \end{equation}

if \(\varepsilon_{s} > \varepsilon_{T}\), then decode \(1\). Otherwise, \(\epsilon_{1} < \epsilon_{T}\), decode \(0\).

## Hamming Distance

the Hamming Distance between two sequences is the number of positions in which these two sequences differ from each other

## error-correction code

an error-correction code is a collection of binary strings called “codewords”

- size of the code: numer of codewords \(M\) (\(M=2\) for repetition codes), we want this to be large because — the number of bits that the code can encode is \(\log_{2} M\), because that’s the number of combinations of a binary bit \(\log_{2} M\) which you can encode with a thing of size \(M\)
- length of the code: the length of each codeword \(L\) (\(M =3\) for repetition codes), we want this to be small to be efficient
- minimum distance of the code: the minimum distance between any two codewords in the code \(d_{c}\) (measure by Hamming Distance, repetition codes its 3), we want this high

### minimum codeword size

Key question: *assume we want to correct \(t\) bit flips; what is the minimum distance \(d_{c}\) we will need?

Note that if we had \(t\) bit flips, we would have a Hamming Distance of \(t\) bitflips. So, we will need at least \(d_{c} = 2t + 1\) away to disambiguate exactly (if you have a distance of just \(t+1\), you will not be able to tell a code that’s exactly in line with your error, \(t+1\) away, if your code error had a Hamming Distance of \(t\)).

formally:

- an error correction code can correct \(t\) errors its minimum distance is \(d_{c} \geq 2t+1\); meaning if you have a code error \(d_{c}\), we can correct up to \(t = \left\lfloor \frac{d_{c}-1}{2}\right\rfloor\)
- a code can
**detect**\(t\) errors \(d_{c} \geq t+1\), meaning we can’t accidentally end up with a random codeword

### linear code

In a linear code, if you XOR two codes, you will get another codeword.

### rate (error correction code)

\begin{equation} R = \frac{\log_{2} M}{L} \end{equation}

We want the rate to be as high as possible.

### repetition code

Literally send it multiple times

Message | Code |
---|---|

0 | 0 0 0 |

1 | 1 1 1 |

Then, you look at the three received bits and try to see what the most nearest legitimate codeword is.

By doing nearest neighbor (closest value) decoding, we