Skip to main content
IBM Quantum Platform

OpenQASM 3

qiskit.qasm3

Qiskit fornisce alcuni strumenti per la conversione tra le rappresentazioni OpenQASM 3 di programmi quantistici e la classe QuantumCircuit classe. Questi continueranno ad evolversi man mano che aumenterà il supporto di Qiskit per le funzionalità di circuito dinamico espresse da OpenQASM 3.

Esportazione in OpenQASM e 3

Le funzioni di alto livello sono semplicemente dump() e dumps()che esportano rispettivamente in un file (dato come nome del file) e in una stringa Python.

dump

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

GitHub

Serializzare un QuantumCircuit come oggetto simile a un file in un flusso OpenQASM 3.

Parametri

  • circuit (QuantumCircuit) – Circuito da serializzare.
  • stream (TextIOBase) – oggetto simile a uno stream per scaricare la serializzazione di OpenQASM 3
  • **kwargs - Argomenti per il costruttore di Exporter costruttore.

Tipo di restituzione

Nessuna

dumps

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

GitHub

Serializzare un QuantumCircuit in una stringa OpenQASM 3.

Parametri

  • circuit (QuantumCircuit) – Circuito da serializzare.
  • **kwargs - Argomenti per il costruttore di Exporter costruttore.

Risultati

La serializzazione di OpenQASM 3

Tipo di restituzione

STR

Entrambe le funzioni di esportazione sono wrapper monouso attorno alla classe principale Exporter principale. Per esigenze di esportazione più complesse, tra cui lo scarico di più circuiti in un'unica sessione, può essere più conveniente o più veloce utilizzare l'interfaccia completa.

Programma di esportazione

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

Basi: object

QASM3 classe principale dell'esportatore.

Parametri

  • includes (Sequence[str]) –

    i nomi dei file che devono essere emessi come include.

    Nota

    Attualmente, solo il file della libreria standard stdgates.inc è compreso correttamente dall'esportatore, nel senso che conosce le porte che definisce. È possibile specificare altri include, ma è necessario passare i nomi delle porte che definiscono nell'argomento basis_gates per evitare che l'esportatore produca una definizione di gate separata.

  • basis_gates (Sequence[str]) – l'insieme di gate definiti di base del backend.

  • disable_constants (bool) – se True, emette sempre costanti in virgola mobile per i valori numerici dei parametri. Se False (il valore predefinito), i valori vicini ai multipli delle costanti OpenQASM 3 (pi, euler e tau) saranno emessi in termini di tali costanti, migliorando potenzialmente la precisione dell'output.

  • alias_classical_registers (bool | None) –

    Se True, i bit possono essere contenuti in più di un registro. In tal caso, i registri saranno emessi usando definizioni "alias", che potrebbero non essere ben supportate dai consumatori di OpenQASM 3.

    Vedi anche

    Parametro allow_aliasing

    Un valore per allow_aliasing sostituisce qualsiasi valore dato qui e sostituisce questo parametro.

  • allow_aliasing (bool | None) –

    Se True, i bit possono essere contenuti in più di un registro. In tal caso, i registri saranno emessi usando definizioni "alias", che potrebbero non essere ben supportate dai consumatori di OpenQASM 3. Il valore predefinito è False o il valore di alias_classical_registers.

    Aggiunto nella versione 0.25.0.

  • indent (str) – la stringa di rientro da usare per ogni livello all'interno di un blocco rientrato. Può essere impostato sulla stringa vuota per disabilitare l'indentazione.

  • experimental (ExperimentalFeatures) – eventuali funzioni sperimentali da abilitare durante l'esportazione. Vedere ExperimentalFeatures per maggiori dettagli.

  • annotation_handlers (dict[str, OpenQASM3Serializer] | None) – una mappatura degli spazi dei nomi ai serializzatori di annotazioni. Quando viene rilevato un Annotation oggetto, per serializzarlo verrà utilizzato lo spazio dei nomi più specifico presente in questa mappatura che corrisponda all'attributo dell'annotazione namespace .

  • implicit_defcals (dict[str, DefcalInstruction] | None) – mappatura di Instruction.names su un oggetto associato DefcalInstruction . Tutte le istruzioni contenenti il nome della chiave nel circuito di input dovrebbero essere emesse come se fosse definita un'istruzione defcal corrispondente a quella specificata DefcalInstruction . Il nome della chiave e il DefcalInstruction.name non devono necessariamente corrispondere. Il defcal nome non deve entrare in conflitto con una parola chiave di OpenQASM 3.

