Dorabella - Edward Elgar

Hangout and post about Non-Zodiac related subjects here. (Please refrain from Politics & Religion)

Dorabella - Edward Elgar

Postby Quicktrader » Sun Feb 07, 2016 2:29 pm

Composer Edward Elgar once sent a secret message to a reverend's daughter..so far, it has been unsolved for approximately 100+ years. Elgar was the composer of wonderful 'Enigma' and other musical masterpieces. In one of his compositions, clues were found on how he had encrypted the message.

The cipher:

dorabella.gif



The method:

dorabella_notes.gif



It appears that we deal with a simple substitution cipher and can the message in the notes be solved:

"Marco Elgar"
"A very old cipher"
"Do you go to London"

This is actually confirmed by his cleartext note "Do you go to London tomorrow" written next in his notes. Once understood, the method is both, quite easy and efficient: Assume eight directions, two vertically (up & down), horizontally (left & right) and diagonally (four directions). In each direction, he can either use a symbol consisting of one, two or three brackets. He then places the alphabet on his transformation pattern. In his notes, he did so in alphabetical order, e.g. ABC. However, he also shows that it may be reversed (e.g. CBA). So in fact he divides the alphabet into groups of three letters which he may place into the pattern, all of them potentially into two directions. Thus we get 8x7x6x5x4x3x2x1 = 40,320 variations with 2^8 forward/backward settings, thus a total of 10,321,920 potential settings of the alphabet. The one who knows how this setting is done, is able to read the cleartext.

Recently I wrote a script to solve the cipher. The script analyzes all potential settings and compares the result with any dictionary (Aho-Corasick again). The program was not so easy as it is a two-step encryption). To solve the cipher, however, only takes approximately two hours of CPU computation.

On the first run, I searched for at least 2 words of length>5, which should exist in a text of almost 90 letters. No result. On the second run I searched for one word of length>5 only. It found some solutions, however no complete cleartext. Currently the PC is running to search for >4 words of length>3, which should occurr in such a cleartext, too. If that won't do it, the cipher

- is not encrypted as given in Elgar's notes (e.g. shuffling of the letters as someone likes to, thus billions of billions potential variations)
- is in a different language, e.g. Latin or French

Latter is not so unlikely as the date written under the cipher is actually the 100 year jubilee's date of the 'storming of the bastille'.

We'll see if it will work..if so, the Edward Elgar society has claimed to pay 5,000 British pounds for a solution :DD. If not, I'll try French and Latin, otherwise will give this one up.

Example of a pattern, definition of the cipher's alphabet (code):

PATTERN.jpg


QT
You do not have the required permissions to view the files attached to this post.
*ZODIACHRONOLOGY*
User avatar
Quicktrader
 
Posts: 1497
Joined: Mon Apr 01, 2013 11:23 am
Location: Vienna, Austria (Europe)

Re: Dorabella - Edward Elgar

Postby Tahoe27 » Sun Feb 07, 2016 2:35 pm

Too bad the key was never found in the reverends daughter's possession. She most certainly had it.
Image

"...they may be dealing with one or more ersatz Zodiacs--other psychotics eager to get into the act, or perhaps even other murderers eager to lay their crimes at the real Zodiac's doorstep." L.A. Times, 1969
User avatar
Tahoe27
 
Posts: 4166
Joined: Wed Mar 27, 2013 7:13 pm

Re: Dorabella - Edward Elgar

Postby Quicktrader » Sun Feb 07, 2016 3:58 pm

Tahoe27 wrote:Too bad the key was never found in the reverends daughter's possession. She most certainly had it.


Guess that's true..

..let's play a small game:

WHAT WOULD YOU WRITE TO THE DAUGHTER OF A REVEREND, IF YOU KEPT THE MESSAGE SECRET FROM HER FATHER?

Sorry my dear..last Sunday I met your mother inside the confessional box..and we both could not resist..

QT
*ZODIACHRONOLOGY*
User avatar
Quicktrader
 
Posts: 1497
Joined: Mon Apr 01, 2013 11:23 am
Location: Vienna, Austria (Europe)

