input: 
  def solve_linear_programming_using_simplex(objective_function: List[float], constraints: List[List[float]], rhs_values: List[float], is_maximization: bool) -> Tuple[float, List[float]]:
      """Solves a linear programming problem using the Simplex method. This method involves finding the
      maximum or minimum value of a linear function by iteratively moving from one vertex to another in a polytope defined by the constraints.
      The algorithm begins by converting the problem into standard form by introducing slack variables, if necessary, and then constructs a tableau.
      Iteratively, the Simplex algorithm moves from one vertex to the next until an optimum solution is found.
      The final solution is read by inspecting the tableau.
      >>> solve_linear_programming_using_simplex([3, 4], [[1, 1], [2, 1]], [5, 8], True)
      (11.0, [2.0, 3.0])
      >>> solve_linear_programming_using_simplex([-1, -1], [[1, 0], [0, 1]], [1, 1], False)
      (-2.0, [1.0, 1.0])
      """
  
output:     
      num_vars = len(objective_function)
      num_constraints = len(constraints)
      
      # Initialize the tableau
      tableau = []
      for i in range(num_constraints):
          row = constraints[i] + [0] * num_constraints
          row[num_vars + i] = 1
          row.append(rhs_values[i])
          tableau.append(row)
      
      # Add the objective function row
      obj_row = [-coeff for coeff in objective_function] + [0] * num_constraints + [0]
      tableau.append(obj_row)
      
      # Simplex algorithm
      while True:
          # Find the entering variable (most negative coefficient in the objective row)
          entering_var = min(range(len(tableau[0]) - 1), key=lambda x: tableau[-1][x])
          if tableau[-1][entering_var] >= 0:
              break  # No negative coefficients left, optimal solution found
          
          # Find the leaving variable (minimum ratio test)
          ratios = [tableau[i][-1] / tableau[i][entering_var] if tableau[i][entering_var] > 0 else float('inf') for i in range(num_constraints)]
          leaving_var = min(range(num_constraints), key=lambda x: ratios[x])
          if ratios[leaving_var] == float('inf'):
              raise ValueError("Unbounded problem")
          
          # Pivot on the entering and leaving variables
          pivot = tableau[leaving_var][entering_var]
          tableau[leaving_var] = [x / pivot for x in tableau[leaving_var]]
          for i in range(num_constraints + 1):
              if i != leaving_var:
                  multiplier = tableau[i][entering_var]
                  tableau[i] = [tableau[i][j] - multiplier * tableau[leaving_var][j] for j in range(len(tableau[i]))]
      
      # Extract the solution
      solution = [0] * num_vars
      for i in range(num_vars):
          if tableau[-1][i] == 0:
              for j in range(num_constraints):
                  if tableau[j][i] == 1:
                      solution[i] = tableau[j][-1]
                      break
      
      # Calculate the objective value
      obj_value = sum(objective_function[i] * solution[i] for i in range(num_vars))
      if not is_maximization:
          obj_value = -obj_value
      
      return obj_value, solution
  