Partly refactored
[cipher-tools.git] / cipher.py
index 6cce72543224f02468e8a7609b674d158d238127..2eb89f72306e30e4db99e539e36733aa792d13c4 100644 (file)
--- a/cipher.py
+++ b/cipher.py
@@ -2,632 +2,386 @@ import string
 import collections
 import math
 from enum import Enum
-from itertools import zip_longest, cycle, chain
+from itertools import zip_longest, cycle, chain, count
+import numpy as np
+from numpy import matrix
+from numpy import linalg
 from language_models import *
-
-
-modular_division_table = [[0]*26 for _ in range(26)]
-for a in range(26):
-    for b in range(26):
-        c = (a * b) % 26
-        modular_division_table[b][c] = a
-
-
-def every_nth(text, n, fillvalue=''):
-    """Returns n strings, each of which consists of every nth character, 
-    starting with the 0th, 1st, 2nd, ... (n-1)th character
-    
-    >>> every_nth(string.ascii_lowercase, 5)
-    ['afkpuz', 'bglqv', 'chmrw', 'dinsx', 'ejoty']
-    >>> every_nth(string.ascii_lowercase, 1)
-    ['abcdefghijklmnopqrstuvwxyz']
-    >>> every_nth(string.ascii_lowercase, 26) # doctest: +NORMALIZE_WHITESPACE
-    ['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']
-    >>> every_nth(string.ascii_lowercase, 5, fillvalue='!')
-    ['afkpuz', 'bglqv!', 'chmrw!', 'dinsx!', 'ejoty!']
+import pprint
+
+
+
+from utilities import *
+from segment import *
+
+from caesar import *
+from affine import *
+from keyword import *
+from polybius import *
+from column_transposition import *
+from railfence import *
+
+
+def make_cadenus_keycolumn(doubled_letters = 'vw', start='a', reverse=False):
+    """Makes the key column for a Cadenus cipher (the column down between the
+        rows of letters)
+
+    >>> make_cadenus_keycolumn()['a']
+    0
+    >>> make_cadenus_keycolumn()['b']
+    1
+    >>> make_cadenus_keycolumn()['c']
+    2
+    >>> make_cadenus_keycolumn()['v']
+    21
+    >>> make_cadenus_keycolumn()['w']
+    21
+    >>> make_cadenus_keycolumn()['z']
+    24
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['a']
+    1
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['b']
+    0
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['c']
+    24
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['i']
+    18
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['j']
+    18
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['v']
+    6
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['z']
+    2
+    """
+    index_to_remove = string.ascii_lowercase.find(doubled_letters[0])
+    short_alphabet = string.ascii_lowercase[:index_to_remove] + string.ascii_lowercase[index_to_remove+1:]
+    if reverse:
+        short_alphabet = cat(reversed(short_alphabet))
+    start_pos = short_alphabet.find(start)
+    rotated_alphabet = short_alphabet[start_pos:] + short_alphabet[:start_pos]
+    keycolumn = {l: i for i, l in enumerate(rotated_alphabet)}
+    keycolumn[doubled_letters[0]] = keycolumn[doubled_letters[1]]
+    return keycolumn
+
+def cadenus_encipher(message, keyword, keycolumn, fillvalue='a'):
+    """Encipher with the Cadenus cipher
+
+    >>> cadenus_encipher(sanitise('Whoever has made a voyage up the Hudson ' \
+                                  'must remember the Kaatskill mountains. ' \
+                                  'They are a dismembered branch of the great'), \
+                'wink', \
+                make_cadenus_keycolumn(doubled_letters='vw', start='a', reverse=True))
+    'antodeleeeuhrsidrbhmhdrrhnimefmthgeaetakseomehetyaasuvoyegrastmmuuaeenabbtpchehtarorikswosmvaleatned'
+    >>> cadenus_encipher(sanitise('a severe limitation on the usefulness of ' \
+                                  'the cadenus is that every message must be ' \
+                                  'a multiple of twenty-five letters long'), \
+                'easy', \
+                make_cadenus_keycolumn(doubled_letters='vw', start='a', reverse=True))
+    'systretomtattlusoatleeesfiyheasdfnmschbhneuvsnpmtofarenuseieeieltarlmentieetogevesitfaisltngeeuvowul'
     """
-    split_text = chunks(text, n, fillvalue)
-    return [''.join(l) for l in zip_longest(*split_text, fillvalue=fillvalue)]
+    rows = chunks(message, len(message) // 25, fillvalue=fillvalue)
+    columns = zip(*rows)
+    rotated_columns = [col[start:] + col[:start] for start, col in zip([keycolumn[l] for l in keyword], columns)]    
+    rotated_rows = zip(*rotated_columns)
+    transpositions = transpositions_of(keyword)
+    transposed = [transpose(r, transpositions) for r in rotated_rows]
+    return cat(chain(*transposed))
 
-def combine_every_nth(split_text):
-    """Reforms a text split into every_nth strings
-    
-    >>> combine_every_nth(every_nth(string.ascii_lowercase, 5))
-    'abcdefghijklmnopqrstuvwxyz'
-    >>> combine_every_nth(every_nth(string.ascii_lowercase, 1))
-    'abcdefghijklmnopqrstuvwxyz'
-    >>> combine_every_nth(every_nth(string.ascii_lowercase, 26))
-    'abcdefghijklmnopqrstuvwxyz'
+def cadenus_decipher(message, keyword, keycolumn, fillvalue='a'):
     """
-    return ''.join([''.join(l) 
-                    for l in zip_longest(*split_text, fillvalue='')])
-
-def chunks(text, n, fillvalue=None):
-    """Split a text into chunks of n characters
-
-    >>> chunks('abcdefghi', 3)
-    ['abc', 'def', 'ghi']
-    >>> chunks('abcdefghi', 4)
-    ['abcd', 'efgh', 'i']
-    >>> chunks('abcdefghi', 4, fillvalue='!')
-    ['abcd', 'efgh', 'i!!!']
+    >>> cadenus_decipher('antodeleeeuhrsidrbhmhdrrhnimefmthgeaetakseomehetyaa' \
+                         'suvoyegrastmmuuaeenabbtpchehtarorikswosmvaleatned', \
+                 'wink', \
+                 make_cadenus_keycolumn(reverse=True))
+    'whoeverhasmadeavoyageupthehudsonmustrememberthekaatskillmountainstheyareadismemberedbranchofthegreat'
+    >>> cadenus_decipher('systretomtattlusoatleeesfiyheasdfnmschbhneuvsnpmtof' \
+                        'arenuseieeieltarlmentieetogevesitfaisltngeeuvowul', \
+                 'easy', \
+                 make_cadenus_keycolumn(reverse=True))
+    'aseverelimitationontheusefulnessofthecadenusisthateverymessagemustbeamultipleoftwentyfiveletterslong'
     """
-    if fillvalue:
-        padding = fillvalue[0] * (n - len(text) % n)
+    rows = chunks(message, len(message) // 25, fillvalue=fillvalue)
+    transpositions = transpositions_of(keyword)
+    untransposed_rows = [untranspose(r, transpositions) for r in rows]
+    columns = zip(*untransposed_rows)
+    rotated_columns = [col[-start:] + col[:-start] for start, col in zip([keycolumn[l] for l in keyword], columns)]    
+    rotated_rows = zip(*rotated_columns)
+    # return rotated_columns
+    return cat(chain(*rotated_rows))
+
+
+def hill_encipher(matrix, message_letters, fillvalue='a'):
+    """Hill cipher
+
+    >>> hill_encipher(np.matrix([[7,8], [11,11]]), 'hellothere')
+    'drjiqzdrvx'
+    >>> hill_encipher(np.matrix([[6, 24, 1], [13, 16, 10], [20, 17, 15]]), \
+        'hello there')
+    'tfjflpznvyac'
+    """
+    n = len(matrix)
+    sanitised_message = sanitise(message_letters)
+    if len(sanitised_message) % n != 0:
+        padding = fillvalue[0] * (n - len(sanitised_message) % n)
     else:
         padding = ''
-    return [(text+padding)[i:i+n] for i in range(0, len(text), n)]
-
-def transpose(items, transposition):
-    """Moves items around according to the given transposition
-    
-    >>> transpose(['a', 'b', 'c', 'd'], (0,1,2,3))
-    ['a', 'b', 'c', 'd']
-    >>> transpose(['a', 'b', 'c', 'd'], (3,1,2,0))
-    ['d', 'b', 'c', 'a']
-    >>> transpose([10,11,12,13,14,15], (3,2,4,1,5,0))
-    [13, 12, 14, 11, 15, 10]
+    message = [pos(c) for c in sanitised_message + padding]
+    message_chunks = [message[i:i+n] for i in range(0, len(message), n)]
+    # message_chunks = chunks(message, len(matrix), fillvalue=None)
+    enciphered_chunks = [((matrix * np.matrix(c).T).T).tolist()[0] 
+            for c in message_chunks]
+    return cat([unpos(round(l))
+            for l in sum(enciphered_chunks, [])])
+
+def hill_decipher(matrix, message, fillvalue='a'):
+    """Hill cipher
+
+    >>> hill_decipher(np.matrix([[7,8], [11,11]]), 'drjiqzdrvx')
+    'hellothere'
+    >>> hill_decipher(np.matrix([[6, 24, 1], [13, 16, 10], [20, 17, 15]]), \
+        'tfjflpznvyac')
+    'hellothereaa'
     """