Re: Dorabella - Edward Elgar

Postby Mr lowe » Sun Feb 07, 2016 6:50 pm

TEMPTATION

edit ?
A killer we sort stood there among the dead
Mr lowe
 
Posts: 822
Joined: Fri Aug 15, 2014 4:07 am

Re: Dorabella - Edward Elgar

Postby glurk » Sun Feb 07, 2016 10:29 pm

Tahoe27 wrote:Too bad the key was never found in the reverends daughter's possession. She most certainly had it.

No, she died never knowing the cipher solution. This is a pretty famous unsolved cipher.

https://en.wikipedia.org/wiki/Dorabella_Cipher

-glurk
--------------------------------
I don't believe in monsters.
User avatar
glurk
 
Posts: 675
Joined: Mon Apr 01, 2013 6:35 am
Location: Location, Location.

Re: Dorabella - Edward Elgar

Postby Tahoe27 » Sun Feb 07, 2016 11:04 pm

glurk wrote:
Tahoe27 wrote:Too bad the key was never found in the reverends daughter's possession. She most certainly had it.

No, she died never knowing the cipher solution. This is a pretty famous unsolved cipher.

https://en.wikipedia.org/wiki/Dorabella_Cipher

-glurk


That is interesting! Makes me wonder if she had it, but didn't know it.
Image

"...they may be dealing with one or more ersatz Zodiacs--other psychotics eager to get into the act, or perhaps even other murderers eager to lay their crimes at the real Zodiac's doorstep." L.A. Times, 1969
User avatar
Tahoe27
 
Posts: 4166
Joined: Wed Mar 27, 2013 7:13 pm

Re: Dorabella - Edward Elgar

Postby Quicktrader » Mon Feb 08, 2016 3:36 am

Tahoe27 wrote:
glurk wrote:
Tahoe27 wrote:Too bad the key was never found in the reverends daughter's possession. She most certainly had it.

No, she died never knowing the cipher solution. This is a pretty famous unsolved cipher.

https://en.wikipedia.org/wiki/Dorabella_Cipher

-glurk


That is interesting! Makes me wonder if she had it, but didn't know it.


Guess her father took it and threw it away..
*ZODIACHRONOLOGY*
User avatar
Quicktrader
 
Posts: 1497
Joined: Mon Apr 01, 2013 11:23 am
Location: Vienna, Austria (Europe)

Re: Dorabella - Edward Elgar

Postby Quicktrader » Mon Feb 08, 2016 12:52 pm

Here we go with the Python source code including Aho-Corasick algorithm (pattern search).

However no solution was found in English or French, Italian is currently on-process. It only finds some nonsense cleartexts with up to 5 words in it..however no lexically correct solution.

UPDATE:
No 'immediate' solution was found in English, French or Italian language. Therefor one may wonder if Edward Elgar had shuffled the letters in a completely random way over the pattern. Then 24! variations are possible (620,448,401,733,239,439,360,000 variations..the Chinese supercomputer "Tianhe-2" would need approximately 2,000-4,000 years to solve this cipher..).

:roll:

QT

Code: Select all
## Dictionary
lex = ['...'] ## Enter your dictionary here in format: ['word1', 'word2',..]

## Trigramme variety for intermediary (rotary)
A_ = ["ABC", "CBA"]
B_ = ["DEF", "FDE"]
C_ = ["GHI", "IHG"]
D_ = ["KLM", "MLK"]
E_ = ["NOP", "PON"]
F_ = ["QRS", "SRQ"]
G_ = ["TVW", "WVT"]
H_ = ["XYZ", "ZYX"]


## Definition of trigram variables (preset)
a = 0
b = 0
c = 0
d = 0
e = 0
f = 0
g = 0
h = 0


## Intermediary definition (forward/backward)
A = A_[a]
B = B_[b]
C = C_[c]
D = D_[d]
E = E_[e]
F = F_[f]
G = G_[g]
H = H_[h]


## Variaty of trigram variables
rra = [0,1]
rrb = [0,1]
rrc = [0,1]
rrd = [0,1]
rre = [0,1]
rrf = [0,1]
rrg = [0,1]
rrh = [0,1]

