Affine ciphers

From: Neil Smith Date: Wed, 21 May 2014 17:19:22 +0000 (+0100) Subject: Fixed the merge conflict X-Git-Url: https://git.njae.me.uk/?a=commitdiff_plain;h=ee8bb0b7953e32c988f4faa72c0eb4c6cd6e4ea8;hp=c66d9937e6ce523f9db7602997ad5e2924dfd7ec;p=cipher-training.git Fixed the merge conflict --- diff --git a/cipher.sublime-project b/cipher.sublime-project index 2c63c08..c051f12 100644 --- a/cipher.sublime-project +++ b/cipher.sublime-project @@ -1,2 +1,9 @@ { + "folders": + [ + { + "follow_symlinks": true, + "path": "slides" + } + ] } diff --git a/slides/affine-break.html b/slides/affine-break.html new file mode 100644 index 0000000..cca64e8 --- /dev/null +++ b/slides/affine-break.html @@ -0,0 +1,91 @@ + + + + Affine ciphers + + + + + + + + + + + + diff --git a/slides/affine-encipher.html b/slides/affine-encipher.html new file mode 100644 index 0000000..1a09109 --- /dev/null +++ b/slides/affine-encipher.html @@ -0,0 +1,234 @@ + + + + Affine ciphers + + + + +

