Partilhar via


Visualize 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

Blocos de Notas do Jupyter

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 abaixo @EntryPoint().

    Captura de tela do Q# arquivo no Visual Studio Code mostrando onde encontrar o comando code lens circuit.

  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.

    Captura de tela da janela do Q# circuito mostrando o diagrama de circuito resultante para a operação de bit aleatório.

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.

Captura de tela do Visual Studio Code mostrando como visualizar os Q# circuitos no painel de circuitos depois de depurar o programa.

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 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 tela do Visual Studio Code mostrando como visualizar o circuito durante a depuração de um 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.

    Captura de tela do Visual Studio Code mostrando como visualizar o circuito para uma única Q# operaçã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())
    

    Captura de tela de um Jupyter Notebook mostrando como visualizar o circuito para uma Q# operação.

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

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.

Perfil alvo

O perfil atualmente selecionado target influencia como os diagramas de circuitos são gerados. Os perfis de destino 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.

Nota

  • Para selecionar o target perfil no VS Code, selecione Exibir -> Paleta de Comandos e selecioneQ#: Definir o perfil do Azure Quantum QIRtarget. Você pode selecionar QIR base, QIR Adaptive RIou unrestricted na lista suspensa.

  • Para selecionar o perfil em Python, chame targetqsharp.init(target_profile=qsharp.TargetProfile.Base)ou qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)qsharp.init(target_profile=qsharp.TargetProfile.Unrestricted).

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.

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

    Captura de tela de circuitos quânticos quando target o perfil é Irrestrito.

  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.

    Captura de tela de circuitos quânticos quando target o perfil é base QIR.