def generate_session_parameters():
global sess_param_computed
delta = 1
alpha = 1
beta = 1
temp_q = 1
for _ in range(m):
p = sympy.sieve[random.randrange(psize)]
pm.append(p)
temp_q *= p
for _ in range(n):
p = sympy.sieve[random.randrange(psize)]
while p in pm:
p = sympy.sieve[random.randrange(psize)]
pn.append(p)
delta *= pow(p, 3)
alpha *= pow(p, 2)*(p-1)
beta *= p*(p-1)*temp_q
y = random.randrange(delta)
while sympy.igcd(y, delta) != 1:
y = random.randrange(delta)
sess_param_computed = True
params["alpha"] = alpha
params["delta"] = delta
params["beta"] = beta
params["totient_delta"] = totient(delta)
params["y"] = y
def count_blinds_in_triangle(n):
total = 0
for level in range(2, ((n + 1) // 2) + 1):
t = totient(level)
total += t * (int(n / level) - 1)
if level % 10000 == 0:
print("%{:.2f}".format((level / n) * 100))
return total
def range_totient(n: int, max_: int, min_: int = 2) -> int:
"""
Calculate the count of numbers in an interval which are coprime to n
"""
full_range = int(max_ - min_ - ((max_ - min_) % n))
rt = int(round(totient(n) / n * full_range, 12))
new_min = min_ + full_range + 1
for i in range(new_min, max_ + 1):
if are_coprime(i, n):
rt += 1
return rt
def matrix():
determinant = []
circulant_matrix = []
eigenvalues=[]
for i in range(2, 21):
array = []
for j in range(1, i + 1):
l = totient(j)
array.append(l)
circulant_matrix.append(circulant(array))
determinant.append(det(np.transpose(circulant_matrix[-1])))
eigenvalues.append(eigvals(circulant_matrix[-1]))
i = range(2, 21)
df = DataFrame({'n': i, 'determininant': determinant, 'eigenvalues': eigenvalues})
df.to_excel('rough.xlsx', index=False)
for i in range(len(determinant)):
print(np.transpose(circulant_matrix[i]))
print("the eigenvalues of circulant matrix for n= " + str(i + 2) + " is " + str(eigenvalues[i]))
print("the determinant of circulant matrix for n= " + str(i + 2) + " is " + str(determinant[i]))
print()
def group_isomorphism(G, H, isomorphism=True):
'''
Compute an isomorphism between 2 given groups.
Arguments:
G (a finite `FpGroup` or a `PermutationGroup`) -- First group
H (a finite `FpGroup` or a `PermutationGroup`) -- Second group
isomorphism (boolean) -- This is used to avoid the computation of homomorphism
when the user only wants to check if there exists
an isomorphism between the groups.
Returns:
If isomorphism = False -- Returns a boolean.
If isomorphism = True -- Returns a boolean and an isomorphism between `G` and `H`.
Summary:
Uses the approach suggested by Robert Tarjan to compute the isomorphism between two groups.
First, the generators of `G` are mapped to the elements of `H` and
we check if the mapping induces an isomorphism.
Examples
========
>>> from sympy.combinatorics import Permutation
>>> Permutation.print_cyclic = True
>>> from sympy.combinatorics.perm_groups import PermutationGroup
>>> from sympy.combinatorics.free_groups import free_group
>>> from sympy.combinatorics.fp_groups import FpGroup
>>> from sympy.combinatorics.homomorphisms import homomorphism, group_isomorphism
>>> from sympy.combinatorics.named_groups import DihedralGroup, AlternatingGroup
>>> D = DihedralGroup(8)
>>> p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
>>> P = PermutationGroup(p)
>>> group_isomorphism(D, P)
(False, None)
>>> F, a, b = free_group("a, b")
>>> G = FpGroup(F, [a**3, b**3, (a*b)**2])
>>> H = AlternatingGroup(4)
>>> (check, T) = group_isomorphism(G, H)
>>> check
True
>>> T(b*a*b**-1*a**-1*b**-1)
(0 2 3)
'''
if not isinstance(G, (PermutationGroup, FpGroup)):
raise TypeError("The group must be a PermutationGroup or an FpGroup")
if not isinstance(H, (PermutationGroup, FpGroup)):
raise TypeError("The group must be a PermutationGroup or an FpGroup")
if isinstance(G, FpGroup) and isinstance(H, FpGroup):
G = simplify_presentation(G)
H = simplify_presentation(H)
# Two infinite FpGroups with the same generators are isomorphic
# when the relators are same but are ordered differently.
if G.generators == H.generators and (G.relators).sort() == (
H.relators).sort():
if not isomorphism:
return True
return (True, homomorphism(G, H, G.generators, H.generators))
# `_H` is the permutation group isomorphic to `H`.
_H = H
g_order = G.order()
h_order = H.order()
if g_order == S.Infinity:
raise NotImplementedError(
"Isomorphism methods are not implemented for infinite groups.")
if isinstance(H, FpGroup):
if h_order == S.Infinity:
raise NotImplementedError(
"Isomorphism methods are not implemented for infinite groups.")
_H, h_isomorphism = H._to_perm_group()
if (g_order != h_order) or (G.is_abelian != H.is_abelian):
if not isomorphism:
return False
return (False, None)
if not isomorphism:
# Two groups of the same cyclic numbered order
# are isomorphic to each other.
n = g_order
if (igcd(n, totient(n))) == 1:
return True
# Match the generators of `G` with subsets of `_H`
gens = list(G.generators)
for subset in itertools.permutations(_H, len(gens)):
images = list(subset)
images.extend([_H.identity] * (len(G.generators) - len(images)))
_images = dict(zip(gens, images))
if _check_homomorphism(G, _H, _images):
if isinstance(H, FpGroup):
images = h_isomorphism.invert(images)
T = homomorphism(G, H, G.generators, images, check=False)
if T.is_isomorphism():
# It is a valid isomorphism
if not isomorphism:
return True
return (True, T)
if not isomorphism:
return False
return (False, None)
import math
from math import gcd
from sympy.ntheory.factor_ import totient
from fractions import gcd
from functools import reduce
def f(n):
return 27*(n**3)+9*(n**2)+3*n+1 #poly
n=1
l=[]
while n<250:
l.append(totient(f(n)))
n=n+1
print(reduce(gcd,l))
def modular_inverse(n: int, base: int) -> int:
"""Returns the modular inverse of n in base"""
n **= totient(base) - 1
n %= base
return n
p = sympy.sieve[random.randrange(psize)]
while p in pm:
p = sympy.sieve[random.randrange(psize)]
pn.append(p)
delta *= pow(p, 3)
alpha *= pow(p, 2) * (p - 1)
beta *= p * (p - 1) * temp_q
assert pow(beta, 2) % alpha == 0, 'alpha does not divide beta^2'
assert beta % alpha != 0, 'alpha divides beta'
print('beta % alpha', beta % alpha)
print("pn: {0}\npm: {1}\n".format(pn, pm))
totient_delta = totient(delta)
y = random.randrange(delta)
while sympy.igcd(y, delta) != 1:
y = random.randrange(delta)
print("delta: {0}\n beta: {1}\n alpha: {2}\n y: {3}".format(
delta, beta, alpha, y))
# Alice work (recebe delta, beta e alpha de trent)
xa = random.randrange(1, delta)
xb = random.randrange(1, totient_delta)
while xb * beta % totient_delta == 0:
xb = random.randrange(totient_delta)
gamma = alpha * pow(xa, 2) + beta * xb
def totient(n: Union[int, float, complex]) -> int:
try:
import sympy.ntheory.factor_ as f_
except ModuleNotFoundError:
raise Exception("Install sympy to use number-theoretic functions!")
return f_.totient(cint(n))
def egcd(a, b):
x,y, u,v = 0,1, 1,0
while a != 0:
q, r = b//a, b%a
m, n = x-u*q, y-v*q
b,a, x,y, u,v = a,r, u,v, m,n
gcd = b
return gcd, x, y
if __name__ == '__main__':
f = open("./bin/joan.marc.pastor_pubkeyRSA_pseudo.pem")
key = RSA.import_key(f.read())
f.close()
n = key.n
e = key.e
# totient() implementation: https://docs.sympy.org/latest/_modules/sympy/ntheory/factor_.html#totient
phiN = totient(n)
gcd, a, b = egcd(e, phiN)
if (a >= 0):
d = a
else:
d = a + phiN
key = RSA.construct((n, e, d), consistency_check=False)
f = open("./out/RSAprivateKey.pem", "wb")
f.write(key.export_key("PEM"))
f.close()
def group_isomorphism(G, H, isomorphism=True):
'''
Compute an isomorphism between 2 given groups.
Arguments:
G (a finite `FpGroup` or a `PermutationGroup`) -- First group
H (a finite `FpGroup` or a `PermutationGroup`) -- Second group
isomorphism (boolean) -- This is used to avoid the computation of homomorphism
when the user only wants to check if there exists
an isomorphism between the groups.
Returns:
If isomorphism = False -- Returns a boolean.
If isomorphism = True -- Returns a boolean and an isomorphism between `G` and `H`.
Summary:
Uses the approach suggested by Robert Tarjan to compute the isomorphism between two groups.
First, the generators of `G` are mapped to the elements of `H` and
we check if the mapping induces an isomorphism.
Examples
========
>>> from sympy.combinatorics import Permutation
>>> from sympy.combinatorics.perm_groups import PermutationGroup
>>> from sympy.combinatorics.free_groups import free_group
>>> from sympy.combinatorics.fp_groups import FpGroup
>>> from sympy.combinatorics.homomorphisms import homomorphism, group_isomorphism
>>> from sympy.combinatorics.named_groups import DihedralGroup, AlternatingGroup
>>> D = DihedralGroup(8)
>>> p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
>>> P = PermutationGroup(p)
>>> group_isomorphism(D, P)
(False, None)
>>> F, a, b = free_group("a, b")
>>> G = FpGroup(F, [a**3, b**3, (a*b)**2])
>>> H = AlternatingGroup(4)
>>> (check, T) = group_isomorphism(G, H)
>>> check
True
>>> T(b*a*b**-1*a**-1*b**-1)
(0 2 3)
'''
if not isinstance(G, (PermutationGroup, FpGroup)):
raise TypeError("The group must be a PermutationGroup or an FpGroup")
if not isinstance(H, (PermutationGroup, FpGroup)):
raise TypeError("The group must be a PermutationGroup or an FpGroup")
if isinstance(G, FpGroup) and isinstance(H, FpGroup):
G = simplify_presentation(G)
H = simplify_presentation(H)
# Two infinite FpGroups with the same generators are isomorphic
# when the relators are same but are ordered differently.
if G.generators == H.generators and (G.relators).sort() == (H.relators).sort():
if not isomorphism:
return True
return (True, homomorphism(G, H, G.generators, H.generators))
# `_H` is the permutation group isomorphic to `H`.
_H = H
g_order = G.order()
h_order = H.order()
if g_order == S.Infinity:
raise NotImplementedError("Isomorphism methods are not implemented for infinite groups.")
if isinstance(H, FpGroup):
if h_order == S.Infinity:
raise NotImplementedError("Isomorphism methods are not implemented for infinite groups.")
_H, h_isomorphism = H._to_perm_group()
if (g_order != h_order) or (G.is_abelian != H.is_abelian):
if not isomorphism:
return False
return (False, None)
if not isomorphism:
# Two groups of the same cyclic numbered order
# are isomorphic to each other.
n = g_order
if (igcd(n, totient(n))) == 1:
return True
# Match the generators of `G` with subsets of `_H`
gens = list(G.generators)
for subset in itertools.permutations(_H, len(gens)):
images = list(subset)
images.extend([_H.identity]*(len(G.generators)-len(images)))
_images = dict(zip(gens,images))
if _check_homomorphism(G, _H, _images):
if isinstance(H, FpGroup):
images = h_isomorphism.invert(images)
T = homomorphism(G, H, G.generators, images, check=False)
if T.is_isomorphism():
# It is a valid isomorphism
if not isomorphism:
return True
return (True, T)
if not isomorphism:
return False
return (False, None)
from sympy.ntheory.factor_ import totient p = 78203 q = 79999 print(totient(p * q))
print("\n============\nSolution :\n============\n")
data = np.array(data)
print("M = product of all modulos =", " * ".join(map(str, data[:, 1])), "=", end = " ")
M = np.prod(data[:, 1])
print(M, '\n')
M_arr = M//data[:, 1]
print("Now, ")
for i in range(len(M_arr)):
print("M" + str(i+1), "=", "M/m" + str(i+1), "=", M_arr[i])
print()
inv_M = [pow(int(M_arr[i]), totient(data[i][1]) - 1, int(data[i][1])) for i in range(len(M_arr))]
print("Now, ")
for i in range(len(M_arr)):
print("M" + str(i+1) + "^(-1) (mod m" + str(i+1) + ") =", inv_M[i])
print()
ans = 0
print("Now, x = (Summation of all (ai)*(Mi)*(Mi^(-1)) (mod M), for all i = 1(1)n\n")
print("So, x =", end = " ")
for i in range(len(M_arr)):
if i == len(M_arr)-1:
print(str(data[i][0]) + "*" + str(M_arr[i]) + "*" + str(inv_M[i]), "(mod " + str(M) + ")")
else:
print(str(data[i][0]) + "*" + str(M_arr[i]) + "*" + str(inv_M[i]) + " +", end = " ")
ans = (ans + (int(data[i][0]) * int(M_arr[i]) * int(inv_M[i])) % M) % M
def phi(n):
return totient(n)
import math
from sympy.ntheory.factor_ import totient
if __name__ == '__main__':
a, m = list(map(int, input("Enter number and modulo : ").split()))
assert(math.gcd(a,m) == 1)
phi = totient(m)
for i in range(1, phi+1):
if phi%i == 0:
if pow(a,i,m) == 1:
break
print("\nORD(a) =", i, "(mod m)\n")
def len_of_chain(n):
if n == 1:
return 1
return 1 + len_of_chain(totient(n))
