def compute_derivative_of_interpolation_polynomial(
determinant_of_original_matrix, field_size, i_value, j_value,
l_iterator, matrix, summation_boundary_t):
result = 0
# print("I: {} J: {} L: {} T: {}".format(i_value, j_value, l_iterator, summation_boundary_t))
for k in range(j_value, summation_boundary_t + 1):
# print("K: {}".format(k))
# apply the formula for each k
#
k_term = divide((math.factorial(k) % field_size),
((math.factorial(k - j_value)) % field_size),
field_size)
minus_one_term = ((-1)**(l_iterator - 1 + k)) % field_size
divided_determinant = divide(
int(determinant(get_minor(matrix, l_iterator - 1, k), field_size)),
determinant_of_original_matrix, field_size)
#
i_term = i_value**(k - j_value)
former_result = result
result = (result +
(k_term * minus_one_term * divided_determinant * i_term) %
field_size) % field_size
'''
print(result, "=", former_result, "+(", k_term, "*", minus_one_term, "*([",
int(determinant(get_minor(matrix, l_iterator - 1, k), field_size)), "/",
determinant(matrix, field_size), "=", divided_determinant, "])*", i_term, ")")
'''
return result
def compute_polynomial(x_values, y_values, k, field_size, print_statements):
polynomials = []
for l in range(len(x_values)):
l_polynomial = []
for j in range(k):
l_k_n = 1
equation = []
# m: iteration index
for m in range(k):
# j: index for this specific lagrange coefficient
if m != j:
# p = divide(x - int(x_values[m]), int(x_values[j]) - int(x_values[m]), field_size) % field_size
divisor = divide(1, int(x_values[j]) - int(x_values[m]), field_size)
equation.append(([divisor, 1], [(- int(x_values[m]) * divisor) % field_size, 0]))
# print("EQ:", equation)
# print("EQ:", equation)
try:
tmp = equation[0]
# print(tmp)
for tup in range(1, k-1):
tmp = multiply(tmp, equation[tup], field_size)
tmp = [[(tmp[i][0] * y_values[j]) % field_size, tmp[i][1]] for i in range(len(tmp))]
# print(tmp)
l_polynomial.append(tmp)
# print("-->", l_polynomial)
except IndexError:
return -1
polynomial = sum_polynomials(l_polynomial, field_size)
if print_statements:
print("Reconstructed polynomial:", print_function(polynomial, False))
return polynomial
def lagrange_polynomial(j, k, x_values, x, field_size):
l_k_n = 1
# m: iteration index
for m in range(k):
# j: index for this specific lagrange coefficient
if m != j:
p = divide(x - int(x_values[m]), int(x_values[j]) - int(x_values[m]), field_size) % field_size
l_k_n = (l_k_n * p) % field_size
return l_k_n
def compute_birkhoff_coefficients_and_polynomials(
degree_of_function, determinant_of_original_matrix, field_size,
function_dict, matrix, person_ids, print_statements, vector_of_shares):
for i, share in enumerate(vector_of_shares):
# calculate birkhoff interpolation coefficient
birkhoff_coefficient = (int(share) * (-1)**i * divide(
(determinant(get_minor(matrix, i, 0), field_size)) % field_size,
determinant_of_original_matrix, field_size)) % field_size
# generate a function with the coefficient as scalar
function_dict[person_ids[i]] = generate_function(
degree_of_function, birkhoff_coefficient, field_size)
if print_statements or debug:
print("Birkhoff Coefficient a_{}_0:".format(i + 1),
birkhoff_coefficient, "=", share, "*(-1)**", i, "*",
(determinant(get_minor(matrix, i, 0), field_size)) %
field_size, '/', determinant_of_original_matrix)
def binomial_coefficient(n, k, field_size):
try:
if n == k or k == 0:
return 1
elif k == 1:
return n
else:
return (int(
divide((math.factorial(n) % field_size),
((math.factorial(k) % field_size *
math.factorial(n - k) % field_size) % field_size),
field_size)))
except ValueError as e:
print(e)
raise ValueError(
"In binomial_coefficient: n must be bigger or equal k;\n{}".format(
e))
def compute_interpolation_constant(i, k, participating_ids, field_size):
gamma_i = 1
for j in participating_ids:
if j != i:
gamma_i = (gamma_i * divide((k - j) % field_size, (i - j) % field_size, field_size)) % field_size
return gamma_i