Skip to main content
IBM Quantum Platform

OpenQASM 3

qiskit.qasm3

O Qiskit fornece algumas ferramentas para conversão entre OpenQASM 3 representações de programas quânticos e a classe QuantumCircuit classe. Eles continuarão a evoluir à medida que o suporte do Qiskit aos recursos de circuito dinâmico expressos por OpenQASM 3 aumentar.

Exportando para OpenQASM 3

As funções de alto nível são simplesmente dump() e dumps()que exportam, respectivamente, para um arquivo (fornecido como um nome de arquivo) e para uma cadeia de caracteres Python.

dump

qiskit.qasm3.dump(circuit, stream, **kwargs)

GitHub

Serializar um QuantumCircuit como um fluxo OpenQASM 3 para um objeto do tipo arquivo.

Parâmetros

  • circuit (QuantumCircuit) – Circuito para serializar.
  • stream (TextIOBase) – objeto semelhante a um fluxo para despejar a serialização OpenQASM 3
  • **kwargs - Argumentos para o Exporter construtor.

Tipo de retorno

Nenhum

dumps

qiskit.qasm3.dumps(circuit, **kwargs)

GitHub

Serializar um QuantumCircuit em uma cadeia de caracteres OpenQASM 3.

Parâmetros

Retorna

A serialização do OpenQASM 3

Tipo de retorno

str

Essas duas funções de exportador são invólucros de uso único em torno da classe principal Exporter classe. Para necessidades de exportação mais complexas, incluindo o despejo de vários circuitos em uma única sessão, pode ser mais conveniente ou mais rápido usar a interface completa.

Exportador

class qiskit.qasm3.Exporter(includes=('stdgates.inc', ), basis_gates=('U', ), disable_constants=False, alias_classical_registers=None, allow_aliasing=None, indent='  ', experimental=<ExperimentalFeatures: 0>, annotation_handlers=None, implicit_defcals=None)

GitHub

Bases: object

QASM3 classe principal do exportador.

Parâmetros

  • includes (Sequence[str]) –

    os nomes de arquivos que devem ser emitidos como includes.

    Nota

    No momento, somente o arquivo da biblioteca padrão stdgates.inc é compreendido corretamente pelo exportador, no sentido de que ele conhece as portas que define. Você pode especificar outros includes, mas precisará passar os nomes das portas que eles definem no argumento basis_gates para evitar que o exportador produza uma definição gate separada.

  • basis_gates (Sequence[str]) – o conjunto básico de portas definidas do backend.

  • disable_constants (bool) – se True, sempre emite constantes de ponto flutuante para valores de parâmetros numéricos. Se for False (o padrão), os valores próximos a múltiplos de OpenQASM 3 constantes (pi, euler e tau) serão emitidos em termos dessas constantes, o que pode melhorar a precisão da saída.

  • alias_classical_registers (bool | None) –

    Se True, então os bits podem estar contidos em mais de um registro. Nesse caso, os registros serão emitidos usando definições de "alias", que podem não ser bem suportadas pelos consumidores do OpenQASM 3.

    Veja Também

    Parâmetro allow_aliasing

    Um valor para allow_aliasing substitui qualquer valor fornecido aqui e substitui esse parâmetro.

  • allow_aliasing (bool | None) –

    Se True, então os bits podem estar contidos em mais de um registro. Nesse caso, os registros serão emitidos usando definições de "alias", que podem não ser bem suportadas pelos consumidores do OpenQASM 3. O padrão é False ou o valor de alias_classical_registers.

    Adicionado na versão 0.25.0.

  • indent (str) – a cadeia de caracteres de recuo a ser usada para cada nível em um bloco recuado. Pode ser definido como uma string vazia para desativar o recuo.

  • experimental (ExperimentalFeatures) – quaisquer recursos experimentais a serem ativados durante a exportação. Veja ExperimentalFeatures para obter mais detalhes.

  • annotation_handlers (dict[str, OpenQASM3Serializer] | None) – um mapeamento de namespaces para serializadores de anotações. Quando um objeto Annotation é encontrado, o namespace mais específico nesse mapeamento que corresponde ao atributo namespace da anotação será usado para serializá-lo.

  • implicit_defcals (dict[str, DefcalInstruction] | None) – mapeamento de Instruction.names para um objeto DefcalInstruction associado. Todas as instruções com o nome da chave no circuito de entrada devem ser emitidas como se houvesse uma instrução defcal correspondente ao DefcalInstruction definido. O nome da chave e o endereço DefcalInstruction.name não precisam ser iguais. O nome defcal não pode coincidir com uma palavra-chave OpenQASM 3.

