Como visualizar diagramas de circuitos quânticos com Q#

Os diagramas de circuitos quânticos são uma representação visual das operações quânticas. Os diagramas de circuitos mostram o fluxo de qubits através do programa quântico, incluindo as portas e medições que o programa aplica aos qubits.

Neste artigo, aprende a representar visualmente algoritmos quânticos com diagramas de circuitos quânticos no Azure Quantum Development Kit (QDK) usando Visual Studio Code (VS Code) e Jupyter Notebook.

Para mais informações sobre diagramas de circuitos quânticos, consulte Convenções de circuitos quânticos.

Pré-requisitos

• A versão mais recente de VS Code, ou abrir VS Code para a Web.

• A versão mais recente da QDK extensão, da extensão Python, e da Jupyter extensão instalada em VS Code.

• A versão mais recente da qdk biblioteca Python com o extra opcional jupyter .

  python -m pip install --upgrade "qdk[jupyter]"
  

Visualize circuitos quânticos em VS Code

Para visualizar circuitos quânticos de programas Q# em VS Code, conclua as etapas a seguir.

Ver diagramas de circuitos para um programa Q#

1. Abra um arquivo Q# no VS Code, ou carregue uma das amostras quânticas.

2. Escolha o comando Circuit do Code Lens que precede a operação do seu ponto de entrada.

   

A janela de circuito Q# aparece e mostra o diagrama do seu programa. Por exemplo, o circuito a seguir corresponde a uma operação que coloca um qubit em um estado de superposição e, em seguida, mede o qubit. O diagrama de circuito mostra um registro de qubit que é inicializado para o estado $\ket{0}$. Em seguida, um portão de Hadamard é aplicado ao qubit, seguido por uma operação de medição, que é representada por um símbolo de metro. Neste caso, o resultado da medição é zero.

Consulte diagramas de circuitos para operações individuais

Para visualizar o circuito quântico para uma operação individual num ficheiro Q#, escolha o comando Circuit da lente de código que precede a operação.

Ver diagramas de circuitos quando estiver a depurar

Quando usa o VS Code depurador num programa Q#, pode visualizar o circuito quântico com base no estado do programa no ponto de interrupção atual do depurador.

1. Escolhe o comando Debug da lente de código que precede a tua operação de entrada.
2. No painel Executar e Depurar, expanda o menu suspenso Circuito Quântico nas VARIÁVEIS. O QDK painel de circuitos abre-se, mostrando o circuito enquanto percorres o programa.
3. Defina pontos de interrupção e percorra o código para ver como o circuito é atualizado à medida que o programa é executado.

Circuitos quânticos em Jupyter Notebook

Em Jupyter Notebook, pode visualizar circuitos quânticos com os módulos qdk.qsharp e qdk.widgets de Python. O widgets módulo fornece um widget que renderiza um diagrama de circuito quântico como uma imagem SVG.

Exibir diagramas de circuito para uma expressão de entrada

1. No VS Code, abra o menu Exibir e escolha Paleta de comandos.

2. Insira e selecione Criar: Novo Jupyter Notebook.

3. Na primeira célula do bloco de anotações, execute o código a seguir para importar o qsharp pacote.

   from qdk import qsharp
   

4. Crie uma nova célula e insira seu código Q#. Por exemplo, o código a seguir prepara um Estado de Bell:

   %%qsharp
   
   // Prepare a Bell State.
   operation BellState() : Unit {
       use register = Qubit[2];
       H(register[0]);
       CNOT(register[0], register[1]);
   }
   

5. Para exibir um circuito quântico simples com base no estado atual do seu programa, passe uma expressão de ponto de entrada para a qsharp.circuit função. Por exemplo, o diagrama de circuito do código anterior mostra dois registradores de qubit que são inicializados para o estado $\ket{0}$. Em seguida, um portão Hadamard é aplicado ao primeiro qubit. Finalmente, uma porta CNOT é aplicada onde o primeiro qubit é o controle, representado por um ponto, e o segundo qubit é o alvo, representado por um X.

   qsharp.circuit("BellState()")
   

   q_0    ── H ──── ● ──
   q_1    ───────── X ──
   

6. Para visualizar um circuito quântico como uma imagem SVG, use o widgets módulo. Crie uma nova célula e, em seguida, execute o código a seguir para visualizar o circuito que você criou na célula anterior.

   from qdk.widgets import Circuit
   
   Circuit(qsharp.circuit("BellState()"))
   

   

Ver diagramas de circuitos para operações com qubits

Você pode gerar diagramas de circuito de operações que tomam qubits, ou matrizes de qubits, como entrada. O diagrama mostra um fio para cada qubit de entrada, juntamente com fios para qubits adicionais que você aloca dentro da operação. Quando a operação leva uma matriz de qubits (Qubit[]), o circuito mostra a matriz como um registro de 2 qubits.

1. Adicione uma nova célula e, em seguida, copie e execute o seguinte código Q#. Este código prepara um estado gato.

   %%qsharp
   
   operation PrepareCatState(register : Qubit[]) : Unit {
       H(register[0]);
       ApplyToEach(CNOT(register[0], _), register[1...]);
   }
   

2. Adicione uma nova célula e execute o seguinte código para visualizar o PrepareCatState circuito da operação.

   Circuit(qsharp.circuit(operation="PrepareCatState"))
   

Diagramas de circuitos para circuitos dinâmicos

Os diagramas de circuitos são gerados executando a lógica clássica dentro de um programa Q# e mantendo o controle de todos os portões alocados e aplicados. Loops e condicionais são suportados quando lidam apenas com valores clássicos.

No entanto, programas que contêm loops e expressões condicionais que usam resultados de medição de qubit são mais difíceis de representar com um diagrama de circuito. Por exemplo, considere a seguinte expressão:

if (M(q) == One) {
   X(q)
}

Esta expressão não pode ser representada com um diagrama de circuito simples porque as portas são condicionais a um resultado de medição. Os circuitos com portões que dependem dos resultados da medição são chamados circuitos dinâmicos.

Você pode gerar diagramas para circuitos dinâmicos executando o programa no simulador quântico e rastreando os portões à medida que são aplicados. Isto chama-se modo de traço porque os qubits e portas são traçados à medida que a simulação é realizada.

A desvantagem dos circuitos rastreados é que eles capturam apenas o resultado da medição e as respetivas aplicações de portas lógicas para uma única simulação. No exemplo acima, se o resultado da medição for Zero, então o X portão não está no diagrama. Se você executar a simulação novamente, então você pode obter um circuito diferente.