-    transposed = [''] * len(transposition)
-    for p, t in enumerate(transposition):
-       transposed[p] = items[t]
-    return transposed
+    adjoint = linalg.det(matrix)*linalg.inv(matrix)
+    inverse_determinant = modular_division_table[int(round(linalg.det(matrix))) % 26][1]
+    inverse_matrix = (inverse_determinant * adjoint) % 26
+    return hill_encipher(inverse_matrix, message, fillvalue)          
 
-def untranspose(items, transposition):
-    """Undoes a transpose
-    
-    >>> untranspose(['a', 'b', 'c', 'd'], [0,1,2,3])
-    ['a', 'b', 'c', 'd']
-    >>> untranspose(['d', 'b', 'c', 'a'], [3,1,2,0])
-    ['a', 'b', 'c', 'd']
-    >>> untranspose([13, 12, 14, 11, 15, 10], [3,2,4,1,5,0])
-    [10, 11, 12, 13, 14, 15]
-    """
-    transposed = [''] * len(transposition)
-    for p, t in enumerate(transposition):
-       transposed[t] = items[p]
-    return transposed
-
-def deduplicate(text):
-    return list(collections.OrderedDict.fromkeys(text))
-
-
-def caesar_encipher_letter(accented_letter, shift):
-    """Encipher a letter, given a shift amount
-
-    >>> caesar_encipher_letter('a', 1)
-    'b'
-    >>> caesar_encipher_letter('a', 2)
-    'c'
-    >>> caesar_encipher_letter('b', 2)
-    'd'
-    >>> caesar_encipher_letter('x', 2)
-    'z'
-    >>> caesar_encipher_letter('y', 2)
-    'a'
-    >>> caesar_encipher_letter('z', 2)
-    'b'
-    >>> caesar_encipher_letter('z', -1)
-    'y'
-    >>> caesar_encipher_letter('a', -1)
-    'z'
-    >>> caesar_encipher_letter('A', 1)
-    'B'
-    >>> caesar_encipher_letter('é', 1)
-    'f'
-    """
-    letter = unaccent(accented_letter)
-    if letter in string.ascii_letters:
-        if letter in string.ascii_uppercase:
-            alphabet_start = ord('A')
-        else:
-            alphabet_start = ord('a')
-        return chr(((ord(letter) - alphabet_start + shift) % 26) + 
-                   alphabet_start)
-    else:
-        return letter
 