dump

dump(circuit, stream)

GitHub

Converta o circuito para OpenQASM 3, despejando o resultado em um arquivo ou fluxo de texto.

dumps

dumps(circuit)

GitHub

Converta o circuito para OpenQASM 3, retornando o resultado como uma cadeia de caracteres.

Todas essas interfaces gerarão QASM3ExporterError em caso de falha.

QASM3ExporterError

exception qiskit.qasm3.QASM3ExporterError(*message)

GitHub

Bases: QASM3Error

Ocorreu um erro durante a execução do exportador OpenQASM 3.

Defina a mensagem de erro.

Recursos experimentais

A linguagem OpenQASM 3 ainda está evoluindo à medida que os recursos de hardware são aprimorados, portanto, não há uma sintaxe final que o Qiskit possa atingir de forma confiável. Para representar a linguagem em evolução, às vezes lançamos recursos antes da padronização formal, que pode precisar ser alterada à medida que o processo de revisão nos comitês de design do OpenQASM 3 avança. Por padrão, os exportadores suportarão apenas os recursos padronizados da linguagem. Para ativar esses recursos de lançamento antecipado, use o argumento da palavra-chave experimental do dump() e dumps(). Os sinalizadores de recursos disponíveis são:

ExperimentalFeatures

class qiskit.qasm3.ExperimentalFeatures(*values)

GitHub

Bases: Flag

Sinalizadores para recursos experimentais compatíveis com o exportador OpenQASM 3.

Eles são experimentais e estão mais sujeitos a alterações, pois a especificação OpenQASM 3 ainda não os aceitou formalmente e, portanto, a sintaxe pode não estar finalizada.

SWITCH_CASE_V1

Valor Padrão: 1

Suporte à exportação de instruções switch-case conforme proposto por https://github.com/openqasm/openqasm/pull/463 no commit bfa787aa3078.

Eles têm o formato de saída:

switch (i) {
    case 0:
    case 1:
        x $0;
    break;

    case 2: {
        z $0;
    }
    break;

    default: {
        cx $0, $1;
    }
    break;
}

Isso difere da sintaxe da declaração switch conforme estabilizada. Se esse sinalizador não for passado, o analisador produzirá a saída usando a sintaxe estabilizada, o que tornaria o mesmo exemplo acima como:

switch (i) {
    case 0, 1 {
        x $0;
    }
    case 2 {
        z $0;
    }
    default {
        cx $0, $1;
    }
}

Se quiser habilitar vários recursos experimentais, você deve combinar os sinalizadores usando o operador | , como flag1 | flag2.

Por exemplo, para executar uma exportação usando a semântica inicial do suporte switch :

from qiskit import qasm3, QuantumCircuit, QuantumRegister, ClassicalRegister

# Build the circuit
qreg = QuantumRegister(3)
creg = ClassicalRegister(3)
qc = QuantumCircuit(qreg, creg)
with qc.switch(creg) as case:
    with case(0):
        qc.x(0)
    with case(1, 2):
        qc.x(1)
    with case(case.DEFAULT):
        qc.x(2)

# Export to an OpenQASM 3 string.
qasm_string = qasm3.dumps(qc, experimental=qasm3.ExperimentalFeatures.SWITCH_CASE_V1)
Nota

