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. Eles mostram o fluxo de qubits através do programa quântico, incluindo os portões e medidas aplicadas a eles.

Neste artigo, você aprenderá como representar visualmente algoritmos quânticos com diagramas de circuitos quânticos usando o Visual Studio Code ou Jupyter Notebooks.

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

Pré-requisitos

Código VS

• A versão mais recente do Visual Studio Code ou abra o VS Code na Web.

• A versão mais recente da extensão do Azure Quantum Development Kit.

• Os pacotes mais recentes do Azure Quantum qsharp e azure-quantum Python.

  python -m pip install --upgrade qsharp azure-quantum
  

Blocos de Notas do Jupyter

• A versão mais recente do Visual Studio Code ou abra o VS Code na Web.

• VS Code com as extensões Azure Quantum Development Kit, Python e Jupyter instaladas.

• O Azure Quantum qsharp e qsharp-widgets os pacotes mais recentes e o ipykernel pacote.

  python -m pip install --upgrade qsharp qsharp-widgets ipykernel
  

Circuitos quânticos com o Visual Studio Code

Siga estas etapas para visualizar circuitos quânticos de Q# programas no Visual Studio Code. Para obter mais informações sobre convenções de diagramas de circuitos quânticos, consulte Convenções de circuitos quânticos.

Visualização de diagramas de circuitos para um Q# programa

1. Abra um Q# arquivo no Visual Studio Code ou carregue um dos exemplos quânticos.

2. Para visualizar o circuito quântico Q# do programa, selecione View -> Command Palette e digite "circuit" que deve abrir a opção : Mostrar circuitoQ#. Você também pode clicar em Circuito na lista de comandos anteriores Main().

   

3. O circuito é exibido na janela do Q# circuito. Por exemplo, o circuito a seguir corresponde a uma operação que coloca um qubit em uma superposição e depois o mede. O diagrama de circuito mostra um registro de qubit que é inicializado para o estado |0⟩. Em seguida, um portão de Hadamard, H, é aplicado ao qubit, seguido por uma operação de medição, que é representada por um símbolo de metro.

   

Visualização de diagramas de circuitos para operações

Você pode visualizar o circuito quântico para uma única Q# operação. Para fazer isso, clique no botão Circuito na lente de código que aparece acima da declaração de operação.

Visualizando diagramas de circuito durante a depuração

Ao depurar um Q# programa, você pode visualizar o circuito quântico com base no estado atual do programa.

1. Selecione o botão Depurar na lista de comandos da lente de código anterior ao Main().

2. Na vista Executar e depurar no lado esquerdo, expanda a secção Circuito Quântico no painel Variáveis para mostrar o circuito à medida que percorre o programa.

   

3. Você pode percorrer o código e definir pontos de interrupção em vários pontos para ver a atualização do circuito à medida que o programa é executado.

4. O circuito quântico Q# atual é mostrado no painel Circuito. Este diagrama de circuito representa o estado atual do simulador, ou seja, os portões que foram aplicados até o ponto atual de execução.

   

Circuitos quânticos com Jupyter Notebooks

Em Jupyter Notebooks, você pode visualizar circuitos quânticos usando o qsharp-widgets pacote. Este pacote fornece um widget que renderiza um diagrama de circuito quântico como uma imagem SVG.

1. No Visual Studio Code, selecione View > Command palette e selecione Create: New Jupyter Notebook.

2. Na primeira célula do bloco de anotações, execute o seguinte código para importar o Q# módulo.

   import qsharp
   

3. Adicione uma nova célula e insira o Q# código. Por exemplo, o código a seguir prepara um estado de sino.

   %%qsharp
   
   // Prepare a Bell State.
   use register = Qubit[2];
   H(register[0]);
   CNOT(register[0], register[1]);
   

4. Você pode usar a dump_circuit() função para exibir um circuito quântico com base no estado atual do programa. Por exemplo, o diagrama de circuito mostra dois registros de qubit que são inicializados para o estado |0⟩. Em seguida, um portão de Hadamard, H, é aplicado ao primeiro qubit. Depois disso, uma porta CNOT é aplicada usando o primeiro qubit como controle, que é representado como um ponto, e o segundo qubit como target, que é representado como um X.

   qsharp.dump_circuit()
   

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

5. Você pode visualizar circuitos quânticos como uma imagem SVG usando o qsharp-widgets pacote. Neste caso, a porta CNOT é representada como uma linha que liga os dois qubits, com um ponto no qubit de controle e uma cruz circunscrita target no qubit. Para obter mais informações, consulte Convenções de circuitos quânticos.

   from qsharp_widgets import Circuit
   
   Circuit(qsharp.dump_circuit())
   

   

