input: 
  def solve_linear_programming_problem_using_simplex(problem_definition):
      """
      Solve a linear programming problem using the Simplex method. The method involves finding 
      the maximum or minimum value of a linear objective function subject to a number of constraints. 
      The Simplex Method iteratively moves through the vertices of a polytope defined by the constraints 
      until it finds the optimal solution.
      
      Example:
      >>> solve_linear_programming_problem_using_simplex('Maximize 3x + 4y subject to x + y <= 4, 2x + y <= 5, x >= 0, y >= 0')
      'The optimal solution is achieved at point (3, 1) with the maximum value being 13.'
      """
  
output:     import re
      from scipy.optimize import linprog
  
      # Parse the problem definition
      objective_match = re.search(r'(Maximize|Minimize) (.*) subject to (.*)', problem_definition)
      if not objective_match:
          raise ValueError("Invalid problem definition format")
      
      objective_type = objective_match.group(1)
      objective_function = [float(coeff) for coeff in re.findall(r'-?\d*\.?\d+', objective_match.group(2))]
      constraints = objective_match.group(3).split(', ')
      
      # Prepare the constraints
      A = []
      b = []
      for constraint in constraints:
          if '>=' in constraint:
              op = '>='
          elif '<=' in constraint:
              op = '<='
          else:
              raise ValueError("Invalid constraint operator")
          
          lhs, rhs = constraint.split(op)
          lhs_coeffs = [float(coeff) for coeff in re.findall(r'-?\d*\.?\d+', lhs)]
          rhs_value = float(rhs)
          
          if op == '>=':
              A.append([-coeff for coeff in lhs_coeffs])
              b.append(-rhs_value)
          else:
              A.append(lhs_coeffs)
              b.append(rhs_value)
      
      # Solve the problem using linprog
      if objective_type == 'Maximize':
          result = linprog([-coeff for coeff in objective_function], A_ub=A, b_ub=b, bounds=(0, None))
      else:
          result = linprog(objective_function, A_ub=A, b_ub=b, bounds=(0, None))
      
      if result.success:
          x_values = result.x
          optimal_value = result.fun if objective_type == 'Minimize' else -result.fun
          solution_point = tuple(round(x, 2) for x in x_values)
          return f'The optimal solution is achieved at point {solution_point} with the {"maximum" if objective_type == "Maximize" else "minimum"} value being {round(optimal_value, 2)}.'
      else:
          return 'No optimal solution found.'