Todos os recursos habilitados pelos sinalizadores experimentais são naturalmente transitórios. Se for necessário remover os sinalizadores, eles estarão sujeitos à política padrão de depreciação do Qiskit. Deixaremos esses sinalizadores experimentais em vigor pelo tempo que for razoável.

No entanto, não podemos garantir nenhuma janela de suporte para os consumidores do código OpenQASM 3 gerado usando esses sinalizadores experimentais, se a especificação da linguagem OpenQASM 3 alterar a proposta na qual o sinalizador se baseia. É possível que qualquer ferramenta que você esteja usando para consumir o código OpenQASM 3 criado com esses sinalizadores possa atualizar ou remover seu suporte enquanto o Qiskit continuar a oferecer o sinalizador. Você não deve confiar no código experimental resultante do OpenQASM 3 para o armazenamento de programas a longo prazo.

Importando de OpenQASM 3

Atualmente, são oferecidas apenas duas funções de alto nível, pois o suporte do Qiskit para importação do OpenQASM 3 está em sua fase inicial, e espera-se que a implementação mude significativamente. As duas funções são load() e loads()que são contrapartes diretas de dump() e dumps()respectivamente, carregando um programa indiretamente de um arquivo nomeado e diretamente de uma determinada cadeia de caracteres.

Nota

Embora ainda estejamos no período de lançamento exploratório, para usar qualquer uma das funções, o pacote qiskit_qasm3_import deve estar instalado. Isso pode ser feito instalando o Qiskit com o extra qasm3-import , por exemplo:

pip install qiskit[qasm3-import]

Esperamos que essa funcionalidade acabe sendo incorporada ao Qiskit e não exija mais uma importação opcional, mas ainda não temos um cronograma para isso.

load

qiskit.qasm3.load(filename, *, num_qubits=None, annotation_handlers=None)

GitHub

Carregue um programa OpenQASM 3 do arquivo filename.

Parâmetros

  • filename (str) – o nome do arquivo a partir do qual o programa será carregado.
  • num_qubits (int | None) – argumento de palavra-chave que fornece o número de qubits físicos/virtuais.
  • annotation_handlers (dict[str, annotation.OpenQASM3Serializer] | None) – um mapeamento cujas chaves são namespaces (pais) e cujos valores são serializadores capazes de lidar com os namespaces filhos desses namespaces. Requer qiskit_qasm3_import>=0.6.0.

Retorna

uma representação de circuito do programa OpenQASM 3.

Tipo de retorno

QuantumCircuit

Aumentos

QASM3ImporterError - se o arquivo OpenQASM 3 for inválido ou não puder ser representado por um arquivo QuantumCircuit.

Adicionado na versão 2.1

O argumento annotation_handlers . Isso requer qiskit_qasm3_import>=0.6.0.

loads

qiskit.qasm3.loads(program, *, num_qubits=None, annotation_handlers=None)

GitHub

Carrega um programa OpenQASM 3 a partir da cadeia de caracteres fornecida.

Exemplos

Carregue uma string OpenQASM3 em um circuito quântico com/sem o argumento num_qubits.

from qiskit import qasm3

# An OpenQASM 3 program that only uses 2 physical qubits.
prog = '''
    OPENQASM 3.0;
    include "stdgates.inc";
    h $0;
    cx $0, $1;
'''
# The importer can be supplied with the number of qubits in the target backend.
# so the result is full width.
qc = qasm3.loads(prog, num_qubits=5)
assert qc.num_qubits == 5

Parâmetros

  • program (str) – o programa OpenQASM 3.
  • num_qubits (int | None) – fornece o número de qubits físicos/virtuais.
  • annotation_handlers (dict[str, annotation.OpenQASM3Serializer] | None) – um mapeamento cujas chaves são namespaces (pais) e cujos valores são serializadores capazes de lidar com os namespaces filhos desses namespaces. Requer qiskit_qasm3_import>=0.6.0.