Visualizando diagramas de circuito para uma expressão de entrada

Você pode gerar um diagrama de circuito para qualquer programa com uma expressão de entrada chamando qsharp.circuit() e passando a expressão de entrada como um argumento.

1. Por exemplo, adicione uma nova célula e copie o código a seguir, que prepara um estado GHZ.

   %%qsharp
   
   import Std.Diagnostics.*;
   import Std.Measurement.*;
   
   operation GHZSample(n: Int) : Result[] {
       use qs = Qubit[n];
   
       H(qs[0]);
       ApplyToEach(CNOT(qs[0], _), qs[1...]);
   
       let results = MeasureEachZ(qs);
       ResetAll(qs);
       return results;
   }
   

2. Adicione uma nova célula e execute o seguinte código para visualizar o circuito. Por exemplo, prepare um estado GHZ com 3 qubits.

   Circuit(qsharp.circuit("GHZSample(3)"))
   

Visualização de diagramas de circuitos para operações com qubits

Você pode gerar diagramas de circuito para qualquer operação que use qubits ou matrizes de qubits. O diagrama mostra quantos fios houver qubit de entrada, além de quaisquer qubits adicionais alocados 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 copie o exemplo a seguir. 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"))
   

Condições que afetam os diagramas de circuitos

Ao visualizar circuitos quânticos, as seguintes condições podem afetar a visualização do diagrama de circuitos.

Circuitos dinâmicos

Os diagramas de circuito são gerados executando toda a lógica clássica dentro de um Q# programa e mantendo o controle de quaisquer qubits que foram alocados ou portas que foram aplicadas. Loops e condicionais são suportados desde que lidem 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, uma expressão como a seguinte

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

não pode ser representado com um diagrama de circuito simples, uma vez que as portas são condicionadas a um resultado de medição. Tal circuito é chamado de circuito dinâmico .

Diagramas de circuitos podem ser gerados para circuitos dinâmicos executando o programa no simulador quântico e traçando os portões à medida que são aplicados. Isso é chamado de modo de rastreamento , pois os qubits e portas estão sendo rastreados à medida que a simulação está sendo executada.

A desvantagem dos circuitos rastreados é que eles capturam apenas o resultado da medição, e as consequentes aplicações de portão, para uma única simulação. No exemplo acima, se o resultado da medição for Zero, você não verá a X porta no diagrama. Outra execução da simulação pode mostrar um circuito ligeiramente diferente.

Target perfil

O perfil atualmente selecionado target influencia como os diagramas de circuitos são gerados. Target Os perfis são usados para especificar os target recursos do hardware e as restrições impostas ao programa Quântico.

Quando o target perfil é definido como Irrestrito ou QIR Adaptive RI, os diagramas de circuito mostram as operações quânticas que são invocadas Q# no programa. Quando o target perfil é definido como base QIR, os diagramas de circuito mostram as operações quânticas que seriam executadas no hardware se o programa fosse enviado ao Azure Quantum com esse target perfil.

Especificamente, são aplicadas decomposições de porta que tornariam o circuito resultante compatível com as capacidades do target hardware. Essas são as mesmas decomposições que seriam aplicadas durante a geração e o envio de código para o Azure Quantum.

1. Por exemplo, considere o seguinte Q# programa que mede um qubit e uma matriz de qubits.

   import Std.Measurement.*;
   
   operation Main() : (Result, Result[]) {
       // The `M` operation performs a measurement of a single qubit in the
       // computational basis, also known as the Pauli Z basis.
       use q = Qubit();
       let result = M(q);
       Reset(q);
   
       // The `MeasureEachZ` operation measures each qubit in an array in the
       // computational basis and returns an array of `Result` values.
       use qs = Qubit[2];
       let results = MeasureEachZ(qs);
   
       return (result, results);
   }
   

2. Quando target o perfil é definido como Irrestrito ou QIR Adaptive RI, os portões exibidos no circuito correspondem exatamente às operações quânticas que são invocadas Q# no programa.

   

3. Quando o perfil é base target QIR, o circuito parece diferente. Como o perfil targets base não permite a reutilização do qubit após a medição, a medição agora é realizada em um qubit emaranhado. Como Reset a operação não é um portão suportado no Perfil Base, ela é descartada. O circuito resultante corresponde ao que seria executado no hardware se este programa fosse enviado ao Azure Quantum com esse target perfil.