code: 
  
  
  def lowerCamelCase    (    lowerCAmelCase       :			Dict	):
  
  
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	if len(_UpperCAmelCase	) == 0 or not all(len(_UpperCAmelCase	) == 2 for pair in coordinates	):
  		raise ValueError('The program cannot work out a fitting polynomial.'	)
  
  	if len({tuple(_UpperCAmelCase	) for pair in coordinates}	) != len(_UpperCAmelCase	):
  		raise ValueError('The program cannot work out a fitting polynomial.'	)
  
  	__magic_name__ :					int  			=  {x for x, _ in coordinates}
  	if len(_UpperCAmelCase	) == 1:
  		return f'x={coordinates[0][0]}'
  
  	if len(_UpperCAmelCase	) != len(_UpperCAmelCase	):
  		raise ValueError('The program cannot work out a fitting polynomial.'	)
  
  	__magic_name__ :					Any  			=  len(_UpperCAmelCase	)
  
  	__magic_name__ :					Optional[Any]  			=  0
  	__magic_name__ :					Optional[int]  			=  []
  	# put the x and x to the power values in a matrix
  	while count_of_line < x:
  		__magic_name__ :					Tuple  			=  0
  		__magic_name__ :					List[Any]  			=  coordinates[count_of_line][0]
  		__magic_name__ :					Optional[int]  			=  []
  		while count_in_line < x:
  			count_line.append(a ** (x - (count_in_line + 1))	)
  			count_in_line += 1
  		matrix.append(_UpperCAmelCase	)
  		count_of_line += 1
  
  	__magic_name__ :					Optional[int]  			=  0
  	# put the y values into a vector
  	__magic_name__ :					str  			=  []
  	while count_of_line < x:
  		vector.append(coordinates[count_of_line][1]	)
  		count_of_line += 1
  
  	__magic_name__ :					str  			=  0
  
  	while count < x:
  		__magic_name__ :					Optional[Any]  			=  0
  		while zahlen < x:
  			if count == zahlen:
  				zahlen += 1
  			if zahlen == x:
  				break
  			__magic_name__ :					List[str]  			=  matrix[zahlen][count] / matrix[count][count]
  			for counting_columns, item in enumerate(matrix[count]	):
  				# manipulating all the values in the matrix
  				matrix[zahlen][counting_columns] -= item * bruch
  			# manipulating the values in the vector
  			vector[zahlen] -= vector[count] * bruch
  			zahlen += 1
  		count += 1
  
  	__magic_name__ :					str  			=  0
  	# make solutions
  	__magic_name__ :					Dict  			=  []
  	while count < x:
  		solution.append(str(vector[count] / matrix[count][count]	)	)
  		count += 1
  
  	__magic_name__ :					List[Any]  			=  0
  	__magic_name__ :					Tuple  			=  'f(x)='
  
  	while count < x:
  		__magic_name__ :					Optional[int]  			=  solution[count].split('E'	)
  		if len(_UpperCAmelCase	) > 1:
  			__magic_name__ :					Union[str, Any]  			=  f'{remove_e[0]}*10^{remove_e[1]}'
  		solved += f'x^{x - (count + 1)}*{solution[count]}'
  		if count + 1 != x:
  			solved += "+"
  		count += 1
  
  	return solved
  
  
  if __name__ == "__main__":
  							print(points_to_polynomial([]))
  							print(points_to_polynomial([[]]))
  							print(points_to_polynomial([[1, 0], [2, 0], [3, 0]]))
  							print(points_to_polynomial([[1, 1], [2, 1], [3, 1]]))
  							print(points_to_polynomial([[1, 3], [2, 3], [3, 3]]))
  							print(points_to_polynomial([[1, 1], [2, 2], [3, 3]]))
  							print(points_to_polynomial([[1, 1], [2, 4], [3, 9]]))
  							print(points_to_polynomial([[1, 3], [2, 6], [3, 1_1]]))
  							print(points_to_polynomial([[1, -3], [2, -6], [3, -1_1]]))
  							print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))
style_context: 
  
  
  '''simple docstring'''
  
  from __future__ import annotations
  
  
  
  
  
  def lowerCamelCase    (    lowerCAmelCase       :			list[int | float]	,	lowerCAmelCase       :			int	,	lowerCAmelCase       :			int	):
  
  
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	if len(lowerCAmelCase	) == 0:
  		raise ValueError('find_min() arg is an empty sequence'	)
  	if (
  	    left >= len(lowerCAmelCase	)
  	    or left < -len(lowerCAmelCase	)
  	    or right >= len(lowerCAmelCase	)
  	    or right < -len(lowerCAmelCase	)
  	):
  		raise IndexError('list index out of range'	)
  	if left == right:
  		return nums[left]
  	__magic_name__ :					Tuple  			=  (left + right) >> 1  # the middle
  	__magic_name__ :					str  			=  find_min(lowerCAmelCase	,	lowerCAmelCase	,	lowerCAmelCase	)  # find min in range[left, mid]
  	__magic_name__ :					Optional[Any]  			=  find_min(lowerCAmelCase	,	mid + 1	,	lowerCAmelCase	)  # find min in range[mid + 1, right]
  
  	return left_min if left_min <= right_min else right_min
  
  
  if __name__ == "__main__":
  							import doctest
  
  							doctest.testmod(verbose=True)