Retorna

uma representação de circuito do programa OpenQASM 3.

Tipo de retorno

QuantumCircuit

Aumentos

Adicionado na versão 2.1

O argumento annotation_handlers . Isso requer qiskit_qasm3_import>=0.6.0.

Essas duas funções levantam QASM3ImporterError em caso de falha.

QASM3ImporterError

exception qiskit.qasm3.QASM3ImporterError(*message)

GitHub

Bases: QASM3Error

Um erro gerado durante o importador OpenQASM 3.

Defina a mensagem de erro.

Por exemplo, podemos definir um programa quântico usando OpenQASM 3 e usar loads() para convertê-lo diretamente em um programa QuantumCircuit:

import qiskit.qasm3

program = """
    OPENQASM 3.0;
    include "stdgates.inc";

    input float[64] a;
    qubit[3] q;
    bit[2] mid;
    bit[3] out;

    let aliased = q[0:1];

    gate my_gate(a) c, t {
      gphase(a / 2);
      ry(a) c;
      cx c, t;
    }
    gate my_phase(a) c {
      ctrl @ inv @ gphase(a) c;
    }

    my_gate(a * 2) aliased[0], q[{1, 2}][0];
    measure q[0] -> mid[0];
    measure q[1] -> mid[1];

    while (mid == "00") {
      reset q[0];
      reset q[1];
      my_gate(a) q[0], q[1];
      my_phase(a - pi/2) q[1];
      mid[0] = measure q[0];
      mid[1] = measure q[1];
    }

    if (mid[0]) {
      let inner_alias = q[{0, 1}];
      reset inner_alias;
    }

    out = measure q;
"""
circuit = qiskit.qasm3.loads(program)
circuit.draw("mpl")
Diagrama de circuito gerado pelo código anterior.

Interface de importação experimental

As funções de importação fornecidas acima dependem do analisador de referência baseado em ANTLR do próprio projeto OpenQASM, que se destina mais a ser uma referência de linguagem do que um analisador de desempenho. Você precisa ter a extensão qiskit-qasm3-import instalada para usá-la.

O Qiskit está desenvolvendo um analisador nativo, escrito em Rust, que está disponível como parte do pacote principal do Qiskit. Esse analisador ainda está em seus primeiros estágios experimentais, portanto, faltam recursos e sua interface está mudando e se expandindo, mas, em geral, ele é muito mais eficiente para o subconjunto de OpenQASM 3 que suporta atualmente, e seus componentes internos produzem melhores diagnósticos de erros em falhas de análise.

Você pode usar a interface experimental imediatamente, com funções semelhantes às da interface principal acima:

load_experimental

qiskit.qasm3.load_experimental(pathlike_or_filelike, /, *, custom_gates=None, include_path=None)

Carregue um programa OpenQASM 3 de um arquivo de origem em um arquivo QuantumCircuit.

Aviso

Essa versão nativa do importador OpenQASM 3 é atualmente experimental. Normalmente, ele é muito mais rápido do que o load()mas tem um conjunto reduzido de recursos suportados, que será ampliado com o tempo.

Parâmetros

  • pathlike_or_filelike (str |os.PathLike |io.TextIOBase) – a fonte do programa. Isso pode ser fornecido como um caminho de arquivo ou como um objeto de fluxo de texto aberto. Se o fluxo já estiver aberto, ele será consumido no espaço Python, enquanto os nomes de arquivos são abertos e consumidos no espaço Rust; pode haver características de desempenho ligeiramente diferentes, dependendo do seu sistema e de como os fluxos são armazenados em buffer por padrão.
  • custom_gates (Iterable[CustomGate]) – Python construtores a serem usados para portas nomeadas específicas. Se não for fornecido, o Qiskit usará seus próprios construtores de biblioteca padrão para portas definidas no arquivo de biblioteca padrão OpenQASM 3.0 stdgates.inc.
  • include_path (Iterable[str]) – o caminho a ser pesquisado na resolução de declarações include . Se não for fornecido, o Qiskit fará com que ele aponte para um local que contenha apenas o endereço stdgates.inc . Os caminhos são testados na ordem sequencial.