-def caesar_decipher_letter(letter, shift):
-    """Decipher a letter, given a shift amount
-    
-    >>> caesar_decipher_letter('b', 1)
-    'a'
-    >>> caesar_decipher_letter('b', 2)
-    'z'
-    """
-    return caesar_encipher_letter(letter, -shift)
+# Where each piece of text ends up in the AMSCO transpositon cipher.
+# 'index' shows where the slice appears in the plaintext, with the slice
+# from 'start' to 'end'
+AmscoSlice = collections.namedtuple('AmscoSlice', ['index', 'start', 'end'])
 
-def caesar_encipher(message, shift):
-    """Encipher a message with the Caesar cipher of given shift
-    
-    >>> caesar_encipher('abc', 1)
-    'bcd'
-    >>> caesar_encipher('abc', 2)
-    'cde'
-    >>> caesar_encipher('abcxyz', 2)
-    'cdezab'
-    >>> caesar_encipher('ab cx yz', 2)
-    'cd ez ab'
-    >>> caesar_encipher('Héllo World!', 2)
-    'Jgnnq Yqtnf!'
-    """
-    enciphered = [caesar_encipher_letter(l, shift) for l in message]
-    return ''.join(enciphered)
+class AmscoFillStyle(Enum):
+    continuous = 1
+    same_each_row = 2
+    reverse_each_row = 3
 
-def caesar_decipher(message, shift):
-    """Decipher a message with the Caesar cipher of given shift
-    
-    >>> caesar_decipher('bcd', 1)
-    'abc'
-    >>> caesar_decipher('cde', 2)
-    'abc'
-    >>> caesar_decipher('cd ez ab', 2)
-    'ab cx yz'
-    >>> caesar_decipher('Jgnnq Yqtnf!', 2)
-    'Hello World!'
+def amsco_transposition_positions(message, keyword, 
+      fillpattern=(1, 2),
+      fillstyle=AmscoFillStyle.continuous,
+      fillcolumnwise=False,
+      emptycolumnwise=True):
+    """Creates the grid for the AMSCO transposition cipher. Each element in the
+    grid shows the index of that slice and the start and end positions of the
+    plaintext that go to make it up.
+
+    >>> amsco_transposition_positions(string.ascii_lowercase, 'freddy', \
+        fillpattern=(1, 2)) # doctest:  +NORMALIZE_WHITESPACE
+    [[AmscoSlice(index=3, start=4, end=6),
+     AmscoSlice(index=2, start=3, end=4),
+     AmscoSlice(index=0, start=0, end=1),
+     AmscoSlice(index=1, start=1, end=3),
+     AmscoSlice(index=4, start=6, end=7)],
+    [AmscoSlice(index=8, start=12, end=13),
+     AmscoSlice(index=7, start=10, end=12),
+     AmscoSlice(index=5, start=7, end=9),
+     AmscoSlice(index=6, start=9, end=10),
+     AmscoSlice(index=9, start=13, end=15)],
+    [AmscoSlice(index=13, start=19, end=21),
+     AmscoSlice(index=12, start=18, end=19),
+     AmscoSlice(index=10, start=15, end=16),
+     AmscoSlice(index=11, start=16, end=18),
+     AmscoSlice(index=14, start=21, end=22)],
+    [AmscoSlice(index=18, start=27, end=28),
+     AmscoSlice(index=17, start=25, end=27),
+     AmscoSlice(index=15, start=22, end=24),
+     AmscoSlice(index=16, start=24, end=25),
+     AmscoSlice(index=19, start=28, end=30)]]
     """
-    return caesar_encipher(message, -shift)
-
-def affine_encipher_letter(accented_letter, multiplier=1, adder=0, one_based=True):
-    """Encipher a letter, given a multiplier and adder
-    
-    >>> ''.join([affine_encipher_letter(l, 3, 5, True) \
-            for l in string.ascii_uppercase])
-    'HKNQTWZCFILORUXADGJMPSVYBE'
-    >>> ''.join([affine_encipher_letter(l, 3, 5, False) \
-            for l in string.ascii_uppercase])
-    'FILORUXADGJMPSVYBEHKNQTWZC'
+    transpositions = transpositions_of(keyword)
+    fill_iterator = cycle(fillpattern)
+    indices = count()
+    message_length = len(message)
+
+    current_position = 0
+    grid = []
+    current_fillpattern = fillpattern
+    while current_position < message_length:
+        row = []
+        if fillstyle == AmscoFillStyle.same_each_row:
+            fill_iterator = cycle(fillpattern)
+        if fillstyle == AmscoFillStyle.reverse_each_row:
+            fill_iterator = cycle(current_fillpattern)
+        for _ in range(len(transpositions)):
+            index = next(indices)
+            gap = next(fill_iterator)
+            row += [AmscoSlice(index, current_position, current_position + gap)]
+            current_position += gap
+        grid += [row]
+        if fillstyle == AmscoFillStyle.reverse_each_row:
+            current_fillpattern = list(reversed(current_fillpattern))
+    return [transpose(r, transpositions) for r in grid]
+
+def amsco_transposition_encipher(message, keyword, 
+    fillpattern=(1,2), fillstyle=AmscoFillStyle.reverse_each_row):
+    """AMSCO transposition encipher.
+
+    >>> amsco_transposition_encipher('hellothere', 'abc', fillpattern=(1, 2))
+    'hoteelhler'
+    >>> amsco_transposition_encipher('hellothere', 'abc', fillpattern=(2, 1))
+    'hetelhelor'
+    >>> amsco_transposition_encipher('hellothere', 'acb', fillpattern=(1, 2))
+    'hotelerelh'
+    >>> amsco_transposition_encipher('hellothere', 'acb', fillpattern=(2, 1))
+    'hetelorlhe'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'encode')
+    'etecstthhomoerereenisxip'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(1, 2))
+    'hetcsoeisterereipexthomn'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(1, 2), fillstyle=AmscoFillStyle.continuous)
+    'hecsoisttererteipexhomen'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(2, 1))
+    'heecisoosttrrtepeixhemen'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(1, 3, 2))
+    'hxtomephescieretoeisnter'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(1, 3, 2), fillstyle=AmscoFillStyle.continuous)
+    'hxomeiphscerettoisenteer'
     """