+
+# Affine ciphers
+
+a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
+--|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|--
+b | e | h | k | n | q | t | w | z | c | f | i | l | o | r | u | x | a | d | g | j | m | p | s | v | y
+
+An extension of Caesar ciphers
+
+* Count the gaps in the letters.
+
+---
+# How affine ciphers work
+
+_ciphertext_letter_ =_plaintext_letter_ Ã a + b
+
+* Convert letters to numbers
+* Take the total modulus 26
+
+# Enciphering is easy
+
+* Build the `affine_encipher()` function
+
+---
+
+# Deciphering affine ciphers is harder
+
+`$$p = \frac{c - b}{a} \mod 26$$`
+
+But modular division is hard!
+
+Define division as mutiplication by the inverse: `$\frac{x}{y} = x \times \frac{1}{y} = x \times y^{-1}$`
+
+A number _x_, when multiplied by its inverse _x_-1, gives result of 1.
+
+This is not always defined in modular arithmetic. For instance, 7 Ã 4 = 28 = 2 mod 26, but 20 Ã 4 = 80 = 2 mod 26. Therefore, 4 doesn't have a multiplicative inverse (and therefore makes a bad key for affine ciphers).
+
+Result from number theory: only numbers coprime with _n_ have multiplicative inverses in arithmetic mod _n_.
+
+Another result from number theory: for non-negative integers _a_ and _n_, and there exist unique integers _x_ and _y_ such that _ax_ + _ny_ = gcd(_a_, _b_)
+
+Coprime numbers have gcd of 1.
+
+_ax_ + _ny_ = 1 mod _n_. But _ny_ mod _n_ = 0, so _ax_ = 1 mod _n_, so _a_ = _x_-1.
+
+Perhaps the algorithm for finding gcds could be useful?
+
+---
+
+# Euclid's algorithm
+
+.float-right[![right-aligned GCD](gcd.svg)]
+
+World's oldest algorithm.
+
+_a_ = _qb_ + _r_ ; gcd(_a_, _b_) = gcd(_qb_ + _r_, _b_) = gcd(_r_, _b_) = gcd(_b_, _r_)
+
+Repeatedly apply these steps until _r_ = 0, when the other number = gcd(a,b). For instance, _a_ = 81, _b_ = 57
+
+* 81 = 1 Ã 57 + 24
+* 57 = 2 Ã 24 + 9
+* 24 = 2 Ã 9 + 6
+* 9 = 1 Ã 6 + 3
+* 6 = 2 Ã 3 + 0
+
+Therefore, gcd(81, 57) = 3 and 81_x_ + 57_y_ = 3
+
+Now unfold the derivation to find _x_ and _y_
+
+* 3 = 9 Ã 1 + 6 Ã -1
+* 3 = 9 Ã 1 + (24 - 2 Ã 9) Ã -1 = 9 Ã 3 + 24 Ã -1
+* 3 = (57 - 2 Ã 24) Ã 3 + 24 Ã -1 = 57 Ã 3 + 24 Ã -7
+* 3 = 57 Ã 3 + (81 - 57 Ã 1) Ã -7 = 57 Ã 10 + 81 Ã -7 
+
+Can we do this in one pass?
+
+---
+
+# Hands up if you're lost
+
+## (Be honest)
+
+---
+
+# Triple constraints
+
+## Fast, cheap, good: pick two
+
+## Programmer time, execution time, space: pick one, get some of another.
+
+(Scripting languages like Python are popular because they reduce programmer time. Contrast with Java and Pascal.)
+
+Extended Euclid's algorithm has lots of programmer time (and risk of bugs), but will take virtually no space (6 numbers).
+
+Can we trade space for ease?
+
+A standard technique is memoisation: store the results somewhere, then just look them up.
+
+---
+
+# Modular multiplication table for 7
+
+(7) | 0 | 1 | 2 | 3 | 4 | 5 | 6
+----|---|---|---|---|---|---|---
+ 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0
+ 1 | 0 | 1 | 2 | 3 | 4 | 5 | 6
+ 2 | 0 | 2 | 4 | 6 | 1 | 3 | 5
+ 3 | 0 | 3 | 6 | 2 | 5 | 1 | 4
+ 4 | 0 | 4 | 1 | 5 | 2 | 6 | 3
+ 5 | 0 | 5 | 3 | 1 | 6 | 4 | 2
+ 6 | 0 | 6 | 5 | 4 | 3 | 2 | 1
+
+Can use this to find the multiplicative inverses.
+
+(7) | 1 | 2 | 3 | 4 | 5 | 6
+----|---|---|---|---|---|---
+ | 1 | 4 | 5 | 2 | 3 | 6
+
+How much to store?
+
+---
+
+# How much to store?
+
+1. The inverses for this modular base.
+2. The inverses for all bases (12 of them)
+3. All the _x_ Ã· _y_ = _z_ mod _n_ triples...
+4. ...for all _n_
+5. The decipherment table for this key
+6. The decipherment table for all keys
+
+The choice is a design decision, taking into account space needed, time to create and use, expected use patterns, etc. 
+
+## Thoughts?
+
+---
+
+# How much to store?
+
+Keeping the decipherment close to encipherment seems aesthetically better to me. 
+
+Giving the ability to do division is the most obvious (to me).
+
+As there are only a few possible modular bases, might as well calculate the whole table at startup.
+
+## Now implement affine decipherment.
+
+Check both enciphering and deciphering work. Round-trip some text. 
+---
+
+# Counting from 0 or 1
+
+When converting letters to numbers, we're using the range 0-25.
+
+Another convention is to use numbers in range 1-26.
+
+Implement this.
+
+* You'll need another parameter:
+```python
+affine_encipher_letter(letter, multiplier, adder, one_based=False)
+```
+
+

+ + + + + + + diff --git a/slides/aims.html b/slides/aims.html new file mode 100644 index 0000000..fcf0c70 --- /dev/null +++ b/slides/aims.html @@ -0,0 +1,76 @@ + + + + Aims + + + + + + + + + \ No newline at end of file diff --git a/slides/alternative-plaintext-scoring.html b/slides/alternative-plaintext-scoring.html new file mode 100644 index 0000000..d6f4aa1 --- /dev/null +++ b/slides/alternative-plaintext-scoring.html @@ -0,0 +1,244 @@ + + + + Alternative plaintext scoring + + + + +

