input: from typing import List
  
  def solve_linear_programming_problem_via_simplex(
      objective_function: List[float], constraints: List[List[float]], rhs: List[float]
  ) -> List[float]:
      """ Use the Simplex Method to solve a linear programming problem, which involves 
      finding the maximum or minimum value of a linear function. This method uses 
      simultaneous equations to define a polytope that contains the solution to the linear 
      programming problem. It then finds the optimal solution in this polytope by 
      iteratively making moves from a vertex to another in the polytope that gives an 
      increase in the message value. 
      The Simplex algorithm takes a problem defined by:
      1. The initial objective function coefficients.
      2. A set of constraints which are linear equations involving the objective function coefficients.
      3. A right-hand side value for each constraint.
      
      >>> solve_linear_programming_problem_via_simplex([1, 1], [[1, 0], [0, 1]], [2, 3])
      [2.0, 3.0]
      >>> solve_linear_programming_problem_via_simplex([10, 6, 4], [[1, 1, 1], [10, 4, 5], [2, 2, 6]], [100, 600, 300])
      [33.33, 66.67, 0.0]
      """
output:     import numpy as np
  
      def simplex(A, b, c):
          m, n = A.shape
          tableau = np.zeros((m + 1, n + m + 1))
          tableau[0, :n] = -c
          tableau[1:, :n] = A
          tableau[1:, n:n+m] = np.eye(m)
          tableau[1:, -1] = b
  
          while True:
              pivot_col = np.argmax(tableau[0, :-1])
              if tableau[0, pivot_col] <= 0:
                  break
              ratios = tableau[1:, -1] / tableau[1:, pivot_col]
              ratios[tableau[1:, pivot_col] <= 0] = np.inf
              pivot_row = np.argmin(ratios) + 1
              tableau[pivot_row] /= tableau[pivot_row, pivot_col]
              for i in range(m + 1):
                  if i != pivot_row:
                      tableau[i] -= tableau[i, pivot_col] * tableau[pivot_row]
  
          return tableau[0, -1] * np.where(tableau[0, :n] == 0, 1, 0)
  
      A = np.array(constraints)
      b = np.array(rhs)
      c = np.array(objective_function)
  
      result = simplex(A, b, c)
      return [round(x, 2) for x in result]