Construção geral de

Dois dos estados emaranhados mais conhecidos são o estado GHZ $|\psi\rangle = 1/\sqrt{2}\left( |0\rangle^{\otimes n} + |1\rangle^{\otimes n}\right)$ e o$W_n$-state, com$W_3 = 1/\sqrt{3}\left(|100\rangle + |010\rangle + |001\rangle\right)$ .

Construir o estado GHZ é simples para $n$ arbitrário . No entanto, a execução do $W_n$ -state é mais difícil. Para $n=2$ é fácil, e para $n=4$ podemos usar

H q[0,3]
X q[0,3]
Toffoli q[0],q[3],q[1]
X q[0,3]
Toffoli q[0],q[3],q[2]
CNOT q[2],q[0]
CNOT q[2],q[3]

Mesmo para $n=3$ , temos implementações, veja esta resposta, por exemplo. No entanto, eu não encontrei um algoritmo que, dado um $n$ , produz o circuito para a construção do $W_n$ .

Existe um algoritmo desse tipo, definido por portas de um e dois qubit? E se sim, o que é isso?

Sim, existem várias implementações desse algoritmo no kata quântico de superposição (tarefas 14 e 15):

• Para $n = 2^k$ , você pode usar um algoritmo recursivo: crie um estado W nos primeiros $2^{k-1}$ qubits, aloque um qubit ancilla em $|+\rangle$ , Execute alguns SWAPs controlados para definir o estado dos segundos $2^{k-1}$ qubits e, em seguida, alguns NOTs controlados para redefinir a ancilla novamente para $|0\rangle$ ( WState_PowerOfTwo_Referenceoperação).
• Para um $n$ arbitrário , você pode usar um algoritmo recursivo, conforme descrito por DaftWullie ( WState_Arbitrary_Referenceoperação).
• Há também um truque que você pode usar para criar um $W_n$ estado para uma arbitrária $n$ usando o primeiro algoritmo recursivo. Aloque qubits extras para preencher os $n$ dados em $2^k$ , crie um estado $W_{2^k}$ neles e meça os qubits extras; se todos os qubits forem iguais a 0, o estado dos qubits originais é $W_n$ ; caso contrário, redefina e repita o processo ( WState_Arbitrary_Postselectoperação).

Esta é minha tarefa favorita desse kata, porque permite muitas abordagens diferentes.

A maneira conceitualmente mais simples de produzir um estado W é algo análogo à amostragem clássica de reservatório , na medida em que envolve uma série de operações locais que acabam criando um efeito uniforme.

Basicamente, você olha para cada qubit por sua vez e considera "quanta amplitude me resta no estado all-0s e quanto quero transferir para o estado just-qubit-is-ON?". Acontece que a família de rotações que você precisa é o que chamarei de "portões de probabilidades", que têm a seguinte matriz:

$$M(p:q) = \sqrt{\frac{1}{p+q}} \begin{bmatrix} \sqrt{p} & \sqrt{q} \\ -\sqrt{q} & \sqrt{p} \end{bmatrix}$$

Usando esses portões, você pode obter um estado W com uma sequência de operações cada vez mais controladas:

Este circuito é um pouco ineficiente. Custou $O(N^2 + N \lg(1/\epsilon))$ onde $N$ é o número de qubits e $\epsilon$ é a precisão absoluta desejada (uma vez que, em um contexto corrigido por erros, as portas de chances não são nativas e devem ser aproximadas) .

Podemos melhorar a eficiência mudando de uma estratégia de "transferência do que foi deixado para trás" para uma estratégia de "transferência do que está viajando". Isso adiciona uma varredura de correção no final, mas requer apenas controles únicos em cada operação. Isso reduz o custo para $O(N \lg(1/\epsilon))$ :

$N$$\sqrt{1/N}$ ). Aqui estão os números relevantes.

A etapa de remoção parcial:

Como executar uma operação indexada (bem ... mais ou menos. A figura mais próxima tinha um acumulador que não é o ideal para este caso):

$O(N \lg(1/\epsilon))$$O(N + \lg(1/\epsilon))$

Você pode definir a sequência recursivamente. Conceitualmente, o que você quer fazer é:

• $|0\rangle^{\otimes N}$

• $$\frac{1}{\sqrt{N}}\left(\begin{array}{cc} 1 & \sqrt{N-1} \\ \sqrt{N-1} & -1 \end{array}\right)$$

• $|W_{N-1}\rangle$$N$$|1\rangle$

• Aplique um portão de inversão de bits no qubit 1.

Esse algoritmo, como expresso, não é composto apenas de portas de um e dois qubit, mas certamente pode ser decomposto como tal por construções de universalidade padrão.

$N=2^n$$n$$|1\rangle$$|W_2\rangle$$|W_4\rangle$$|W_8\rangle$ $O(\log N)$