+
+# Alternative plaintext scoring methods
+
+---
+
+# Back to frequency of letter counts
+
+Letter | Count
+-------|------
+a | 489107
+b | 92647
+c | 140497
+d | 267381
+e | 756288
+. | .
+. | .
+. | .
+z | 3575
+
+Another way of thinking about this is a 26-dimensional vector. 
+
+Create a vector of our text, and one of idealised English. 
+
+The distance between the vectors is how far from English the text is.
+
+---
+
+# Vector distances
+
+.float-right[![right-aligned Vector subtraction](vector-subtraction.svg)]
+
+Several different distance measures (__metrics__, also called __norms__):
+
+* L2 norm (Euclidean distance): 
+`$\|\mathbf{a} - \mathbf{b}\| = \sqrt{\sum_i (\mathbf{a}_i - \mathbf{b}_i)^2} $`
+
+* L1 norm (Manhattan distance, taxicab distance): 
+`$\|\mathbf{a} - \mathbf{b}\| = \sum_i |\mathbf{a}_i - \mathbf{b}_i| $`
+
+* L3 norm: 
+`$\|\mathbf{a} - \mathbf{b}\| = \sqrt[3]{\sum_i |\mathbf{a}_i - \mathbf{b}_i|^3} $`
+
+The higher the power used, the more weight is given to the largest differences in components.
+
+(Extends out to:
+
+* L0 norm (Hamming distance): 
+`$$\|\mathbf{a} - \mathbf{b}\| = \sum_i \left\{
+\begin{matrix} 1 &\mbox{if}\ \mathbf{a}_i \neq \mathbf{b}_i , \\
+ 0 &\mbox{if}\ \mathbf{a}_i = \mathbf{b}_i \end{matrix} \right. $$`
+
+* L∞ norm: 
+`$\|\mathbf{a} - \mathbf{b}\| = \max_i{(\mathbf{a}_i - \mathbf{b}_i)} $`
+
+neither of which will be that useful here, but they keep cropping up.)
+---
+
+# Normalisation of vectors
+
+Frequency distributions drawn from different sources will have different lengths. For a fair comparison we need to scale them. 
+
+* Eucliean scaling (vector with unit length): `$$ \hat{\mathbf{x}} = \frac{\mathbf{x}}{\| \mathbf{x} \|} = \frac{\mathbf{x}}{ \sqrt{\mathbf{x}_1^2 + \mathbf{x}_2^2 + \mathbf{x}_3^2 + \dots } }$$`
+
+* Normalisation (components of vector sum to 1): `$$ \hat{\mathbf{x}} = \frac{\mathbf{x}}{\| \mathbf{x} \|} = \frac{\mathbf{x}}{ \mathbf{x}_1 + \mathbf{x}_2 + \mathbf{x}_3 + \dots }$$`
+
+---
+
+# Angle, not distance
+
+Rather than looking at the distance between the vectors, look at the angle between them.
+
+.float-right[![right-aligned Vector dot product](vector-dot-product.svg)]
+
+Vector dot product shows how much of one vector lies in the direction of another: 
+`$ \mathbf{A} \bullet \mathbf{B} = 
+\| \mathbf{A} \| \cdot \| \mathbf{B} \| \cos{\theta} $`
+
+But, 
+`$ \mathbf{A} \bullet \mathbf{B} = \sum_i \mathbf{A}_i \cdot \mathbf{B}_i $`
+and `$ \| \mathbf{A} \| = \sum_i \mathbf{A}_i^2 $`
+
+A bit of rearranging give the cosine simiarity:
+`$$ \cos{\theta} = \frac{ \mathbf{A} \bullet \mathbf{B} }{ \| \mathbf{A} \| \cdot \| \mathbf{B} \| } = 
+\frac{\sum_i \mathbf{A}_i \cdot \mathbf{B}_i}{\sum_i \mathbf{A}_i^2 \times \sum_i \mathbf{B}_i^2} $$`
+
+This is independent of vector lengths!
+
+Cosine similarity is 1 if in parallel, 0 if perpendicular, -1 if antiparallel.
+
+---
+
+# Which is best?
+
+ | Euclidean | Normalised
+---|-----------|------------ 
+L1 | x | x
+L2 | x | x
+L3 | x | x
+Cosine | x | x
+
+And the probability measure!
+
+* Nine different ways of measuring fitness.
+
+## Computing is an empircal science
+
+Let's do some experiments to find the best solution!
+
+---
+
+# Experimental harness
+
+## Step 1: build some other scoring functions
+
+We need a way of passing the different functions to the keyfinding function.
+
+## Step 2: find the best scoring function
+
+Try them all on random ciphertexts, see which one works best.
+
+---
+
+# Functions are values!
+
+```python
+>>> Pletters
+<function Pletters at 0x7f60e6d9c4d0>
+```
+
+```python
+def caesar_break(message, fitness=Pletters):
+ """Breaks a Caesar cipher using frequency analysis
+...
+ for shift in range(26):
+ plaintext = caesar_decipher(message, shift)
+ fit = fitness(plaintext)
+```
+
+---
+
+# Changing the comparison function
+
+* Must be a function that takes a text and returns a score
+ * Better fit must give higher score, opposite of the vector distance norms
+
+```python
+def make_frequency_compare_function(target_frequency, frequency_scaling, metric, invert):
+ def frequency_compare(text):
+ ...
+ return score
+ return frequency_compare
+```
+
+---
+
+# Data-driven processing
+
+```python
+metrics = [{'func': norms.l1, 'invert': True, 'name': 'l1'}, 
+ {'func': norms.l2, 'invert': True, 'name': 'l2'},
+ {'func': norms.l3, 'invert': True, 'name': 'l3'},
+ {'func': norms.cosine_similarity, 'invert': False, 'name': 'cosine_similarity'}]
+scalings = [{'corpus_frequency': normalised_english_counts, 
+ 'scaling': norms.normalise,
+ 'name': 'normalised'},
+ {'corpus_frequency': euclidean_scaled_english_counts, 
+ 'scaling': norms.euclidean_scale,
+ 'name': 'euclidean_scaled'}]
+```
+
+Use this to make all nine scoring functions.
+
+
+