dump

dump(circuit, stream)

GitHub

Converte il circuito in OpenQASM 3, scaricando il risultato in un file o in un flusso di testo.

dumps

dumps(circuit)

GitHub

Converte il circuito in OpenQASM 3, restituendo il risultato come stringa.

Tutte queste interfacce sollevano QASM3ExporterError in caso di fallimento.

QASM3ExporterError

exception qiskit.qasm3.QASM3ExporterError(*message)

GitHub

Basi: QASM3Error

Si è verificato un errore durante l'esecuzione dell'esportatore OpenQASM 3.

Impostare il messaggio di errore.

Funzioni sperimentali

Il linguaggio OpenQASM 3 è ancora in evoluzione con il miglioramento delle capacità dell'hardware, quindi non esiste una sintassi definitiva a cui Qiskit possa fare riferimento in modo affidabile. Al fine di rappresentare il linguaggio in evoluzione, a volte rilasceremo delle funzionalità prima della standardizzazione formale, che potrebbero dover cambiare con l'avanzare del processo di revisione nei comitati di progettazione di OpenQASM 3. Per impostazione predefinita, gli esportatori supporteranno solo le caratteristiche standardizzate della lingua. Per abilitare queste funzionalità di early-release, utilizzare l'argomento della parola chiave experimental di dump() e dumps(). I flag di funzione disponibili sono:

ExperimentalFeatures

class qiskit.qasm3.ExperimentalFeatures(*values)

GitHub

Basi: Flag

Flag per le caratteristiche sperimentali che l'esportatore OpenQASM 3 supporta.

Questi sono sperimentali e sono più suscettibili di modifiche, perché la specifica OpenQASM 3 non li ha ancora accettati formalmente, quindi la sintassi potrebbe non essere finalizzata.

SWITCH_CASE_V1

Valore predefinito: 1

Supporta l'esportazione delle dichiarazioni switch-case come proposto da https://github.com/openqasm/openqasm/pull/463 al commit bfa787aa3078.

Questi hanno il formato di uscita:

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

    case 2: {
        z $0;
    }
    break;

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

Questo differisce dalla sintassi dell'istruzione switch come stabilizzata. Se questo flag non viene passato, il parser produrrà l'output utilizzando la sintassi stabilizzata, che renderà lo stesso esempio precedente come:

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

Se si vogliono abilitare più funzioni sperimentali, si devono combinare i flag usando l'operatore | , come ad esempio flag1 | flag2.

Ad esempio, per eseguire un'esportazione utilizzando la semantica iniziale del supporto 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

Tutte le caratteristiche abilitate dai flag sperimentali sono naturalmente transitorie. Se dovesse essere necessario rimuovere i flag, essi saranno soggetti alla politica di deprezzamento standard di Qiskit. Lasceremo questi flag sperimentali per tutto il tempo ragionevole.

Tuttavia, non possiamo garantire alcuna finestra di supporto per i consumatori di codice OpenQASM 3 generato utilizzando questi flag sperimentali, se la specifica del linguaggio OpenQASM 3 cambia la proposta su cui si basa il flag. È possibile che qualsiasi strumento utilizzato per consumare il codice OpenQASM 3 creato con questi flag possa aggiornare o rimuovere il proprio supporto mentre Qiskit continua a offrire il flag. Non ci si deve affidare al codice sperimentale OpenQASM 3 per la memorizzazione a lungo termine dei programmi.

Importazione da OpenQASM 3

Attualmente vengono offerte solo due funzioni di alto livello, poiché il supporto di Qiskit per l'importazione da OpenQASM 3 è agli inizi e si prevede che l'implementazione cambierà in modo significativo. Le due funzioni sono load() e loads(), che sono le controparti dirette di dump() e dumps(), rispettivamente per caricare un programma indirettamente da un file nominato e direttamente da una stringa data.

Nota

Mentre siamo ancora nel periodo di rilascio esplorativo, per utilizzare una delle due funzioni è necessario installare il pacchetto qiskit_qasm3_import . Questo può essere fatto installando Qiskit con l'extra qasm3-import , ad esempio con:

