input: def solve_linear_programming_using_simplex(linear_program: dict) -> tuple:
      """
      Solves a linear programming problem using the Simplex Method. The input is a dictionary
      containing the decision variables, objective function, and constraints. The output is a
      tuple containing the optimal values for the decision variables and the maximum or minimum
      value of the objective function.
      
      The Simplex Method involves:
      1. Defining the problem in terms of decision variables, objective function, and constraints.
      2. Converting the problem into standard form by introducing slack variables, if needed.
      3. Creating a tableau containing the coefficients of the decision variables and the right-hand
         sides of the constraints.
      4. Setting up the starting solution in the tableau and iteratively using the Simplex algorithm
         to move from a vertex to the next until an optimum solution is reached.
      5. Determining the optimum solution by inspecting the values in the tableau.
      
      Example:
      linear_program = {
          'decision_variables': ['x1', 'x2'],
          'objective_function': [2, 3],
          'constraints': [
              [1, 1, 4],
              [1, -1, 1]
          ],
          'is_max': True
      }
      solve_linear_programming_using_simplex(linear_program)
      
      Expected Output:
      ({'x1': 2.5, 'x2': 1.5}, 10.5)
      """
      pass
output:     
      # Extract the decision variables, objective function, and constraints from the input dictionary
      decision_variables = linear_program['decision_variables']
      objective_function = linear_program['objective_function']
      constraints = linear_program['constraints']
      is_max = linear_program['is_max']
      
      # Convert the problem into standard form by introducing slack variables
      num_vars = len(decision_variables)
      num_constraints = len(constraints)
      slack_variables = [f's{i+1}' for i in range(num_constraints)]
      all_variables = decision_variables + slack_variables
      
      # Create the initial tableau
      tableau = []
      for i, constraint in enumerate(constraints):
          row = constraint[:-1] + [1 if j == i else 0 for j in range(num_constraints)] + [constraint[-1]]
          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 (column with the most negative coefficient in the objective row)
          entering_col = min(range(num_vars + num_constraints), key=lambda i: tableau[-1][i])
          
          # If no negative coefficients in the objective row, we have reached the optimal solution
          if tableau[-1][entering_col] >= 0:
              break
          
          # Find the leaving variable (row with the minimum ratio test)
          min_ratio = float('inf')
          leaving_row = -1
          for i in range(num_constraints):
              if tableau[i][entering_col] > 0:
                  ratio = tableau[i][-1] / tableau[i][entering_col]
                  if ratio < min_ratio:
                      min_ratio = ratio
                      leaving_row = i
          
          # If no positive coefficients in the entering column, the problem is unbounded
          if leaving_row == -1:
              raise ValueError("The problem is unbounded.")
          
          # Pivot on the entering and leaving variables
          pivot = tableau[leaving_row][entering_col]
          tableau[leaving_row] = [x / pivot for x in tableau[leaving_row]]
          for i in range(num_constraints + 1):
              if i != leaving_row:
                  factor = tableau[i][entering_col]
                  tableau[i] = [x - factor * y for x, y in zip(tableau[i], tableau[leaving_row])]
      
      # Extract the optimal values for the decision variables
      optimal_values = {}
      for i, var in enumerate(decision_variables):
          for j in range(num_constraints):
              if tableau[j][i] == 1 and all(tableau[k][i] == 0 for k in range(num_constraints) if k != j):
                  optimal_values[var] = tableau[j][-1]
                  break
          else:
              optimal_values[var] = 0
      
      # Calculate the optimal value of the objective function
      optimal_objective_value = tableau[-1][-1]
      if not is_max:
          optimal_objective_value = -optimal_objective_value
      
      return optimal_values, optimal_objective_value
  