-    letter = unaccent(accented_letter)
-    if letter in string.ascii_letters:
-        if letter in string.ascii_uppercase:
-            alphabet_start = ord('A')
-        else:
-            alphabet_start = ord('a')
-        letter_number = ord(letter) - alphabet_start
-        if one_based: letter_number += 1
-        cipher_number = (letter_number * multiplier + adder) % 26
-        if one_based: cipher_number -= 1
-        return chr(cipher_number % 26 + alphabet_start)
-    else:
-        return letter
+    grid = amsco_transposition_positions(message, keyword, 
+        fillpattern=fillpattern, fillstyle=fillstyle)
+    ct_as_grid = [[message[s.start:s.end] for s in r] for r in grid]
+    return combine_every_nth(ct_as_grid)
 
-def affine_decipher_letter(letter, multiplier=1, adder=0, one_based=True):
-    """Encipher a letter, given a multiplier and adder
-    
-    >>> ''.join([affine_decipher_letter(l, 3, 5, True) \
-            for l in 'HKNQTWZCFILORUXADGJMPSVYBE'])
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    >>> ''.join([affine_decipher_letter(l, 3, 5, False) \
-            for l in 'FILORUXADGJMPSVYBEHKNQTWZC'])
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    """
-    if letter in string.ascii_letters:
-        if letter in string.ascii_uppercase:
-            alphabet_start = ord('A')
-        else:
-            alphabet_start = ord('a')
-        cipher_number = ord(letter) - alphabet_start
-        if one_based: cipher_number += 1
-        plaintext_number = ( 
-            modular_division_table[multiplier]
-                                  [(cipher_number - adder) % 26])
-        if one_based: plaintext_number -= 1
-        return chr(plaintext_number % 26 + alphabet_start) 
-    else:
-        return letter
 
-def affine_encipher(message, multiplier=1, adder=0, one_based=True):
-    """Encipher a message
-    
-    >>> affine_encipher('hours passed during which jerico tried every ' \
-           'trick he could think of', 15, 22, True)
-    'lmyfu bkuusd dyfaxw claol psfaom jfasd snsfg jfaoe ls omytd jlaxe mh'
+def amsco_transposition_decipher(message, keyword, 
+    fillpattern=(1,2), fillstyle=AmscoFillStyle.reverse_each_row):
+    """AMSCO transposition decipher
+
+    >>> amsco_transposition_decipher('hoteelhler', 'abc', fillpattern=(1, 2))
+    'hellothere'
+    >>> amsco_transposition_decipher('hetelhelor', 'abc', fillpattern=(2, 1))
+    'hellothere'
+    >>> amsco_transposition_decipher('hotelerelh', 'acb', fillpattern=(1, 2))
+    'hellothere'
+    >>> amsco_transposition_decipher('hetelorlhe', 'acb', fillpattern=(2, 1))
+    'hellothere'
+    >>> amsco_transposition_decipher('etecstthhomoerereenisxip', 'encode')
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('hetcsoeisterereipexthomn', 'cipher', fillpattern=(1, 2))
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('hecsoisttererteipexhomen', 'cipher', fillpattern=(1, 2), fillstyle=AmscoFillStyle.continuous)
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('heecisoosttrrtepeixhemen', 'cipher', fillpattern=(2, 1))
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('hxtomephescieretoeisnter', 'cipher', fillpattern=(1, 3, 2))
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('hxomeiphscerettoisenteer', 'cipher', fillpattern=(1, 3, 2), fillstyle=AmscoFillStyle.continuous)
+    'hereissometexttoencipher'
     """
-    enciphered = [affine_encipher_letter(l, multiplier, adder, one_based) 
-                  for l in message]
-    return ''.join(enciphered)
 
-def affine_decipher(message, multiplier=1, adder=0, one_based=True):
-    """Decipher a message
-    
-    >>> affine_decipher('lmyfu bkuusd dyfaxw claol psfaom jfasd snsfg ' \
-           'jfaoe ls omytd jlaxe mh', 15, 22, True)
-    'hours passed during which jerico tried every trick he could think of'
+    grid = amsco_transposition_positions(message, keyword, 
+        fillpattern=fillpattern, fillstyle=fillstyle)
+    transposed_sections = [s for c in [l for l in zip(*grid)] for s in c]
+    plaintext_list = [''] * len(transposed_sections)
+    current_pos = 0
+    for slice in transposed_sections:
+        plaintext_list[slice.index] = message[current_pos:current_pos-slice.start+slice.end][:len(message[slice.start:slice.end])]
+        current_pos += len(message[slice.start:slice.end])
+    return cat(plaintext_list)
+
+
+def bifid_grid(keyword, wrap_alphabet, letter_mapping):
+    """Create the grids for a Bifid cipher
     """
