Model Implementation
The developed algebra equations were first implemented in Python. This is, to my knowledge, the most effective way to model and numerically verify hypotheses. Each operator was implemented inside a separate function. Operations are carried out on rational variables (the Fraction library). Results are presented as bounded arrays. In the final implementation, however, these operators operate on infinite data structures.
Interleaving operation
Let’s start by building the interleaving operation:
Source code
# Interleaving (hash) operation on two lists with given steps (delta).
from fractions import Fraction
from math import floor, ceil
A = range(1, 24)
deltaA = Fraction(1, 2)
B = list(map(chr, range(ord('a'), ord('z')+1)))
deltaB = Fraction(1, 2)
def hash(A: list, deltaA: Fraction, B: list, deltaB: Fraction):
result = []
delta = deltaB / (deltaA + deltaB)
for i in range(0, 20):
if floor(i*delta) == floor((i+1)*delta):
result.append(B[i-int(floor((i+1)*delta))])
else:
result.append(A[int(floor(i*delta))])
deltaC = (deltaA*deltaB)/(deltaA+deltaB)
return result, deltaC
def main():
print("A:", A[0:10], " deltaA:", deltaA)
print("B:", B[0:10], " deltaB:", deltaB)
hash_result1, delta_hash1 = hash(A, deltaA, B, deltaB)
hash_result2, delta_hash2 = hash(B, deltaB, A, deltaA)
print("Hash(A,B):", hash_result1[0:10], " deltaHash:", delta_hash1)
print("Hash(B,A):", hash_result2[0:10], " deltaHash:", delta_hash2)
if __name__ == '__main__':
main()
Run output
$ python hash.py
A: range(1, 11) deltaA: 1/2
B: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] deltaB: 1/2
Hash(A,B): ['a', 1, 'b', 2, 'c', 3, 'd', 4, 'e', 5] deltaHash: 1/4
Hash(B,A): [1, 'a', 2, 'b', 3, 'c', 4, 'd', 5, 'e'] deltaHash: 1/4
Running the code prints the input data A and B, along with the results of the operations A#B and B#A. As you can see, the interleaving operation is not commutative.
De-interleaving operation
The de-interleaving operation requires implementing two complementary operations.
Source code - even
# De-interleaving (dehash) operation, even.
from fractions import Fraction
from math import floor, ceil
A = range(1, 24)
deltaA = Fraction(1, 2)
B = list(map(chr, range(ord('a'), ord('z')+1)))
deltaB = Fraction(1, 2)
def hash(A: list, deltaA: Fraction, B: list, deltaB: Fraction):
result = []
delta = deltaB / (deltaA + deltaB)
for i in range(0, 20):
if floor(i*delta) == floor((i+1)*delta):
result.append(B[i-int(floor((i+1)*delta))])
else:
result.append(A[int(floor(i*delta))])
deltaC = (deltaA*deltaB)/(deltaA+deltaB)
return result, deltaC
def dehasheven(C: list, deltaC: Fraction, deltaA: Fraction):
result = []
deltaB = deltaA*deltaC / (deltaA - deltaC)
for i in range(0, 6):
result.append(C[i+int(ceil((i+1)*deltaA/deltaB))])
return result, deltaB
def main():
hash_result, delta_hash = hash(B, deltaB, A, deltaA)
print("Hash(A,B):", hash_result[0:10], " deltaHash:", delta_hash)
mod_result, delta_mod = dehasheven(hash_result, delta_hash, deltaA)
print("Mod(Hash):", mod_result[0:10], " deltaMod:", delta_mod)
if __name__ == '__main__':
main()
result - even
$ python dehash_even.py
Hash(A,B): [1, 'a', 2, 'b', 3, 'c', 4, 'd', 5, 'e'] deltaHash: 1/4
Mod(Hash): ['a', 'b', 'c', 'd', 'e', 'f'] deltaMod: 1/2
Source code - odd
# De-interleaving (dehash) operation, odd.
from fractions import Fraction
from math import floor, ceil
A = range(1, 24)
deltaA = Fraction(1, 2)
B = list(map(chr, range(ord('a'), ord('z')+1)))
deltaB = Fraction(1, 2)
def hash(A: list, deltaA: Fraction, B: list, deltaB: Fraction):
result = []
delta = deltaB / (deltaA + deltaB)
for i in range(0, 20):
if floor(i*delta) == floor((i+1)*delta):
result.append(B[i-int(floor((i+1)*delta))])
else:
result.append(A[int(floor(i*delta))])
deltaC = (deltaA*deltaB)/(deltaA+deltaB)
return result, deltaC
def dehashodd(C: list, deltaC: Fraction, deltaB: Fraction):
result = []
deltaA = deltaB*deltaC / (deltaB - deltaC)
for i in range(0, 6):
result.append(C[i+int(i*deltaB/deltaA)])
return result, deltaA
def main():
hash_result, delta_hash = hash(B, deltaB, A, deltaA)
print("Hash(A,B):", hash_result[0:10], " deltaHash:", delta_hash)
div_result, delta_div = dehashodd(hash_result, delta_hash, deltaB)
print("Div(Hash):", div_result[0:10], " deltaDiv:", delta_div)
if __name__ == '__main__':
main()
result - odd
$ python dehash_odd.py
Hash(A,B): [1, 'a', 2, 'b', 3, 'c', 4, 'd', 5, 'e'] deltaHash: 1/4
Div(Hash): [1, 2, 3, 4, 5, 6] deltaDiv: 1/2
This code first joins two streams and then extracts the source data back out.
Sum operation
Summation joins two data streams arriving at different rates.
Source code
# Summation operation on two lists with given steps (delta).
from fractions import Fraction
from math import floor, ceil
A = range(1, 24)
deltaA = Fraction(1, 2)
B = list(map(chr, range(ord('a'), ord('z')+1)))
deltaB = Fraction(1)
def sum(A: list, deltaA: Fraction, B: list, deltaB: Fraction):
result = []
deltaC = min(deltaA, deltaB)
for i in range(0, 20):
if deltaC == deltaA:
result.append(str(A[i])+B[int(i*deltaA/deltaB)]),
else:
result.append(str(A[int(i*deltaB/deltaA)])+B[i]),
return result, deltaC
def main():
print("A:", A[0:10], " deltaA:", deltaA)
print("B:", B[0:10], " deltaB:", deltaB)
sum_result, delta_sum = sum(A, deltaA, B, deltaB)
print("Sum:", sum_result[0:10], " deltaSum:", delta_sum)
if __name__ == '__main__':
main()
result
$ python sum.py
A: range(1, 11) deltaA: 1/2
B: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] deltaB: 1
Sum: ['1a', '2a', '3b', '4b', '5c', '6c', '7d', '8d', '9e', '10e'] deltaSum: 1/2
Difference operation
The complementary operation to sum is the difference operation.
Source code
# Difference (diff) operation on two lists with given steps (delta).
from fractions import Fraction
from math import floor, ceil
A = range(1, 24)
deltaA = Fraction(1, 2)
B = list(map(chr, range(ord('a'), ord('z')+1)))
deltaB = Fraction(1)
def sum(A: list, deltaA: Fraction, B: list, deltaB: Fraction):
result = []
deltaC = min(deltaA, deltaB)
for i in range(0, 20):
if deltaC == deltaA:
result.append(str(A[i])+B[int(i*deltaA/deltaB)]),
else:
result.append(str(A[int(i*deltaB/deltaA)])+B[i]),
return result, deltaC
def diff(C: list, deltaA: Fraction, deltaB: Fraction):
result = []
deltaC = min(deltaA, deltaB)
for i in range(0, 10):
if deltaA > deltaB:
result.append(C[int(ceil(i*deltaA/deltaB))])
else:
result.append(C[i])
return result, deltaC
def main():
sum_result, delta_sum = sum(A, deltaA, B, deltaB)
diff_result, delta_diff = diff(sum_result, deltaA, deltaB)
print("Sum:", sum_result[0:10], " deltaSum:", delta_sum)
print("Diff(Sum):", diff_result[0:10], " deltaDiff:", delta_diff)
if __name__ == '__main__':
main()
result
$ python diff.py
Sum: ['1a', '2a', '3b', '4b', '5c', '6c', '7d', '8d', '9e', '10e'] deltaSum: 1/2
Diff(Sum): ['1a', '2a', '3b', '4b', '5c', '6c', '7d', '8d', '9e', '10e'] deltaDiff: 1/2
Source code
The source code for the examples shown here can be found in the project repository under the /examples/python-model/ directory.
A JavaScript implementation can be tested directly on the site: