input: 
  from typing import List
  
  def linear_programming_simplex(objective: List[float], constraints: List[List[float]], rhs: List[float]) -> List[float]:
      """
      Solve a linear programming problem using the Simplex Method. The method involves finding
      the maximum or minimum value of a linear function subject to linear constraints. The approach
      is to iteratively move from a vertex to the next within the polytope defined by the constraints
      until the optimal solution is reached.
  
      :param objective: List of coefficients of the objective function.
      :param constraints: List of lists where each sublist represents the coefficients of the constraints.
      :param rhs: List of right-hand side values of the constraints.
      :return: List of optimal values of the decision variables.
      
      Example:
      To find the maximum value of: 
      maximize  2x + 3y + 5z 
      subject to:
      2x + 4y + 7z <= 14
      3x + y + z <= 30
      5x + 3y + 2z <= 40
      
      >>> linear_programming_simplex([2, 3, 5], [[2, 4, 7], [3, 1, 1], [5, 3, 2]], [14, 30, 40])
      [0.4285714285714286, 5.071428571428571, 0.0]
      """
  
output:     import numpy as np
  
      def to_tableau(objective, constraints, rhs):
          num_vars = len(objective)
          num_constraints = len(constraints)
          tableau = np.zeros((num_constraints + 1, num_vars + num_constraints + 1))
          for i in range(num_constraints):
              for j in range(num_vars):
                  tableau[i, j] = constraints[i][j]
              tableau[i, num_vars + i] = 1
              tableau[i, -1] = rhs[i]
          for j in range(num_vars):
              tableau[-1, j] = -objective[j]
          tableau[-1, -1] = 0
          return tableau
  
      def pivot_column(tableau):
          return np.argmin(tableau[-1, :-1])
  
      def pivot_row(tableau, pc):
          rhs_col = tableau[:, -1]
          pivot_col = tableau[:, pc]
          ratios = rhs_col / pivot_col
          return np.where(ratios > 0, ratios, np.inf).argmin()
  
      def pivot(tableau, pr, pc):
          tableau[pr, :] /= tableau[pr, pc]
          for i in range(tableau.shape[0]):
              if i != pr:
                  tableau[i, :] -= tableau[i, pc] * tableau[pr, :]
  
      def is_optimal(tableau):
          return np.all(tableau[-1, :-1] >= 0)
  
      def extract_solution(tableau, num_vars):
          solution = np.zeros(num_vars)
          for i in range(num_vars):
              if tableau[-1, i] == 0:
                  row = np.where(tableau[:, i] == 1)[0]
                  if len(row) == 1:
                      solution[i] = tableau[row[0], -1]
          return solution
  
      tableau = to_tableau(objective, constraints, rhs)
      while not is_optimal(tableau):
          pc = pivot_column(tableau)
          pr = pivot_row(tableau, pc)
          pivot(tableau, pr, pc)
      return extract_solution(tableau, len(objective))