[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,7 +9,7 @@ def pollards_rho_discrete_log(g: int, h: int, p: int) -> Optional[int]:
     using Pollard's Rho algorithm.
 
     This is a probabilistic algorithm that finds discrete logarithms in O(√p) 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.
 
     Parameters
@@ -31,15 +31,15 @@ def pollards_rho_discrete_log(g: int, h: int, p: int) -> Optional[int]:
     >>> 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
@@ -60,21 +60,21 @@ def f(x, a, b):
 
     # 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
         # x represents g^a * h^b
         random.seed()  # Ensure truly random values
         a = random.randint(0, p - 2)
         b = random.randint(0, p - 2)
-        
+
         # Ensure x = g^a * h^b mod p
         x = (pow(g, a, p) * pow(h, b, p)) % p
-        
+
         # Skip if x is 0 or 1 (problematic starting points)
         if x <= 1:
             continue
-            
+
         X, A, B = x, a, b  # Tortoise and hare start at same position
 
         # Increased iteration limit for better coverage
@@ -100,21 +100,21 @@ def f(x, a, b):
                     break  # No inverse, try different starting point
 
                 x_log = (r * inv_s) % (p - 1)
-                
+
                 # Verify the solution
                 if pow(g, x_log, p) == h:
                     return x_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)