## Definition of alphabet from intermediary (preset)
M1 = A
M2 = B
M3 = C
M4 = D
M5 = E
M6 = F
M7 = G
M8 = H


## Definition of rotated alphabet variables
M1_rot = A
M2_rot = B
M3_rot = C
M4_rot = D
M5_rot = E
M6_rot = F
M7_rot = G
M8_rot = H


## Definition of alphabet
dmaster = M1+M2+M3+M4+M5+M6+M7+M8


## Cleartext chain from alphabet
cleartext = dmaster[7]+dmaster[20]+dmaster[10]+dmaster[8]+dmaster[6]+dmaster[13]+dmaster[0]+dmaster[8]+dmaster[15]+dmaster[4]+dmaster[11]+dmaster[22]+dmaster[21]+dmaster[9]+dmaster[22]+dmaster[14]+dmaster[22]+dmaster[22]+dmaster[13]+dmaster[20]+dmaster[20]+dmaster[22]+dmaster[9]+dmaster[3]+dmaster[4]+dmaster[3]+dmaster[12]+dmaster[11]+dmaster[23]+dmaster[0]+dmaster[22]+dmaster[0]+dmaster[13]+dmaster[3]+dmaster[8]+dmaster[15]+dmaster[16]+dmaster[8]+dmaster[10]+dmaster[22]+dmaster[22]+dmaster[10]+dmaster[13]+dmaster[12]+dmaster[21]+dmaster[0]+dmaster[22]+dmaster[11]+dmaster[22]+dmaster[13]+dmaster[1]+dmaster[23]+dmaster[21]+dmaster[9]+dmaster[3]+dmaster[15]+dmaster[15]+dmaster[3]+dmaster[11]+dmaster[23]+dmaster[10]+dmaster[23]+dmaster[13]+dmaster[1]+dmaster[23]+dmaster[10]+dmaster[9]+dmaster[1]+dmaster[2]+dmaster[12]+dmaster[23]+dmaster[10]+dmaster[22]+dmaster[12]+dmaster[0]+dmaster[21]+dmaster[23]+dmaster[12]+dmaster[8]+dmaster[20]+dmaster[12]+dmaster[23]+dmaster[13]+dmaster[8]+dmaster[9]+dmaster[3]+dmaster[8]


## Aho-Corasick multiple pattern search algorithm
from collections import deque

def init_trie(keywords):
 """ creates a trie of keywords, then sets fail transitions """
 create_empty_trie()
 add_keywords(keywords)
 set_fail_transitions()
 
def create_empty_trie():
 """ initalize the root of the trie """
 AdjList.append({'value':'', 'next_states':[],'fail_state':0,'output':[]})
 
def add_keywords(keywords):
 """ add all keywords in list of keywords """
 for keyword in keywords:
     add_keyword(keyword)

def find_next_state(current_state, value):
  for node in AdjList[current_state]["next_states"]:
      if AdjList[node]["value"] == value:
          return node
  return None

def add_keyword(keyword):
 """ add a keyword to the trie and mark output at the last node """
 current_state = 0
 j = 0
 keyword = keyword.lower()
 child = find_next_state(current_state, keyword[j])
 while child != None:
     current_state = child
     j = j + 1
     if j < len(keyword):
         child = find_next_state(current_state, keyword[j])
     else:
         break
 for i in range(j, len(keyword)):
     node = {'value':keyword[i],'next_states':[],'fail_state':0,'output':[]}
     AdjList.append(node)
     AdjList[current_state]["next_states"].append(len(AdjList) - 1)
     current_state = len(AdjList) - 1
 AdjList[current_state]["output"].append(keyword)

def set_fail_transitions():
 q = deque()
 child = 0
 for node in AdjList[0]["next_states"]:
     q.append(node)
     AdjList[node]["fail_state"] = 0
 while q:
     r = q.popleft()
     for child in AdjList[r]["next_states"]:
         q.append(child)
         state = AdjList[r]["fail_state"]
         while find_next_state(state, AdjList[child]["value"]) == None \
 and state != 0:
             state = AdjList[state]["fail_state"]
         AdjList[child]["fail_state"] = find_next_state(state, AdjList[child]["value"])
         if AdjList[child]["fail_state"] is None:
             AdjList[child]["fail_state"] = 0
         AdjList[child]["output"] = AdjList[child]["output"] + AdjList[AdjList[child]["fail_state"]]["output"]

