Compreendendo o algoritmo de otimização de líderes de grupo

Contexto:

Eu tenho tentado entender o algoritmo genético discutido no artigo Decomposição de matrizes unitárias para encontrar circuitos quânticos: Aplicação a Hamiltonianos moleculares (Daskin & Kais, 2011) (PDF aqui ) e Algoritmo de Otimização de Líderes de Grupo (Daskin & Kais, 2010) . Vou tentar resumir o que entendi até agora e depois declarar minhas consultas.

Vamos considerar o exemplo do portão de Toffoli na seção III-A no primeiro artigo. Sabemos de outras fontes como esta , que são necessários cerca de 5 portas quânticas de dois qubit para simular o portão de Toffoli. Portanto, escolhemos arbitrariamente um conjunto de portas como $\{V, Z, S, V^{\dagger}\}$ . Nós nos restringimos a um máximo de $5$ portas e nos permitimos usar apenas as portas do conjunto de portas $\{V, Z, S, V^{\dagger}\}$ . Agora, geramos $25$ grupos de $15$ seqüências aleatórias, como:

1 3 2 0,0; 2 3 1 0,0; 3 2 1 0,0; 4 3 2 0,0; 2 1 3 0,0

Na sequência de números acima, os primeiros números em negrito são o número de índice dos portões (ou seja, $V = 1, Z = 2, S = 3, Z^{\dagger} = 4$ ), os últimos números são os valores dos ângulos em $[0,2\pi]$ e os números inteiros do meio são o qubit alvo e os qubits controle respectivamente. Haveria $374$ outras seqüências geradas aleatoriamente.

Nossos grupos de ficar assim (na imagem acima) com $n=25$ e $p=15$ . A adequação de cada corda é proporcional à fidelidade do traço $\mathcal{F} = \frac{1}{N}|\operatorname{Tr}(U_aU_t^{\dagger})|$ onde $U_a$ é a representação da matriz unitária correspondente a qualquer cadeia que geramos e $U_t$ é a representação da matriz unitária da porta Toffoli de 3 qubit. O líder do grupo em qualquer grupo é a que tem o valor máximo de $\mathcal{F}$ .

Quando tivermos os grupos, seguiremos o algoritmo:

A Eq. (4) mencionado na imagem é basicamente:

new string [i] = r_{1} \times old string [i] + r_{2} \times leader string [i] + r_{3} \times random string [i]

$\text{new string} [i] = r_1 \times \text{old string}[i] + r_2 \times \text{leader string}[i] + r_3 \times \text{random string}[i]$

1 \leq i \leq 20

$1 \leq i \leq 20$

r_{1} + r_{2} + r_{3} = 1

$r_1+r_2+r_3 = 1$

[i]

$[i]$

i

$i$ 1 3 2 0.0; 2 3 1 0.0; 3 2 1 0.0; 4 3 2 0.0; 2 1 3 0.0

6

$6$ 3

r_{1} = 0.8

$r_1 = 0.8$

r_{2}, r_{3} = 0.2

$r_2,r_3 = 0.2$

375

$375$

Além disso,

$\frac{4 \times {max}_{gates}}{2} - 1$ $\frac{4\times \text{max}_{\text{gates}}}{2} - 1$

Questões:

$\{V,Z,S,V^{\dagger}\}$ $\{X,Z,R_x,R_{zz},V\}$ $5$ $20$
Após a parte (em "Contexto") discutir a seleção do conjunto de portas e o número de portas, minha explicação / entendimento (parágrafo 3 em diante) do algoritmo está correta?
$4\times \text{max}_{\text{gates}} - 2$ $\text{max}_{\text{gates}}$ $5$ $20$
$0.99$

quantum-gate circuit-construction optimization

— Sanchayan Dutta
fonte

Estou implementando o mesmo algoritmo em python. Você o implementou completamente? Estou preso em algum momento que expliquei no meu post .

— Papai

@ Santa Não, mas alguém aqui pode ter. Você pode migrar a pergunta Stack Overflow para a Quantum Computing . Sinalize-o para um moderador que mencione o problema.

— Sanchayan Dutta 19/02/19

@Santa Você pode encontrar uma implementação de uma versão modificada do algoritmo GLOA aqui . Esteja ciente de que: 1. esta é uma versão modificada do algoritmo original (tentei torná-lo mais flexível), 2. o código é bastante genérico e usa muito uma estrutura de dados compartilhada com outros algoritmos e 3. a licença não é GPL, verifique se planeja compartilhar uma versão (possivelmente modificada) do código.

— Nelimee

Sugiro analisar como um algoritmo genético funciona em um contexto de variáveis discretas para entendê-lo. Eles fornecem uma metodologia, mas você pode aplicar outras técnicas de mutação / cruzamento.

Resumidamente, em um simples problema de otimização em que as variáveis são discretas, podemos resolver heuristicamente com algoritmos genéticos (que pertencem aos algoritmos evolutivos de classe). Geramos uma população de candidatos (aleatoriamente) e alteramos os candidatos a cada iteração para tentar encontrar uma boa solução minimizando / maximizando uma função objetiva (denominada fitness). Você pode representar os candidatos por uma sequência de valores (chamados cromossomos em geral). Se você inserir essa sequência de valores para a função objetivo, estará avaliando o candidato ou atribuindo uma aptidão. As operações de cruzamento / mutação têm como objetivo alterar candidatos e esperar alcançar nosso objetivo de uma maneira relacionada ao que acontece na genética.

O GLOA é apenas mais um algoritmo genético, mas com a diferença de ter diferentes grupos populacionais com um ótimo local (líder como melhor candidato, se você preferir) para cada um e, é claro, uma estratégia ligeiramente diferente para mutação / cruzamento. Normalmente, temos um grupo de candidatos com um melhor candidato em cada iteração.

Agora, para suas perguntas:

1. Você pode escolher qualquer conjunto de portas que desejar (como o exemplo de um conjunto). Isso também se aplica ao número máximo de operações de gate que você deseja restringir sua decomposição. Esses são apenas parâmetros para o algoritmo. Eu diria que isso é completamente arbitrário (não muita lógica necessariamente apenas heurística), mas talvez o que eles escolheram tenha sido mais adaptado ao exemplo ou à configuração do trabalho. Na prática, você precisaria tentar muitos parâmetros.

2. Você está meio que retomando as explicações originais e especialmente o diagrama, então acho que está resumindo bem.

$t$ $1$ $4 \times \text{max}_{\text{gates}}$ $5$ $20$ $80$

Para sua visualização, observe a sequência de exemplo que você fornece:

1 3 2 0,0; 2 3 1 0,0; 3 2 1 0,0; 4 3 2 0,0; 2 1 3 0,0

$\text{max}_{\text{gates}}$ $5$ $5$ $2$ $4$ $5 \times 4 = 20$

1 3 2 0.0 $V$ $3$ $2$ $0.0$ $V$

4. Isso também é arbitrário, dependendo do que você deseja. Pode ser um número fixo de iterações ou até atingir um critério de limite / convergência.

— cnada
fonte

Obrigado pela resposta! Adicionei um instantâneo do pseudo-código na Figura 2, para torná-lo mais claro. No entanto, sinta-se à vontade para removê-lo, se desejar. :)

— Sanchayan Dutta

H

$H$

H^{†}

$H^\dagger$