





from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
_lowerCAmelCase							:					List[str]		    =		299_792_458

# Symbols
_lowerCAmelCase							:					Optional[int]		    =		symbols('''ct x y z''')

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

def    __snake_case  (    _lowerCAmelCase       :       str		)       ->  np.ndarray:
   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    __snake_case  (    _lowerCAmelCase       :       Optional[Any] , _lowerCAmelCase       :       str = None		)       ->  np.ndarray:
   # Ensure event is not empty
   if event is None:
      A_    : str								=	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:
 _lowerCAmelCase							:					str		    =		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
 _lowerCAmelCase							:					Union[str, Any]		    =		{ct: c, x: 1, y: 1, z: 1}
 _lowerCAmelCase							:					Any		    =		[four_vector[i].subs(sub_dict) for i in range(4)]

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







def  _SCREAMING_SNAKE_CASE				(   a  )      ->      bool:
					return str(a  ) == str(a  )[::-1]







def  _SCREAMING_SNAKE_CASE				(   a  )      ->      int:
					return int(a  ) + int(str(a  )[::-1]  )







def  _SCREAMING_SNAKE_CASE				(   a = 1_00_00  )      ->      int:
					__A	:						int       =				[]
					for num in range(1					,						a  ):
										__A	:						List[str]       =				0
										__A	:						List[Any]       =				num
										while iterations < 50:
															__A	:						str       =				sum_reverse(a  )
															iterations += 1
															if is_palindrome(a  ):
																				break
										else:
															lychrel_nums.append(a  )
					return len(a  )


if __name__ == "__main__":
				print(F"""{solution() = }""")