pip install qiskit[qasm3-import]

Prevediamo che alla fine questa funzionalità sarà integrata in Qiskit e non richiederà più un'importazione opzionale, ma non abbiamo ancora una tempistica in merito.

load

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

GitHub

Caricare un programma OpenQASM 3 dal file filename.

Parametri

  • filename (str) – il nome del file da cui caricare il programma.
  • num_qubits (int | None) – che fornisce il numero di qubit fisici/virtuali.
  • annotation_handlers (dict[str, annotation.OpenQASM3Serializer] | None) – una mappatura le cui chiavi sono spazi dei nomi (genitori) e i cui valori sono serializzatori in grado di gestire gli spazi dei nomi figli di quelli indicati. Richiede qiskit_qasm3_import>=0.6.0.

Risultati

una rappresentazione circuitale del programma OpenQASM 3.

Tipo di restituzione

QuantumCircuit

Aumenti

QASM3ImporterError - se il file OpenQASM 3 non è valido o non può essere rappresentato da un file QuantumCircuit.

Aggiunto nella versione 2.1

L'argomento annotation_handlers . Ciò richiede qiskit_qasm3_import>=0.6.0.

loads

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

GitHub

Carica un programma OpenQASM 3 dalla stringa data.

Esempi

Carica una stringa OpenQASM3 in un circuito quantistico con/senza argomento 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

Parametri

  • program (str) – il programma OpenQASM 3.
  • num_qubits (int | None) – fornisce il numero di qubit fisici/virtuali.
  • annotation_handlers (dict[str, annotation.OpenQASM3Serializer] | None) – una mappatura le cui chiavi sono spazi dei nomi (genitori) e i cui valori sono serializzatori in grado di gestire gli spazi dei nomi figli di quelli indicati. Richiede qiskit_qasm3_import>=0.6.0.

Risultati

una rappresentazione circuitale del programma OpenQASM 3.

Tipo di restituzione

QuantumCircuit

Aumenti

Aggiunto nella versione 2.1

L'argomento annotation_handlers . Ciò richiede qiskit_qasm3_import>=0.6.0.

Entrambe queste due funzioni sollevano QASM3ImporterError in caso di fallimento.

QASM3ImporterError

exception qiskit.qasm3.QASM3ImporterError(*message)

GitHub

Basi: QASM3Error

È stato rilevato un errore durante l'importatore di OpenQASM 3.

Impostare il messaggio di errore.

Per esempio, possiamo definire un programma quantistico usando OpenQASM 3 e usare loads() per convertirlo direttamente in un programma 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")
Schema del circuito prodotto dal codice precedente.

Interfaccia di importazione sperimentale

Le funzioni di importazione fornite sopra si basano sul parser di riferimento basato su ANTLR dello stesso progetto OpenQASM, che è inteso più come un riferimento linguistico che come un parser performante. Per utilizzarla è necessario aver installato l'estensione qiskit-qasm3-import .

Qiskit sta sviluppando un parser nativo, scritto in Rust, che è disponibile come parte del pacchetto principale di Qiskit. Questo parser è ancora nelle prime fasi sperimentali, quindi manca di funzioni e la sua interfaccia sta cambiando e si sta espandendo, ma è tipicamente ordini di grandezza più performante per il sottoinsieme di OpenQASM 3 che attualmente supporta, e i suoi interni producono una migliore diagnostica degli errori sui fallimenti del parsing.

È possibile utilizzare immediatamente l'interfaccia sperimentale, con funzioni simili a quelle dell'interfaccia principale di cui sopra:

load_experimental

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

Caricare un programma OpenQASM 3 da un file sorgente in un file QuantumCircuit.

Avvertenza

Questa versione nativa dell'importatore di OpenQASM 3 è attualmente sperimentale. In genere è molto più veloce di load()ma ha un set di funzioni supportate ridotto, che si espanderà nel tempo.