+ + + + + + + diff --git a/slides/c1a_frequency_histogram.png b/slides/c1a_frequency_histogram.png new file mode 100644 index 0000000..7ccbd42 Binary files /dev/null and b/slides/c1a_frequency_histogram.png differ diff --git a/slides/caesar-break.html b/slides/caesar-break.html new file mode 100644 index 0000000..5ea77b9 --- /dev/null +++ b/slides/caesar-break.html @@ -0,0 +1,317 @@ + + + + Breaking caesar ciphers + + + + +

+
+# Breaking caesar ciphers
+
+![center-aligned Caesar wheel](caesarwheel1.gif)
+
+---
+
+# Human vs Machine
+
+Slow but clever vs Dumb but fast
+
+## Human approach
+
+Ciphertext | Plaintext 
+---|---
+![left-aligned Ciphertext frequencies](c1a_frequency_histogram.png) | ![left-aligned English frequencies](english_frequency_histogram.png) 
+
+---
+
+# Human vs machine
+
+## Machine approach
+
+Brute force. 
+
+Try all keys.
+
+* How many keys to try?
+
+## Basic idea
+
+```
+for each key:
+ decipher with this key
+ how close is it to English?
+ remember the best key
+```
+
+What steps do we know how to do?
+
+---
+# How close is it to English?
+
+What does English look like?
+
+* We need a model of English.
+
+How do we define "closeness"?
+
+---
+
+# What does English look like?
+
+## Abstraction: frequency of letter counts
+
+Letter | Count
+-------|------
+a | 489107
+b | 92647
+c | 140497
+d | 267381
+e | 756288
+. | .
+. | .
+. | .
+z | 3575
+
+Use this to predict the probability of each letter, and hence the probability of a sequence of letters. 
+
+---
+
+# An infinite number of monkeys
+
+What is the probability that this string of letters is a sample of English?
+
+## Naive Bayes, or the bag of letters
+
+Ignore letter order, just treat each letter individually.
+
+Probability of a text is `$ \prod_i p_i $`
+
+Letter | h | e | l | l | o | hello
+------------|---------|---------|---------|---------|---------|-------
+Probability | 0.06645 | 0.12099 | 0.04134 | 0.04134 | 0.08052 | 1.10648239 Ã 10-6
+
+Letter | i | f | m | m | p | ifmmp
+------------|---------|---------|---------|---------|---------|-------
+Probability | 0.06723 | 0.02159 | 0.02748 | 0.02748 | 0.01607 | 1.76244520 Ã 10-8
+
+(Implmentation issue: this can often underflow, so get in the habit of rephrasing it as `$ \sum_i \log p_i $`)
+
+Letter | h | e | l | l | o | hello
+------------|---------|---------|---------|---------|---------|-------
+Probability | -1.1774 | -0.9172 | -1.3836 | -1.3836 | -1.0940 | -5.956055
+
+
+---
+
+# Frequencies of English
+
+But before then how do we count the letters?
+
+* Read a file into a string
+```python
+open()
+.read()
+```
+* Count them
+```python
+import collections
+```
+
+Create the `language_models.py` file for this.
+
+---
+
+# Canonical forms
+
+Counting letters in _War and Peace_ gives all manner of junk.
+
+* Convert the text in canonical form (lower case, accents removed, non-letters stripped) before counting
+
+```python
+[l.lower() for l in text if ...]
+```
+---
+
+# Accents
+
+```python
+>>> 'Ã©' in string.ascii_letters
+>>> 'e' in string.ascii_letters
+```
+
+## Unicode, combining codepoints, and normal forms
+
+Text encodings will bite you when you least expect it.
+
+- **Ã©** : LATIN SMALL LETTER E WITH ACUTE (U+00E9)
+
+- **e** + ** ́** : LATIN SMALL LETTER E (U+0065) + COMBINING ACUTE ACCENT (U+0301)
+
+* urlencoding is the other pain point.
+
+---
+
+# Five minutes on StackOverflow later...
+
+```python
+def unaccent(text):
+ """Remove all accents from letters. 
+ It does this by converting the unicode string to decomposed compatibility
+ form, dropping all the combining accents, then re-encoding the bytes.
+
+ >>> unaccent('hello')
+ 'hello'
+ >>> unaccent('HELLO')
+ 'HELLO'
+ >>> unaccent('hÃ©llo')
+ 'hello'
+ >>> unaccent('hÃ©llÃ¶')
+ 'hello'
+ >>> unaccent('HÃLLÃ')
+ 'HELLO'
+ """
+ return unicodedata.normalize('NFKD', text).\
+ encode('ascii', 'ignore').\
+ decode('utf-8')
+```
+
+---
+
+# Find the frequencies of letters in English
+
+1. Read from `shakespeare.txt`, `sherlock-holmes.txt`, and `war-and-peace.txt`.
+2. Find the frequencies (`.update()`)
+3. Sort by count 
+4. Write counts to `count_1l.txt` (`'text{}\n'.format()`)
+
+---
+
+# Reading letter probabilities
+
+1. Load the file `count_1l.txt` into a dict, with letters as keys.
+
+2. Normalise the counts (components of vector sum to 1): `$$ \hat{\mathbf{x}} = \frac{\mathbf{x}}{\| \mathbf{x} \|} = \frac{\mathbf{x}}{ \mathbf{x}_1 + \mathbf{x}_2 + \mathbf{x}_3 + \dots }$$`
+ * Return a new dict
+ * Remember the doctest!
+
+3. Create a dict `Pl` that gives the log probability of a letter
+
+4. Create a function `Pletters` that gives the probability of an iterable of letters
+ * What preconditions should this function have?
+ * Remember the doctest!
+
+---
+
+# Breaking caesar ciphers
+
+## Remember the basic idea
+
+```
+for each key:
+ decipher with this key
+ how close is it to English?
+ remember the best key
+```
+
+Try it on the text in `2013/1a.ciphertext`. Does it work?
+
+---
+
+# Aside: Logging
+
+Better than scattering `print()`statements through your code
+
+```python
+import logging
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.FileHandler('cipher.log'))
+logger.setLevel(logging.WARNING)
+
+ logger.debug('Caesar break attempt using key {0} gives fit of {1} '
+ 'and decrypt starting: {2}'.format(shift, fit, plaintext[:50]))
+
+```
+* Yes, it's ugly.
+
+Use `logger.setLevel()` to change the level: CRITICAL, ERROR, WARNING, INFO, DEBUG
+
+Use `logger.debug()`, `logger.info()`, etc. to log a message.
+
+---
+
+# How much ciphertext do we need?
+
+## Let's do an experiment to find out
+
+1. Load the whole corpus into a string (sanitised)
+2. Select a random chunk of plaintext and a random key
+3. Encipher the text
+4. Score 1 point if `caesar_cipher_break()` recovers the correct key
+5. Repeat many times and with many plaintext lengths
+
+
+

