Fix two knock-in defects - This allows computation of EFVs with StrainDesign

[VonAlphaBisZulu]

Two related defects make knock-in problems return solutions that omit reactions the modules cannot do without. Both are specific to knock-ins; the knockout path is untouched.

1. essential_kis collected costs instead of identifiers

compute_strain_designs.py

essential_kis = set(cmp_ki_cost[er] for er in essential_reacs if er in cmp_ki_cost)

This takes the intervention cost of each essential reaction rather than its identifier. On e_coli_core with every reaction made a knock-in candidate, the set came out as {1.0, 2.0, 3.0} — the distinct lump costs.

SDProblem.__init__ then did

self.lb = [1.0 if r in self.essential_kis else 0.0 for r in model.reactions]

testing a cobra Reaction for membership in a set of floats, which can never succeed. Measured: 0 of 56 binaries pinned, so reactions essential to a module stayed optional. Fixed by collecting identifiers and comparing against r.id; forced-on binaries go from 0 to 11 on that setup.

The same variable also feeds the "targetable reactions" log line, which was correspondingly wrong.

2. The no-interventions-needed shortcut misreads an all-zero knock-in vector

compute_optimal, compute_any and enumerate each start by checking whether the unmodified strain already satisfies the setup, via verify_sd on an all-zero z. For knockouts that is the wild type and the check is right.

For knock-ins an all-zero z means those reactions are absent. verify_sd deactivates a variable together with the constraints acting on it, so the check evaluates an empty system, which passes vacuously instead of failing. The run returned "no interventions are needed" and one empty design without ever solving the MILP.

The shortcut is now skipped whenever any intervention binary is inverted.

Validation

With both fixes, a PROTECT module plus knock-in candidates enumerates minimal reaction sets that support the protected region — elementary flux vectors.

On e_coli_core (growth >= 0.001, all reactions as knock-in candidates, max_cost 45), checked against the minimal-support antichain obtained independently as the Berge dual of the model's own minimal cut sets:

• the two smallest supports (26 lumps) are returned and are set-identical to the dual's
• all 607 returned designs are members of that antichain

Knockout behaviour is unchanged: MCS on e_coli_core (growth >= 0.001, max_cost 3) returns the identical 353 designs before and after. essential_kis is only populated from reactions carrying a knock-in cost, so it stays empty when ki_cost is unused.

Test suite: 368 passed, 2 skipped (performance tests deselected).

🤖 Generated with Claude Code

https://claude.ai/code/session_01RFtof9nZXFvCNoXz19po8C

[VonAlphaBisZulu]

Added a third commit addressing the underlying verification defect rather than only its symptom.

verify_sd deleted intervened variables instead of pinning them to zero

verify_sd rebuilds the continuous part of the problem as a plain LP — it is snapshotted before link_z(), so it carries no indicator or big-M rows and is an independent re-derivation rather than a mirror of the linked MILP. Every accepted solution passes through it.

It deactivated a variable by dropping its column, which equals v = 0 only while every constraint that should still bite survives. That does not hold in general:

• prevent_boundary_knockouts converts a bound excluding zero (e.g. ATPM >= 3.15) into a row with no z-mapping, precisely so that zeroing the reaction contradicts it;
• but for PROTECT modules reassign_lb_ub_from_ineq runs afterwards and folds single-variable rows back into variable bounds, which then vanish with the column.

The check therefore evaluated an empty system and called it feasible. That is the same root cause as the shortcut in the second commit — the shortcut was simply the most visible consumer.

Now the column is kept and its bounds are intersected with {0}: lb' = max(lb, 0), ub' = min(ub, 0). A reaction that may carry zero flux is pinned to zero exactly as before; one whose bounds exclude zero gets an empty interval and is correctly reported infeasible.

Verdicts are unchanged wherever the old form was already right, since a surviving unlinked bound row and an empty variable interval agree.

Re-validation after the change

• e_coli_core MCS (growth >= 0.001, max_cost 3): identical 353 designs, sizes {1: 19, 2: 111, 3: 223}
• EFV via PROTECT + knock-ins (max_cost 45): 607 designs, all 607 members of the minimal-support antichain, and the two size-26 supports set-identical to the Berge dual's
• Test suite: 368 passed, 2 skipped (performance tests deselected)

One note on the "targetable reactions" log line flagged earlier: it needs no separate change. essential_kis is a subset of cmp_ki_cost, and essential knockouts are already popped from cmp_ko_cost, so len(ko) + len(ki) - len(essential_kis) counts the free binaries correctly once the first commit makes essential_kis hold identifiers. It reports 45 = 56 − 11 on the setup above, which is right.

[VonAlphaBisZulu]

Reworked the third commit (force-pushed) after review: column removal is now kept as the default.

Full removal is the stronger oracle — an absent variable owes nothing to feasibility tolerances, whereas an interval of [0, 0] is only as exact as the solver treats it. So the detour is taken only where it is actually needed.

# zeroing a variable whose bounds exclude zero contradicts that bound
if any(self.cont_MILP.lb[j] > 0.0 or self.cont_MILP.ub[j] < 0.0 for j in inactive_vars):
    valid[i] = False
    continue
# otherwise drop the columns outright, exactly as before

For a zero-exclusive variable the intersected interval is empty, so the region is infeasible whatever the remaining system does and no LP has to be built. Every other variable is removed exactly as before, so the tolerance-free property of the original check is preserved in the common case.

Re-validated after the rework:

• e_coli_core MCS (growth >= 0.001, max_cost 3): identical 353 designs, and {ATPM} is still returned as a size-1 MCS
• EFV via PROTECT + knock-ins (max_cost 45): 607 designs, all in the minimal-support antichain, two size-26 supports set-identical to the Berge dual's
• Test suite: 368 passed, 2 skipped

[VonAlphaBisZulu]

Simplified to two commits (force-pushed). The pre-check guard turned out to be redundant once verify_sd was fixed properly, so it has been dropped.

The shortcut in compute_optimal / compute_any / enumerate calls verify_sd on an all-zero z. Its wrong answer on knock-in problems was a symptom of the column-deletion defect, not a separate bug: with verify_sd corrected, the check declines by itself, because biomass >= 0.001 folds into a lower bound, which makes that variable zero-exclusive.

Verified by reverting the guards and re-running:

• EFV via PROTECT + knock-ins: 607 designs, size-26 supports set-identical to the Berge dual's, all 607 members of the antichain
• e_coli_core MCS: identical 353 designs, {ATPM} still returned as a size-1 MCS
• Test suite: 368 passed, 2 skipped

Final diff is 17 insertions across three files:

file	change
compute_strain_designs.py	collect essential knock-in identifiers, not their cost values
strainDesignProblem.py	compare against r.id; docstring corrected
strainDesignMILP.py	reject designs that zero a variable whose bounds exclude zero