Onde colocamos o código de correção de erros no circuito quântico?

Primeiro de tudo: sou iniciante em computação quântica.

Eu gostaria de ter um recurso (ou uma resposta, se não for complicado) explicando onde colocamos os códigos de correção de erros em um circuito quântico.

Na verdade, eu sei que temos diferentes erros possíveis que podem ocorrer (troca de bits, troca de fase etc.) e temos algoritmos para corrigi-los. Mas o que eu gostaria de saber é se existem algumas estratégias para colocarmos o algoritmo de correção de erros. É após cada porta envolvida no algoritmo principal? Existe uma estratégia mais inteligente usada para fazer uma única correção para um conjunto de portas?

Se a resposta for "complicada", eu gostaria de ter um recurso para aprender tudo isso (acho muitas coisas para o código de correção de erros, mas não encontrei nada sobre onde devemos fazer a correção).

Com base na sua pergunta, acho que você não estava procurando o termo correto. Os códigos de correção de erros são métodos para detectar e corrigir possíveis erros que surgem em qubits devido ao efeito de decoerência.

O termo computação quântica tolerante a falhas refere-se ao paradigma de dispositivos quânticos que funcionam efetivamente mesmo quando seus componentes elementares são imperfeitos, e os códigos de correção de erros que você está procurando são a base para construir esse tipo de computação. Convido você a procurar informações relacionadas à tolerância a falhas por si mesmo, pois é uma área bastante grande na computação quântica. No entanto, recomendo vivamente o texto de cálculo quântico tolerante a falhas da Preskill. Nesse artigo, o autor realmente começa a falar sobre códigos de correção de erros, mas depois se aprofunda no conceito de tolerância a falhas, e acho que ele resolverá muitas de suas dúvidas sobre o tópico.

Na computação quântica tolerante a falhas, fazemos uma distinção entre qubits físicos e qubits lógicos .

$n$$n$

Os qubits físicos são os que realmente existem e são barulhentos. É isso que usamos para fazer qubits lógicos, mas normalmente são necessários muitos qubits físicos para fazer um qubit lógico. Isso ocorre devido à grande redundância necessária para detectar e corrigir erros.

O design do código real executado em qubits físicos ocorrerá em camadas. Um engenheiro de software de correção quântica de erros projetará os qubits lógicos escrevendo o programa necessário para implementar o código de correção quântica de erros. Para cada operação que alguém possa precisar em um algoritmo, eles projetarão uma versão compatível com correção de erros, que executa a operação nos qubits lógicos de uma maneira que permita que suas imperfeições sejam detectadas e corrigidas.

Em seguida, o programador aparecerá e escreverá seu programa. Eles não precisarão pensar em qubits físicos ou correção de erros.

Por fim, o compilador combinará tudo para criar a versão tolerante a falhas do programa para executar nos qubits físicos. Isso não se parecerá com o que foi escrito pelo programador. Não parecerá uma constante alternância de coisas que o programador escreveu, seguido de correções de erros para limpá-lo. Ele irá lidar quase completamente com apenas detectar e corrigir os erros que ocorrem constantemente, com pequenas perturbações para implementar o algoritmo.

Como referência, acho que é melhor recomendar algo que explique como as operações em qubits lógicos são implementadas em qubits físicos por meio de um código de correção de erros. Um dos meus artigos faz esse trabalho, explicando isso de várias maneiras para obter operações lógicas no código de superfície. Ele também tem referências a muitos trabalhos de outros na mesma área.