diff --git a/blockchain/diophantine_equation.py b/blockchain/diophantine_equation.py
index 22b0cad75c63..7110d90230c9 100644
--- a/blockchain/diophantine_equation.py
+++ b/blockchain/diophantine_equation.py
@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+from maths.greatest_common_divisor import greatest_common_divisor
+
 
 def diophantine(a: int, b: int, c: int) -> tuple[float, float]:
     """
     Diophantine Equation : Given integers a,b,c ( at least one of a and b != 0), the
     diophantine equation a*x + b*y = c has a solution (where x and y are integers)
-    iff gcd(a,b) divides c.
+    iff greatest_common_divisor(a,b) divides c.
 
     GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
 
@@ -22,7 +24,7 @@ def diophantine(a: int, b: int, c: int) -> tuple[float, float]:
 
     assert (
         c % greatest_common_divisor(a, b) == 0
-    )  # greatest_common_divisor(a,b) function implemented below
+    )  # greatest_common_divisor(a,b) is in maths directory
     (d, x, y) = extended_gcd(a, b)  # extended_gcd(a,b) function implemented below
     r = c / d
     return (r * x, r * y)
@@ -69,32 +71,6 @@ def diophantine_all_soln(a: int, b: int, c: int, n: int = 2) -> None:
         print(x, y)
 
 
-def greatest_common_divisor(a: int, b: int) -> int:
-    """
-    Euclid's Lemma :  d divides a and b, if and only if d divides a-b and b
-
-    Euclid's Algorithm
-
-    >>> greatest_common_divisor(7,5)
-    1
-
-    Note : In number theory, two integers a and b are said to be relatively prime,
-           mutually prime, or co-prime if the only positive integer (factor) that
-           divides both of them is 1  i.e., gcd(a,b) = 1.
-
-    >>> greatest_common_divisor(121, 11)
-    11
-
-    """
-    if a < b:
-        a, b = b, a
-
-    while a % b != 0:
-        a, b = b, a % b
-
-    return b
-
-
 def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
     """
     Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers
