





from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
a__:      int									=		299_792_458

# Symbols
a__					,			a__					,			a__					,			a__:      Optional[Any]									=		symbols('ct x y z')


def 	UpperCamelCase__(       UpperCamelCase__			:       float  )->float:
       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 	UpperCamelCase__(       UpperCamelCase__			:       float  )->float:
       return 1 / sqrt(1 - beta(UpperCamelCase__  ) ** 2  )


def 	UpperCamelCase__(       UpperCamelCase__			:       float  )->np.ndarray:
       return np.array(
           [
               [gamma(UpperCamelCase__  ), -gamma(UpperCamelCase__  ) * beta(UpperCamelCase__  ), 0, 0],
               [-gamma(UpperCamelCase__  ) * beta(UpperCamelCase__  ), gamma(UpperCamelCase__  ), 0, 0],
               [0, 0, 1, 0],
               [0, 0, 0, 1],
           ]  )


def 	UpperCamelCase__(       UpperCamelCase__			:       float ,     UpperCamelCase__			:       np.ndarray | None = None  )->np.ndarray:
       # Ensure event is not empty
       if event is None:
              A__											=						np.array([ct, x, y, z]  )  # Symbolic four vector
       else:
              event[0] *= c  # x0 is ct (speed of light * time)

       return transformation_matrix(UpperCamelCase__  ) @ event


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       # Example of symbolic vector:
       a__:      int									=		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
       a__:      Union[str, Any]									=		{ct: c, x: 1, y: 1, z: 1}
       a__:      Union[str, Any]									=		[four_vector[i].subs(sub_dict) for i in range(4)]

       print(F"\n{numerical_vector}")












from __future__ import annotations

import math


def 	UpperCamelCase__(       UpperCamelCase__			:       int  )->bool:

       if 1 < number < 4:
              # 2 and 3 are primes
              return True
       elif number < 2 or number % 2 == 0 or number % 3 == 0:
              # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
              return False

       # All primes number are in format of 6k +/- 1
       for i in range(5 ,     int(math.sqrt(UpperCamelCase__  ) + 1  ) ,     6  ):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True


def 	UpperCamelCase__(       UpperCamelCase__			:       int  )->list[int]:
       A__											=						str(UpperCamelCase__  )
       A__											=						[n]
       for i in range(1 ,     len(UpperCamelCase__  )  ):
              list_nums.append(int(str_num[i:]  )  )
              list_nums.append(int(str_num[:-i]  )  )
       return list_nums


def 	UpperCamelCase__(       UpperCamelCase__			:       int  )->bool:
       if len(str(UpperCamelCase__  )  ) > 3:
              if not is_prime(int(str(UpperCamelCase__  )[-3:]  )  ) or not is_prime(int(str(UpperCamelCase__  )[:3]  )  ):
                     return False
       return True


def 	UpperCamelCase__(       UpperCamelCase__			:       int = 11  )->list[int]:
       A__											=						[]
       A__											=						13
       while len(UpperCamelCase__  ) != count:
              if validate(UpperCamelCase__  ):
                     A__											=						list_truncated_nums(UpperCamelCase__  )
                     if all(is_prime(UpperCamelCase__  ) for i in list_nums  ):
                            list_truncated_primes.append(UpperCamelCase__  )
              num += 2
       return list_truncated_primes


def 	UpperCamelCase__(       )->int:
       return sum(compute_truncated_primes(11  )  )


if __name__ == "__main__":
       print(F"{sum(compute_truncated_primes(11)) = }")





