'''simple docstring'''





def      __lowerCAmelCase    (							a_							,   a_ = False		)   ->						Optional[Any]:





     '''simple docstring'''





     if n == 2:
          return True
     if not n % 2 or n < 2:
          return False
     if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
          return False
     if n > 3_3170_4406_4679_8873_8596_1981 and not allow_probable:
          raise ValueError(
              'Warning: upper bound of deterministic test is exceeded. '
              'Pass allow_probable=True to allow probabilistic test. '
              'A return value of True indicates a probable prime.'		)
     # array bounds provided by analysis
     SCREAMING_SNAKE_CASE       :      Tuple     						=							[
         2047,
         137_3653,
         2532_6001,
         32_1503_1751,
         2_1523_0289_8747,
         3_4747_4966_0383,
         341_5500_7172_8321,
         1,
         382_5123_0565_4641_3051,
         1,
         1,
         3186_6585_7834_0311_5116_7461,
         3_3170_4406_4679_8873_8596_1981,
     ]

     SCREAMING_SNAKE_CASE       :      Tuple     						=							[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
     for idx, _p in enumerate(__lowerCAmelCase							,   1		):
          if n < _p:
               # then we have our last prime to check
               SCREAMING_SNAKE_CASE       :      Any     						=							primes[:idx]
               break
     SCREAMING_SNAKE_CASE						, SCREAMING_SNAKE_CASE       :      Union[str, Any]     						=							n - 1, 0
     # break up n -1 into a power of 2 (s) and
     # remaining odd component
     # essentially, solve for d * 2 ** s == n - 1
     while d % 2 == 0:
          d //= 2
          s += 1
     for prime in plist:
          SCREAMING_SNAKE_CASE       :      Optional[int]     						=							False
          for r in range(__lowerCAmelCase		):
               SCREAMING_SNAKE_CASE       :      str     						=							pow(__lowerCAmelCase							,   d * 2**r							,   __lowerCAmelCase		)
               # see article for analysis explanation for m
               if (r == 0 and m == 1) or ((m + 1) % n == 0):
                    SCREAMING_SNAKE_CASE       :      Optional[Any]     						=							True
                    # this loop will not determine compositeness
                    break
          if pr:
               continue
          # if pr is False, then the above loop never evaluated to true,
          # and the n MUST be composite
          return False
     return True


def      __lowerCAmelCase    (							)   ->						str:





     '''simple docstring'''





     assert not miller_rabin(561		)
     assert miller_rabin(563		)
     # 2047

     assert not miller_rabin(83_8201		)
     assert miller_rabin(83_8207		)
     # 1_373_653

     assert not miller_rabin(1731_6001		)
     assert miller_rabin(1731_6017		)
     # 25_326_001

     assert not miller_rabin(30_7838_6641		)
     assert miller_rabin(30_7838_6653		)
     # 3_215_031_751

     assert not miller_rabin(1_7130_4557_4801		)
     assert miller_rabin(1_7130_4557_4819		)
     # 2_152_302_898_747

     assert not miller_rabin(2_7797_9972_8307		)
     assert miller_rabin(2_7797_9972_8327		)
     # 3_474_749_660_383

     assert not miller_rabin(113_8500_2390_9441		)
     assert miller_rabin(113_8500_2390_9527		)
     # 341_550_071_728_321

     assert not miller_rabin(127_5041_0188_4880_4351		)
     assert miller_rabin(127_5041_0188_4880_4391		)
     # 3_825_123_056_546_413_051

     assert not miller_rabin(796_6646_4458_5077_8779_1867		)
     assert miller_rabin(796_6646_4458_5077_8779_1951		)
     # 318_665_857_834_031_151_167_461

     assert not miller_rabin(5528_4067_7446_6478_9766_0333		)
     assert miller_rabin(5528_4067_7446_6478_9766_0359		)
     # 3_317_044_064_679_887_385_961_981
     # upper limit for probabilistic test


if __name__ == "__main__":
 test_miller_rabin()





from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
__magic_name__  							=	299_792_458

# Symbols
__magic_name__							,   __magic_name__							,   __magic_name__							,   __magic_name__  							=	symbols('''ct x y z''')





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    if velocity > c:
        raise ValueError("Speed must not exceed light speed 299,792,458 [m/s]!"				)
    elif velocity < 1:
        # Usually the speed should be much higher than 1 (c order of magnitude)
        raise ValueError("Speed must be greater than or equal to 1!"				)

    return velocity / c





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    return 1 / sqrt(1 - beta(__lowerCAmelCase				) ** 2				)





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    return np.array(
        [
            [gamma(__lowerCAmelCase				), -gamma(__lowerCAmelCase				) * beta(__lowerCAmelCase				), 0, 0],
            [-gamma(__lowerCAmelCase				) * beta(__lowerCAmelCase				), gamma(__lowerCAmelCase				), 0, 0],
            [0, 0, 1, 0],
            [0, 0, 0, 1],
        ]				)





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase     ,		__lowerCAmelCase = None				):
    # Ensure event is not empty
    if event is None:
        snake_case__    =					np.array([ct, x, y, z]				)  # Symbolic four vector
    else:
        event[0] *= c  # x0 is ct (speed of light * time)

    return transformation_matrix(__lowerCAmelCase				) @ event


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     # Example of symbolic vector:
     __magic_name__  							=	transform(29_979_245)
     print('''Example of four vector: ''')
     print(F'''ct\' = {four_vector[0]}''')
     print(F'''x\' = {four_vector[1]}''')
     print(F'''y\' = {four_vector[2]}''')
     print(F'''z\' = {four_vector[3]}''')

     # Substitute symbols with numerical values
     __magic_name__  							=	{ct: c, x: 1, y: 1, z: 1}
     __magic_name__  							=	[four_vector[i].subs(sub_dict) for i in range(4)]

     print(F'''\n{numerical_vector}''')



