input: 
  def solve_linear_programming_problem_using_simplex(decision_variables, objective_function, constraints):
      """
      Solves a linear programming problem using the Simplex method. The Simplex method is an algorithm
      that finds the maximum or minimum value of a linear function defined by constraints. It does this
      by iteratively moving from one vertex of the polytope defined by the constraints to another vertex
      that improves the objective value until the optimal solution is found.
      
      The input to the function should be:
      - decision_variables: the list of variables used in the problem.
      - objective_function: the linear objective function to maximize or minimize.
      - constraints: the constraints of the problem in the form of a list of inequalities.
      
      Example:
      >>> solve_linear_programming_problem_using_simplex(['x1', 'x2'], '3*x1 + 2*x2', ['x1 + x2 <= 4', '2*x1 + x2 <= 5'])
      ('2.0*x1 + 2.0*x2', ['x1 + x2 <= 4', '2*x1 + x2 <= 5', 'x1 + x2 <= 4'])
      """
      pass
  
output:     
      # Initialize the Simplex tableau
      tableau = []
      for constraint in constraints:
          row = [float(coeff) for coeff in re.findall(r'-?\d*\.?\d+', constraint)]
          tableau.append(row)
      
      # Add the objective function to the tableau
      obj_coeffs = [float(coeff) for coeff in re.findall(r'-?\d*\.?\d+', objective_function)]
      tableau.append(obj_coeffs)
      
      # Perform the Simplex algorithm
      while any(coeff > 0 for coeff in tableau[-1][:-1]):
          # Find the pivot column
          pivot_col = tableau[-1][:-1].index(max(tableau[-1][:-1]))
          
          # Find the pivot row
          min_ratio = float('inf')
          pivot_row = -1
          for i in range(len(tableau) - 1):
              if tableau[i][pivot_col] > 0:
                  ratio = tableau[i][-1] / tableau[i][pivot_col]
                  if ratio < min_ratio:
                      min_ratio = ratio
                      pivot_row = i
          
          # Perform row operations to make all other entries in pivot column zero
          pivot_element = tableau[pivot_row][pivot_col]
          for i in range(len(tableau)):
              if i != pivot_row:
                  factor = tableau[i][pivot_col] / pivot_element
                  for j in range(len(tableau[i])):
                      tableau[i][j] -= factor * tableau[pivot_row][j]
          
          # Normalize the pivot row
          for j in range(len(tableau[pivot_row])):
              tableau[pivot_row][j] /= pivot_element
      
      # Extract the solution
      solution = {}
      for i, var in enumerate(decision_variables):
          solution[var] = tableau[-1][i]
      
      # Return the optimized objective function and constraints
      optimized_objective = ' + '.join([f"{solution[var]}*{var}" for var in decision_variables])
      return optimized_objective, constraints
  