Algoritmo eficiente para gerar duas permutações difusas e desarranjadas de um conjunto múltiplo aleatoriamente

fundo

$\newcommand\ms[1]{\mathsf #1}\def\msD{\ms D}\def\msS{\ms S}\def\mfS{\mathfrak S}\newcommand\mfm[1]{#1}\def\po{\color{#f63}{\mfm{1}}}\def\pc{\color{#6c0}{\mfm{c}}}\def\pt{\color{#08d}{\mfm{2}}}\def\pth{\color{#6c0}{\mfm{3}}}\def\pf{4}\def\pv{\color{#999}5}\def\gr{\color{#ccc}}\let\ss\gr$ Suponha que eu tenha dois lotes idênticos de $n$ bolinhas de gude. Cada mármore pode ser uma das cores $c$ , onde $c≤n$ . Deixe $n_i$ denotam o número de berlindes de cor $i$ em cada lote.

Seja $\msS$ o multiset $\small\{\overbrace{\po,…,\po}^{n_1},\;\overbrace{\pt,…,\pt}^{n_2},\;…,\;\overbrace{\vphantom 1\pc,…,\pc}^{n_c}\}$ representando um lote. Na representação de frequência , $\msS$ também pode ser escrito como $(\po^{n_1} \;\pt^{n_2}\; … \;\pc^{n_c})$ .

O número de permutações distintas de $\msS$ é dado pelo multinomial :

| S_{S} | = (\binom{n}{n_{1}, n_{2}, \dots, n_{c}}) = \frac{n!}{n_{1}! n_{2}! \dots n_{c}!} = n! \prod_{i = 1}^{c} \frac{1}{n_{i}!} .

$\left|\mfS_{\msS}\right|=\binom{n}{n_1,n_2,\dots,n_c}=\frac{n!}{n_1!\,n_2!\cdots n_c!}=n! \prod_{i=1}^c \frac1{n_i!}.$

Questão

Existe um algoritmo eficiente para gerar duas permutações difusas e perturbadas $P$ e $Q$ de $\msS$ aleatoriamente? (A distribuição deve ser uniforme.)

Uma permutação $P$ é difusa se para cada elemento distinto $i$ de $P$ , os casos de $i$ são espaçados de forma aproximadamente uniforme em $P$ .
Por exemplo, suponha que $\msS=(\po^4\;\pt^4)=\{\po,\po,\po,\po,\pt,\pt,\pt,\pt\}$ .
- $\{\po, \po, \po, \pt, \pt, \pt, \pt, \po\}$ não é difuso
- $\{\po, \pt, \po, \pt, \po, \pt, \po, \pt\}$ é difuso
Mais rigorosamente:
- Se , há apenas uma instância de para "espaçar" em , então deixe . $n_i=1$ $i$ $P$ $\Delta(i)=0$
- Caso contrário, deixe é a distância entre o exemplo e exemplo de em . Subtraia a distância esperada entre as instâncias de , definindo o seguinte: Se estiver uniformemente espaçado em , então deverá ser zero ou muito próximo de zero se . $d(i,j)$ $j$ $j+1$ $i$ $P$ $i$ $δ (i, j) = d (i, j) - \frac{n}{n_{i}} Δ (i) = \sum_{j = 1}^{n_{i} - 1} δ (i, j)^{2}$ $\delta(i,j)=d(i,j)-\frac n{n_i}\qquad\qquad\Delta(i)=\sum_{j=1}^{n_i-1} \delta(i,j)^2$ $i$ $P$ $\Delta(i)$ $n_i\nmid n$
Agora definir a estatística para medir a quantidade de cada é uniformemente espaçados em . Chamamos difuso se for próximo de zero, ou aproximadamente . (Pode-se escolher um limite específico para para que seja difuso se ) $s(P)=\sum_{i=1}^c\Delta(i)$ $i$ $P$ $P$ $s(P)$ $s(P)\ll n^2$ $k\ll1$ $\msS$ $P$ $s(P)<kn^2$

Essa restrição lembra um problema mais estrito de agendamento em tempo real chamado problema de cata -vento com multiset (para que ) e densidade . O objetivo é agendar uma sequência infinita cíclica modo que qualquer subsequência de comprimento contenha pelo menos uma instância de . Em outras palavras, uma programação viável requer todos os ; se é densa ( ), então e . O problema do cata-vento parece estar completo com NP. $\ms A=n/\msS$ $a_i=n/n_i$ $\rho=\sum_{i=1}^c n_i/n=1$ $P$ $a_i$ $i$ $d(i,j)≤a_i$ $\ms A$ $\rho= 1$ $d(i,j)=a_i$ $s(P)=0$
Duas permutações e são desarranjadas se é uma desarranjo de ; isto é, para cada índice . $P$ $Q$ $P$ $Q$ $P_i ≠ Q_i$ $i\in[n]$
Por exemplo, suponha que . $\msS=(\po^2\;\pt^2)=\{\po,\po,\pt,\pt\}$
- $\{\po, \pt, \po, \pt\}$ e não são perturbados $\{\po, \po, \pt, \pt\}$
- $\{\po, \pt, \po, \pt\}$ e estão desarranjados $\{\pt, \po, \pt, \po\}$

Análise exploratória

Estou interessado na família de multisets com e para . Em particular, vamos . $n=20$ $n_i=4$ $i\lesssim4$ $\msD=(\gr1^4\,\gr2^4\,\gr3^4\,\gr4^3\,\gr5^2\,\gr6^1\,\gr7^1\,\gr8^1)$

A probabilidade de que duas permutações aleatórias e de sejam perturbadas é de cerca de 3%. $P$ $Q$ $\msD$

Isso pode ser calculado da seguinte maneira, onde é o polinômio do ésimo Laguerre: Veja aqui uma explicação. $L_k$ $k$
$\begin{aligned} | D_{D} | & = \int_{0}^{\infty} d t e^{- t} \prod_{i = 1}^{c} L_{n_{i}} (t) = \int_{0}^{\infty} d t e^{- t} (L_{4} (t))^{3} (L_{3} (t)) (L_{2} (t)) (L_{1} (t))^{3} \\ = 4.5 \times 10^{11} \\ | S_{D} | & = n! \prod_{i = 1}^{c} \frac{1}{n_{i}!} = \frac{20!}{(4!)^{3} (3!) (2!) (1!)^{3}} = 1.5 \times 10^{13} \\ p & = | D_{D} | / | S_{D} | \approx 0.03 \end{aligned}$ $\begin{align*} \left|{\mathfrak D}_{\msD}\right| &=\int_0^\infty \!\!dt\; e^{-t}\, \prod_{i=1}^c L_{n_i}(t) =\int_0^\infty \!\!dt\; e^{-t}\, \bigl(L_4(t)\bigr)^3\bigl(L_3(t)\bigr)\bigl(L_2(t)\bigr)\bigl(L_1(t)\bigr)^3\\ &=4.5\times10^{11}\\ \left|\mfS_{\msD}\right| &=n!\prod_{i=1}^c \frac1{n_i!} =\frac{20!}{(4!)^3\,(3!)\,(2!)\,(1!)^3} =1.5\times10^{13}\\ p&=\left|{\mathfrak D}_{\msD}\right|/ \left|\mfS_{\msD}\right|\approx0.03\end{align*}$
A probabilidade de uma permutação aleatória de ser difusa é de cerca de 0,01%, definindo o limiar arbitrário em aproximadamente . $P$ $\msD$ $s(P)<25$

Abaixo está um gráfico de probabilidade empírica de 100.000 amostras de onde é uma permutação aleatória de . $s(P)$ $P$ $\msD$

Em tamanhos médios de amostra, . $s(P)\sim \text{Gamma}(\alpha\approx8,\beta\approx18)$

$\begin{array}{ccl} P & s (P) & cdf (s (P)) \\ {1, 8, 2, 3, 4, 1, 5, 2, 3, 6, 1, 4, 2, 3, 7, 1, 5, 2, 4, 3} & \frac{11}{9} \approx 1 & < 10^{- 5} \\ {8, 2, 3, 4, 1, 6, 5, 2, 3, 4, 1, 7, 1, 2, 3, 5, 4, 1, 2, 3} & \frac{140}{9} \approx 16 & < 10^{- 4} \\ {3, 6, 5, 1, 3, 4, 2, 1, 2, 7, 8, 5, 2, 4, 1, 3, 3, 2, 1, 4} & \frac{650}{9} \approx 72 & 0.05 \\ {3, 1, 3, 4, 8, 2, 2, 1, 1, 5, 3, 3, 2, 6, 4, 4, 2, 1, 7, 5} & \frac{1223}{9} \approx 136 & 0.45 \\ {4, 1, 1, 4, 5, 5, 1, 3, 3, 7, 1, 2, 2, 4, 3, 3, 8, 2, 2, 6} & \frac{1697}{9} \approx 189 & 0.80 \end{array}$ $\begin{array}{ccl}\renewcommand\mfm[1]{\textbf{#1}} \hline P & s(P) & \text{cdf}(s(P)) \\ \hline \{\po, \ss8, \pt, \pth, \pf, \po, \pv, \pt, \pth, \ss6, \po, \pf, \pt, \pth, \ss7, \po, \pv, \pt, \pf, \pth\} & \frac{11}9\approx1\, & <10^{-5} \\ \{\ss8, \pt, \pth, \pf, \po, \ss6, \pv, \pt, \pth, \pf, \po, \ss7, \po, \pt, \pth, \pv, \pf, \po, \pt, \pth\} & \frac{140}9\approx16 & <10^{-4} \\ \{\pth, \ss6, \pv, \po, \pth, \pf, \pt, \po, \pt, \ss7, \ss8, \pv, \pt, \pf, \po, \pth, \pth, \pt, \po, \pf\} & \frac{650}9\approx72 & \phantom{<1}0.05 \\ \{\pth, \po, \pth, \pf, \ss8, \pt, \pt, \po, \po, \pv, \pth, \pth, \pt, \ss6, \pf, \pf, \pt, \po, \ss7, \pv\} & \frac{1223}9\approx136 & \phantom{<1}0.45 \\ \{\pf, \po, \po, \pf, \pv, \pv, \po, \pth, \pth, \ss7, \po, \pt, \pt, \pf, \pth, \pth, \ss8, \pt, \pt, \ss6\} & \frac{1697}9\approx189 & \phantom{<1}0.80 \\ \hline \end{array}$

A probabilidade de que duas permutações aleatórias sejam válidas (difusas e desarranjadas) é de cerca de . $v\approx(0.03)(0.0001)^2\approx10^{-10}$

Algoritmos ineficientes

Um algoritmo "rápido" comum para gerar um desarranjo aleatório de um conjunto é baseado em rejeição:

fazer
     P ← random_permutation ( D )
até is_derangement ( D , P )
retornar P

que leva aproximadamente iterações, uma vez que existem cerca de possíveis distúrbios. No entanto, um algoritmo aleatório baseado em rejeição não seria eficiente para esse problema, pois levaria na ordem de iterações. $e$ $n!/e$ $1/v\approx10^{10}$

No algoritmo usado pelo Sage , um desarranjo aleatório de um multiset "é formado escolhendo um elemento aleatoriamente da lista de todos os possíveis desarranjos". No entanto, isso também é ineficiente, pois existem permutações válidas para enumerar e, além disso, seria necessário um algoritmo para fazer isso de qualquer maneira. $v\,|\mfS_{\msD}|^2\approx10^{16}$

Outras perguntas

Qual é a complexidade desse problema? Pode ser reduzido a qualquer paradigma familiar, como fluxo de rede, coloração de gráficos ou programação linear?

algorithms combinatorics probability-theory permutations sampling hftf
fonte

Em relação à sua definição de "espaçado", você não deseja que para com como sentinelas? Ou seja, um único elemento deve estar no meio, dois devem particionar a permutação em terços e assim por diante.

d (i, j) - n / (n_{i} + 1)

$d(i,j) - n/(n_i + 1)$

0 \leq i \leq j \leq n + 1

$0 \leq i \leq j \leq n+1$

P_{0} = P_{n + 1} = i

$P_0 = P_{n+1} = i$

Raphael

O que acontece se para o mal (pequeno, mas grande o suficiente); nós temos permutações difusas? Certamente não suportamos uma mudança para encontrar duas demente! Parece que nenhum elemento pode ocorrer mais de vezes.

S = {1^{n - k}, 2^{k}}

$S = \{ 1^{n-k}, 2^k\}$

k

$k$

n / 2

$n/2$

Raphael

Qual é a razão de todos os pares de permutações perturbadas entre todos os pares de permutações difusas ? Da mesma forma, de todos os pares de permutações perturbadas, quantos consistem em duas difusas? (Se uma das razões for "alta", podemos concentrar nosso esforço em uma metade do processo, deixando a outra em rejeição.)

Raphael

@Raphael (# 3a) De 1 milhão de permutações aleatórias de , essas 561 difusas tinham . dos pares estão desarranjados.

D

$\mathsf D$

s (P) \leq 30

$s(P)\le 30$

6118 / (\binom{561}{2}) = 6118 / 157080 \approx 3.9 %

$6118/\binom{561}{2}=6118/157080\approx3.9\%$

hftf 5/05

@Raphael (# 3b) Dos 10 milhões de pares aleatórios de permutações de , 306893 pares eram perturbados. Apenas 29 desses pares tiveram ambas as permutações com . Aqui está um histograma ( valores ).

D

$\mathsf D$

s (P) \leq 50

$s(P)\le50$

hftf 5/05

Respostas:

Uma abordagem: você pode reduzir isso ao seguinte problema: Dada uma fórmula booleana , escolha uma atribuição uniformemente aleatoriamente dentre todas as atribuições satisfatórias de . Esse problema é difícil para o NP, mas existem algoritmos padrão para gerar um que é distribuído aproximadamente uniformemente, emprestando métodos dos algoritmos #SAT. Por exemplo, uma técnica é escolher uma função hash cujo intervalo tenha um tamanho cuidadosamente escolhido (aproximadamente o mesmo tamanho que o número de atribuições satisfatórias de ), escolher uniformemente aleatoriamente um valor dentro do intervalo de $\varphi(x)$ $x$ $\varphi(x)$ $x$ $h$ $\varphi$ $y$ $h$ e use um solucionador SAT para encontrar uma atribuição satisfatória para a fórmula . Para torná-lo eficiente, você pode escolher como um mapa linear esparso. $\varphi(x) \land (h(x)=y)$ $h$

Isso pode estar matando uma pulga com um canhão, mas se você não tiver outras abordagens que pareçam viáveis, essa é uma que você pode tentar.

DW
fonte

achando isso difícil de seguir. é um valor booleano e é uma string binária (conjunto de variáveis binárias)? então a equação final significa ...?

φ (x)

$\varphi(x)$

h (x)

$h(x)$

Vzn

algumas discussões / análises estendidas sobre esse problema começaram no bate - papo do cs com outros antecedentes, que descobriram alguma subjetividade nos requisitos complexos do problema, mas não encontraram nenhum erro ou supervisão geral. ¹

aqui está um código testado / analisado que, comparado com a outra solução baseada em SAT, é relativamente "rápido e sujo", mas não é trivial / complicado para depurar. é vagamente conceitualmente baseado em um esquema de otimização pseudo-aleatório / ganancioso local, algo semelhante a, por exemplo, 2-OPT for TSP . a idéia básica é começar com uma solução aleatória que se encaixa em alguma restrição e, em seguida, perturbá-la localmente para procurar melhorias, buscando avidamente por melhorias e iterando através delas e terminando quando todas as melhorias locais tiverem sido esgotadas. um critério de projeto era que o algoritmo fosse o mais eficiente / evitasse a rejeição o máximo possível.

existe alguma pesquisa sobre algoritmos de desarranjo [4], por exemplo, usados no SAGE [5], mas eles não são orientados em torno de vários conjuntos.

a perturbação simples é apenas "troca" de duas posições na (s) tupla (s). a implementação está em ruby. A seguir, são apresentadas algumas visões gerais / notas com referências aos números das linhas.

qb2.rb (gist-github)

a abordagem aqui é começar com duas tuplas desarranjadas (# 106) e depois melhorar localmente / avidamente a dispersão (# 107), combinada em um conceito chamado derangesperse(# 97), preservando a desarranjo. note que a troca de duas mesmas posições no par de tuplas preserva a perturbação e pode melhorar a dispersão e isso é (parte do) método / estratégia dispersa.

a derangesub - rotina funciona da esquerda para a direita na matriz (multiset) e troca com elementos posteriormente na matriz em que a troca não está com o mesmo elemento (nº 10). o algoritmo será bem-sucedido se, sem mais trocas na última posição, as duas tuplas ainda estiverem desarranjadas (# 16).

existem 3 abordagens diferentes para desarranjar as tuplas iniciais. a 2ª tupla p2é sempre embaralhada. pode-se começar com a tupla 1 ( p1) ordenada por a."primeira ordem de mais alta potência" (nº 128), b.ordem aleatória (nº 127) c.e "primeira ordem de mais baixa potência" ("última ordem de mais alta potência") (nº 126).

a rotina de dispersão disperseé mais envolvida, mas conceitualmente não é tão difícil. mais uma vez, usa swaps. em vez de tentar otimizar a dispersão em geral sobre todos os elementos, ele simplesmente tenta aliviar iterativamente o pior caso atual. a idéia é encontrar os 1 ^st elementos menos dispersos, esquerda para a direita. a perturbação é trocar os elementos esquerdo ou direito ( x, yíndices) do par menos disperso com outros elementos, mas nunca nenhum entre o par (o que sempre diminuiria a dispersão) e também pular a tentativa de trocar com os mesmos elementos ( selectno # 71) . mé o índice do ponto médio do par (# 65).

no entanto, a dispersão é medida / otimizada em ambas as tuplas do par (# 40) usando a dispersão "menos / mais à esquerda" em cada par (# 25, # 44).

o algoritmo tentativas para trocar elementos "mais distante" 1 ^st ( sort_by / reverse# 71).

existem duas estratégias diferentes true, falsepara decidir se é necessário trocar o elemento esquerdo ou direito do par menos disperso (nº 80), o elemento esquerdo para a posição de troca no elemento esquerdo / direito no lado direito ou o elemento mais à esquerda ou à direita no par disperso do elemento de troca.

o algoritmo termina (nº 91) quando não pode mais melhorar a dispersão (movendo a pior localização dispersa para a direita ou aumentando a dispersão máxima sobre todo o par de tuplas (nº 85)).

são produzidas estatísticas para rejeições acima de c1000 desarranjos nas 3 abordagens (# 116) e c= 1000 desarranjos (# 97), observando os 2 algoritmos dispersos para um par desarranjado da rejeição (# 19, # 106). o último rastreia a dispersão média total (após desarranjo garantido). um exemplo de execução é o seguinte

c       0.661000
b       0.824000
a       0.927000
[2.484, 2, 4]
[2.668, 2, 4]

isso mostra que o a-truealgoritmo fornece melhores resultados com ~ 92% de não-rejeição e uma distância média dispersa pior de ~ 2,6 e um mínimo garantido de 2 a 1000 tentativas, ou seja, pelo menos 1 elemento intermediário não igual entre todos os pares do mesmo elemento. encontrou soluções com até três elementos não iguais.

o algoritmo de desarranjo é a pré-rejeição linear do tempo, e o algoritmo de dispersão (executando em entrada desarranjada) parece ser possivelmente ~ . $O(n \log n)$

¹ o problema é encontrar arranjos de pacotes que satisfazem o chamado "feng shui" [1] ou uma ordem aleatória "agradável" em que "agradável" é um tanto subjetivo e ainda não quantificado "oficialmente"; o autor do problema o analisou / reduziu aos critérios de desarranjo / dispersão com base em pesquisas realizadas pela comunidade do questionário e "especialistas em feng shui". [2] existem idéias diferentes sobre "regras do feng shui". alguma pesquisa "publicada" foi realizada sobre algoritmos, mas aparece nos estágios iniciais. [3]

[1] Pacote feng shui / QBWiki

[2] Pacotes de Quizbowl e feng shui / Lifshitz

[3] Colocação de perguntas , fórum do centro de recursos HSQuizbowl

[4] Gerando desarranjos aleatórios / Martinez, Panholzer, Prodinger

[5] Algoritmo de desarranjo sábio (python) / McAndrew

vzn
fonte

Por outro lado, há uma falha na rotina do desarranjo e nem sempre desarranja. a posição de swap pode avançar sem trocar nada. Há uma correção simples para testar o sucesso corretamente.

vzn