Comment itérer sur des vecteurs par ordre de probabilité dans un petit espace

12

Considérons un vecteur dimensionnel où . Pour chaque nous connaissons et supposons que les sont indépendants. En utilisant ces probabilités, existe-t-il un moyen efficace d'itérer sur des vecteurs binaires de dimension dans l'ordre du plus probable au moins probable (avec des choix arbitraires pour les liens) en utilisant l'espace sublinéaire dans la taille de sortie? $n$ $v$ $v_i \in \{0,1\}$ $i$ $p_i = P(v_i = 1)$ $v_i$ $n$

Prenons par exemple . Le vecteur le plus probable est et le moins probable est . $p = \{0.8, 0.3, 0.6\}$ $(1,0,1)$ $\{0,1,0\}$

Pour un très petit, nous pourrions étiqueter chacun des vecteurs avec sa probabilité et simplement trier, mais cela n'utiliserait bien sûr pas encore l'espace sublinéaire. $n$ $2^n$

Une variante proche de cette question a déjà été posée sur /cs/24123/how-to-iterate-over-vectors-in-order-of-probability .

ds.algorithms space-bounded

— Lembik
source

Y a-t-il une raison pour laquelle vous n'avez pas posé la question de suivi là aussi? Le problème principal ici est-il de le faire dans l'espace sublinéaire?

— Suresh Venkat

@SureshVenkat Oui, le problème concerne entièrement l'espace sublinéaire (dans la taille de sortie). Je l'ai posée ici car je pense que la question peut être très difficile.

— Lembik

Résoudre ce problème dans l' espace et le temps

semble nécessiter des techniques similaires à SUBSET-SUM (savoir rapidement quelles sommes de sous-ensembles annulent presque différentes sommes). Ainsi, il est peu probable d'avoir une solution rapide.

poly (n)

$\textrm{poly}(n)$

— Geoffrey Irving

@GeoffreyIrving Pensez-vous que cette intuition puisse être rendue plus formelle?

— Lembik

9

Ce qui suit donne un algorithme qui utilise environ temps et espace. $2^n$ $2^{n/2}$

Examinons d'abord le problème du tri des sommes de tous les sous-ensembles de éléments. $n$

Considérez ce sous-problème: vous avez deux listes triées de longueur , et vous souhaitez créer une liste triée des sommes par paire des nombres dans les listes. Vous souhaitez le faire dans un temps d'environ (la taille de sortie), mais dans un espace sublinéaire. Nous pouvons atteindre un espace . Nous gardons une file d'attente prioritaire et retirons les sommes de la file d'attente prioritaire dans l'ordre croissant. $m$ $O(m^2)$ $O(m)$

Soit les listes et , triées par ordre croissant. Nous prenons les sommes , , et les mettons dans une file d'attente prioritaire. $a_1 \ldots a_m$ $b_1 \ldots b_m$ $m$ $a_i + b_1$ $i = 1 \ldots m$

Maintenant, lorsque nous tirons la plus petite somme restante de la file d'attente prioritaire, si nous mettons alors la somme dans la file d'attente prioritaire. L'espace est dominé par la file d'attente prioritaire, qui contient toujours au plus sommes. Et le temps est , puisque nous utilisons pour chaque opération de file d'attente prioritaire. Cela montre que nous pouvons faire le sous-problème en $a_i + b_j$ $j < m$ $a_i + b_{j+1}$ $m$ $O(m^2 \log m)$ $O(\log m)$ temps et espace. $O(m^2 \log m)$ $O(m)$

Maintenant, pour trier les sommes de tous les sous-ensembles de nombres, nous utilisons simplement ce sous-programme où la liste est l'ensemble des sommes des sous-ensembles de la première moitié des éléments, et la liste est l'ensemble des sommes des sous-ensembles de la seconde moitié des articles. On peut retrouver ces listes récursivement avec le même algorithme. $n$ $a_i$ $b_i$

Nous allons maintenant considérer le problème d'origine. Soit l'ensemble des coordonnées qui sont et l'ensemble des coordonnées . Alors $S_0$ $0$ $S_1$ $1$

\begin{array}{rcl} \prod_{i \in S_{0}} p (v_{i} = 0) \prod_{i \in S_{1}} p (v_{i} = 1) & = & \prod_{1 \leq i \leq n} p (v_{i} = 0) \prod_{i \in S_{1}} \frac{p (v_{i} = 1)}{p (v_{i} = 0)} \\ = & \prod_{1 \leq i \leq n} p (v_{i} = 0) \exp (\sum_{i \in S_{1}} \log \frac{p (v_{i} = 1)}{p (v_{i} = 0)}) . \end{array}

$\begin{eqnarray*}\prod_{i \in S_0} p(v_i=0) \prod_{i \in S_1} p(v_i=1) &=& \prod_{1\leq i \leq n} p(v_i=0) \prod_{i \in S_1} \frac{p(v_i=1)}{p(v_i=0)} \\ &=& \prod_{1\leq i \leq n} p(v_i=0) \exp\,\left(\sum_{i \in S_1} \log \frac{p(v_i=1)}{p(v_i = 0)}\right).\end{eqnarray*}$

Le tri de ces nombres revient à trier les nombres , nous avons donc réduit le problème du tri des sommes des sous-ensembles de éléments. $\sum_{i\in S_1}\log p(v_i=1) - \log p(v_i=0)$ $n$

— Peter Shor
source

Y a-t-il vraisemblablement une réduction qui rendrait improbable une solution poly temps / espace?

— Lembik

2^{n}

$2^n$

n 2^{n}

$n\, 2^n$

Je vous remercie. Je ne voulais pas dire poly temps bien sûr, mais plutôt quelque chose de linéaire dans la taille de sortie et l'espace poly.

— Lembik

4

$O(n)$

$x \in \{0,1\}^n$ $O(n)$ $r(x)$ $x$ $x'$ $p(x') > p(x)$ $x'\in \{0,1\}^n$ $x'$ $p(x') > p(x)$ $r(x)$ $x$
$k$ $x$ $r(x) = k$ $O(n)$ $x \in \{0,1\}^n$ $x$ $r(x)$ $x$ $r(x) = k$
$k$ $0$ $2^n-1$ $k$ $x$ $r(x) =k$

(Nous devons également nous occuper des liens possibles, mais ce n'est pas difficile.)

— Yury
source

Je vous remercie. C'est un algorithme assez lent cependant :)

— Lembik

0

Modifier: cette réponse est incorrecte. Voir les commentaires pour plus de détails. ~ gandaliter

$O(2^n)$ $O(n)$

$(i, p_i)$ $\left|0.5 - p_i\right|$
$v$ $v_i$ $1$ $p_i > 0.5$ $0$ $v$ $v_i$ $v$
Appelez cette fonction récursive sur la liste triée et un vecteur vide.

$0$ $1$ $0.5$

$O(2^n)$ $O(n)$ $n$ $O(2^n)$ $O(n)$ $O(2^n)$ pas de temps. Par conséquent, cet algorithme est optimal dans le pire des cas.

— gandaliter
source

Θ (2^{n})

$\Theta(2^n)$

Merci. Je ne l'ai clairement pas lu assez attentivement! J'ai édité ma réponse.

— gandaliter

3

v_{1} = 1

$v_1=1$

2^{n - 1}

$2^{n-1}$

v_{1} = 1

$v_1=1$

p_{i} = 0.5

$p_i=0.5$

Vous avez raison, cela ne fonctionne pas. Pardon!

— gandaliter