def get_keywords_found(line):
 """ returns true if line contains any keywords in trie """
 line = line.lower()
 current_state = 0
 keywords_found = []

 for i in range(len(line)):
     while find_next_state(current_state, line[i]) is None and current_state != 0:
         current_state = AdjList[current_state]["fail_state"]
     current_state = find_next_state(current_state, line[i])
     if current_state is None:
         current_state = 0
     else:
         for j in AdjList[current_state]["output"]:
             keywords_found.append({"index":i-len(j) + 1,"word":j})
 return keywords_found


# Main program
from itertools import permutations
AdjList = []
init_trie(lex)

## Permutation for rotary set-up
combinations = permutations("ABCDEFGH")
liste = ([''.join(x) for x in combinations])


## FCCP-List creation and Aho-Corasick-Analyis
print ('FCCP-List')
w = 0
for w in range(0,40320):
    rotary = liste[w]
    cleartext_rot = dmaster_rot[7]+dmaster_rot[20]+dmaster_rot[10]+dmaster_rot[8]+dmaster_rot[6]+dmaster_rot[13]+dmaster_rot[0]+dmaster_rot[8]+dmaster_rot[15]+dmaster_rot[4]+dmaster_rot[11]+dmaster_rot[22]+dmaster_rot[21]+dmaster_rot[9]+dmaster_rot[22]+dmaster_rot[14]+dmaster_rot[22]+dmaster_rot[22]+dmaster_rot[13]+dmaster_rot[20]+dmaster_rot[20]+dmaster_rot[22]+dmaster_rot[9]+dmaster_rot[3]+dmaster_rot[4]+dmaster_rot[3]+dmaster_rot[12]+dmaster_rot[11]+dmaster_rot[23]+dmaster_rot[0]+dmaster_rot[22]+dmaster_rot[0]+dmaster_rot[13]+dmaster_rot[3]+dmaster_rot[8]+dmaster_rot[15]+dmaster_rot[16]+dmaster_rot[8]+dmaster_rot[10]+dmaster_rot[22]+dmaster_rot[22]+dmaster_rot[10]+dmaster_rot[13]+dmaster_rot[12]+dmaster_rot[21]+dmaster_rot[0]+dmaster_rot[22]+dmaster_rot[11]+dmaster_rot[22]+dmaster_rot[13]+dmaster_rot[1]+dmaster_rot[23]+dmaster_rot[21]+dmaster_rot[9]+dmaster_rot[3]+dmaster_rot[15]+dmaster_rot[15]+dmaster_rot[3]+dmaster_rot[11]+dmaster_rot[23]+dmaster_rot[10]+dmaster_rot[23]+dmaster_rot[13]+dmaster_rot[1]+dmaster_rot[23]+dmaster_rot[10]+dmaster_rot[9]+dmaster_rot[1]+dmaster_rot[2]+dmaster_rot[12]+dmaster_rot[23]+dmaster_rot[10]+dmaster_rot[22]+dmaster_rot[12]+dmaster_rot[0]+dmaster_rot[21]+dmaster_rot[23]+dmaster_rot[12]+dmaster_rot[8]+dmaster_rot[20]+dmaster_rot[12]+dmaster_rot[23]+dmaster_rot[13]+dmaster_rot[8]+dmaster_rot[9]+dmaster_rot[3]+dmaster_rot[8]   
    for a, b, c, d, e, f, g, h in ((a,b,c,d,e,f,g,h) for a in rra for b in rrb for c in rrc for d in rrd for e in rre for f in rrf for g in rrg for h in rrh):
        ## Rotary split for rotary-dependent alphabet configuration
        if rotary[0] == "A":
            M1_rot = A_[a]
        if rotary[0] == "B":
            M1_rot = B_[b]
        if rotary[0] == "C":
            M1_rot = C_[c]   
        if rotary[0] == "D":
            M1_rot = D_[d]
        if rotary[0] == "E":
            M1_rot = E_[e]
        if rotary[0] == "F":
            M1_rot = F_[f]
        if rotary[0] == "G":
            M1_rot = G_[g]
        if rotary[0] == "H":
            M1_rot = H_[h]
        if rotary[1] == "A":
            M2_rot = A_[a]
        if rotary[1] == "B":
            M2_rot = B_[b]
        if rotary[1] == "C":
            M2_rot = C_[c]   
        if rotary[1] == "D":
            M2_rot = D_[d]
        if rotary[1] == "E":
            M2_rot = E_[e]
        if rotary[1] == "F":
            M2_rot = F_[f]
        if rotary[1] == "G":
            M2_rot = G_[g]
        if rotary[1] == "H":
            M2_rot = H_[h]
        if rotary[2] == "A":
            M3_rot = A_[a]
        if rotary[2] == "B":
            M3_rot = B_[b]
        if rotary[2] == "C":
            M3_rot = C_[c]   
        if rotary[2] == "D":
            M3_rot = D_[d]
        if rotary[2] == "E":
            M3_rot = E_[e]
        if rotary[2] == "F":
            M3_rot = F_[f]
        if rotary[2] == "G":
            M3_rot = G_[g]
        if rotary[2] == "H":
            M3_rot = H_[h]
        if rotary[3] == "A":
            M4_rot = A_[a]
        if rotary[3] == "B":
            M4_rot = B_[b]
        if rotary[3] == "C":
            M4_rot = C_[c]   
        if rotary[3] == "D":
            M4_rot = D_[d]
        if rotary[3] == "E":
            M4_rot = E_[e]
        if rotary[3] == "F":
            M4_rot = F_[f]
        if rotary[3] == "G":
            M4_rot = G_[g]
        if rotary[3] == "H":
            M4_rot = H_[h]
        if rotary[4] == "A":
            M5_rot = A_[a]
        if rotary[4] == "B":
            M5_rot = B_[b]
        if rotary[4] == "C":
            M5_rot = C_[c]   
        if rotary[4] == "D":
            M5_rot = D_[d]
        if rotary[4] == "E":
            M5_rot = E_[e]
        if rotary[4] == "F":
            M5_rot = F_[f]
        if rotary[4] == "G":
            M5_rot = G_[g]
        if rotary[4] == "H":
            M5_rot = H_[h]
        if rotary[5] == "A":
            M6_rot = A_[a]
        if rotary[5] == "B":
            M6_rot = B_[b]
        if rotary[5] == "C":
            M6_rot = C_[c]   
        if rotary[5] == "D":
            M6_rot = D_[d]
        if rotary[5] == "E":
            M6_rot = E_[e]
        if rotary[5] == "F":
            M6_rot = F_[f]
        if rotary[5] == "G":
            M6_rot = G_[g]
        if rotary[5] == "H":
            M6_rot = H_[h]
        if rotary[6] == "A":
            M7_rot = A_[a]
        if rotary[6] == "B":
            M7_rot = B_[b]
        if rotary[6] == "C":
            M7_rot = C_[c]   
        if rotary[6] == "D":
            M7_rot = D_[d]
        if rotary[6] == "E":
            M7_rot = E_[e]
        if rotary[6] == "F":
            M7_rot = F_[f]
        if rotary[6] == "G":
            M7_rot = G_[g]
        if rotary[6] == "H":
            M7_rot = H_[h]
        if rotary[7] == "A":
            M8_rot = A_[a]
        if rotary[7] == "B":
            M8_rot = B_[b]
        if rotary[7] == "C":
            M8_rot = C_[c]   
        if rotary[7] == "D":
            M8_rot = D_[d]
        if rotary[7] == "E":
            M8_rot = E_[e]
        if rotary[7] == "F":
            M8_rot = F_[f]
        if rotary[7] == "G":
            M8_rot = G_[g]
        if rotary[7] == "H":
            M8_rot = H_[h]

        ## Rotary-dependent alphabet configuration
        dmaster_rot = M1_rot+M2_rot+M3_rot+M4_rot+M5_rot+M6_rot+M7_rot+M8_rot
        cleartext_rot = dmaster_rot[7]+dmaster_rot[20]+dmaster_rot[10]+dmaster_rot[8]+dmaster_rot[6]+dmaster_rot[13]+dmaster_rot[0]+dmaster_rot[8]+dmaster_rot[15]+dmaster_rot[4]+dmaster_rot[11]+dmaster_rot[22]+dmaster_rot[21]+dmaster_rot[9]+dmaster_rot[22]+dmaster_rot[14]+dmaster_rot[22]+dmaster_rot[22]+dmaster_rot[13]+dmaster_rot[20]+dmaster_rot[20]+dmaster_rot[22]+dmaster_rot[9]+dmaster_rot[3]+dmaster_rot[4]+dmaster_rot[3]+dmaster_rot[12]+dmaster_rot[11]+dmaster_rot[23]+dmaster_rot[0]+dmaster_rot[22]+dmaster_rot[0]+dmaster_rot[13]+dmaster_rot[3]+dmaster_rot[8]+dmaster_rot[15]+dmaster_rot[16]+dmaster_rot[8]+dmaster_rot[10]+dmaster_rot[22]+dmaster_rot[22]+dmaster_rot[10]+dmaster_rot[13]+dmaster_rot[12]+dmaster_rot[21]+dmaster_rot[0]+dmaster_rot[22]+dmaster_rot[11]+dmaster_rot[22]+dmaster_rot[13]+dmaster_rot[1]+dmaster_rot[23]+dmaster_rot[21]+dmaster_rot[9]+dmaster_rot[3]+dmaster_rot[15]+dmaster_rot[15]+dmaster_rot[3]+dmaster_rot[11]+dmaster_rot[23]+dmaster_rot[10]+dmaster_rot[23]+dmaster_rot[13]+dmaster_rot[1]+dmaster_rot[23]+dmaster_rot[10]+dmaster_rot[9]+dmaster_rot[1]+dmaster_rot[2]+dmaster_rot[12]+dmaster_rot[23]+dmaster_rot[10]+dmaster_rot[22]+dmaster_rot[12]+dmaster_rot[0]+dmaster_rot[21]+dmaster_rot[23]+dmaster_rot[12]+dmaster_rot[8]+dmaster_rot[20]+dmaster_rot[12]+dmaster_rot[23]+dmaster_rot[13]+dmaster_rot[8]+dmaster_rot[9]+dmaster_rot[3]+dmaster_rot[8]
        if int(len(get_keywords_found(cleartext_rot))) >3: ## Number of keywords to be found in cleartext_rot
            print (rotary, dmaster_rot, cleartext_rot, get_keywords_found(cleartext_rot))
    w = w + 1
