MathWork01 Part 01 (intro) MathWork01 Part 02 MathWork02
Introduction: On this page I describe a very simple
process of coding&decoding a string of 10 ciphers. As an example I
decode the number 3145926554.
If you know a little bit more about mathematics you see the number is 10^{9} times p. 

Let's just start calculating, every pair of neighboring
ciphers are added together (if the sum exceeds 10 you must lower it by
10).
Start of coding:


Now each neighboring pair of ciphers is added (and may be corrected by 10):


You see; we have now 9 ciphers and so there must be some
loss of information. If you try do decode the 9 cipher code you see
there are 10 possible solutions, this fits with the idea of having 1
less cipher. If we would, for example, know the first 'true cipher' (the 3) then it would be easy to decode this string of 9 ciphers into the original sting of 10 ciphers. But that would be a little to easy to decode. So we proceed further, from the string of 9 ciphers we form a new string of 8 ciphers in exactly the same way:

And so we go on and on until we are left with only one
cipher, you can do the calculation for yourself. If I did not make a
error, the last cipher will be 5.
Now we add the first true cipher 3 and the last calculated 5. We add
and find 8. 

If you know how the coding was done, the decoding is just
plain sailing (try it yourself).
As far as I know (but I am very limited in my knowledge on this), this method is not in use anywhere (and if it would, no one would tell because the decoding is so simple). 

You can easily change this method, for example, you could
transform the original 3145926554 in two steps to 94359919 and then
think of something to produce the 2 extra ciphers in front you need to
decode it. All other kinds of changes could be made, you could work with building blocks of 2 ciphers and add these blocks together (and lower by 100 if needed). Just as the latest example; the 3145926554 must be split up like this:
And so you calculate:
And just follow the same scheme as in the 'one cipher' manner. You can repeat different method's after one another because there is no information loss. Because this method only will work if all bits are there (so you must have 0% 'package loss') it would be wise to combine this with some kind of 'self repairing' code. A self repairing code is, for example, found in all your CD players (some extra information is added to the original info and you can withstand a fair portion of information loss before you run into trouble). At last, you could use a building block of 1 'cipher' but chosen from
an alphabet of 128 different 'letters' and each letter is represented
via a number 000, 001, ..., 127. Just like the Alt159 = Alt415 (but that
is with 256 different letters...). So you can
code text as well (there is no need to restrict this to numbers....). 

We leave this cute little math alone, it's free to use
like most of my creations.
If you find a good place to use this, please inform me (just out of curiosity).
And if you get rich from it, don't forget me please...
I will not write all kinds of theorems on this, if you are a
mathematician you can do that for yourself. 