-    enciphered = [affine_decipher_letter(l, multiplier, adder, one_based) 
-                  for l in message]
-    return ''.join(enciphered)
-
-
-class KeywordWrapAlphabet(Enum):
-    from_a = 1
-    from_last = 2
-    from_largest = 3
-
-
-def keyword_cipher_alphabet_of(keyword, wrap_alphabet=KeywordWrapAlphabet.from_a):
-    """Find the cipher alphabet given a keyword.
-    wrap_alphabet controls how the rest of the alphabet is added
-    after the keyword.
-
-    >>> keyword_cipher_alphabet_of('bayes')
-    'bayescdfghijklmnopqrtuvwxz'
-    >>> keyword_cipher_alphabet_of('bayes', KeywordWrapAlphabet.from_a)
-    'bayescdfghijklmnopqrtuvwxz'
-    >>> keyword_cipher_alphabet_of('bayes', KeywordWrapAlphabet.from_last)
-    'bayestuvwxzcdfghijklmnopqr'
-    >>> keyword_cipher_alphabet_of('bayes', KeywordWrapAlphabet.from_largest)
-    'bayeszcdfghijklmnopqrtuvwx'
+    cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet)
+    if letter_mapping is None:
+        letter_mapping = {'j': 'i'}
+    translation = ''.maketrans(letter_mapping)
+    cipher_alphabet = cat(collections.OrderedDict.fromkeys(cipher_alphabet.translate(translation)))
+    f_grid = {k: ((i // 5) + 1, (i % 5) + 1) 
+              for i, k in enumerate(cipher_alphabet)}
+    r_grid = {((i // 5) + 1, (i % 5) + 1): k 
+              for i, k in enumerate(cipher_alphabet)}
+    return translation, f_grid, r_grid
+
+def bifid_encipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a, 
+                   letter_mapping=None, period=None, fillvalue=None):
+    """Bifid cipher
+
+    >>> bifid_encipher("indiajelly", 'iguana')
+    'ibidonhprm'
+    >>> bifid_encipher("indiacurry", 'iguana', period=4)
+    'ibnhgaqltm'
+    >>> bifid_encipher("indiacurry", 'iguana', period=4, fillvalue='x')
+    'ibnhgaqltzml'
     """
-    if wrap_alphabet == KeywordWrapAlphabet.from_a:
-        cipher_alphabet = ''.join(deduplicate(sanitise(keyword) + 
-                                              string.ascii_lowercase))
+    translation, f_grid, r_grid = bifid_grid(keyword, wrap_alphabet, letter_mapping)
+    
+    t_message = message.translate(translation)
+    pairs0 = [f_grid[l] for l in sanitise(t_message)]
+    if period:
+        chunked_pairs = [pairs0[i:i+period] for i in range(0, len(pairs0), period)]
+        if len(chunked_pairs[-1]) < period and fillvalue:
+            chunked_pairs[-1] += [f_grid[fillvalue]] * (period - len(chunked_pairs[-1]))
     else:
-        if wrap_alphabet == KeywordWrapAlphabet.from_last:
-            last_keyword_letter = deduplicate(sanitise(keyword))[-1]
-        else:
-            last_keyword_letter = sorted(sanitise(keyword))[-1]
-        last_keyword_position = string.ascii_lowercase.find(
-            last_keyword_letter) + 1
-        cipher_alphabet = ''.join(
-            deduplicate(sanitise(keyword) + 
-                        string.ascii_lowercase[last_keyword_position:] + 
-                        string.ascii_lowercase))
-    return cipher_alphabet
-
-
-def keyword_encipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a):
-    """Enciphers a message with a keyword substitution cipher.
-    wrap_alphabet controls how the rest of the alphabet is added
-    after the keyword.
-    0 : from 'a'
-    1 : from the last letter in the sanitised keyword
-    2 : from the largest letter in the sanitised keyword
-
-    >>> keyword_encipher('test message', 'bayes')
-    'rsqr ksqqbds'
-    >>> keyword_encipher('test message', 'bayes', KeywordWrapAlphabet.from_a)
-    'rsqr ksqqbds'
-    >>> keyword_encipher('test message', 'bayes', KeywordWrapAlphabet.from_last)
-    'lskl dskkbus'
-    >>> keyword_encipher('test message', 'bayes', KeywordWrapAlphabet.from_largest)
-    'qspq jsppbcs'
-    """
-    cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet)
-    cipher_translation = ''.maketrans(string.ascii_lowercase, cipher_alphabet)
-    return unaccent(message).lower().translate(cipher_translation)
-
-def keyword_decipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a):
-    """Deciphers a message with a keyword substitution cipher.
-    wrap_alphabet controls how the rest of the alphabet is added
-    after the keyword.
-    0 : from 'a'
-    1 : from the last letter in the sanitised keyword
-    2 : from the largest letter in the sanitised keyword
+        chunked_pairs = [pairs0]
     
-    >>> keyword_decipher('rsqr ksqqbds', 'bayes')
-    'test message'
-    >>> keyword_decipher('rsqr ksqqbds', 'bayes', KeywordWrapAlphabet.from_a)
-    'test message'
-    >>> keyword_decipher('lskl dskkbus', 'bayes', KeywordWrapAlphabet.from_last)
-    'test message'
-    >>> keyword_decipher('qspq jsppbcs', 'bayes', KeywordWrapAlphabet.from_largest)
-    'test message'
-    """
-    cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet)
-    cipher_translation = ''.maketrans(cipher_alphabet, string.ascii_lowercase)
-    return message.lower().translate(cipher_translation)
-
-
-def vigenere_encipher(message, keyword):
-    """Vigenere encipher
+    pairs1 = []
+    for c in chunked_pairs:
+        items = sum(list(list(i) for i in zip(*c)), [])
+        p = [(items[i], items[i+1]) for i in range(0, len(items), 2)]
+        pairs1 += p
+    
+    return cat(r_grid[p] for p in pairs1)
 
-    >>> vigenere_encipher('hello', 'abc')
-    'hfnlp'
-    """
-    shifts = [ord(l) - ord('a') for l in sanitise(keyword)]
-    pairs = zip(message, cycle(shifts))
-    return ''.join([caesar_encipher_letter(l, k) for l, k in pairs])
 
-def vigenere_decipher(message, keyword):
-    """Vigenere decipher
+def bifid_decipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a, 
+                   letter_mapping=None, period=None, fillvalue=None):
+    """Decipher with bifid cipher
 
-    >>> vigenere_decipher('hfnlp', 'abc')
-    'hello'
+    >>> bifid_decipher('ibidonhprm', 'iguana')
+    'indiaielly'
+    >>> bifid_decipher("ibnhgaqltm", 'iguana', period=4)
+    'indiacurry'
+    >>> bifid_decipher("ibnhgaqltzml", 'iguana', period=4)
+    'indiacurryxx'
     """