print ('List complete')
*ZODIACHRONOLOGY*
User avatar
Quicktrader
 
Posts: 1497
Joined: Mon Apr 01, 2013 11:23 am
Location: Vienna, Austria (Europe)

Re: Dorabella - Edward Elgar

Postby Quicktrader » Thu Mar 09, 2017 1:01 pm

Update with the Dorabella cipher..

Did rewrite both, the Python program as well as the dictionary. Latter is now based on word roots, thus goes faster (e.g. searching for 'SELF' only instead of 'HIMSELF', 'HERSELF', 'MYSELF' etc..). Assuming that the cipher was written in English, too.

It is possible to create a computable string of 28 letters, checking out all possible variations. Symbols with frequency >5% rather to be placed in the top alphabet segment (ETAOINSHRDLC) and vice versa. One may consider a group of the letters, e.g. ABC, being placed on one segment of the pigpen-cipher-style circle Elgar had used (http://2.bp.blogspot.com/-CCrOaObtH2E/U ... tebook.gif). According to Elgar's notes there'd exist 2^8 x 8! = 10,321,920 variations.

With Python I was able to computate all of those variations, however no useful result exists. This may have only three reasons:
A - Elgar did not 'group' the letters in groups of three, as he did in his notes
B - Elgar had used a different language, e.g. French or Latin
C - Transcription of the cipher went wrong (two or three symbols are not 100% clear if they go e.g. 'down' or 'down to the right')

Based on the so far 'knowledge' that none of the 10,321,920 variations delivers any useful result, I started to check out the 'A' possibility meaning that Elgar had shuffled his letters indiscriminately without considering any groups of three letters. As four cipher symbols haven't been used at all ('left 1', 'left 2', 'lower left 3' and 'upper right 3' - the numbers represent the amount of half rings), a total of 20 alphabetical letters may have been used in the key. Thus 20! or 2,432,902,008,176,640,000 variations do exist (the encryption is quite efficient, imo....).

This variety may be reduced due to differentiation of symbols occurring often, average or less (top, middle or lower alphabet frequency). In addition to this, the search procedure can be built up in multiple levels (e.g. finding one word of length > 4 in a string of 10 letters, finding the next one in a second string etc. and finally finding at least three words in a string of 28 letters - which is what I currently do).

In addition to this one may assume that the symbol with approximately 12.5% is representing the letter 'E' ('upper left 2'), a secend letter may be entered into the python program on each individual 'run'.

One run currently takes approximately 5-6 hours, thus I already was able to set the letter E plus the letter T, which hasn't provided with any useful results (talking about approximately 500,000 results that may deliver a minimum of e.g. 3 words in the 28-letter string, however those don't match - e.g. two words overlapping).

