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 = []
for i in range(0, 10):
if deltaA > deltaB:
result.append(C[int(ceil(i*deltaA/deltaB))])
else:
result.append(C[i])
return result, deltaA
def main():
sum_result, delta_sum = sum(A, deltaA, B, deltaB)
diff_result, delta_diff = diff(sum_result, deltaA, deltaB)
slow_result, delta_slow = diff(sum_result, deltaB, deltaA)
print("Sum:", sum_result[0:10], " deltaSum:", delta_sum)
print("Diff(Sum):", diff_result[0:10], " deltaDiff:", delta_diff)
print("Diff(Sum, slower):", slow_result[0:10], " deltaDiff:", delta_slow)
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
Diff(Sum, slower): ['1a', '3b', '5c', '7d', '9e', '11f', '13g', '15h', '17i', '19j'] deltaDiff: 1
The diff function takes the target interval as deltaA, while deltaB is the interval of the join’s other component. The input C has interval min(deltaA, deltaB). The result must return the target interval even when it is larger than the input interval: the second example selects every other record and has interval 1, rather than 1/2. Difference selects whole join records; it does not remove the other component’s fields.
Source code
Historical model scripts are available in the project repository under /examples/python-model/. The listings above show the corrected difference function and its interval convention.
A JavaScript implementation can be tested directly on the site: