How do I translate an pulp.LpProblem into matrices?

[tornikeo]

What is the correct way to "recover" c, A, lb, and ub variables as np.ndarrays matrices from an already defined LpProblem? I need to translate a codebase that is using pulp.LpProblem into a codebase relying on scipy.optimize.milp. I've tried the following function, but this seems incorrect as scipy and pulp give different solutions:

def extract_lp_matrices(model):
    # Ensure the problem is a maximization problem
    if model.sense == pulp.LpMinimize:
        model.objective = -model.objective

    # variables in sorted order
    variables = list(model.variables())
    variables.sort(key=lambda v: v.name)
    num_vars = len(variables)

    # Extract objective coefficients (c)
    c = np.array([model.objective.get(v, 0) for v in variables])

    # Extract constraint matrix (A) and bounds (ub)
    constraint_list = list(model.constraints.values())
    num_constraints = len(constraint_list)

    A = np.zeros((num_constraints, num_vars))
    lb = np.full(num_constraints, -np.inf)
    ub = np.full(num_constraints, +np.inf)

    for i, constraint in enumerate(constraint_list):
        for var, coeff in constraint.items():
            j = variables.index(var)  # Find index of variable
            A[i, j] = coeff

        if constraint.sense == pulp.LpConstraintLE:
            ub[i] = constraint.constant
        elif constraint.sense == pulp.LpConstraintEQ:
            ub[i] = constraint.constant
            lb[i] = constraint.constant
        else:
            lb[i] = constraint.constant
    return c, A, ub, lb

The specific model I'm working for is a 0/1 integer program.

Is there a pre-defined function that can facilitate this transition from PuLP into c,A,lb,ub arrays?

[pchtsp]

No pre-defined function. But PuLP generates an MPS file to communicate to solvers. I'm sure the MPS format is close to your definition of matrix. And maybe you can find a tool that converts an MPS file into the simplex matrix. https://en.wikipedia.org/wiki/MPS_(format)

[tkralphs]

As we've just been discussing in #802, one way to potentially do this would be to grab the MPS file written out by PuLP (not sure how one would do this part), then use CyLP to read in the MPS file and create a model, which would be in terms of numpy matrices and vectors.