Como visualizar diagramas de circuitos quânticos com Q#

Artigo
10/23/2024

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 as portas e as medições aplicadas a eles.

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

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

Pré-requisitos

Código do 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 Kit de desenvolvimento do Azure Quantum.
Os pacotes mais recentes do Azure Quantum qsharp e azure-quantum do Python.
```
python -m pip install --upgrade qsharp azure-quantum
```

Jupyter Notebooks

A versão mais recente do Visual Studio Code ou abra o VS Code na Web.
VS Code com as extensões do 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 diagrama de circuito quântico, consulte Convenções de circuitos quânticos.

Visualizando Diagramas de Circuito para um Q# Programa

Abra um Q# arquivo no Visual Studio Code ou carregue um dos exemplos quânticos.
Para visualizar o circuito quântico do programa, selecione Exibir -> Paleta de Q# Comandos e digite "circuito" que deve abrir a opção : Mostrar circuitoQ#. Você também pode clicar em Circuito na lista de comandos anteriores Main().
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, em seguida, o mede. O diagrama de circuito mostra um registro de qubit que é inicializado para o estado |0⟩. Em seguida, uma porta de Hadamard, H, é aplicada ao qubit, seguida por uma operação de medição, que é representada por um símbolo de medidor.

Visualizando diagramas de circuito 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.

Captura de tela do Visual Studio Code mostrando como visualizar os circuitos no Q# painel de circuitos após a depuração do programa.

Exibindo 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.

Selecione o botão Depurar na lista de comandos de lente de código anteriores Main().
No modo de exibição Executar e depurar no lado esquerdo, expanda a seção Circuito Quântico no painel Variáveis para mostrar o circuito à medida que você percorre o programa.
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.
O circuito quântico atual é mostrado no Q# painel Circuito. Este diagrama de circuito representa o estado atual do simulador, ou seja, as portas que foram aplicadas até o ponto atual de execução.

Circuitos quânticos com Jupyter Notebooks

No 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.

No Visual Studio Code, selecione Exibir> Paleta de comandos e selecione Criar: Novo Jupyter Notebook.
Na primeira célula do notebook, execute o código a seguir para importar o Q# módulo.
```
import qsharp
```

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]);

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, uma porta Hadamard, H, é aplicada 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 ──
```
Você pode visualizar circuitos quânticos como uma imagem SVG usando o qsharp-widgets pacote. Nesse caso, a porta CNOT é representada como uma linha que conecta os dois qubits, com um ponto no qubit de controle e uma cruz circunscrita no target 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.

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;
}

Adicione uma nova célula e execute o código a seguir para visualizar o circuito. Por exemplo, prepare um estado GHZ com 3 qubits.
```
Circuit(qsharp.circuit("GHZSample(3)"))
```

Exibindo diagramas de circuito 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 tantos fios quanto o qubit de entrada, além de quaisquer qubits adicionais alocados na operação. Quando a operação usa uma matriz de qubits (Qubit[]), o circuito mostra a matriz como um registro de 2 qubits.

Adicione uma nova célula e copie o exemplo a seguir. Esse código prepara um estado cat.

%%qsharp

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

Adicione uma nova célula e execute o código a seguir para visualizar o PrepareCatState circuito da operação.
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```

Condições que afetam diagramas de circuito

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

Circuitos dinâmicos

Os diagramas de circuito são gerados executando toda a lógica clássica dentro de um Q# programa e acompanhando todos os 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, os 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 condicionais a um resultado de medição. Esse circuito é chamado de circuito dinâmico .

Os diagramas de circuito podem ser gerados para circuitos dinâmicos executando o programa no simulador quântico e rastreando as portas à medida que são aplicadas. 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 porta 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.

Perfil de Target

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

Quando o target perfil é definido como IR Adaptável Irrestrito ou QIR, 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.

Observação

Para selecionar o target perfil no VS Code, selecione Exibir –> Paleta de Comandos e selecioneQ#: Definir o perfil QIR target do Azure Quantum. Você pode selecionar QIR base, QIR Adaptive RIou unrestricted na lista suspensa.
Para selecionar o target perfil em Python, chame qsharp.init(target_profile=qsharp.TargetProfile.Base), qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)ou qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted).

Especificamente, são aplicadas decomposições de portas 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.

Por exemplo, considere o programa a seguir Q# 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);
}

Quando target profile é definido como Unrestricted ou QIR Adaptive RI, as portas exibidas no circuito correspondem exatamente às operações quânticas que são invocadas no Q# programa.
Quando o target perfil é base QIR, o circuito parece diferente. Como o perfil targets base não permite a reutilização de qubit após a medição, a medição agora é executada em um qubit emaranhado. Como Reset a operação não é uma porta com suporte no Perfil Base, ela é descartada. O circuito resultante corresponde ao que seria executado no hardware se esse programa fosse enviado ao Azure Quantum com esse target perfil.

Compartilhar via