а запиши в виде математических действий на псевдопитоне/си оставив суть

import numpy as np
from fractions import Fraction

def simplex_method(c, A, b, verbose=False):
    """
    Параметры:
    c -- коэффициенты целевой функции (на минимум)
    A -- матрица ограничений
    b -- правые части ограничений
    verbose -- выводить промежуточные шаги
    """
    # Преобразование в numpy массивы и использование Fraction для точных вычислений
    c = np.array([Fraction(val) for val in c])
    A = np.array([[Fraction(val) for val in row] for row in A])
    b = np.array([Fraction(val) for val in b])
    
    m, n = A.shape  
    
    
    tableau = np.zeros((m + 1, n + m + 1), dtype=object)
    for i in range(m + 1):
        for j in range(n + m + 1):
            tableau[i, j] = Fraction(0)
    
    
    tableau[0, 0] = Fraction(0)  # значение целевой функции
    tableau[0, 1:n+1] = c  
    
    for i in range(m):
        tableau[i+1, 0] = b[i]  
        tableau[i+1, 1:n+1] = A[i]  
        tableau[i+1, n+1+i] = Fraction(1)  # единичная матрица для базисных переменных
    
    
    basis = list(range(n, n + m))
    

    iteration = 0
    while True:
        iteration += 1
        if verbose:
            print(f"\nИтерация {iteration}:")
            print_tableau(tableau, n, m, basis)
        
        
        if all(tableau[0, 1:] >= 0):
            break
        
        # Выбор входящей переменной (с наиболее отрицательным коэффициентом)
        entering_col = np.argmin(tableau[0, 1:]) + 1
        
       
        if all(tableau[1:, entering_col] <= 0):
            return None, float('-inf'), "Задача не имеет решения (целевая функция не ограничена снизу)"
        
        # Выбор выходящей переменной (минимальное отношение)
        ratios = []
        for i in range(1, m + 1):
            if tableau[i, entering_col] > 0:
                ratios.append((tableau[i, 0] / tableau[i, entering_col], i))
            else:
                ratios.append((float('inf'), i))
        
        _, leaving_row = min(ratios)
        
        basis[leaving_row - 1] = entering_col - 1
        
        pivot = tableau[leaving_row, entering_col]
        tableau[leaving_row] = tableau[leaving_row] / pivot
        
        
        for i in range(m + 1):
            if i != leaving_row:
                factor = tableau[i, entering_col]
                tableau[i] = tableau[i] - factor * tableau[leaving_row]
    
    
    x = np.zeros(n, dtype=object)
    for i, idx in enumerate(basis):
        if idx < n:
            x[idx] = tableau[i+1, 0]
    
    z = -tableau[0, 0]  
    
    return x, z, "Оптимальное решение найдено"

def print_tableau(tableau, n, m, basis):
   
    headers = [""] + [f"x{j+1}" for j in range(n)] + [f"s{j+1}" for j in range(m)] + ["RHS"]
    basis_vars = [f"x{b+1}" if b < n else f"s{b-n+1}" for b in basis]
    
    
    print("    " + " ".join(f"{h:^8}" for h in headers))
    
    
    row_str = "z   " + " ".join(f"{float(val):8.2f}" for val in tableau[0])
    print(row_str)
    
    
    for i in range(1, m + 1):
        row_str = f"{basis_vars[i-1]:<4}" + " ".join(f"{float(val):8.2f}" for val in tableau[i])
        print(row_str)


def solve_example_problem():
    # Целевая функция: F = x₁ + 2x₂ → max, или -x₁ - 2x₂ → min
    c = [-1, -2]
    
    A = [
        [4, -2, 1, 0, 0],
        [-1, 3, 0, 1, 0],
        [2, 4, 0, 0, -1]
    ]
    
    b = [12, 6, 16]
    
    # Для третьего ограничения нужна искусственная переменная, но поскольку мы используем библиотеку SciPy, нам не нужно её вводить вручную
    
    from scipy.optimize import linprog
    
    
    result = linprog(
        c=[-1, -2],  
        A_ub=[[4, -2], [-1, 3], [-2, -4]], 
        b_ub=[12, 6, -16],  
        bounds=[(0, None), (0, None)]  
    )
    
    print("\nРешение с помощью SciPy:")
    print(f"x₁ = {result.x[0]:.2f}, x₂ = {result.x[1]:.2f}")
    print(f"Максимальное значение F = {-result.fun:.2f}")
    print("\nРешение с помощью нашей реализации симплекс-метода:")
    
    
    # Добавим искусственную переменную x₆ для третьего ограничения
    c_extended = [-1, -2, 0, 0, 0, 1000]  # Большой штраф для искусственной переменной
    
    A_extended = [
        [4, -2, 1, 0, 0, 0],
        [-1, 3, 0, 1, 0, 0],
        [2, 4, 0, 0, -1, 1]
    ]
    
    x, z, status = simplex_method(c_extended, A_extended, b, verbose=True)
    
    if x is not None:
        print("\nРезультат:")
        print(f"x₁ = {float(x[0]):.2f}, x₂ = {float(x[1]):.2f}")
        print(f"Максимальное значение F = {float(z):.2f}")
    else:
        print(f"\nСтатус: {status}")

if __name__ == "__main__":
    solve_example_problem()