[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

maths/pollard_rho_discrete_log.py

@@ -9,9 +9,9 @@ def pollards_rho_discrete_log(base: int, target: int, modulus: int) -> Optional[
     using Pollard's Rho algorithm.
 
     This is a probabilistic algorithm that finds discrete logarithms in O(√modulus) time.
-    The algorithm may not always find a solution in a single run due to its 
+    The algorithm may not always find a solution in a single run due to its
     probabilistic nature, but it will find the correct answer when it succeeds.
-    
+
     More info: https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm_for_logarithms
 
     Parameters
@@ -33,15 +33,15 @@ def pollards_rho_discrete_log(base: int, target: int, modulus: int) -> Optional[
     >>> result = pollards_rho_discrete_log(2, 22, 29)
     >>> result is not None and pow(2, result, 29) == 22
     True
-    
+
     >>> result = pollards_rho_discrete_log(3, 9, 11)
     >>> result is not None and pow(3, result, 11) == 9
     True
-    
+
     >>> result = pollards_rho_discrete_log(5, 3, 7)
     >>> result is not None and pow(5, result, 7) == 3
     True
-    
+
     >>> # Case with no solution should return None or fail verification
     >>> result = pollards_rho_discrete_log(3, 7, 11)
     >>> result is None or pow(3, result, 11) != 7
@@ -53,7 +53,7 @@ def pseudo_random_function(
     ) -> tuple[int, int, int]:
         """
         Pseudo-random function that partitions the search space into 3 sets.
-        
+
         Returns a tuple of (new_value, new_exponent_base, new_exponent_target).
         """
         if current_value % 3 == 0:
@@ -80,31 +80,43 @@ def pseudo_random_function(
 
     # Try multiple random starting points to avoid immediate collisions
     max_attempts = 50  # Increased attempts for better reliability
-    
+
     for attempt in range(max_attempts):
         # Use different starting values to avoid trivial collisions
         # current_value represents base^exponent_base * target^exponent_target
         random.seed()  # Ensure truly random values
         exponent_base = random.randint(0, modulus - 2)
         exponent_target = random.randint(0, modulus - 2)
-        
+
         # Ensure current_value = base^exponent_base * target^exponent_target mod modulus
-        current_value = (pow(base, exponent_base, modulus) * pow(target, exponent_target, modulus)) % modulus
-        
+        current_value = (
+            pow(base, exponent_base, modulus) * pow(target, exponent_target, modulus)
+        ) % modulus
+
         # Skip if current_value is 0 or 1 (problematic starting points)
         if current_value <= 1:
             continue
-            
+
         # Tortoise and hare start at same position
-        tortoise_value, tortoise_exp_base, tortoise_exp_target = current_value, exponent_base, exponent_target
-        hare_value, hare_exp_base, hare_exp_target = current_value, exponent_base, exponent_target
+        tortoise_value, tortoise_exp_base, tortoise_exp_target = (
+            current_value,
+            exponent_base,
+            exponent_target,
+        )
+        hare_value, hare_exp_base, hare_exp_target = (
+            current_value,
+            exponent_base,
+            exponent_target,
+        )
 
         # Increased iteration limit for better coverage
         max_iterations = max(int(math.sqrt(modulus)) * 2, modulus // 2)
         for i in range(1, max_iterations):
             # Tortoise: one step
-            tortoise_value, tortoise_exp_base, tortoise_exp_target = pseudo_random_function(
-                tortoise_value, tortoise_exp_base, tortoise_exp_target
+            tortoise_value, tortoise_exp_base, tortoise_exp_target = (
+                pseudo_random_function(
+                    tortoise_value, tortoise_exp_base, tortoise_exp_target
+                )
             )
             # Hare: two steps
             hare_value, hare_exp_base, hare_exp_target = pseudo_random_function(
@@ -113,8 +125,12 @@ def pseudo_random_function(
 
             if tortoise_value == hare_value and i > 1:  # Avoid immediate collision
                 # Collision found
-                exponent_difference = (tortoise_exp_base - hare_exp_base) % (modulus - 1)
-                target_difference = (hare_exp_target - tortoise_exp_target) % (modulus - 1)
+                exponent_difference = (tortoise_exp_base - hare_exp_base) % (
+                    modulus - 1
+                )
+                target_difference = (hare_exp_target - tortoise_exp_target) % (
+                    modulus - 1
+                )
 
                 if target_difference == 0:
                     break  # Try with different starting point
@@ -125,22 +141,24 @@ def pseudo_random_function(
                 except ValueError:
                     break  # No inverse, try different starting point
 
-                discrete_log = (exponent_difference * inverse_target_diff) % (modulus - 1)
-                
+                discrete_log = (exponent_difference * inverse_target_diff) % (
+                    modulus - 1
+                )
+
                 # Verify the solution
                 if pow(base, discrete_log, modulus) == target:
                     return discrete_log
                 break  # This attempt failed, try with different starting point
-    
+
     return None
 
 
 if __name__ == "__main__":
     import doctest
-    
+
     # Run doctests
     doctest.testmod(verbose=True)
-    
+
     # Also run the main example
     result = pollards_rho_discrete_log(2, 22, 29)
     print(f"pollards_rho_discrete_log(2, 22, 29) = {result}")

maths/test_pollard_rho_discrete_log.py

@@ -29,18 +29,19 @@ def test_basic_example(self):
                 self.assertEqual(pow(2, result, 29), 22)
                 found_solution = True
                 break
-        
-        self.assertTrue(found_solution, 
-                       "Algorithm should find a solution within 5 attempts")
+
+        self.assertTrue(
+            found_solution, "Algorithm should find a solution within 5 attempts"
+        )
 
     def test_simple_cases(self):
         """Test simple discrete log cases with known answers."""
         test_cases = [
-            (2, 8, 17),   # 2^3 ≡ 8 (mod 17)
-            (5, 3, 7),    # 5^5 ≡ 3 (mod 7)  
-            (3, 9, 11),   # 3^2 ≡ 9 (mod 11)
+            (2, 8, 17),  # 2^3 ≡ 8 (mod 17)
+            (5, 3, 7),  # 5^5 ≡ 3 (mod 7)
+            (3, 9, 11),  # 3^2 ≡ 9 (mod 11)
         ]
-        
+
         for g, h, p in test_cases:
             # Try multiple times due to probabilistic nature
             found_solution = False
@@ -56,8 +57,7 @@ def test_no_solution_case(self):
         """Test case where no solution exists."""
         # 3^x ≡ 7 (mod 11) has no solution (verified by brute force)
         # The algorithm should return None or fail to find a solution
-        result = pollards_rho_discrete_log(3, 7, 11)
-        if result is not None:
+        if (result := pollards_rho_discrete_log(3, 7, 11)) is not None:
             # If it returns a result, it must be wrong since no solution exists
             self.assertNotEqual(pow(3, result, 11), 7)
 
@@ -67,7 +67,7 @@ def test_edge_cases(self):
         result = pollards_rho_discrete_log(1, 1, 7)
         if result is not None:
             self.assertEqual(pow(1, result, 7), 1)
-        
+
         # h = 1: g^x ≡ 1 (mod p) - looking for the multiplicative order
         result = pollards_rho_discrete_log(3, 1, 7)
         if result is not None:
@@ -76,27 +76,27 @@ def test_edge_cases(self):
     def test_small_primes(self):
         """Test with small prime moduli."""
         test_cases = [
-            (2, 4, 5),   # 2^2 ≡ 4 (mod 5)
-            (2, 3, 5),   # 2^? ≡ 3 (mod 5)
-            (2, 1, 3),   # 2^2 ≡ 1 (mod 3)
-            (3, 2, 5),   # 3^3 ≡ 2 (mod 5)
+            (2, 4, 5),  # 2^2 ≡ 4 (mod 5)
+            (2, 3, 5),  # 2^? ≡ 3 (mod 5)
+            (2, 1, 3),  # 2^2 ≡ 1 (mod 3)
+            (3, 2, 5),  # 3^3 ≡ 2 (mod 5)
         ]
-        
+
         for g, h, p in test_cases:
             result = pollards_rho_discrete_log(g, h, p)
             if result is not None:
                 # Verify the result is mathematically correct
                 self.assertEqual(pow(g, result, p), h)
-                
+
     def test_larger_examples(self):
         """Test with larger numbers to ensure algorithm scales."""
         # Test cases with larger primes
         test_cases = [
-            (2, 15, 31),   # Find x where 2^x ≡ 15 (mod 31)
-            (3, 10, 37),   # Find x where 3^x ≡ 10 (mod 37) 
-            (5, 17, 41),   # Find x where 5^x ≡ 17 (mod 41)
+            (2, 15, 31),  # Find x where 2^x ≡ 15 (mod 31)
+            (3, 10, 37),  # Find x where 3^x ≡ 10 (mod 37)
+            (5, 17, 41),  # Find x where 5^x ≡ 17 (mod 41)
         ]
-        
+
         for g, h, p in test_cases:
             result = pollards_rho_discrete_log(g, h, p)
             if result is not None:
@@ -108,17 +108,18 @@ def test_multiple_runs_consistency(self):
         # and ensure any returned result is mathematically correct
         g, h, p = 2, 22, 29
         results = []
-        
+
         for _ in range(10):  # Run 10 times
             result = pollards_rho_discrete_log(g, h, p)
             if result is not None:
                 results.append(result)
                 self.assertEqual(pow(g, result, p), h)
-        
+
         # Should find at least one solution in 10 attempts
-        self.assertGreater(len(results), 0, 
-                          "Algorithm should find solution in multiple attempts")
+        self.assertGreater(
+            len(results), 0, "Algorithm should find solution in multiple attempts"
+        )
 
 
 if __name__ == "__main__":
-    unittest.main(verbosity=2)
+    unittest.main(verbosity=2)