Efficiently expressing feasibility problems in Linear Systems, as feasibility problems in Asymptotic-Linear-Programs

We present a polynomial-time algorithm that obtains a set of Asymptotic Linear Programs (ALPs) from a given linear system S, such that one of these ALPs admits a feasible solution if and only if S admits a feasible solution. We also show how to use the same algorithm to determine whether or not S admits a non-trivial solution for any desired subset of its variables. S is allowed to consist of linear constraints over real variables with integer coefficients, where each constraint has either a lesser-than-or-equal-to, or a lesser-than, or a not-equal-to relational operator. Each constraint of the obtained ALPs has a lesser-than-or-equal-to relational operator, and the coefficients of its variables vary linearly with respect to the time parameter that tends to positive infinity.

💡 Research Summary

The paper addresses the problem of determining feasibility for a linear system S_linear that may contain constraints of four types: ≤, <, =, and ≠, with real variables and integer coefficients. While previous work showed how to convert systems with only ≤ and < constraints into an Asymptotic Linear Program (ALP) – a linear program whose coefficients are linear functions of a time‑parameter K that tends to infinity – handling ≠ constraints remained exponential because each inequality would require a case split (e.g., x ≠ 0 becomes x < 0 or x > 0).

The author introduces a polynomial‑time construction that reduces any such system to a finite collection of ALPs, each containing only ≤ constraints, such that S_linear is feasible if and only if at least one ALP in the collection is feasible. The key ideas are:

1. Strict‑inequality handling – Replace each < constraint by two constraints involving a new slack variable e and the asymptotic parameter K: (a – x) ≥ e and K·e ≥ 1. As K → ∞, e can be made arbitrarily small, reproducing the original strict inequality.

2. Modeling ≠ constraints – For each ≠ constraint c·x ≠ r, introduce a new variable f and write c·x – r = f with the additional requirement f ≠ 0. Then define a set of auxiliary variables y₁,…,y_R and z₁,…,z_R linked by
   f_i = Σ_{j≠i} y_j, (K+i)·y_i = z_i.
   The paper proves two theorems: (i) the linear system relating y, x, and z always has a solution because a certain matrix has determinant (N‑1)! ≠ 0; (ii) for sufficiently large K, “at least two z_i are non‑zero” is equivalent to “all y_i are non‑zero”, which in turn forces all f_i ≠ 0.

3. Case enumeration – Choose any pair of the R variables z_i and enforce that both are non‑zero. For each pair there are four sign possibilities (both positive, both negative, one positive/one negative, etc.), yielding 2·R·(R‑1) total cases. For each case, the sign conditions are expressed again using the e/K trick, turning them into ≤ constraints.

4. Construction of ALPs – For each of the 2·R·(R‑1) cases, combine the original ≤ constraints, the transformed < constraints, the equality‑to‑≤ conversions, and the sign‑condition constraints to form an ALP_i. The coefficients of all variables are linear in K, satisfying the definition of an ALP.

5. Correctness – The paper shows that if S_linear has a feasible solution, then there exists a pair of z_i that are non‑zero, and the corresponding ALP_i will be feasible. Conversely, if any ALP_i is feasible, the constructed values can be mapped back to a feasible solution of S_linear. Hence feasibility of S_linear is equivalent to feasibility of the disjunction of the ALPs.

6. Non‑trivial subset detection – To test whether a specific subset of variables can be non‑zero in any feasible solution, the author adds a single ≠ constraint that forces a weighted sum of scaled versions of those variables (using the same K‑scaling technique) to be non‑zero. The same algorithm then decides feasibility, providing a polynomial‑time method for the non‑triviality question.

The algorithm runs in O(R²) time for the number of ≠ constraints R, and each ALP can be built in polynomial time with respect to the total number of variables and constraints. The paper concludes by noting that extending this approach to binary (0‑1) variables would imply that ALP is NP‑hard, an important open problem, and suggests investigating weakly polynomial‑time algorithms for ALP similar to those existing for ordinary linear programming.