Parametri

  • pathlike_or_filelike (str |os.PathLike |io.TextIOBase) – l'origine del programma. Può essere fornito come un percorso di file o come un oggetto di flusso di testo aperto. Se il flusso è già aperto, viene consumato nello spazio Python, mentre i nomi di file vengono aperti e consumati nello spazio Rust; le prestazioni potrebbero essere leggermente diverse, a seconda del sistema e di come i flussi sono bufferizzati di default.
  • custom_gates (Iterable[CustomGate]) – Python da utilizzare per particolari porte denominate. Se non vengono forniti, Qiskit utilizzerà i propri costruttori della libreria standard per le porte definite nel file OpenQASM 3.0 della libreria standard stdgates.inc.
  • include_path (Iterable[str]) – il percorso da cercare quando si risolvono le dichiarazioni di include . Se non viene indicato, Qiskit farà in modo che questo punti a una posizione contenente solo stdgates.inc . I percorsi vengono provati nell'ordine di sequenza.

Risultati

l'oggetto circuito costruito.

Tipo di restituzione

QuantumCircuit

Aumenti

.QASM3ImporterError - se si è verificato un errore durante il parsing o l'analisi semantica. In caso di errore di parsing, la maggior parte dei messaggi di errore viene stampata sul terminale e formattata, per una migliore leggibilità.

loads_experimental

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

Caricare un programma OpenQASM 3 da una stringa in un file QuantumCircuit.

Avvertenza

Questa versione nativa dell'importatore di OpenQASM 3 è attualmente sperimentale. In genere è molto più veloce di loads()ma ha un set di funzioni supportate ridotto, che si espanderà nel tempo.

Parametri

  • source (str) – il sorgente del programma in una stringa Python.
  • custom_gates (Iterable[CustomGate]) – Python da utilizzare per particolari porte denominate. Se non vengono forniti, Qiskit utilizzerà i propri costruttori della libreria standard per le porte definite nel file OpenQASM 3.0 della libreria standard stdgates.inc.
  • include_path (Iterable[str]) – il percorso da cercare quando si risolvono le dichiarazioni di include . Se non viene indicato, Qiskit farà in modo che questo punti a una posizione contenente solo stdgates.inc . I percorsi vengono provati nell'ordine di sequenza.

Risultati

l'oggetto circuito costruito.

Tipo di restituzione

QuantumCircuit

Aumenti

.QASM3ImporterError - se si è verificato un errore durante il parsing o l'analisi semantica. In caso di errore di parsing, la maggior parte dei messaggi di errore viene stampata sul terminale e formattata, per una migliore leggibilità.

Queste due funzioni sono entrambe sperimentali, cioè rilasciano un messaggio di errore ExperimentalWarning all'atto dell'utilizzo e le loro interfacce possono essere soggette a modifiche nell'ambito della serie di release di Qiskit 1.x. In particolare, il parser nativo può essere promosso a versione predefinita di load() e loads(). Se siete disposti ad accettare il rischio di utilizzare l'interfaccia sperimentale, potete disattivare l'avviso facendo:

import warnings
from qiskit.exceptions import ExperimentalWarning

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

Queste due funzioni consentono di specificare i percorsi di inclusione come iterabili di percorsi e di specificare i costruttori personalizzati di Python da utilizzare per particolari porte. Questi costruttori personalizzati sono specificati utilizzando l'opzione CustomGate oggetto:

CustomGate

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

Basi: object

Informazioni ricevute dallo spazio Python su come costruire un oggetto dello spazio Python per rappresentare un determinato gate che potrebbe essere dichiarato.

constructor

Un oggetto Python richiamabile che accetta num_params angoli come argomenti posizionali e restituisce un Gate oggetto che rappresenta il gate.

name

Il nome del cancello così come appare nel programma OpenQASM 3. Questo non è necessariamente identico al nome che Qiskit dà al cancello.

num_params

Il numero di parametri angolari che il gate richiede.

num_qubits

Il numero di qubit su cui agisce il gate.

Se non custom_gates viene specificato, Qiskit tenterà di utilizzare gli oggetti gate della propria libreria standard per i gate definiti nel file della libreria standard di OpenQASMstdgates.ince 3. Su questo modulo è disponibile la seguente sequenza di porte, qualora volessi utilizzarla come base:

qiskit.qasm3.STDGATES_INC_GATES

Una tupla di oggetti CustomGate che specifica i costruttori di Qiskit da usare per il file di inclusione stdgates.inc .

Questa pagina è stata utile?
Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.