Générer de manière algorithmique tous les points de grille à l'intérieur d'un hypercube

$\def\R{\mathbb{R}}\def\Z{\mathbb{Z}}\def\n#1{\|#1\|_\infty}$ Le problème vient directement des mathématiques computationnelles et peut être a déclaré ce qui suit:

Étant donné une matrice régulière $M\in\R^{d\times d}$ , trouver efficacement tous les vecteurs $v\in\Z^d$ tels que $\n{Mv}\leq1$ , où $\n{Mv}$ est la composante maximale de la vecteur en module.

Je donne un algorithme ci-dessous, mais il est très inefficace, car il a beaucoup plus d'étapes que le nombre de points de grille. C'est toujours supportable pour $d=5$ dans mon cas, mais ça échoue complètement pour $d=6$ , je n'ai pas beaucoup de temps; de plus, j'aimerais également travailler sur des dimensions plus élevées.

Mon algorithme actuel est basé sur ce qui suit (avertissement: contient plus de mathématiques): Tout d'abord, calculez $\n{M^{-1}}$ . Ensuite, on observe que $\n{v}\leq\n{M^{-1}}\n{Mv}\leq\n{M^{-1}}$ . Cela signifie que nous pouvons calculer $L=\operatorname{floor} \n{M^{-1}}$ puis essayer tous les vecteurs $v\in\lbrace-L,-L+1,\dots,L-1,L\}^d$ ; il y en a exactement $(2L+1)^d$ . (Et là réside le problème: si $d=6$ et $L=18$ , j'obtiens $2.5{\rm\small E}9$ itérations, ce qui est des ordres de grandeur plus grand que le nombre de points que je pense qu'il y a.)

Voici une autre façon de voir le problème: Vous avez un réseau engendré par les colonnes de . Utilisez l'algorithme Lenstra – Lenstra – Lovász (LLL) pour obtenir une base réduite de ce réseau. Si vous remplacez par une nouvelle matrice formée par la sortie de LLL, alors les colonnes de généreront toujours le même réseau, mais les vecteurs de base seront plus proches d'être orthogonaux entre eux, et les entrées de devrait avoir une plus petite ampleur.$M$$M$$M$$M^{-1}$

À partir de là, il serait également utile de lier chaque composant de séparément: c'est-à-dire que vous pouvez lier le ème composantpar. (Soit dit en passant, le n'est pas correct; nous devons utiliser la somme des éléments sur chaque ligne, pas le maximum.)$v$$i$$|v_i|$$\sum_{j=1}^d |(M^{-1})_{ij}|$$\|v\|_\infty \leq \|M^{-1}\|$

Pour des valeurs de jusqu'à environ 30, l'algorithme LLL se terminera pratiquement instantanément. De manière asymptotique, cela prend , donc cela ralentira pour les très grands , mais en même temps le nombre de points que nous devons vérifier augmente de façon exponentielle en , donc le temps d'exécution du LLL n'est pas vraiment le goulot d'étranglement. En revanche, les économies sur le nombre de points à contrôler peuvent être énormes. J'ai écrit du code GAP pour générer une matrice aléatoire régulière (stochastique) et comparer les limites sur les composants de$d$$O(d^6)$$d$$d$$M$$v$ que nous obtenons en utilisant la base d'origine, par rapport à la base réduite en LLL (Soit dit en passant, nous n'avons pas besoin de supposer que la matrice est régulière; j'ai fait cette restriction uniquement parce que c'était le cas dans votre demande):

d: = 8;
M: = IdentityMat (d);
pour i dans [1..d] faire
  pour j dans [1..d] do
    M [i] [j]: = aléatoire ([- 10 ^ 8..10 ^ 8]);
  od;
  M [i]: = M [i] / Sum (M [i]);
od;
L: = LLLReducedBasis (M) .basis;
MM: = M ^ -1 * 1,0;
LL: = L ^ -1 * 1.0;
pour i dans [1..d] faire
  pour j dans [1..d] do
    MM [i] [j]: = MM [i] [j] * SignFloat (MM [i] [j]);
    LL [i] [j]: = LL [i] [j] * SignFloat (LL [i] [j]);
  od;
od;

Impression ("Limites de la base d'origine:");
uns: = [1..d] * 0 + 1;
v: = MM * uns;
pour i dans [1..d] faire
  v [i]: = Int (Floor (v [i]));
  Imprimer (v [i]);
  Impression(" ");
od;
Imprimer ("\ n (");
Imprimer (produit (v * 2 + 1));
Imprimer ("points à vérifier) ​​\ n");

Print ("Limites pour la base LLL:");
v: = LL * ceux;
pour i dans [1..d] faire
  v [i]: = Int (Floor (v [i]));
  Imprimer (v [i]);
  Impression(" ");
od;
Imprimer ("\ n (");
Imprimer (produit (v * 2 + 1));
Imprimer ("points à vérifier) ​​\ n");

La sortie suivante (basée sur la graine aléatoire par défaut, avec ) n'est pas atypique:$d=8$

Limites de la base d'origine: 9 23 24 4 23 16 23 4 
(258370076349 points à vérifier)
Limites pour la base de LLL: 3 3 2 2 3 4 2 3 
(2701125 points à vérifier)

Edit : Ce problème est un cas particulier du problème général d'énumération des points de réseau dans les polytopes convexes, qui s'avère être un problème bien étudié, et il existe des algorithmes plus efficaces que celui décrit ci-dessus. Voir cet article pour une enquête.