Como acompanhar os emaranhados ao emular a computação quântica?

Estou tentando construir uma biblioteca de computação quântica como meu projeto universitário. Ainda estou aprendendo todos os aspectos do campo da computação quântica. Eu sei que já existem bibliotecas eficientes para emulação quântica. Eu só quero fazer o meu próprio, o que me ajudará a entender alguns dos principais conceitos da Computação Quântica.

Eu sei que qubits podem ser armazenados com uma matriz complexa de elementos. Além disso, um gate qubit é um array 2D 2D. Então, a seguir estão minhas dúvidas (principalmente relacionadas ao emaranhamento):2 n n 2 n × 2 $n$$2^n$$n$$2^n \times 2^n$

1. Quando preciso encontrar o produto tensorial dos portões (como , para um sistema de qubit)? É sempre necessário calcular o produto tensorial da ordem , mesmo que os qubits não estejam emaranhados?3 2 n × 2 $I \otimes H \otimes I$$3$$2^n \times 2^n$

2. Com apenas uma matriz de elementos (que eu armazeno os coeficientes), posso realmente calcular de alguma forma quais qubits estão entrelaçados? Ou preciso criar outra estrutura de dados para armazenar as informações de emaranhamento dos meus qubits (sobre quais qubits estão emaranhados)?$2^n$$n$

3. Minha segunda pergunta é realmente relevante? Preciso acompanhar as informações de emaranhamento? Quero dizer, não sei se multiplicar portas com coeficientes é suficiente (mesmo que o sistema esteja emaranhado). Talvez seja relevante apenas no momento da medição.

Certamente é suficiente sempre calcular a matriz unitária completa e aplicá-la ao vetor de estado de entrada . Se é isso que você escolhe fazer, é tudo o que você precisa fazer, pois todas as informações de emaranhamento estão contidas nesse vetor. Uma maneira rápida e fácil de verificar se um determinado qubit está emaranhado é seguir o rastreio parcial do seu vetor de estado (puro) sobre todos os outros qubits. Se a matriz resultante é de classificação 1, esse qubit está em um estado separável, caso contrário, está emaranhado.2 $2^n\times 2^n$$2^n$

Suponho que o ponto de sua pergunta seja realmente "Como esse enorme custo computacional pode ser evitado?". Em geral, não pode - se você estiver usando toda a potência do computador quântico, sempre precisará do vetor de estado de entrada . No entanto, existem vários truques que reduzem o custo computacional, como atrasar a necessidade de um vetor de estado tão grande, mantendo o controle do emaranhado.$2^n$

Melhorias na eficiência

A maior economia que você pode fazer em comparação com a implementação ingênua acima é evitar as matrizes unitárias . Por exemplo, se você estiver usando apenas portas de 1 ou 2 qubit, simplesmente usar a escassez de matrizes significa que você só precisa de armazenamento de vez de . O ( 2 n ) O ( 2 2 n$2^n\times 2^n$$O(2^n)$$O(2^{2n})$

Depois, existem outras táticas que você pode empregar. Por exemplo, imagine que você deseja aplicar o de dois qubits unitária portão em qubits e . Você pode pegar conjuntos de 4 elementos do seu vetor de estado ( para fixo utilizando todos os ) diferentes e apenas aplicando o unitário nesse vetor de 4 elementos. Repetir isso para cada retornará no vetor de estado original.$U$$i$$j$$|x\rangle_{1,2,\ldots n\setminus i,j}|y\rangle_{i,j}$$x\in\{0,1\}^{n-2}$$y\in\{0,1\}^2$$4\times 4$$U$$x$$U$

Eu imagino que existem outras estratégias que alguém poderia inventar. O que se sugeriu a partir da pergunta original foi o rastreamento de emaranhamento. Isso fornece melhorias de memória e velocidade no início de uma computação, mas acaba sendo equivalente, porque (presumivelmente) tudo no computador quântico acaba entrelaçado.

Rastreamento de emaranhamento

Vamos supor que seu cálculo consiste apenas em evolução e medição unitárias no conjunto de qubits, ou seja, não há decoerência, mapas probabilísticos etc. Vamos supor ainda que você comece de um estado totalmente separável, como . Nesse ponto, todo qubit é separável e é suficiente manter registros diferentes, cada um transmitindo o estado de um qubit separável. Se o seu primeiro gate for apenas uma operação de qubit único no qubit , basta atualizar o estado armazenado no qubit como e você não precisará tocar em nada outro.$n$$|0\rangle^{\otimes n}$$n$$U$$i$$i$$|\psi_i\rangle\mapsto U|\psi_i\rangle$

Se você quer fazer um de dois qubits portão entre qubits e , digamos, então você tem que combinar os estados em ambos os locais. Portanto, você substitui dois registros, cada um da dimensão 2, por um registro da dimensão 4, contendo o estado . O problema é que agora você não pode dividir esse estado novamente, portanto, é necessário manter esses dois qubits em um registro para sempre. Obviamente, se você tiver um gate 1 qubit para aplicar no qubit , agora precisará aplicar . Então, da próxima vez que você quer um portão 2-qubit entre, digamos, ei J V | ψ i ⟩ | ψ j ⟩ U i | ψ i , j ⟩ ↦ U ⊗ I | ψ i , j ⟩ j k ( i , j ) k $V$$i$$j$$V|\psi_i\rangle|\psi_j\rangle$$U$$i$$|\psi_{i,j}\rangle\mapsto U\otimes\mathbb{I}|\psi_{i,j}\rangle$$j$$k$, você terá que combinar os espaços para e . Esses espaços continuarão crescendo, mas se um portão estiver localizado em apenas um espaço, você só precisará aplicá-lo lá (usando os operadores para preenchê-lo no restante dos qubits), e você não precisará faça qualquer coisa para os outros espaços.$(i,j)$$k$$\mathbb{I}$

Se você estiver fazendo algo assim, não terá (pelo menos nos primeiros passos do seu algoritmo) um único registro de elemento . Você precisará ter vários registros diferentes e acompanhar quais qubits são descritos por quais registradores em uma matriz separada. Cada vez que você combina os espaços de alguns qubits, atualiza essa matriz extra.$2^n$

Aqui estão alguns pseudocódigos muito grosseiros que podem ajudar a transmitir meu significado:

#initialise variables
entangled_blocks={{1},{2},{3},...,{n}}
quantum_states={{1,0},{1,0},...,{1,0}}

#apply action of each gate
for each gate
   for each gate_target
       target_block=entangled_blocks entry containing gate_target
   next gate_target
   if all target_blocks equal then
      apply gate on target_block (pad with identity on other qubits)
   else
      new_entangled_block=union(target_blocks)
      new_state_vec=tensor_product(quantum_states for each target block)
      apply gate on new_state_vec (pad with identity on other qubits)
      replace all target_blocks in entangled_blocks with new_entangled_block
      replace all quantum_states(all target blocks) with new_state_vec
   end if
next gate

Outras opções

(De modo algum exaustivo)

Você pode estar interessado em ler sobre os Estados dos produtos da matriz, que são uma boa maneira de encapsular as informações sobre estados não muito entrelaçados e que podem fornecer uma rota alternativa para você, dependendo exatamente do que você está tentando alcançar.