diff --git a/blockchain/modular_division.py b/blockchain/modular_division.py
deleted file mode 100644
index a9d0f65c5b27..000000000000
--- a/blockchain/modular_division.py
+++ /dev/null
@@ -1,154 +0,0 @@
-from __future__ import annotations
-
-
-def modular_division(a: int, b: int, n: int) -> int:
-    """
-    Modular Division :
-    An efficient algorithm for dividing b by a modulo n.
-
-    GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
-
-    Given three integers a, b, and n, such that gcd(a,n)=1 and n>1, the algorithm should
-    return an integer x such that 0≤x≤n−1, and  b/a=x(modn) (that is, b=ax(modn)).
-
-    Theorem:
-    a has a multiplicative inverse modulo n iff gcd(a,n) = 1
-
-
-    This find x = b*a^(-1) mod n
-    Uses ExtendedEuclid to find the inverse of a
-
-    >>> modular_division(4,8,5)
-    2
-
-    >>> modular_division(3,8,5)
-    1
-
-    >>> modular_division(4, 11, 5)
-    4
-
-    """
-    assert n > 1 and a > 0 and greatest_common_divisor(a, n) == 1
-    (d, t, s) = extended_gcd(n, a)  # Implemented below
-    x = (b * s) % n
-    return x
-
-
-def invert_modulo(a: int, n: int) -> int:
-    """
-    This function find the inverses of a i.e., a^(-1)
-
-    >>> invert_modulo(2, 5)
-    3
-
-    >>> invert_modulo(8,7)
-    1
-
-    """
-    (b, x) = extended_euclid(a, n)  # Implemented below
-    if b < 0:
-        b = (b % n + n) % n
-    return b
-
-
-# ------------------ Finding Modular division using invert_modulo -------------------
-
-
-def modular_division2(a: int, b: int, n: int) -> int:
-    """
-    This function used the above inversion of a to find x = (b*a^(-1))mod n
-
-    >>> modular_division2(4,8,5)
-    2
-
-    >>> modular_division2(3,8,5)
-    1
-
-    >>> modular_division2(4, 11, 5)
-    4
-
-    """
-    s = invert_modulo(a, n)
-    x = (b * s) % n
-    return x
-
-
-def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
-    """
-    Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers x
-    and y, then d = gcd(a,b)
-    >>> extended_gcd(10, 6)
-    (2, -1, 2)
-
-    >>> extended_gcd(7, 5)
-    (1, -2, 3)
-
-    ** extended_gcd function is used when d = gcd(a,b) is required in output
-
-    """
-    assert a >= 0 and b >= 0
-
-    if b == 0:
-        d, x, y = a, 1, 0
-    else:
-        (d, p, q) = extended_gcd(b, a % b)
-        x = q
-        y = p - q * (a // b)
-
-    assert a % d == 0 and b % d == 0
-    assert d == a * x + b * y
-
-    return (d, x, y)
-
-
-def extended_euclid(a: int, b: int) -> tuple[int, int]:
-    """
-    Extended Euclid
-    >>> extended_euclid(10, 6)
-    (-1, 2)
-
-    >>> extended_euclid(7, 5)
-    (-2, 3)
-
-    """
-    if b == 0:
-        return (1, 0)
-    (x, y) = extended_euclid(b, a % b)
-    k = a // b
-    return (y, x - k * y)
-
-
-def greatest_common_divisor(a: int, b: int) -> int:
-    """
-    Euclid's Lemma :  d divides a and b, if and only if d divides a-b and b
-    Euclid's Algorithm
-
-    >>> greatest_common_divisor(7,5)
-    1
-
-    Note : In number theory, two integers a and b are said to be relatively prime,
-        mutually prime, or co-prime if the only positive integer (factor) that divides
-        both of them is 1  i.e., gcd(a,b) = 1.
-
-    >>> greatest_common_divisor(121, 11)
-    11
-
-    """
-    if a < b:
-        a, b = b, a
-
-    while a % b != 0:
-        a, b = b, a % b
-
-    return b
-
-
-if __name__ == "__main__":
-    from doctest import testmod
-
-    testmod(name="modular_division", verbose=True)
-    testmod(name="modular_division2", verbose=True)
-    testmod(name="invert_modulo", verbose=True)
-    testmod(name="extended_gcd", verbose=True)
-    testmod(name="extended_euclid", verbose=True)
-    testmod(name="greatest_common_divisor", verbose=True)
diff --git a/ciphers/affine_cipher.py b/ciphers/affine_cipher.py
index cd1e33b88425..10d16367cced 100644
--- a/ciphers/affine_cipher.py
+++ b/ciphers/affine_cipher.py
@@ -1,6 +1,8 @@
 import random
 import sys
 
+from maths.greatest_common_divisor import gcd_by_iterative
+
 from . import cryptomath_module as cryptomath
 
 SYMBOLS = (
@@ -26,7 +28,7 @@ def check_keys(key_a: int, key_b: int, mode: str) -> None:
             "Key A must be greater than 0 and key B must "
             f"be between 0 and {len(SYMBOLS) - 1}."
         )
-    if cryptomath.gcd(key_a, len(SYMBOLS)) != 1:
+    if gcd_by_iterative(key_a, len(SYMBOLS)) != 1:
         sys.exit(
             f"Key A {key_a} and the symbol set size {len(SYMBOLS)} "
             "are not relatively prime. Choose a different key."
@@ -76,7 +78,7 @@ def get_random_key() -> int:
     while True:
         key_b = random.randint(2, len(SYMBOLS))
         key_b = random.randint(2, len(SYMBOLS))
-        if cryptomath.gcd(key_b, len(SYMBOLS)) == 1 and key_b % len(SYMBOLS) != 0:
+        if gcd_by_iterative(key_b, len(SYMBOLS)) == 1 and key_b % len(SYMBOLS) != 0:
             return key_b * len(SYMBOLS) + key_b
 
 
diff --git a/ciphers/cryptomath_module.py b/ciphers/cryptomath_module.py
index 6f15f7b733e6..02e94e4b9e92 100644
--- a/ciphers/cryptomath_module.py
+++ b/ciphers/cryptomath_module.py
@@ -1,11 +1,8 @@
-def gcd(a: int, b: int) -> int:
-    while a != 0:
-        a, b = b % a, a
-    return b
+from maths.greatest_common_divisor import gcd_by_iterative
 
 
 def find_mod_inverse(a: int, m: int) -> int:
-    if gcd(a, m) != 1:
+    if gcd_by_iterative(a, m) != 1:
         msg = f"mod inverse of {a!r} and {m!r} does not exist"
         raise ValueError(msg)
     u1, u2, u3 = 1, 0, a
diff --git a/ciphers/hill_cipher.py b/ciphers/hill_cipher.py
index b4424e82298e..1201fda901e5 100644
--- a/ciphers/hill_cipher.py
+++ b/ciphers/hill_cipher.py
@@ -39,19 +39,7 @@
 
 import numpy
 
-
-def greatest_common_divisor(a: int, b: int) -> int:
-    """
-    >>> greatest_common_divisor(4, 8)
-    4
-    >>> greatest_common_divisor(8, 4)
-    4
-    >>> greatest_common_divisor(4, 7)
-    1
-    >>> greatest_common_divisor(0, 10)
-    10
-    """
-    return b if a == 0 else greatest_common_divisor(b % a, a)
+from maths.greatest_common_divisor import greatest_common_divisor
 
 
 class HillCipher:
diff --git a/ciphers/rsa_key_generator.py b/ciphers/rsa_key_generator.py
index eedc7336804a..44970e8cbc15 100644
--- a/ciphers/rsa_key_generator.py
+++ b/ciphers/rsa_key_generator.py
@@ -2,6 +2,8 @@
 import random
 import sys
 
+from maths.greatest_common_divisor import gcd_by_iterative
+
 from . import cryptomath_module, rabin_miller
 
 
@@ -27,7 +29,7 @@ def generate_key(key_size: int) -> tuple[tuple[int, int], tuple[int, int]]:
     # Generate e that is relatively prime to (p - 1) * (q - 1)
     while True:
         e = random.randrange(2 ** (key_size - 1), 2 ** (key_size))
-        if cryptomath_module.gcd(e, (p - 1) * (q - 1)) == 1:
+        if gcd_by_iterative(e, (p - 1) * (q - 1)) == 1:
             break
 
     # Calculate d that is mod inverse of e
diff --git a/maths/carmichael_number.py b/maths/carmichael_number.py
index c9c144759246..81712520ffc7 100644
--- a/maths/carmichael_number.py
+++ b/maths/carmichael_number.py
@@ -10,14 +10,7 @@
 Examples of Carmichael Numbers: 561, 1105, ...
 https://en.wikipedia.org/wiki/Carmichael_number
 """
-
-
-def gcd(a: int, b: int) -> int:
-    if a < b:
-        return gcd(b, a)
-    if a % b == 0:
-        return b
-    return gcd(b, a % b)
+from maths.greatest_common_divisor import greatest_common_divisor
 
 
 def power(x: int, y: int, mod: int) -> int:
@@ -33,7 +26,7 @@ def power(x: int, y: int, mod: int) -> int:
 def is_carmichael_number(n: int) -> bool:
     b = 2
     while b < n:
-        if gcd(b, n) == 1 and power(b, n - 1, n) != 1:
+        if greatest_common_divisor(b, n) == 1 and power(b, n - 1, n) != 1:
             return False
         b += 1
     return True
diff --git a/maths/least_common_multiple.py b/maths/least_common_multiple.py
index 10cc63ac7990..4f28da8ab2a7 100644
--- a/maths/least_common_multiple.py
+++ b/maths/least_common_multiple.py
@@ -1,6 +1,8 @@
 import unittest
 from timeit import timeit
 
+from maths.greatest_common_divisor import greatest_common_divisor
+
 
 def least_common_multiple_slow(first_num: int, second_num: int) -> int:
     """
@@ -20,26 +22,6 @@ def least_common_multiple_slow(first_num: int, second_num: int) -> int:
     return common_mult
 
 
-def greatest_common_divisor(a: int, b: int) -> int:
-    """
-    Calculate Greatest Common Divisor (GCD).
-    see greatest_common_divisor.py
-    >>> greatest_common_divisor(24, 40)
-    8
-    >>> greatest_common_divisor(1, 1)
-    1
-    >>> greatest_common_divisor(1, 800)
-    1
-    >>> greatest_common_divisor(11, 37)
-    1
-    >>> greatest_common_divisor(3, 5)
-    1
-    >>> greatest_common_divisor(16, 4)
-    4
-    """
-    return b if a == 0 else greatest_common_divisor(b % a, a)
-
-
 def least_common_multiple_fast(first_num: int, second_num: int) -> int:
     """
     Find the least common multiple of two numbers.
diff --git a/maths/primelib.py b/maths/primelib.py
index 28b5aee9dcc8..cf01750cf912 100644
--- a/maths/primelib.py
+++ b/maths/primelib.py
@@ -21,7 +21,6 @@
 
 is_even(number)
 is_odd(number)
-gcd(number1, number2)  // greatest common divisor
 kg_v(number1, number2)  // least common multiple
 get_divisors(number)    // all divisors of 'number' inclusive 1, number
 is_perfect_number(number)
@@ -40,6 +39,8 @@
 
 from math import sqrt
 
+from maths.greatest_common_divisor import gcd_by_iterative
+
 
 def is_prime(number: int) -> bool:
     """
@@ -317,39 +318,6 @@ def goldbach(number):
 # ----------------------------------------------
 
 
-def gcd(number1, number2):
-    """
-    Greatest common divisor
-    input: two positive integer 'number1' and 'number2'
-    returns the greatest common divisor of 'number1' and 'number2'
-    """
-
-    # precondition
-    assert (
-        isinstance(number1, int)
-        and isinstance(number2, int)
-        and (number1 >= 0)
-        and (number2 >= 0)
-    ), "'number1' and 'number2' must been positive integer."
-
-    rest = 0
-
-    while number2 != 0:
-        rest = number1 % number2
-        number1 = number2
-        number2 = rest
-
-    # precondition
-    assert isinstance(number1, int) and (
-        number1 >= 0
-    ), "'number' must been from type int and positive"
-
-    return number1
-
-
-# ----------------------------------------------------
-
-
 def kg_v(number1, number2):
     """
     Least common multiple
@@ -567,14 +535,14 @@ def simplify_fraction(numerator, denominator):
     ), "The arguments must been from type int and 'denominator' != 0"
 
     # build the greatest common divisor of numerator and denominator.
-    gcd_of_fraction = gcd(abs(numerator), abs(denominator))
+    gcd_of_fraction = gcd_by_iterative(abs(numerator), abs(denominator))
 
     # precondition
     assert (
         isinstance(gcd_of_fraction, int)
         and (numerator % gcd_of_fraction == 0)
         and (denominator % gcd_of_fraction == 0)
-    ), "Error in function gcd(...,...)"
+    ), "Error in function gcd_by_iterative(...,...)"
 
     return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)
 
diff --git a/project_euler/problem_005/sol2.py b/project_euler/problem_005/sol2.py
index 1b3e5e130f03..4558e21fd0f0 100644
--- a/project_euler/problem_005/sol2.py
+++ b/project_euler/problem_005/sol2.py
@@ -1,3 +1,5 @@
+from maths.greatest_common_divisor import greatest_common_divisor
+
 """
 Project Euler Problem 5: https://projecteuler.net/problem=5
 
@@ -16,23 +18,6 @@
 """
 
 
-def greatest_common_divisor(x: int, y: int) -> int:
-    """
-    Euclidean Greatest Common Divisor algorithm
-
-    >>> greatest_common_divisor(0, 0)
-    0
-    >>> greatest_common_divisor(23, 42)
-    1
-    >>> greatest_common_divisor(15, 33)
-    3
-    >>> greatest_common_divisor(12345, 67890)
-    15
-    """
-
-    return x if y == 0 else greatest_common_divisor(y, x % y)
-
-
 def lcm(x: int, y: int) -> int:
     """
     Least Common Multiple.