Visualizar diagramas de circuito quântico com Q#

Artigo
04/26/2024

Diagramas de circuito quântico são uma representação visual de operações quânticas. Eles mostram o fluxo de qubits por meio do programa quântico, incluindo as portas e medidas aplicadas a eles.

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

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

Se você quiser usar Visual Studio Code para visualizar circuitos quânticos, será necessário:

A versão mais recente do Visual Studio Code ou abrir o VS Code na Web.
A versão mais recente da extensão do Kit de Desenvolvimento do Azure Quantum .

Se você quiser usar o Jupyter Notebooks para visualizar circuitos quânticos, será necessário:

A versão mais recente do Visual Studio Code ou abrir o VS Code na Web.
VS Code com as extensões do Kit de Desenvolvimento do Azure Quantum, Python e Jupyter instaladas.
O Azure Quantum qsharp mais recente e qsharp-widgets os pacotes e o ipykernel pacote.
```
python -m pip install --upgrade qsharp qsharp-widgets ipykernel
```

Circuitos quânticos com 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.

Exibindo diagramas de circuito para um Q# programa

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

Exibindo 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 de Visual Studio Code mostrando como visualizar os circuitos no Q# painel de circuitos após a depuração do programa.

Exibindo diagramas de circuito ao depurar

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

Clique no botão Depurar na lista de comandos de lente de código abaixo @EntryPoint().
Na exibição Executar e depurar no lado esquerdo, expanda a seção Circuito Quântico no painel Variáveis para mostrar o circuito conforme 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. Esse 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

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

Em Visual Studio Code, selecione Exibir > Paleta de comandos e selecione Create: 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 qubit inicializados para o estado |0⟩. Em seguida, um portão 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 ──
```
Você pode visualizar circuitos quânticos como uma imagem SVG usando o qsharp-widgets pacote . Nesse caso, o portão CNOT é representado 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())
```

Exibindo 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

open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.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 usa qubits ou matrizes de qubits. O diagrama mostra quantos fios houver qubit de entrada, além de qubits adicionais alocados dentro da 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 de gato.

%%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 circuito da PrepareCatState operação.
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```

Condições que afetam diagramas de circuito

Ao visualizar circuitos quânticos, as condições a seguir 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 alocados ou portões que foram aplicados. Há suporte para loops e condicionais, desde que eles só lidem com valores clássicos.

No entanto, programas que contêm loops e expressões condicionais que usam resultados de medida qubit são mais complicados 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, pois os portões são condicionais em um resultado de medida. Esse circuito é chamado de circuito dinâmico .

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

A desvantagem dos circuitos rastreados é que eles capturam apenas o resultado da medida e os aplicativos de portão conseqüentes para uma única simulação. No exemplo acima, se o resultado da medida 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 destino

O perfil selecionado target no momento influencia como os diagramas de circuito são gerados. Os perfis de destino 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 Irrestrito, os diagramas de circuito mostram as operações quânticas invocadas no Q# 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 target o perfil no VS Code, acesse Exibir –> Paleta de Comandos e gravar Q#: defina o perfil qir target do Azure Quantum. Você pode selecionar Unrestricted ou QIR Base Profile na lista suspensa.
Para selecionar target o perfil em Python, escreva qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted) ou qsharp.init(target_profile=qsharp.TargetProfile.Base).

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

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

namespace Sample {
    open Microsoft.Quantum.Measurement;

    @EntryPoint()
    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 o perfil é definido como Irrestrito, os portões exibidos no circuito correspondem exatamente às operações quânticas 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 medida agora é executada em um qubit emaranhado. Como Reset a operação não é um portão com suporte no Perfil Base, ela é descartada. O circuito resultante corresponderá ao que seria executado no hardware se este programa fosse enviado ao Azure Quantum com esse target perfil.

Share via