code: 
  
  def        __SCREAMING_SNAKE_CASE    (      a__						:      Optional[Any]					)				->							str:
  	if len(__lowerCamelCase					) == 0 or not all(len(__lowerCamelCase					) == 2 for pair in coordinates					):
  		raise ValueError("""The program cannot work out a fitting polynomial."""					)
  
  	if len({tuple(__lowerCamelCase					) for pair in coordinates}					) != len(__lowerCamelCase					):
  		raise ValueError("""The program cannot work out a fitting polynomial."""					)
  
  	__A   : Tuple								= {x for x, _ in coordinates}
  	if len(__lowerCamelCase					) == 1:
  		return f"""x={coordinates[0][0]}"""
  
  	if len(__lowerCamelCase					) != len(__lowerCamelCase					):
  		raise ValueError("""The program cannot work out a fitting polynomial."""					)
  
  	__A   : Tuple								= len(__lowerCamelCase					)
  
  	__A   : int								= 0
  	__A   : list[list[float]]								= []
  	# put the x and x to the power values in a matrix
  	while count_of_line < x:
  		__A   : Optional[int]								= 0
  		__A   : Dict								= coordinates[count_of_line][0]
  		__A   : list[float]								= []
  		while count_in_line < x:
  			count_line.append(a ** (x - (count_in_line + 1))					)
  			count_in_line += 1
  		matrix.append(__lowerCamelCase					)
  		count_of_line += 1
  
  	__A   : List[str]								= 0
  	# put the y values into a vector
  	__A   : list[float]								= []
  	while count_of_line < x:
  		vector.append(coordinates[count_of_line][1]					)
  		count_of_line += 1
  
  	__A   : Optional[Any]								= 0
  
  	while count < x:
  		__A   : Optional[int]								= 0
  		while zahlen < x:
  			if count == zahlen:
  				zahlen += 1
  			if zahlen == x:
  				break
  			__A   : 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
  
  	__A   : Any								= 0
  	# make solutions
  	__A   : list[str]								= []
  	while count < x:
  		solution.append(str(vector[count] / matrix[count][count]					)					)
  		count += 1
  
  	__A   : Union[str, Any]								= 0
  	__A   : Tuple								= """f(x)="""
  
  	while count < x:
  		__A   : list[str]								= solution[count].split("""E"""					)
  		if len(__lowerCamelCase					) > 1:
  			__A   : List[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, 11]]))
  			print(points_to_polynomial([[1, -3], [2, -6], [3, -11]]))
  			print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))
  
  
  
  
  
  
style_context: 
  
  import os
  import tempfile
  import unittest
  from typing import List
  
  from transformers.models.esm.tokenization_esm import VOCAB_FILES_NAMES, EsmTokenizer
  from transformers.testing_utils import require_tokenizers
  from transformers.tokenization_utils import PreTrainedTokenizer
  from transformers.tokenization_utils_base import PreTrainedTokenizerBase
  
  
  
  
  
  
  @require_tokenizers
  class     lowerCamelCase_			(  unittest.TestCase  ):
  	_lowercase		:      List[str]    				=							EsmTokenizer
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[Any]       ):
  		super().setUp()
  		__A   : Dict								= tempfile.mkdtemp()
  		# fmt: off
  		__A   : List[str]								= ["<cls>", "<pad>", "<eos>", "<unk>", "L", "A", "G", "V", "S", "E", "R", "T", "I", "D", "P", "K", "Q", "N", "F", "Y", "M", "H", "W", "C", "X", "B", "U", "Z", "O", ".", "-", "<null_1>", "<mask>"]  # noqa: E501
  		# fmt: on
  		__A   : int								= os.path.join(self.tmpdirname				,			VOCAB_FILES_NAMES["""vocab_file"""]       )
  		with open(self.vocab_file				,			"""w"""				,			encoding="""utf-8"""       ) as vocab_writer:
  			vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]       )       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Dict				,			**__A	:    int       ):
  		return [self.get_tokenizer(**__A       )]
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Optional[int]				,			**__A	:    List[Any]       ):
  		return self.tokenizer_class.from_pretrained(self.tmpdirname				,			**__A       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[str]       ):
  		__A   : Union[str, Any]								= self.tokenizer_class(self.vocab_file       )
  
  		__A   : int								= tokenizer.tokenize("""LAGVS"""       )
  		self.assertListEqual(__A				,			["""L""", """A""", """G""", """V""", """S"""]       )
  		self.assertListEqual(tokenizer.convert_tokens_to_ids(__A       )				,			[4, 5, 6, 7, 8]       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    str       ):
  		__A   : Union[str, Any]								= self.tokenizer_class(self.vocab_file       )
  
  		__A   : int								= """LAGVS"""
  		self.assertListEqual(tokenizer.encode(__A       )				,			[0, 4, 5, 6, 7, 8, 2]       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Dict       ):
  		__A   : str								= self.tokenizer_class(self.vocab_file       )
  
  		__A   : Tuple								= ["""LAGVS""", """WCB"""]
  		__A   : str								= tokenizer(__A				,			padding=__A       )["""input_ids"""]
  
  		self.assertListEqual(__A				,			[[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2]]       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[Any]       ):
  		__A   : Dict								= self.tokenizer_class(self.vocab_file       )
  
  		__A   : Any								= ["""LAGVS""", """WCB"""]
  		__A   : str								= tokenizer(__A				,			padding=__A       )["""input_ids"""]
  
  		self.assertListEqual(__A				,			[[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2, 1, 1]]       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[str]       ):
  		__A   : Optional[int]								= self.get_tokenizers(fast=__A       )
  		for tokenizer in tokenizers:
  			with self.subTest(F"""{tokenizer.__class__.__name__}"""       ):
  				__A   : Any								= """<unk>"""
  				__A   : str								= """<mask>"""
  
  				__A   : Optional[Any]								= tokenizer.tokenize(__A       )
  				__A   : str								= tokenizer.tokenize(__A       )
  
  				self.assertEqual(len(__A       )				,			1       )
  				self.assertEqual(len(__A       )				,			1       )
  				self.assertEqual(token_a[0]				,			__A       )
  				self.assertEqual(token_a[0]				,			__A       )
  
  
  
  
  
  