Visualizar diagramas do circuito quântico com Q#

Artigo
04/28/2024

Os diagramas do circuito quântico são uma representação visual das operações quânticas. Mostram o fluxo de qubits através do programa quântico, incluindo as portas e as medidas aplicadas aos mesmos.

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

Para obter mais informações sobre as convenções do diagrama de circuito quântico, veja Quantum circuits conventions (Convenções de circuitos quânticos).

Se quiser utilizar o Visual Studio Code para visualizar circuitos quânticos, precisa de:

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 .

Se quiser utilizar o Jupyter Notebooks para visualizar circuitos quânticos, precisa de:

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 estes passos para visualizar circuitos quânticos de Q# programas no Visual Studio Code. Para obter mais informações sobre as convenções do diagrama de circuito quântico, veja Quantum circuits conventions (Convenções de circuitos quânticos).

Ver diagramas de circuitos de um Q# programa

Abra um Q# ficheiro no Visual Studio Code ou carregue um dos exemplos quânticos.
Para visualizar o circuito quântico do Q# programa, selecione Ver –> Paleta de Comandos e escreva "circuito", que deverá apresentar a opção Q#: Mostrar circuito . Também pode clicar em Circuito a partir da lista de comandos abaixo @EntryPoint().
O circuito é apresentado na janela do Q# circuito. Por exemplo, o circuito seguinte corresponde a uma operação que coloca um qubit numa sobreposição e, em seguida, mede-o. O diagrama de circuito mostra um registo de qubit que é inicializado para o estado |0⟩. Em seguida, uma porta Hadamard, H, é aplicada ao qubit, seguida de uma operação de medição, que é representada por um símbolo de medidor.

Ver diagramas de circuitos para operações

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

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

Ver diagramas de circuito ao depurar

Ao depurar um Q# programa, 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 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.
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 é apresentado no Q# painel Circuito. Este diagrama de circuito representa o estado atual do simulador, ou seja, as portas que foram aplicadas até ao ponto atual de execução.

Circuitos quânticos com Jupyter Notebooks

No Jupyter Notebooks, pode visualizar circuitos quânticos com o qsharp-widgets pacote. Este pacote fornece um widget que compõe um diagrama de circuito quântico como uma imagem SVG.

No Visual Studio Code, selecione Ver > Paleta de comandos e selecione Create: Novo Jupyter Notebook.
Na primeira célula do bloco de notas, execute o seguinte código para importar o Q# módulo.
```
import qsharp
```
Adicione uma nova célula e introduza o Q# código. Por exemplo, o seguinte código prepara um Estado da Campainha.
```
%%qsharp

// Prepare a Bell State.
use register = Qubit[2];
H(register[0]);
CNOT(register[0], register[1]);
```
Pode utilizar a dump_circuit() função para apresentar um circuito quântico com base no estado atual do programa. Por exemplo, o diagrama de circuito mostra dois registos de qubit que são inicializados no estado |0⟩. Em seguida, é aplicada uma porta Hadamard, H, ao primeiro qubit. Depois disso, é aplicada uma porta CNOT com o primeiro qubit como controlo, 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 ──
```
Pode visualizar circuitos quânticos como uma imagem SVG com o qsharp-widgets pacote. Neste caso, a porta CNOT é representada como uma linha que liga os dois qubits, com um ponto no qubit de controlo e uma cruz circunscrita no target qubit. Para obter mais informações, veja Quantum circuits conventions (Convenções de circuitos quânticos).
```
from qsharp_widgets import Circuit

Circuit(qsharp.dump_circuit())
```

Ver diagramas de circuito para uma expressão de entrada

Pode gerar um diagrama de circuito para qualquer programa com uma expressão de entrada ao chamar qsharp.circuit() e transmitir a expressão de entrada como um argumento.

Por exemplo, adicione uma nova célula e copie o seguinte código, 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 seguinte código para visualizar o circuito. Por exemplo, prepare um estado GHZ com 3 qubits.
```
Circuit(qsharp.circuit("GHZSample(3)"))
```

Ver diagramas de circuitos para operações com qubits

Pode gerar diagramas de circuito para qualquer operação que utilize qubits ou matrizes de qubits. O diagrama mostra tantos fios quanto qubits de entrada, além de qubits adicionais que são alocados na operação. Quando a operação utiliza uma matriz de qubits (Qubit[]), o circuito mostra a matriz como um registo de 2 qubits.

Adicione uma nova célula e copie o exemplo seguinte. Este 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 seguinte código 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 seguintes condições podem afetar a visualização do diagrama de circuito.

Circuitos dinâmicos

Os diagramas de circuitos são gerados ao executar toda a lógica clássica num Q# programa e ao controlar todos os qubits que foram alocados ou portas que foram aplicados. Os ciclos e condicionais são suportados desde que apenas lidem com valores clássicos.

No entanto, os programas que contêm ciclos e expressões condicionais que utilizam resultados de medição de 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, uma vez que as portas estão condicionais num resultado de medição. Um circuito deste tipo é denominado circuito dinâmico .

Os diagramas de circuitos podem ser gerados para circuitos dinâmicos ao executar o programa no simulador quântico e ao rastrear as portas à medida que são aplicadas. Isto é denominado modo de rastreio , uma vez que os qubits e as portas estão a ser rastreados à medida que a simulação está a ser executada.

A desvantagem dos circuitos rastreados é que apenas capturam 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, 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 atualmente selecionado influencia target a forma como os diagramas de circuito são gerados. Os perfis de destino são utilizados para especificar as capacidades do target hardware e as restrições impostas ao programa quântico.

Quando o target perfil está definido como Sem restrições, os diagramas de circuito mostram as operações quânticas que são invocadas no Q# programa. Quando o target perfil está definido como base QIR, os diagramas de circuito mostram as operações quânticas que seriam executadas em hardware se o programa fosse submetido para o Azure Quantum com este target perfil.

Nota

Para selecionar o target perfil no VS Code, aceda a Ver –> Paleta de Comandos e escreva Q#: Defina o perfil qir target do Azure Quantum. Pode selecionar Unrestricted ou QIR Base Profile a partir da lista pendente.
Para selecionar o target perfil em Python, escreva qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted) ou qsharp.init(target_profile=qsharp.TargetProfile.Base).

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

Por exemplo, considere o seguinte Q# programa 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 está definido como Sem restrições, as portas apresentadas no circuito correspondem exatamente às operações quânticas que são invocadas no Q# programa.
Quando o target perfil é a base QIR, o circuito tem um aspeto diferente. Uma vez que o Perfil targets Base não permite a reutilização do qubit após a medição, a medição é agora efetuada num qubit entrelaçado. Uma Reset vez que a operação não é uma porta suportada no Perfil Base, esta é removida. O circuito resultante corresponde ao que seria executado em hardware se este programa fosse submetido para o Azure Quantum com este target perfil.

Partilhar via