There is one section reading somehow like 'ABBA', which rather excludes potential cleartext combinations such as TWWT etc (with 'B' symbol representing a non-frequent alphabetical letter..thus rather no vowel).

Results currently look like this and should it be possible to find a solution sooner or later based on the chosen method (if things go well):

Code: Select all
EWENGOLDACCAWOLONGOLDGZOOLEO [{'index': 4, 'word': 'gold'}, {'index': 14, 'word': 'long'}, {'index': 17, 'word': 'gold'}]
EGENSODRAWWAGONONSONRSPOONEO [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 21, 'word': 'spoon'}]
EGENSODRAWWAGONONSONRSPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENRODRAWWAGONONRONRRPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENROLLAWWAGONONRONLRPHONEH [{'index': 2, 'word': 'enroll'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENHODRAWWAGONONHONRHPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENHOURAWWAGONONHONRHPHONEH [{'index': 4, 'word': 'hour'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENHOLDAWWAGONONHONDHPHONEH [{'index': 4, 'word': 'hold'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENLOSSAWWAGONONLONSLPHONEH [{'index': 4, 'word': 'loss'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENLODRAWWAGONONLONRLPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENLOSGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLORGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLOHGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLOLGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLODGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLOCGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLOUGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLOMGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLOFGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLOPGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLOGGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENLOWGAWWAGONONLONGLPHONEH [{'index': 10, 'word': 'wagon'}, {'index': 17, 'word': 'long'}, {'index': 22, 'word': 'phone'}]
EGENDODRAWWAGONONDONRDPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENCODRAWWAGONONCONRCPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENUODRAWWAGONONUONRUPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENMODRAWWAGONONMONRMPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENFODRAWWAGONONFONRFPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENFOURAWWAGONONFONRFPHONEH [{'index': 4, 'word': 'four'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENFORMAWWAGONONFONMFPHONEH [{'index': 4, 'word': 'form'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENPODRAWWAGONONPONRPPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENGODRAWWAGONONGONRGPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENGOLDAWWAGONONGONDGPHONEH [{'index': 4, 'word': 'gold'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENWODRAWWAGONONWONRWPHONEH [{'index': 6, 'word': 'draw'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]
EGENWORDAWWAGONONWONDWPHONEH [{'index': 4, 'word': 'word'}, {'index': 10, 'word': 'wagon'}, {'index': 22, 'word': 'phone'}]


QT
*ZODIACHRONOLOGY*
User avatar
Quicktrader
 
Posts: 1497
Joined: Mon Apr 01, 2013 11:23 am
Location: Vienna, Austria (Europe)

Re: Dorabella - Edward Elgar

Postby Quicktrader » Sat Mar 18, 2017 5:42 pm

Sommmmmething new:

So far I had a Python tool programmed to analyze and hopefully solve the Dorabella cipher. The problem with it was that it worked sort of homophone style rather than strictly monoalphabetic (substitution cipher). This has lead to multiple variations which in practice wouldn't occurr, thus more potential solutions, computation etc.

This is why I deepened into some permutations (wasn't that easy..) as well as grouped the symbols occurring as frequent, middle or non-frequent. By doing so, computation effort can be kept somehow low, at least.

Program is still running, way less results than before (which is actually good as we are looking for only one, the valid solution). Thought I place the Python code here, it builds up an array of 'chains' according to which symbol is at some cipher-destined place as well as represented by any letter from the three alphabetical groups (above). All chains are later analyzed on words of a pigpen dictionary (e.g. HAUE instead of HAVE). So far, no spectacular results have occured. The 12.5% symbol is assumed to be represented by 'E', the second most is entered individually (currently 'T', may be modified in 'alph_top'). Symbols are 'named' like the direction of the symbols, e.g. ro1 quite German for 'rechts oben eins' (upper right one, would be 'ur1' in English).

The program covers the first 26 letters of the cipher, which actually should provide at least 4-6 'hits' in the dictionary.

Code: Select all
lex = ['HAUE',...##dictionary]
alpha_top = ["A", "O", "I", "N", "S", "R", "H", "L", "D", "C"] ## w/o E, ro1
alpha_mid = ["R", "H", "L", "D", "C", "U", "M", "F", "P", "G", "W"]
alpha_low = ["F", "P", "G", "W", "Y", "B", "K", "X", "Q", "Z"]

oo1 = 0
..
lo3 = 0
## variable defintions

AHO CORASICK
... ## place here Aho Corasick or any other linguistic analyzer function)
import re
AdjList = []
init_trie(lex)
...


print ('FCCP-List')
lo2 = 'E'
ro1 = input ("ro1: ")
from itertools import *
for t in permutations(["A", "O", "I", "N", "S", "R", "H", "L"],3): ## Amount of different letters from 'top'
    for m in permutations (["H", "L", "D", "C", "U", "M", "F", "P", "G", "W"],7): ## Amount of different letters from 'mid'
        for l in permutations (["G", "W", "Y", "B", "K", "Z"],3): ## Amount of different letters from 'low'
            rr2 = l[0]
            ll3 = m[0]
            ru2 = t[0]
            rr3 = t[1]
            rr1 = l[1]
            uu2 = t[2]
            oo1 = m[1]
            lu1 = m[2]
            ro2 = m[3]
            ru3 = m[4]
            lo1 = m[5]
            ru1 = m[6]
            uu3 = l[2]
            chain = rr2+ll3+ru2+rr3+rr1+uu2+oo1+rr3+lu1+ro2+ru3+lo2+lo1+ru1+lo2+uu3+lo2+lo2+uu2+ll3+ll3+lo2+ru1+ro1+ro2+ro1
            if int(len(get_keywords_found(chain))) >1: ## Minimum Keywords
                print (chain, get_keywords_found(chain))
print ('List complete')


The program is now running quite fine, the latest result was e.g.

ZLAIKOWIUDGEPFEBEEOLLEFTDT [{'index': 7, 'word': 'iudge'}, {'index': 20, 'word': 'left'}]

which obviously is not the final solution, yet. To figure out the correct way of permutation was quite tough as the number of disjunct letters was necessary in the beginning although the chains are built later-on..whatever, it now works. Based on the Dorabella pigpen cipher style, the word 'judge' is correctly being found as 'iudge' (I=J and U=V), too.

QT
*ZODIACHRONOLOGY*
User avatar
Quicktrader
 
Posts: 1497
Joined: Mon Apr 01, 2013 11:23 am
Location: Vienna, Austria (Europe)


Return to The Hangout

Who is online

Users browsing this forum: No registered users and 1 guest

cron