Retorna

o objeto do circuito construído.

Tipo de retorno

QuantumCircuit

Aumentos

.QASM3ImporterError - se ocorrer um erro durante a análise parsing ou semântica. No caso de um erro de análise, a maioria das mensagens de erro é impressa no terminal e formatada, para melhor legibilidade.

loads_experimental

qiskit.qasm3.loads_experimental(source, /, *, custom_gates=None, include_path=None)

Carregue um programa OpenQASM 3 de uma string em um arquivo QuantumCircuit.

Aviso

Essa versão nativa do importador OpenQASM 3 é atualmente experimental. Normalmente, ele é muito mais rápido do que o loads()mas tem um conjunto reduzido de recursos suportados, que será ampliado com o tempo.

Parâmetros

  • source (str) – o código-fonte do programa em uma cadeia de caracteres Python.
  • custom_gates (Iterable[CustomGate]) – Python construtores a serem usados para portas nomeadas específicas. Se não for fornecido, o Qiskit usará seus próprios construtores de biblioteca padrão para portas definidas no arquivo de biblioteca padrão OpenQASM 3.0 stdgates.inc.
  • include_path (Iterable[str]) – o caminho a ser pesquisado na resolução de declarações include . Se não for fornecido, o Qiskit fará com que ele aponte para um local que contenha apenas o endereço stdgates.inc . Os caminhos são testados na ordem sequencial.

Retorna

o objeto do circuito construído.

Tipo de retorno

QuantumCircuit

Aumentos

.QASM3ImporterError - se ocorrer um erro durante a análise parsing ou semântica. No caso de um erro de análise, a maioria das mensagens de erro é impressa no terminal e formatada, para melhor legibilidade.

Essas duas funções são experimentais, o que significa que elas emitem uma mensagem ExperimentalWarning no uso, e suas interfaces podem estar sujeitas a alterações na série de versões do Qiskit 1.x. Em particular, o analisador nativo pode ser promovido para ser a versão padrão do load() e loads(). Se você não se importar em aceitar o risco de usar a interface experimental, poderá desativar o aviso:

import warnings
from qiskit.exceptions import ExperimentalWarning

warnings.filterwarnings("ignore", category=ExperimentalWarning, module="qiskit.qasm3")

Essas duas funções permitem a especificação de caminhos de inclusão como um iterável de caminhos e a especificação de construtores Python personalizados a serem usados para portas específicas. Esses construtores personalizados são especificados usando o parâmetro CustomGate objeto:

CustomGate

class qiskit.qasm3.CustomGate(constructor, name, num_params, num_qubits)

Bases: object

Informações recebidas do espaço Python sobre como construir um objeto do espaço Python para representar uma determinada porta que pode ser declarada.

constructor

Um objeto Python chamável que recebe os ângulos num_params como argumentos posicionais e retorna um objeto Gate objeto que representa o portão.

name

O nome do portão como aparece no programa OpenQASM 3. Isso não é necessariamente idêntico ao nome que Qiskit dá ao portão.

num_params

O número de parâmetros de ângulo que a porta exige.

num_qubits

O número de qubits em que a porta atua.

Se não custom_gates for especificado, o Qiskit tentará usar os objetos de porta da biblioteca padrão para as portas definidas no arquivo da biblioteca padrão do OpenQASMstdgates.ince 3. Esta sequência de portas está disponível neste módulo, caso você queira utilizá-la como base:

qiskit.qasm3.STDGATES_INC_GATES

Uma tupla de objetos CustomGate especificando os construtores do Qiskit a serem usados para o arquivo de inclusão stdgates.inc .

Esta página foi útil?
Relate um bug, erro de digitação ou solicite conteúdo no GitHub.