Partilhar via


Visualizar diagramas do circuito quântico com Q#

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

Pré-requisitos

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

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

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

  2. 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().

    Captura de ecrã do Q# ficheiro no Visual Studio Code a mostrar onde encontrar o comando do circuito de lente de código.

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

    Captura de ecrã da janela do Q# circuito a mostrar o diagrama do circuito resultante para a operação de bits aleatórios.

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.

  1. Clique no botão Depurar na lista de comandos de lente de código abaixo @EntryPoint().

  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.

    Captura de ecrã do Visual Studio Code a mostrar como visualizar o circuito durante a depuração de um programa.

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

    Captura de ecrã do Visual Studio Code a mostrar como visualizar o circuito para uma única Q# operaçã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.

  1. No Visual Studio Code, selecione Ver > Paleta de comandos e selecione Create: Novo Jupyter Notebook.

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

    import qsharp
    
  3. 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]);
    
  4. 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 ──
    
  5. 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())
    

    Captura de ecrã de um Jupyter Notebook a mostrar como visualizar o circuito para uma Q# operação.

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.

  1. 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;
    }
    
  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)"))
    

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.

  1. 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...]);
    }
    
  2. 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.

  1. 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);
        }
    }
    
  2. 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.

    Captura de ecrã a mostrar circuitos quânticos quando target o perfil é Sem restrições.

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

    Captura de ecrã a mostrar circuitos quânticos quando target o perfil é a base QIR.