+ + + + + + + diff --git a/slides/caesar-encipher.html b/slides/caesar-encipher.html new file mode 100644 index 0000000..3bc519c --- /dev/null +++ b/slides/caesar-encipher.html @@ -0,0 +1,192 @@ + + + + Caesar cipher + + + + +

+
+# Caesar ciphers
+
+![centre-aligned Caesar wheel](caesarwheel1.gif)
+
+Letter-by-letter enciphering
+
+---
+
+# Enciphering and deciphering
+
+## Arithmetic on letters
+
+Convert .plaintext[letter] â .plaintext[number] â 
+.ciphertext[number] â .ciphertext[letter]
+
+Functions you will need
+
+```python
+ord()
+
+chr()
+
+%
+```
+
+* What are good test cases?
+
+---
+
+# The [string module](http://docs.python.org/3.3/library/string.html) is your friend
+
+```python
+import string
+
+string.ascii_letters
+string.ascii_lowercase
+string.ascii_uppercase
+string.digits
+string.punctuation
+```
+
+---
+# DRY and YAGNI
+
+Is your code DRY?
+
+---
+
+# Doctest
+
+* Why document?
+* Why test?
+
+```python
+def caesar_encipher_letter(letter, shift):
+    """Encipher a letter, given a shift amount
+
+    >>> caesar_encipher_letter('a', 1)
+    'b'
+    """
+    if letter in string.ascii_letters:
+    .
+    .
+    .
+```
+
+---
+
+# The magic doctest incantation
+
+```python
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()
+```
+
+---
+
+# Doing all the letters
+
+## Test-first developement
+
+1. Write the tests.
+    * They will fail. There is no code.
+2. Write code until the tests pass.
+3. Refactor.
+
+---
+
+# Doing all the letters
+
+## Abysmal
+
+```python
+ciphertext = ''
+for i in range(len(plaintext)):
+    ciphertext += caesar_encipher_letter(plaintext[i], key)
+```
+
+---
+
+# Doing all the letters
+
+## Bad
+
+```python
+ciphertext = ''
+for p in plaintext:
+    ciphertext += caesar_encipher_letter(p, key)
+```
+
+...but easily generalisable
+
+---
+
+# Doing all the letters
+
+## Good (but unPythonic)
+
+```python
+ciphertext = map(lambda p: caesar_encipher_letter(p, key), plaintext)
+```
+
+---
+
+# Doing all the letters
+
+## Best
+
+```python
+ciphertext = [caesar_encipher_letter(p, key) for p in plaintext]
+```
+---
+
+# Not all iterables are equal
+
+```python
+''.join()
+```
+
+