-    shifts = [ord(l) - ord('a') for l in sanitise(keyword)]
-    pairs = zip(message, cycle(shifts))
-    return ''.join([caesar_decipher_letter(l, k) for l, k in pairs])
-
-beaufort_encipher=vigenere_decipher
-beaufort_decipher=vigenere_encipher
-
+    translation, f_grid, r_grid = bifid_grid(keyword, wrap_alphabet, letter_mapping)
+    
+    t_message = message.translate(translation)
+    pairs0 = [f_grid[l] for l in sanitise(t_message)]
+    if period:
+        chunked_pairs = [pairs0[i:i+period] for i in range(0, len(pairs0), period)]
+        if len(chunked_pairs[-1]) < period and fillvalue:
+            chunked_pairs[-1] += [f_grid[fillvalue]] * (period - len(chunked_pairs[-1]))
+    else:
+        chunked_pairs = [pairs0]
+        
+    pairs1 = []
+    for c in chunked_pairs:
+        items = [j for i in c for j in i]
+        gap = len(c)
+        p = [(items[i], items[i+gap]) for i in range(gap)]
+        pairs1 += p
 
-def transpositions_of(keyword):
-    """Finds the transpostions given by a keyword. For instance, the keyword
-    'clever' rearranges to 'celrv', so the first column (0) stays first, the
-    second column (1) moves to third, the third column (2) moves to second, 
-    and so on.
+    return cat(r_grid[p] for p in pairs1) 
 
-    If passed a tuple, assume it's already a transposition and just return it.
 
-    >>> transpositions_of('clever')
-    (0, 2, 1, 4, 3)
-    >>> transpositions_of('fred')
-    (3, 2, 0, 1)
-    >>> transpositions_of((3, 2, 0, 1))
-    (3, 2, 0, 1)
-    """
-    if isinstance(keyword, tuple):
-        return keyword
-    else:
-        key = deduplicate(keyword)
-        transpositions = tuple(key.index(l) for l in sorted(key))
-        return transpositions
-
-def pad(message_len, group_len, fillvalue):
-    padding_length = group_len - message_len % group_len
-    if padding_length == group_len: padding_length = 0
-    padding = ''
-    for i in range(padding_length):
-        if callable(fillvalue):
-            padding += fillvalue()
-        else:
-            padding += fillvalue
-    return padding
+def autokey_encipher(message, keyword):
+    """Encipher with the autokey cipher
 
-def column_transposition_encipher(message, keyword, fillvalue=' ', 
-      fillcolumnwise=False,
-      emptycolumnwise=False):
-    """Enciphers using the column transposition cipher.
-    Message is padded to allow all rows to be the same length.
-
-    >>> column_transposition_encipher('hellothere', 'abcdef', fillcolumnwise=True)
-    'hlohr eltee '
-    >>> column_transposition_encipher('hellothere', 'abcdef', fillcolumnwise=True, emptycolumnwise=True)
-    'hellothere  '
-    >>> column_transposition_encipher('hellothere', 'abcdef')
-    'hellothere  '
-    >>> column_transposition_encipher('hellothere', 'abcde')
-    'hellothere'
-    >>> column_transposition_encipher('hellothere', 'abcde', fillcolumnwise=True, emptycolumnwise=True)
-    'hellothere'
-    >>> column_transposition_encipher('hellothere', 'abcde', fillcolumnwise=True, emptycolumnwise=False)
-    'hlohreltee'
-    >>> column_transposition_encipher('hellothere', 'abcde', fillcolumnwise=False, emptycolumnwise=True)
-    'htehlelroe'
-    >>> column_transposition_encipher('hellothere', 'abcde', fillcolumnwise=False, emptycolumnwise=False)
-    'hellothere'
-    >>> column_transposition_encipher('hellothere', 'clever', fillcolumnwise=True, emptycolumnwise=True)
-    'heotllrehe'
-    >>> column_transposition_encipher('hellothere', 'clever', fillcolumnwise=True, emptycolumnwise=False)
-    'holrhetlee'
-    >>> column_transposition_encipher('hellothere', 'clever', fillcolumnwise=False, emptycolumnwise=True)
-    'htleehoelr'
-    >>> column_transposition_encipher('hellothere', 'clever', fillcolumnwise=False, emptycolumnwise=False)
-    'hleolteher'
-    >>> column_transposition_encipher('hellothere', 'cleverly')
-    'hleolthre e '
-    >>> column_transposition_encipher('hellothere', 'cleverly', fillvalue='!')
-    'hleolthre!e!'
-    >>> column_transposition_encipher('hellothere', 'cleverly', fillvalue=lambda: '*')
-    'hleolthre*e*'
+    >>> autokey_encipher('meetatthefountain', 'kilt')
+    'wmpmmxxaeyhbryoca'
     """
-    transpositions = transpositions_of(keyword)
-    message += pad(len(message), len(transpositions), fillvalue)
-    if fillcolumnwise:
-        rows = every_nth(message, len(message) // len(transpositions))
-    else:
-        rows = chunks(message, len(transpositions))
-    transposed = [transpose(r, transpositions) for r in rows]
-    if emptycolumnwise:
-        return combine_every_nth(transposed)
-    else:
-        return ''.join(chain(*transposed))
+    shifts = [pos(l) for l in keyword + message]
+    pairs = zip(message, shifts)
+    return cat([caesar_encipher_letter(l, k) for l, k in pairs])
 
-def column_transposition_decipher(message, keyword, fillvalue=' ', 
-      fillcolumnwise=False,
-      emptycolumnwise=False):
-    """Deciphers using the column transposition cipher.
-    Message is padded to allow all rows to be the same length.
+def autokey_decipher(ciphertext, keyword):
+    """Decipher with the autokey cipher
 
-    >>> column_transposition_decipher('hellothere', 'abcde', fillcolumnwise=True, emptycolumnwise=True)
-    'hellothere'
-    >>> column_transposition_decipher('hlohreltee', 'abcde', fillcolumnwise=True, emptycolumnwise=False)
-    'hellothere'
-    >>> column_transposition_decipher('htehlelroe', 'abcde', fillcolumnwise=False, emptycolumnwise=True)
-    'hellothere'
-    >>> column_transposition_decipher('hellothere', 'abcde', fillcolumnwise=False, emptycolumnwise=False)
-    'hellothere'
-    >>> column_transposition_decipher('heotllrehe', 'clever', fillcolumnwise=True, emptycolumnwise=True)
-    'hellothere'
-    >>> column_transposition_decipher('holrhetlee', 'clever', fillcolumnwise=True, emptycolumnwise=False)
-    'hellothere'
-    >>> column_transposition_decipher('htleehoelr', 'clever', fillcolumnwise=False, emptycolumnwise=True)
-    'hellothere'
-    >>> column_transposition_decipher('hleolteher', 'clever', fillcolumnwise=False, emptycolumnwise=False)
-    'hellothere'
-    """
-    transpositions = transpositions_of(keyword)
-    message += pad(len(message), len(transpositions), fillvalue)
-    if emptycolumnwise:
-        rows = every_nth(message, len(message) // len(transpositions))
-    else:
-        rows = chunks(message, len(transpositions))
-    untransposed = [untranspose(r, transpositions) for r in rows]
-    if fillcolumnwise:
-        return combine_every_nth(untransposed)
-    else:
-        return ''.join(chain(*untransposed))
-
-def scytale_encipher(message, rows, fillvalue=' '):
-    """Enciphers using the scytale transposition cipher.
-    Message is padded with spaces to allow all rows to be the same length.
-
-    >>> scytale_encipher('thequickbrownfox', 3)
-    'tcnhkfeboqrxuo iw '
-    >>> scytale_encipher('thequickbrownfox', 4)
-    'tubnhirfecooqkwx'
-    >>> scytale_encipher('thequickbrownfox', 5)
-    'tubn hirf ecoo qkwx '
-    >>> scytale_encipher('thequickbrownfox', 6)
-    'tqcrnxhukof eibwo '
-    >>> scytale_encipher('thequickbrownfox', 7)
-    'tqcrnx hukof  eibwo  '
-    """
-    # transpositions = [i for i in range(math.ceil(len(message) / rows))]
-    # return column_transposition_encipher(message, transpositions, 
-    #     fillvalue=fillvalue, fillcolumnwise=False, emptycolumnwise=True)
-    transpositions = [i for i in range(rows)]
-    return column_transposition_encipher(message, transpositions, 
-        fillvalue=fillvalue, fillcolumnwise=True, emptycolumnwise=False)
-
-def scytale_decipher(message, rows):
-    """Deciphers using the scytale transposition cipher.
-    Assumes the message is padded so that all rows are the same length.
-    
-    >>> scytale_decipher('tcnhkfeboqrxuo iw ', 3)
-    'thequickbrownfox  '
-    >>> scytale_decipher('tubnhirfecooqkwx', 4)
-    'thequickbrownfox'
-    >>> scytale_decipher('tubn hirf ecoo qkwx ', 5)
-    'thequickbrownfox    '
-    >>> scytale_decipher('tqcrnxhukof eibwo ', 6)
-    'thequickbrownfox  '
-    >>> scytale_decipher('tqcrnx hukof  eibwo  ', 7)
-    'thequickbrownfox     '
-    """
-    # transpositions = [i for i in range(math.ceil(len(message) / rows))]
-    # return column_transposition_decipher(message, transpositions, 
-    #     fillcolumnwise=False, emptycolumnwise=True)
-    transpositions = [i for i in range(rows)]
-    return column_transposition_decipher(message, transpositions, 
-        fillcolumnwise=True, emptycolumnwise=False)
-
-
-def railfence_encipher(message, height, fillvalue=''):
-    """Railfence cipher.
-    Works by splitting the text into sections, then reading across them to
-    generate the rows in the cipher. The rows are then combined to form the
-    ciphertext.
-
-    Example: the plaintext "hellotherefriends", with a height of four, written 
-    out in the railfence as 
-       h h i
-       etere*
-       lorfns
-       l e d
-    (with the * showing the one character to finish the last section). 
-    Each 'section' is two columns, but unfolded. In the example, the first
-    section is 'hellot'.
-
-    >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 2, fillvalue='!')
-    'hlohraateerishsslnpeefetotsigaleccpeselteevsmhatetiiaogicotxfretnrifneihr!'
-    >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 3, fillvalue='!')
-    'horaersslpeeosglcpselteevsmhatetiiaogicotxfretnrifneihr!!lhateihsnefttiaece!'
-    >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 5, fillvalue='!')
-    'hresleogcseeemhetaocofrnrner!!lhateihsnefttiaece!!ltvsatiigitxetifih!!oarspeslp!'
-    >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 10, fillvalue='!')
-    'hepisehagitnr!!lernesge!!lmtocerh!!otiletap!!tseaorii!!hassfolc!!evtitffe!!rahsetec!!eixn!'
-    >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 3)
-    'horaersslpeeosglcpselteevsmhatetiiaogicotxfretnrifneihrlhateihsnefttiaece'
-    >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 5)
-    'hresleogcseeemhetaocofrnrnerlhateihsnefttiaeceltvsatiigitxetifihoarspeslp'
-    >>> railfence_encipher('hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers', 7)
-    'haspolsevsetgifrifrlatihnettaeelemtiocxernhorersleesgcptehaiaottneihesfic'
-    """
-    sections = chunks(message, (height - 1) * 2, fillvalue=fillvalue)
-    n_sections = len(sections)
-    # Add the top row
-    rows = [''.join([s[0] for s in sections])]
-    # process the middle rows of the grid
-    for r in range(1, height-1):
-        rows += [''.join([s[r:r+1] + s[height*2-r-2:height*2-r-1] for s in sections])]
-    # process the bottom row
-    rows += [''.join([s[height - 1:height] for s in sections])]
-    # rows += [' '.join([s[height - 1] for s in sections])]
-    return ''.join(rows)
-
-def railfence_decipher(message, height, fillvalue=''):
-    """Railfence decipher. 
-    Works by reconstructing the grid used to generate the ciphertext, then
-    unfolding the sections so the text can be concatenated together.
-
-    Example: given the ciphertext 'hhieterelorfnsled' and a height of 4, first
-    work out that the second row has a character missing, find the rows of the
-    grid, then split the section into its two columns.
-
-    'hhieterelorfnsled' is split into
-        h h i
-        etere
-        lorfns
-        l e d
-    (spaces added for clarity), which is stored in 'rows'. This is then split
-    into 'down_rows' and 'up_rows':
-
-    down_rows:
-       hhi
-       eee
-       lrn
-       led
-
-    up_rows:
-       tr
-       ofs
-
-    These are then zipped together (after the up_rows are reversed) to recover 
-    the plaintext.
-
-    Most of the procedure is about finding the correct lengths for each row then
-    splitting the ciphertext into those rows.
-
-    >>> railfence_decipher('hlohraateerishsslnpeefetotsigaleccpeselteevsmhatetiiaogicotxfretnrifneihr!', 2).strip('!')
-    'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers'
-    >>> railfence_decipher('horaersslpeeosglcpselteevsmhatetiiaogicotxfretnrifneihr!!lhateihsnefttiaece!', 3).strip('!')
-    'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers'
-    >>> railfence_decipher('hresleogcseeemhetaocofrnrner!!lhateihsnefttiaece!!ltvsatiigitxetifih!!oarspeslp!', 5).strip('!')
-    'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers'
-    >>> railfence_decipher('hepisehagitnr!!lernesge!!lmtocerh!!otiletap!!tseaorii!!hassfolc!!evtitffe!!rahsetec!!eixn!', 10).strip('!')
-    'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers'
-    >>> railfence_decipher('horaersslpeeosglcpselteevsmhatetiiaogicotxfretnrifneihrlhateihsnefttiaece', 3)
-    'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers'
-    >>> railfence_decipher('hresleogcseeemhetaocofrnrnerlhateihsnefttiaeceltvsatiigitxetifihoarspeslp', 5)
-    'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers'
-    >>> railfence_decipher('haspolsevsetgifrifrlatihnettaeelemtiocxernhorersleesgcptehaiaottneihesfic', 7)
-    'hellothereavastmeheartiesthisisalongpieceoftextfortestingrailfenceciphers'
+    >>> autokey_decipher('wmpmmxxaeyhbryoca', 'kilt')
+    'meetatthefountain'
     """
-    # find the number and size of the sections, including how many characters
-    #   are missing for a full grid
-    n_sections = math.ceil(len(message) / ((height - 1) * 2))
-    padding_to_add = n_sections * (height - 1) * 2 - len(message)
-    # row_lengths are for the both up rows and down rows
-    row_lengths = [n_sections] * (height - 1) * 2
-    for i in range((height - 1) * 2 - 1, (height - 1) * 2 - (padding_to_add + 1), -1):
-        row_lengths[i] -= 1
-    # folded_rows are the combined row lengths in the middle of the railfence
-    folded_row_lengths = [row_lengths[0]]
-    for i in range(1, height-1):
-        folded_row_lengths += [row_lengths[i] + row_lengths[-i]]
-    folded_row_lengths += [row_lengths[height - 1]]
-    # find the rows that form the railfence grid
-    rows = []
-    row_start = 0
-    for i in folded_row_lengths:
-        rows += [message[row_start:row_start + i]]
-        row_start += i
-    # split the rows into the 'down_rows' (those that form the first column of
-    #   a section) and the 'up_rows' (those that ofrm the second column of a 
-    #   section).
-    down_rows = [rows[0]]
-    up_rows = []
-    for i in range(1, height-1):
-        down_rows += [''.join([c for n, c in enumerate(rows[i]) if n % 2 == 0])]
-        up_rows += [''.join([c for n, c in enumerate(rows[i]) if n % 2 == 1])]
-    down_rows += [rows[-1]]
-    up_rows.reverse()
-    return ''.join(c for r in zip_longest(*(down_rows + up_rows), fillvalue='') for c in r)
+    plaintext = []
+    keys = list(keyword)
+    for c in ciphertext:
+        plaintext_letter = caesar_decipher_letter(c, pos(keys[0]))
+        plaintext += [plaintext_letter]
+        keys = keys[1:] + [plaintext_letter]
+    return cat(plaintext)
 
 
 class PocketEnigma(object):
@@ -664,7 +418,7 @@ class PocketEnigma(object):
             self.validate_wheel_spec(wheel)
             self.make_wheel_map(wheel)
         if position in string.ascii_lowercase:
-            self.position = ord(position) - ord('a')
+            self.position = pos(position)
         else:
             self.position = position
 
@@ -678,8 +432,8 @@ class PocketEnigma(object):
         self.validate_wheel_spec(wheel_spec)
         self.wheel_map = [0] * 26
         for p in wheel_spec:
-            self.wheel_map[ord(p[0]) - ord('a')] = ord(p[1]) - ord('a')
-            self.wheel_map[ord(p[1]) - ord('a')] = ord(p[0]) - ord('a')
+            self.wheel_map[pos(p[0])] = pos(p[1])
+            self.wheel_map[pos(p[1])] = pos(p[0])
         return self.wheel_map
 
     def validate_wheel_spec(self, wheel_spec):
@@ -728,16 +482,15 @@ class PocketEnigma(object):
 
         >>> pe.set_position('f')
         5
-        >>> ''.join([pe.lookup(l) for l in string.ascii_lowercase])
+        >>> cat([pe.lookup(l) for l in string.ascii_lowercase])
         'udhbfejcpgmokrliwntsayqzvx'
         >>> pe.lookup('A')
         ''
         """
         if letter in string.ascii_lowercase:
-            return chr(
-                (self.wheel_map[(ord(letter) - ord('a') - self.position) % 26] + 
-                    self.position) % 26 + 
-                ord('a'))
+            return unpos(
+                (self.wheel_map[(pos(letter) - self.position) % 26] + 
+                    self.position))
         else:
             return ''
 
@@ -785,7 +538,7 @@ class PocketEnigma(object):
         >>> pe.set_position('z')
         25
         """
-        self.position = ord(position) - ord('a')
+        self.position = pos(position)
         return self.position