Como aproximar portas através de portas universais é escalonado com o comprimento da computação?

Entendo que existe uma prova construtiva de que portas arbitrárias podem ser aproximadas por um conjunto finito de portas universais, que é o Teorema de Solovay-Kitaev .
No entanto, a aproximação introduz um erro, que se espalharia e se acumularia em um cálculo longo. Presumivelmente, isso seria muito ruim com a duração do cálculo? Possivelmente, pode-se aplicar o algoritmo de aproximação ao circuito completo como um todo, não a um único portão. Mas como essa escala se ajusta ao comprimento da computação (isto é, como a aproximação se escala com a dimensão dos portões)? Como a aproximação do portão se relaciona com a síntese do portão? Porque eu poderia imaginar que isso afeta o comprimento final da computação?
Ainda mais perturbador para mim: o que acontece se a duração do cálculo não for conhecida no momento em que a sequência do gate é compilada?

— M. Stern
fonte

Ao longo desta resposta, a norma de uma matriz , será levado para ser a norma espectral de (isto é, o maior valor singular de ). O teorema de solovay-Kitaev afirma que a aproximação de uma porta a um erro requer portas , para em qualquer número fixo de dimensões. $A$ $\left\lVert A\right\rVert$ $A$ $A$ $\epsilon$

O ({registro}^{c} \frac{1}{ϵ})

$\mathcal O\left(\log^c\frac 1\epsilon\right)$

c < 4

$c<4$

Para a primeira parte:

a aproximação introduz um erro, que se espalharia e se acumularia em um longo cálculo

Bem, pode ser demonstrado por indução que os erros acumulados através do uso de uma matriz para se aproximar de outra são subaditivos (veja, por exemplo, as notas da aula de Andrew Child ). Ou seja, para matrizes unitárias e , . $U_i$ $V_i$ $\left\lVert U_i - V_i\right\rVert < \epsilon\,\forall\, i \in \left\lbrace1, 2, \ldots, t\right \rbrace\implies \left\lVert U_t\ldots U_2U_1 - V_t\ldots V_2V_1\right\rVert \leq t\epsilon$

O que isso significa em termos de implementação é que, para que um erro geral não seja mais do que , cada porta precisa ser aproximada dentro de , ou $\epsilon$ $\epsilon/t$

aplicando a aproximação ao circuito como um todo

é o mesmo que aplicar a aproximação a cada porta individual, cada uma com um erro individual não superior ao de todo o circuito dividido pelo número de portas que você está aproximando.

Em termos de síntese de , o algoritmo é realizado utilizando produtos do conjunto de para formar um novo conjunto de que forma uma rede para (por qualquer ). A partir da identidade, um novo unitário é encontrado recursivamente no novo portão configurado para obter uma rede mais apertada em torno do unitário de destino. Curiosamente, o tempo para um algoritmo clássico executar essa operação também é , que é o tempo sub-polinomial. No entanto , conforme $\Gamma$ $\Gamma_0$ $\epsilon^2$ $\operatorname{SU}\left(d\right)$ $A \in \operatorname{SU}\left(d\right),\, \exists U\in\Gamma_0\, s.t. \left\lVert A-U\right\rVert\leq\epsilon^2$ $\mathcal O\left(\mathit{poly} \log 1/\epsilon\right)$ Harrow, Recht, Chuang , em dimensões , como uma bola de raio torno de tem um volume , isso é exponencialmente em para um número não fixo de dimensões. $d$ $\epsilon$ $\operatorname{SU}\left(d\right)$ $\propto \epsilon^{d^2-1}$ $d^2$

Isso afeta o tempo final de computação. No entanto, como o dimensionamento no número de portas e na complexidade computacional clássica é sub-polinomial, isso não altera a classe de complexidade de nenhum algoritmo, pelo menos para as classes geralmente consideradas.

Para gates, a complexidade geral (tempo e porta) é então $t$ .

O (t p o eu y registro \frac{t}{ϵ})

$\mathcal O\left(t\, \mathit{poly} \log \frac t\epsilon\right)$

Ao usar o modelo de circuito unitário sem medições intermediárias , o número de portas a serem implementadas será sempre conhecido antes do cálculo. No entanto, é possível assumir que esse não é o caso quando medições intermediárias são usadas; portanto, quando o número de portas que você deseja aproximar é desconhecido, isso significa que é desconhecido. e se você não sabe o que é, você obviamente não pode aproximar cada porta a um erro . Se você conhece um limite para o número de portas (digamos, ), então você pode aproximar cada porta para dentro de para obter um erro geral $t$ $t$ $\epsilon/t$ $t_{\text{max}}$ $\epsilon/t_{\text{max}}$ $\leq\epsilon$ e complexidade embora se não houver limite superior no número de portas é conhecido , então cada porta seria aproximada a algum (menor) , resultando em um erro geral para o número resultante de portas implementadas (que é desconhecido no início) , com um complexidade geral de

O (t p o eu y registro \frac{t_{max}}{ϵ}),

$\mathcal O\left(t\, \mathit{poly} \log \frac {t_{\text{max}}}{\epsilon}\right),$

ϵ^{'}

$\epsilon'$

\leq t^{'} ϵ

$\leq t'\epsilon$

t^{'}

$t'$

O (t^{'} p o eu y registro \frac{1}{ϵ^{'}}) .

$\mathcal O\left(t'\, \mathit{poly} \log \frac {1}{\epsilon'}\right).$

Claro, o erro total deste ainda é ilimitado, assim que um simples ¹ maneira de manter o erro delimitada seria reduzir o erro de cada vez por um fator de, digamos, , para que o portão seria implementado com erro . A complexidade seria então fornecendo uma complexidade geral (agora polinomial) embora isso tenha a vantagem de garantir um erro limitado. $2$ $n^{th}$ $\epsilon/2^n$

O (p o eu y registro \frac{2^{n}}{ϵ^{'}}) = O (p o eu y n registro \frac{1}{ϵ^{'}}),

$\mathcal O\left(\mathit{poly} \log \frac {2^n}{\epsilon'}\right) = \mathcal O\left(\mathit{poly}\, n\log \frac {1}{\epsilon'}\right),$

O (p o eu y t registro \frac{1}{ϵ}),

$\mathcal O\left(\mathit{poly}\, t \log \frac {1}{\epsilon}\right),$

Isso não é tão ruim, então eu espero que (quando o número de portas for desconhecido) os computadores clássicos sejam capazes de continuar criando as portas corretas pelo menos tão rápido quanto um processador quântico precisaria delas. Se não estiver atualmente, espero que uma vez que os processadores quânticos se tornem bons o suficiente para que isso realmente se torne um problema!

^{1 Embora, provavelmente não seja o mais eficiente}

— Mithrandir24601
fonte