+ + + + \ No newline at end of file diff --git a/slides/caesarwheel1.gif b/slides/caesarwheel1.gif new file mode 100644 index 0000000..05da1b7 Binary files /dev/null and b/slides/caesarwheel1.gif differ diff --git a/slides/english_frequency_histogram.png b/slides/english_frequency_histogram.png new file mode 100644 index 0000000..3ab182e Binary files /dev/null and b/slides/english_frequency_histogram.png differ diff --git a/slides/gcd.svg b/slides/gcd.svg new file mode 100644 index 0000000..80f8256 --- /dev/null +++ b/slides/gcd.svg @@ -0,0 +1,344 @@ + + + \ No newline at end of file diff --git a/slides/keyword-encipher.html b/slides/keyword-encipher.html new file mode 100644 index 0000000..7258e9c --- /dev/null +++ b/slides/keyword-encipher.html @@ -0,0 +1,198 @@ + + + + Affine ciphers + + + + +

+
+# Keyword ciphers
+
+a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
+--|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|--
+k | e | y | w | o | r | d | a | b | c | f | g | h | i | j | l | m | n | p | q | s | t | u | v | x | z
+
+* Taking a more Pythonic approach
+
+---
+
+# The cipher
+
+* Still character-by-character substitution, still monosubstitution.
+
+Ciphertext alphabet: start with a keyword, write out the rest of the alphabet, removing duplicates.
+
+## Three variants
+
+Write out the rest of the alphabet...
+
+1. ...starting from 'a' (keywordabcf...)
+2. ...starting from the last letter of the keyword (keywordfgh...)
+3. ...starting from the largest letter of the keyword (keywordzabc...)
+
+---
+
+# A more Pythonic way
+
+_string_`.translate()` and _string_`.maketrans()`
+
+* Make the 'ciphertext' alphabet, relate to the 'plaintext' alphabet (`string.ascii_lowercase`)
+* Use those to make the translation table
+* Enciphering is simply applying `plaintext.translate(enciphering_table)`
+* Deciphering just uses a different table
+
+---
+
+# Making the cipher alphabet from a keyword
+
+Three challenges:
+
+1. How to say which type of cipher alphabet to use
+2. Where to start the rest of the alphabet
+3. Removing duplicate letters
+
+Solutions:
+
+1. Keyword arguments for procedures
+2. sort and slices
+3. Use something like an ordered set
+
+Both enciphering and deciphering need the same keyword-based alphabet, so pull this out into another procedure.
+
+---
+
+# Keyword arguments
+
+Used to:
+1. give a default value for a parameter
+2. allow parameters to be named (not just positional)
+
+Give our `keyword_encipher` and `keyword_decipher` procedures a keyword parameter of `wrap_alphabet`.
+
+Pass this parameter to the `keyword_alphabet` procedure.
+
+## Note: `Enum` introduced in Python 3.4. This is a better solution. 
+
+---
+
+# Deduplicating a sequence
+
+We need
+
+* Something set-like
+* Something ordered
+
+No ordered set in Python, but do have an ordered dict.
+
+* Keys of a dict are a set. 
+* Keys in an ordered dict retain their order (subsequent instances are ignored)
+
+`deduplicated_list = list(collections.OrderedDict.fromkeys(list))`
+
+---
+
+# Sorts and slices
+
+## Recap 
+Write out the rest of the alphabet...
+
+1. ...starting from 'a' (keywordabcf...)
+2. ...starting from the last letter of the keyword (keywordfgh...)
+3. ...starting from the largest letter of the keyword (keywordzabc...)
+
+* Santitise the keyword before we use it
+
+## Cases
+1. As we're deduplicating anyway, just add the entire alphabet to the end of the keyword, then deduplicate. 
+`deduplicate(keyword + string.ascii_lowercase)`
+
+2. and 3. How to find the appropriate letter of the keyword.
+
+Indexing pulls out letters. `'keyword'[0]` = 'k' ; `'keyword'[3]` = 'w' ; `'keyword'[-1]` = 'd'
+Slices pulls out substrings. `'keyword'[1:4]` = 'eyw' ; `'keyword'[:3]` = 'key' ; `'keyword'[5:]` = 'rd'
+
+`deduplicate(keyword + string_ascii_lowercase[from:] + string.ascii_lowercase)`
+
+Question: why not take a slice of the second alphabet copy?
+
+Question: what do we use as the last letter of 'character'? 'r' or 'e'?
+
+`sorted()` will put a string in lexicographical order.
+`.find()` will find an item in a sequence
+
+---
+
+# Keyword enciphering
+
+Now we've got the keyword-based cipher alphabet, simply use `.translate()` to do the enciphering/deciphering.
+
+Use `''.maketrans()` to make the translation table.
+
+Sorted!
+
+Does it pass the tests?
+
+

+ + + + + + + diff --git a/slides/vector-dot-product.svg b/slides/vector-dot-product.svg new file mode 100644 index 0000000..05d69c1 --- /dev/null +++ b/slides/vector-dot-product.svg @@ -0,0 +1,324 @@ + + \ No newline at end of file diff --git a/slides/vector-subtraction.svg b/slides/vector-subtraction.svg new file mode 100644 index 0000000..325257f --- /dev/null +++ b/slides/vector-subtraction.svg @@ -0,0 +1,217 @@ + + \ No newline at end of file