Programmation entière avec un nombre fixe de variables

Le célèbre article de 1983 de H. Lenstra Integer Programming With A Fixed Number Of Variables indique que les programmes entiers avec un nombre fixe de variables peuvent être résolus dans le polynôme temporel dans la longueur des données.

J'interprète cela comme suit.

La programmation entière en général est toujours NP-complète mais si ma taille de problème typique à portée de main (disons environ 10.000 variables, un nombre arbitraire de contraintes) est faisable dans la pratique, alors je pourrais construire un algorithme qui évolue polynomialement dans le nombre de contraintes mais pas dans le nombre de variables et de contraintes.
Le résultat est également applicable à la programmation binaire car je peux forcer n'importe quel entier à 0-1 en ajoutant une contrainte appropriée.

Mon interprétation est-elle correcte?

Ce résultat a-t-il des implications pratiques? Autrement dit, y a-t-il une implémentation disponible ou est-elle utilisée dans des solveurs populaires comme CPLEX, Gurobi ou Mosek?

Quelques citations du journal:

Cette longueur peut, pour notre propos, être définie comme n · m · log (a + 2), où a désigne le maximum des valeurs absolues des coefficients de A et b. En effet, un tel algorithme polynomial est peu susceptible d'exister, car le problème en question est NP-complet

[...]

On a supposé [5], [10] que pour toute valeur fixe de n, il existe un algorithme polynomial pour la solution du problème de programmation linéaire entier. Dans le présent article, nous prouvons cette conjecture en présentant un tel algorithme. Le degré du polynôme par lequel le temps d'exécution de notre algorithme peut être borné est une fonction exponentielle de n.

co.combinatorics linear-programming integer-programming

— Bernhard Kausler
source

"Je pourrais construire un algorithme qui évolue polynomialement en nombre de contraintes ou variables mais pas en nombre de variables et contraintes." Point / question intéressant - jusqu'à présent, nous avons vu que cela était vrai pour les contraintes (en maintenant le nombre de variables fixes), mais il serait peut-être intéressant de se demander si cela pouvait être vrai pour les variables (en maintenant le nombre de contraintes fixes) également ? Intuitivement, il semble que cela ne devrait pas être vrai, sinon l'IP serait le polytime en général, mais je ne suis pas sûr.

— usul

Dans la section 4 de l'article, Lenstra déclare que «le problème de programmation linéaire entier avec une valeur fixe de m est résolu polynomialement». (m est le nombre de contraintes) Ceci suit comme corollaire du résultat principal. Cette section n'est pas claire pour moi. Après réflexion, il suppose peut-être n ET m fixes; ce qui signifie qu'il est polynomial en "a" (le maximum des valeurs absolues des coefficients de A et b). (J'ai supprimé la partie "ou variables" de ma question ci-dessus en conséquence).

— Bernhard Kausler

n

$n$

m

$m$

m

$m$

n

$n$

Réponses:

$n$

$O(n^{2.5n+o(n)} \cdot L)$ $L$ $L$ $n$

Ainsi, le problème est linéaire à paramètre fixe paramétré par le nombre de variables.

1) Oui, la programmation linéaire entière est "toujours" NP-complète. Le temps d'exécution du résultat théorique ci-dessus ne dépend que linéairement du nombre de contraintes, il évolue donc bien dans le nombre de contraintes. Cependant, je ne connais aucune implémentation réelle de cet algorithme.

2) Oui, faire en sorte que les variables prennent des valeurs binaires est simple comme vous l'avez observé.

$L$

O (2^{n} n m + 8^{n} n \sqrt{m \log m} \log m + n^{2.5 n + o (n)} s \log m)

$O(2^nnm + 8^n n \sqrt{m \log m} \log m + n^{2.5n+o(n)}s\log m)$

m

$m$

s

$s$

— Serge Gaspers
source

Ah, merci pour le terme "linéaire à paramètres fixes". C'est le sujet de l'article de Lenstra. Voir aussi: en.wikipedia.org/wiki/Parameterized_complexity

— Bernhard Kausler

n

$n$

O (n 2^{n} m)

$O(n2^n m)$

T (n, m, s)

$T(n,m,s)$

n

$n$

m

$m$

s

$s$

O (2^{n} m + (\log m) T (n, f (n), s)

$O(2^n m + (\log m)T(n, f(n),s)$

O (s)

$O(s)$

f (n)

$f(n)$

n^{O (n)}

$n^{O(n)}$

Cela ne change pas les faits de base de votre réponse, mais une autre référence pertinente est KL Clarkson. Algorithmes de Las Vegas pour la programmation linéaire et entière lorsque la dimension est petite. J. ACM 42 (2): 488-499, 1995, doi: 10.1145 / 201019.201036.

— David Eppstein

m

$m$

n

$n$

O (n^{2.5 n + o (n)} L)

$O(n^{2.5n+o(n)} L)$

T (n, f (n), s)

$T(n,f(n),s)$

f (n) = 4^{n}

$f(n)=4^n$

L = 4^{n} s

$L=4^n s$

f (n)

$f(n)$

O (2^{n} n m + n^{2.5 n + o (n)} (\log m) s)

$O(2^nnm+n^{2.5n+o(n)}(\log m) s)$

Voici quelques points concernant les implications pratiques des résultats de type Lenstra, et les implémentations possibles dans CPLEX, Gurobi, etc. c'est-à-dire des hyperplans le long desquels la largeur du polytope n'est pas trop grande (polynôme en variables et taille des données). Mais Mahajan et Ralphs (pré-impression ici ) ont montré que le problème de la sélection d' une disjonction optimale est NP-complet. Il semblerait donc difficile de créer des implémentations pratiquement efficaces de cette classe d'algos.

La plupart des algos implémentés dans des packages tels que CPLEX pourraient être classés comme des méthodes de branchement et de découpe. Cette famille de techniques fonctionne généralement bien sur les instances IP qui sont réalisables et sont souvent en mesure de trouver des solutions quasi optimales. Mais les algos de type Lenstra se concentrent sur les instances IP les plus défavorables qui sont irréalisables au départ, et l'objectif est de prouver leur infaisabilité entière (et ils étudient la complexité de cette tâche). AFAIK, il n'y a pas de classe de problèmes avec une pertinence pratique qui correspondent à cette description. Ainsi, les gens de CPLEX / Gurobi n'implémenteraient probablement pas de sitôt des algos de type Lenstra.

— kbala
source