[Paper Review] Rescaling Algorithms for Linear Programming - Part I: Conic feasibility

Daniel Dadush, László A. Végh+1 more|arXiv (Cornell University)|Nov 19, 2016

Advanced Optimization Algorithms Research26 references2 citations

TL;DR

This paper presents polynomial-time rescaling algorithms for solving two linear conic feasibility problems: finding a positive vector in the kernel or image of a matrix A. By iteratively applying first-order steps and geometric potential-improving rescalings, the algorithms achieve worst-case complexity bounds of O((m³n + mn²) log |ρ_A|⁻¹) for the kernel problem and O(m²n² log ρ_A⁻¹) for the image problem, with extensions to degenerate cases using bit-size complexity.

ABSTRACT

We propose simple polynomial-time algorithms for two linear conic feasibility problems. For a matrix $A\in \mathbb{R}^{m imes n}$, the kernel problem requires a positive vector in the kernel of $A$, and the image problem requires a positive vector in the image of $A^ op$. Both algorithms iterate between simple first order steps and rescaling steps. These rescalings improve natural geometric potentials. If Goffin's condition measure $ ho_A$ is negative, then the kernel problem is feasible and the worst-case complexity of the kernel algorithm is $O\left((m^3n+mn^2)\log{| ho_A|^{-1}} ight)$; if $ ho_A>0$, then the image problem is feasible and the image algorithm runs in time $O\left(m^2n^2\log{ ho_A^{-1}} ight)$. We also extend the image algorithm to the oracle setting. We address the degenerate case $ ho_A=0$ by extending our algorithms to find maximum support nonnegative vectors in the kernel of $A$ and in the image of $A^ op$. In this case the running time bounds are expressed in the bit-size model of computation: for an input matrix $A$ with integer entries and total encoding length $L$, the maximum support kernel algorithm runs in time $O\left((m^3n+mn^2)L ight)$, while the maximum support image algorithm runs in time $O\left(m^2n^2L ight)$. The standard linear programming feasibility problem can be easily reduced to either maximum support problems, yielding polynomial-time algorithms for Linear Programming.

Motivation & Objective

• To develop efficient, polynomial-time algorithms for determining feasibility of linear conic problems involving the kernel and image of a matrix A.
• To address the degenerate case where Goffin's condition measure ρ_A = 0 by finding maximum support nonnegative vectors in the kernel and image.
• To extend the image algorithm to the oracle computation model for broader applicability.
• To reduce standard linear programming feasibility to the maximum support kernel and image problems, thereby yielding polynomial-time LP algorithms.

Proposed method

• The kernel algorithm iterates between first-order steps and rescaling steps that improve a geometric potential function related to the kernel feasibility.
• The image algorithm uses similar iterative steps, but targets the image of A^T, with rescalings that enhance a potential tied to image feasibility.
• Rescaling steps are designed to improve the condition measure ρ_A, which governs the convergence rate and feasibility status.
• For degenerate cases (ρ_A = 0), the algorithms are extended to find nonnegative vectors with maximum support in the kernel and image, using bit-size complexity models.
• The algorithms are adapted to the oracle model by replacing explicit matrix access with queries, preserving polynomial-time performance.
• Complexity bounds are derived using logarithmic dependence on |ρ_A|⁻¹ for non-degenerate cases and on the total encoding length L for integer matrices in degenerate cases.

Experimental results

Research questions

• RQ1 Can we design a polynomial-time algorithm for determining whether a positive vector exists in the kernel of a given matrix A?
• RQ2 What is the worst-case complexity of a rescaling-based algorithm for the kernel feasibility problem, and how does it depend on the condition measure ρ_A?
• RQ3 How can the image feasibility problem be solved efficiently, and what is the complexity in terms of ρ_A?
• RQ4 Can the image algorithm be extended to the oracle model without sacrificing polynomial-time performance?
• RQ5 How can we handle the degenerate case ρ_A = 0 by finding maximum support nonnegative vectors in the kernel and image?

Key findings

• The kernel feasibility algorithm runs in O((m³n + mn²) log |ρ_A|⁻¹) time when ρ_A < 0, ensuring feasibility of the kernel problem.
• The image feasibility algorithm runs in O(m²n² log ρ_A⁻¹) time when ρ_A > 0, guaranteeing feasibility of the image problem.
• For degenerate matrices with ρ_A = 0 and integer entries, the maximum support kernel algorithm runs in O((m³n + mn²)L) time using bit-size complexity.
• The maximum support image algorithm runs in O(m²n²L) time under the same degenerate, integer matrix conditions.
• The standard linear programming feasibility problem can be reduced to the maximum support kernel or image problem, yielding polynomial-time LP algorithms.
• The rescaling mechanism effectively improves geometric potentials, enabling convergence even in ill-conditioned or degenerate settings.