Circuito DAG

Restituisce la sequenza corrente delle istanze registrate Clbit sotto forma di lista.

Risultati

La sequenza corrente di clbit registrati.

Tipo di restituzione

list(Clbit)

Restituisce il dict contenente i ClassicalRegisters nel circuito

Restituisce la durata totale del circuito, impostata da un passaggio del transpiler di pianificazione. La sua unità è specificata da unit

DEPRECATO da Qiskit 1.3.0 e sarà rimosso in Qiskit 3.0.0

Restituisce la fase globale del circuito.

Metadati del circuito

Nome del circuito. In genere, corrisponde al nome del sito QuantumCircuit da cui è stato generato il DAG.

Restituisce il numero di nodi nel dag.

Numero di tratti catturati tracciati dal circuito.

Numero di variabili classiche catturate e monitorate dal circuito.

Numero di tratti locali dichiarati tracciati dal circuito.

Numero di variabili locali classiche dichiarate e monitorate dal circuito.

Numero di variabili classiche in ingresso tracciate dal circuito.

Numero totale di tratti tracciati dal circuito.

Numero totale di variabili classiche tracciate dal circuito.

Restituisce il dict contenente i QuantumRegisters nel circuito

Restituisce la sequenza corrente delle istanze registrate Qubit sotto forma di lista.

Risultati

La sequenza attuale di qubit registrati.

Tipo di restituzione

list(Qubit)

Restituisce l'unità in cui è specificata la durata.

DEPRECATO da Qiskit 1.3.0 e sarà rimosso in Qiskit 3.0.0

Restituisce un elenco dei fili in ordine.

add_captured_stretch(stretch)

Aggiungere al circuito un tratto catturato.

Parametri

tratto - il tratto da aggiungere.

add_captured_var(var)

Aggiungere al circuito una variabile catturata.

Parametri

var - la variabile da aggiungere.

add_clbits(clbits)

Aggiungere i singoli fili del clbit.

add_creg(creg)

Aggiungere tutti i fili in un registro classico.

add_declared_stretch(stretch)

Aggiungere al circuito un tratto dichiarato.

Parametri

tratto - il tratto da aggiungere.

add_declared_var(var)

Aggiungere al circuito una variabile locale dichiarata.

Parametri

var - la variabile da aggiungere.

add_input_var(var)

Aggiungete una variabile di ingresso al circuito.

Parametri

var - la variabile da aggiungere.

add_qreg(qreg)

Aggiungere tutti i fili in un registro quantico.

add_qubits(qubits)

Aggiungere i fili dei singoli qubit.

ancestors(node)

Restituisce l'insieme degli antenati di un nodo come DAGOpNodes e DAGInNodes.

Gli antenati sono l'insieme di tutti i nodi che possono raggiungere il nodo di destinazione. Mentre l'elemento DAGCircuit.predecessors() contiene solo i predecessori immediati, gli antenati contengono ricorsivamente i predecessori di ciascun predecessore.

apply_operation_back(op, qargs=None, cargs=None, *, check=True)

Applicare un'operazione all'uscita del circuito.

Parametri

• op (qiskit.circuit.Operation) – l'operazione associata al nodo DAG
• qargs (tuple[Qubit]) – qubit a cui verrà applicata l'operazione
• cargs (tuple[Clbit]) – i bit a cui verrà applicata l'operazione
• check (bool) – Se True (impostazione predefinita), questa funzione garantirà il rispetto delle DAGCircuit invarianze della struttura dei dati (tutte qargs sono Qubit\ s, tutte sono nel DAG, ecc.). FalseIn tal caso, il chiamante dovrà garantire autonomamente il rispetto di tali invarianti, ma si eviterà il costo di diversi controlli. Ciò risulta particolarmente utile quando si crea un nuovo DAG a partire da una fonte di nodi di cui si è certi che funzionino correttamente.

Risultati

il nodo per l'operazione che è stata aggiunta al dag

Tipo di restituzione

DAGOpNode

Aumenti

DAGCircuitError – se un nodo foglia è collegato a più uscite

apply_operation_front(op, qargs=None, cargs=None, *, check=True)

Applicare un'operazione all'ingresso del circuito.

Parametri

• op (qiskit.circuit.Operation) – l'operazione associata al nodo DAG
• qargs (tuple[Qubit]) – qubit a cui verrà applicata l'operazione
• cargs (tuple[Clbit]) – i bit a cui verrà applicata l'operazione
• check (bool) – Se True (impostazione predefinita), questa funzione garantirà il rispetto delle DAGCircuit invarianze della struttura dei dati (tutte qargs sono Qubit\ s, tutte sono nel DAG, ecc.). FalseIn tal caso, il chiamante dovrà garantire autonomamente il rispetto di tali invarianti, ma si eviterà il costo di diversi controlli. Ciò risulta particolarmente utile quando si crea un nuovo DAG a partire da una fonte di nodi di cui si è certi che funzionino correttamente.

Risultati

il nodo per l'operazione che è stata aggiunta al dag

Tipo di restituzione

DAGOpNode

Aumenti

DAGCircuitError – se i nodi iniziali sono collegati a più archi in uscita

bfs_successors(node)

Restituisce un iteratore di tuple di (DAGNode, [DAGNodes]) dove DAGNode è il nodo corrente e [DAGNodes] è un elenco di successori in ordine BFS.

classical_predecessors(node)

Restituisce l'iteratore dei predecessori di un nodo che sono collegati da un bordo classico come DAGOpNodes e DAGInNodes.

classical_successors(node)

Restituisce l'iteratore dei successori di un nodo che sono collegati da un bordo classico come DAGOpNodes e DAGOutNodes.

collect_1q_runs()

Restituisce un insieme di corse non condizionate di nodi "op" 1q.

collect_2q_runs()

Restituisce un insieme di corse non condizionate di nodi "op" 2q.

collect_runs(namelist)

Restituisce un insieme di esecuzioni non condizionate di nodi "op" con i nomi indicati.

Ad esempio, "... h [q0]; cx [q0], [q1]; cx [q0], [q1]; h [q1];..." produrrebbe la tupla di nodi cx come elemento dell'insieme restituito da una chiamata a collect_runs( ["cx").] Se invece i nodi cx fossero "cx [q0], [q1]; cx [q1], [q0];", il metodo restituirebbe comunque la coppia in una tupla. L'elenco dei nomi può contenere nomi che non sono presenti nella base del circuito.

I nodi devono avere un solo successore per continuare la corsa.

compose(other, qubits=None, clbits=None, front=False, inplace=True, *, inline_captures=False)

Comporre il circuito other sull'uscita di questo circuito.

Un sottoinsieme di fili di ingresso di other è mappato su un sottoinsieme di fili di uscita di questo circuito.

other può essere più stretto o di pari larghezza rispetto a self.

Parametri

• other (DAGCircuit) – circuito per comporre con se stessi
• qubits (list[Qubit|int]) – qubit di sé su cui comporre.
• clbits (list[Clbit|int]) – frammenti di sé su cui comporre.
• front (bool) – Se il valore è True, verrà eseguita la composizione frontale (funzionalità non ancora implementata)
• inplace (bool) – Se Vero, modifica l'oggetto. Altrimenti restituire il circuito composto.
• inline_captures (bool) – Se True, le variabili contrassegnate come "catture" nel DAG other saranno inserite negli usi esistenti di quelle stesse variabili in self. Se False, tutte le variabili in other devono essere distinte da self, e saranno aggiunte a self.

Risultati

il dag composto (restituisce None se inplace==True).

Tipo di restituzione

DAGCircuito

Aumenti

DAGCircuitError – se other è più ampio o se sono presenti mappature di spigoli duplicate.

control_flow_op_nodes()

Ottenere un elenco di nodi "op" nel dag che contengono istruzioni di flusso di controllo.

Risultati

L'elenco dei nodi dag contenenti le operazioni del flusso di controllo.

Tipo di restituzione

elenco [ DAGOpNode ]

copy_empty_like(*, vars_mode=Ellipsis)

Restituisce una copia di self con la stessa struttura, ma vuota.

Tale struttura comprende:

• nome e altri metadati
• fase globale
• durata
• tutti i qubit e i clbit, compresi i registri.

Risultati

Una copia vuota di sé.

Tipo di restituzione

DAGCircuito

count_ops(*, recurse=True)

Conta le occorrenze dei nomi delle operazioni.

Parametri

recurse - se True (valore predefinito), ricorre nelle operazioni del flusso di controllo. In tutti i casi, viene contato solo il numero di volte in cui l'operazione compare in un possibile blocco; vengono contati entrambi i rami degli if, mentre i blocchi for e while vengono contati solo una volta.

Risultati

una mappatura dei nomi delle operazioni in base al numero di volte in cui compaiono.

Tipo di restituzione

Mappatura [str, int ]

count_ops_longest_path()

Conta le occorrenze dei nomi delle operazioni sul percorso più lungo.

Restituisce un dizionario di conteggi con chiave il nome dell'operazione.

depth(*, recurse=False)

Restituire la profondità del circuito. Se è presente un flusso di controllo, questo conteggio può essere solo una stima, poiché il percorso completo del flusso di controllo non può essere conosciuto staticamente.

Parametri

ricorsione – se True, allora si passa alla ricorsione nelle operazioni di flusso di controllo. I cicli "for" con iteratori di lunghezza nota vengono conteggiati come se il ciclo fosse stato srotolato manualmente ( ovvero con ogni iterazione del corpo del ciclo scritta esplicitamente). I blocchi if-else richiedono più tempo rispetto ai due rami. I cicli "while" vengono conteggiati come se il corpo del ciclo venisse eseguito una sola volta. Il valore predefinito è False e genera un'eccezione DAGCircuitError se è presente un flusso di controllo, per evitare che venga restituito silenziosamente un numero privo di senso.

Risultati

la profondità del circuito

Tipo di restituzione

int

Aumenti

• DAGCircuitError – se non è un grafo aciclico orientato
• DAGCircuitError – se in una chiamata ricorsiva è presente un flusso di controllo sconosciuto, oppure se in una chiamata non ricorsiva è presente un flusso di controllo qualsiasi.

descendants(node)

Restituisce l'insieme dei discendenti di un nodo come DAGOpNodes e DAGOutNodes.

I discendenti sono l'insieme di tutti i nodi raggiungibili dal nodo di destinazione. In confronto, DAGCircuit.successors() è un iteratore sui successori immediati, mentre questo metodo contiene tutti i successori dei successori.

draw(scale=0.7, filename=None, style='color')

Disegna il circuito dag.

Questa funzione richiede l'installazione di Graphviz. Graphviz non è un pacchetto python e non può essere installato da pip (il pacchetto graphviz su PyPI è una libreria di interfaccia Python per Graphviz e non installa effettivamente Graphviz). Per sapere come installarlo, si può consultare la documentazione di Graphviz.

Parametri

• scale (float) – fattore di scala
• filename (str) – percorso del file in cui salvare l'immagine (formato dedotto dal nome)
• style (str) – 'plain': Grafo B&W; 'color' (predefinito): colore dei nodi di input/output/op

Risultati

se nel notebook Jupyter e non si salva su file, altrimenti None.

Tipo di restituzione

Ipython.display.Image

edges(nodes=None)

Iteratore per i valori dei bordi con nodo di origine e di destinazione.

Funziona restituendo i bordi in uscita dai nodi specificati. Se non vengono specificati nodi, vengono restituiti tutti i bordi del grafo.

Parametri

nodes (DAGOpNode, DAGInNode, or DAGOutNode|list(DAGOpNode, DAGInNode, or DAGOutNode) – Un elenco di nodi o un singolo nodo di ingresso. Se non viene specificato nulla, tutti i bordi vengono restituiti dal grafo.

Attese

bordo -

il bordo come una tupla con il formato

(nodo di origine, nodo di destinazione, filo del bordo)

find_bit(bit)

Trova le posizioni nel circuito, mappando i Qubit e i Clbit in indici posizionali BitLocations è definito come: BitLocations = namedtuple( “BitLocations”, ("index", "registers"))

Parametri

bit (Bit) – La parte da individuare.

Risultati

Una 2-tupla. Il primo elemento (index)

contiene l'indice in cui è possibile trovare il sito Bit (in entrambi i formati qubits, clbits, a seconda del tipo). Il secondo elemento (registers) è un elenco di coppie (register, index) con una voce per ogni Register del circuito che contiene la Bit (e l'indice nella Register in cui si trova).

Tipo di restituzione

namedtuple(int, ListTuple [(Register, int)] )

Aumenti:

DAGCircuitError: Se l'indirizzo Bit fornito è di tipo sconosciuto. DAGCircuitError: Se non è stato possibile trovare il circuito Bit in dotazione.

front_layer()

Restituisce un elenco di nodi op nel primo livello di questo dag.

gate_nodes()

Ottenere l'elenco dei nodi gate nel dag.

Risultati

l'elenco di DAGOpNodes che rappresenta le porte.

Tipo di restituzione

elenco [ DAGOpNode ]

has_identifier(var)

Questo identificatore è presente nel DAG?

Parametri

var - l'identificatore o il nome da controllare.

has_stretch(stretch)

Questo tratto è presente nel DAG?

Parametri

var - il tratto o il nome da controllare.

has_var(var)

Questa variabile in tempo reale è presente nel DAG?

Parametri

var - la variabile o il nome da controllare.

idle_wires(ignore=None)

Ritorno dei fili del minimo.

Parametri

ignore (list(str)) – Elenco di nomi di nodi da ignorare. Predefinito: []

Attese

Bit - Bit nel filo del minimo.

Aumenti

DAGCircuitError – Se il DAG non è valido

is_empty()

Restituisce true se nel grafico non sono presenti nodi operativi.

is_predecessor(node, node_pred)

Controlla se un secondo nodo si trova tra i predecessori del nodo.

is_successor(node, node_succ)

Controlla se un secondo nodo è tra i successori del nodo.

iter_captured_stretches()

Iterabile sui tratti catturati tracciati dal circuito.

iter_captured_vars()

Iterabile sulle variabili classiche catturate e tracciate dal circuito.

iter_captures()

Iterabile su tutti gli identificatori catturati tracciati dal circuito.

iter_declared_stretches()

Iterabile sui tratti dichiarati tracciati dal circuito.

iter_declared_vars()

Iterabile sulle variabili classiche dichiarate tracciate dal circuito.

iter_input_vars()

Iterabile sulle variabili classiche di ingresso tracciate dal circuito.

iter_stretches()

Iterabile su tutti i tratti tracciati dal circuito.

iter_vars()

Iterabile su tutte le variabili classiche tracciate dal circuito.

layers(*, vars_mode=Ellipsis)

Restituisce una vista superficiale su un livello di questo DAGCircuit per tutti i d livelli di questo circuito.

Un livello è un circuito le cui porte agiscono su qubit disgiunti, ossia un livello ha profondità 1. Il numero totale di strati è uguale alla profondità d del circuito. Gli strati sono indicizzati da 0 a d-1, con lo strato più antico all'indice 0. Gli strati sono costruiti con un algoritmo greedy. Ogni livello restituito è un dict contenente {“graph”: circuit graph, “partition”: list of qubit lists}.

Il livello restituito contiene nuovi (ma semanticamente equivalenti) DAGOpNodes, DAGInNodes, e DAGOutNodes. Questi non sono gli stessi nodi del dag originale, ma sono equivalenti tramite DAGNode.semantic_eq ( node1, node2 ).

TODO: le porte che utilizzano gli stessi cbit finiranno in livelli diversi, come è attualmente implementato. Questo potrebbe non essere il comportamento desiderato.

longest_path()

Restituisce il percorso più lungo nel dag come elenco di DAGOpNodes, DAGInNodes, e DAGOutNodes.

make_physical(num_qubits=None)

Mettere self nella forma fisica canonica, con il numero di qubit dato.

Questo agisce in posizione e non ha bisogno di attraversare il DAG. È destinato all'uso quando si sa che il DAG rappresenta già un circuito fisico e si deve solo affermare che si tratta della forma fisica canonica.

In questo modo si cancellano tutte le informazioni sui qubit virtuali presenti nel file di configurazione DAGCircuit; se si utilizza questo metodo da soli, potrebbe essere necessario assicurarsi di aver creato e memorizzato un'apposita Layout. In effetti, si applica la disposizione "banale" che mappa il qubit virtuale 0 con il qubit fisico 0, e così via.

Parametri

num_qubits - se dato, il numero totale di qubit fisici nell'output; deve essere almeno pari al numero di qubit nel DAG. Se non viene indicato, il numero di qubit rimane invariato.

multi_qubit_ops()

Ottenere l'elenco delle operazioni a 3+ qubit. Ignorare le direttive come snapshot e barrier.

multigraph_layers()

Rendimento degli strati del multigrafo.

named_nodes(*names)

Ottiene l'insieme dei nodi "op" con il nome dato.

node(node_id)

Ottenere il nodo nel dag.

Parametri

node_id (int) – Identificatore del nodo.

Risultati

il nodo.

Tipo di restituzione

nodo

nodes()

Iteratore per i valori dei nodi.

Attese

nodo - il nodo.

nodes_on_wire(wire, only_ops=False)

Iteratore per i nodi che interessano un determinato filo.

Parametri

• wire (Bit) – il cavo da esaminare.
• only_ops (bool) – Vero se si vogliono solo i nodi ops; altrimenti, vengono restituiti tutti i nodi.

Attese

Iteratore - i nodi successivi sul filo dato

Aumenti

DAGCircuitError – se il cavo specificato non esiste nel DAG

num_blocks()

Restituisce il numero di blocchi di base presenti in questo circuito.

num_clbits()

Restituisce il numero totale di bit classici utilizzati dal circuito.

num_ops()

Ottenere il numero di nodi op nel DAG.

num_qubits()

Restituisce il numero totale di qubit utilizzati dal circuito. num_qubits() sostituisce l'uso precedente di width(). DAGCircuit.width () ora restituisce qubit + clbit per coerenza con Circuit.width () [qiskit-terra #2564].

num_tensor_factors()

Calcolare in quanti componenti può scomporsi il circuito.

op_nodes(op=None, include_directives=True)

Ottenere l'elenco dei nodi "op" nel dag.

Parametri

• op (Type) –qiskit.circuit.Operation sottoclasse dei nodi OP da restituire. Se None, restituisce tutti i nodi operativi.
• include_directives (bool) – includono la barriera, l'istantanea, ecc.

Risultati

l'elenco dei nodi dag contenenti l'opzione data.

Tipo di restituzione

elenco [ DAGOpNode ]

op_predecessors(node)

Restituisce l'iteratore dei predecessori "op" di un nodo nel dag.

op_successors(node)

Restituisce l'iteratore dei successori "op" di un nodo nel dag.

predecessors(node)

Restituisce l'iteratore dei predecessori di un nodo come DAGOpNodes e DAGInNodes.

properties()

Restituisce un dizionario di proprietà del circuito.

quantum_causal_cone(qubit)

Restituisce il cono causale di un qubit.

Il cono causale di un qubit è l'insieme dei qubit che possono influenzare l'uscita di quel qubit tramite interazioni, sia attraverso porte multi-qubit che operazioni. Conoscere il cono causale di un qubit può essere utile per il debug di circuiti difettosi, in quanto può aiutare a identificare il filo o i fili che possono causare il problema.

Questo metodo non considera alcuna dipendenza classica dai dati in DAGCircuit, i fili di bit classici sono ignorati ai fini della costruzione del cono causale.

Parametri

qubit (Qubit) – Il qubit di uscita per il quale vogliamo determinare il cono causale.

Risultati

L'insieme dei qubit le cui interazioni influenzano qubit.

Tipo di restituzione

Insieme [ Qubit ]

quantum_predecessors(node)

Restituisce l'iteratore dei predecessori di un nodo che sono collegati da un bordo quantico come DAGOpNodes e DAGInNodes.

quantum_successors(node)

Restituisce l'iteratore dei successori di un nodo che sono collegati da un bordo quantico come DAGOpNodes e DAGOutNodes.

remove_all_ops_named(opname)

Rimuove tutti i nodi operativi con il nome indicato.

remove_ancestors_of(node)

Rimuove tutti i nodi operativi antenati del nodo.

remove_clbits(*clbits)

Rimuovere i bit classici dal circuito. Tutti i bit DEVONO essere inattivi. Verranno rimossi anche tutti i registri con riferimenti ad almeno uno dei bit specificati.

Parametri

clbits (List[Clbit]) – Le parti da rimuovere.

Aumenti

DAGCircuitError – un clbit non è un Clbit, non fa parte del circuito o non è in stato di inattività.

remove_cregs(*cregs)

Rimuovere i registri classici dal circuito, lasciando i bit sottostanti al loro posto.

Aumenti

• DAGCircuitError – un "creg" non è un " ClassicalRegister, " né si trova in
• il circuito. -

remove_descendants_of(node)

Rimuove tutti i nodi operativi discendenti del nodo.

remove_nonancestors_of(node)

Rimuove tutti i nodi operativi non ancestrali del nodo.

remove_nondescendants_of(node)

Rimuove tutti i nodi operativi non discendenti del nodo.

remove_op_node(node)

Rimuovere un nodo operativo n.

Aggiungere bordi dai predecessori ai successori.

remove_qregs(*qregs)

Rimuovere i registri quantici dal circuito, lasciando i bit sottostanti al loro posto.

Aumenti

• DAGCircuitError – un qreg non è un “ QuantumRegister, ” oppure non si trova in
• il circuito. -

remove_qubits(*qubits)

Rimuovere i bit quantici dal circuito. Tutti i bit DEVONO essere inattivi. Verranno rimossi anche tutti i registri con riferimenti ad almeno uno dei bit specificati.

Parametri

qubits (List[Qubit]) – Le parti da rimuovere.

Aumenti

DAGCircuitError – un qubit non è un Qubit, non fa parte del circuito o non è inattivo.

replace_block_with_op(node_block, op, wire_pos_map, cycle_check=True)

Sostituire un blocco di nodi con un singolo nodo.

Viene utilizzato per consolidare un blocco di DAGOpNodes in un'unica operazione. Un esempio tipico è il consolidamento di un blocco di porte in un unico UnitaryGate che rappresenta la matrice unitaria del blocco.

Parametri

• node_block (List[DAGNode]) – Un elenco di nodi dag che rappresenta il blocco di nodi da sostituire
• op (qiskit.circuit.Operation) – L'operazione di sostituzione del blocco con
• wire_pos_map (Dict[Bit, int]) – Il dizionario che associa i bit alle rispettive posizioni nell'output qargs o cargs. Ciò è necessario per ricostruire l'ordine degli argomenti su più gate nel nodo combinato a operazione singola. Se a Bit non è presente nel dizionario, non verrà aggiunto agli argomenti; ciò può risultare utile quando si ha a che fare con operazioni di controllo del flusso che presentano bit intrinseci nei campi condition o target .
• cycle_check (bool) – Se impostato su True, questo metodo controlla se la sostituzione del node_block fornito con un singolo nodo introdurrebbe un ciclo (che invaliderebbe il DAGCircuit) e solleva un DAGCircuitError se viene introdotto un ciclo. Questo controllo comporta una penalità sul tempo di esecuzione. Se si può garantire che l'input node_block è un blocco contiguo e non introdurrà un ciclo quando viene contratto a un singolo nodo, si può impostare False per migliorare le prestazioni di runtime di questo metodo.

Aumenti

DAGCircuitError – se cycle_check è impostato su True e la sostituzione del blocco specificato introduce un ciclo, oppure se node_block è vuoto.

Risultati

Il nodo operativo che sostituisce il blocco.

Tipo di restituzione

DAGOpNode

reverse_ops()

Invertire le operazioni nel circuito self .

Risultati

il dag invertito.

Tipo di restituzione

DAGCircuito

separable_circuits(remove_idle_qubits=False, *, vars_mode=Ellipsis)

Decomporre il circuito in insiemi di qubit senza porte di collegamento.

Parametri

remove_idle_qubits (bool) – Flag che indica se rimuovere i qubit inattivi dai circuiti separati. Se False, ogni circuito di uscita conterrà lo stesso numero di qubit di self.

Risultati

I circuiti risultanti dalla separazione di self in set

di qubit disconnessi

Tipo di restituzione

Elenco [DAGCircuito ]

Ogni istanza DAGCircuit restituita da questo metodo conterrà lo stesso numero di clbit di self. Le informazioni globali sulla fase contenute in self non saranno mantenute nei sottocircuiti restituiti da questo metodo.

serial_layers(*, vars_mode=Ellipsis)

Ricavare un livello per tutte le porte di questo circuito.

Un livello seriale è un circuito con una porta. I livelli hanno la stessa struttura di layers().

size(*, recurse=False)

Restituisce il numero di operazioni. Se è presente un flusso di controllo, questo conteggio può essere solo una stima, poiché il percorso completo del flusso di controllo non può essere conosciuto staticamente.

Parametri

ricorsione – se True, allora si passa alla ricorsione nelle operazioni di flusso di controllo. I cicli "for" con iteratori di lunghezza nota vengono conteggiati nella forma "unrolled". I blocchi if-else sommano entrambi i rami. I cicli "while" vengono conteggiati come se il corpo del ciclo venisse eseguito una sola volta. Il valore predefinito è False e genera un'eccezione DAGCircuitError se è presente un flusso di controllo, per evitare di restituire silenziosamente un numero per lo più privo di significato.

Risultati

la dimensione del circuito

Tipo di restituzione

int

Aumenti

recurse=TrueDAGCircuitError – se in una chiamata con è presente un’incognita ControlFlowOp , oppure se in una chiamata non ricorsiva è presente un flusso di controllo.

structurally_equal(other)

Questi due DAG sono strutturalmente uguali?

Questa funzione restituisce true se le strutture del grafo sono esattamente uguali l'una all'altra, compresi gli indici dei nodi validi, gli ordini dei bordi e così via. Si tratta di un controllo molto più severo dell'equivalenza dei grafi ed è utile soprattutto per verificare se due DAGCircuit sono state costruite e manipolate esattamente nello stesso modo. Ad esempio, questo metodo può essere utilizzato per verificare se una sequenza di manipolazioni di un DAG è deterministica.

Questo metodo non prende in considerazione i metadati di tracciamento come metadata o namema considera molti dettagli di implementazione di basso livello della rappresentazione interna, molti dei quali non cambiano la semantica del circuito.

Questo metodo dovrebbe, in generale, essere molto più veloce dei controlli di equivalenza dei grafi, ma restituirà False in molte più situazioni. Questo metodo non dovrebbe mai restituire True quando un controllo di equivalenza del grafo restituirebbe False.

substitute_node(node, op, inplace=False, propagate_condition=None)

Sostituire un DAGOpNode con un'unica operazione. qarg, carg e condizioni per la nuova operazione saranno dedotti dal nodo da sostituire. La nuova operazione verrà verificata in modo che corrisponda alla forma dell'operazione sostituita.

Parametri

• node (DAGOpNode) – Nodo da sostituire
• op (qiskit.circuit.Operation) – L'istanza qiskit.circuit.Operation da aggiungere al DAG
• inplace (bool) – Opzionale, valore predefinito False. Se True, il nodo DAG esistente verrà modificato per includere op. Altrimenti, verrà utilizzato un nuovo nodo DAG.
• propagate_condition (bool) – DEPRECATA un'opzione legacy che controllava il comportamento della gestione del flusso di controllo. Non ha più alcun effetto, è stato lasciato per la retrocompatibilità. Verrà rimosso in Qiskit 3.0.

Risultati

il nuovo nodo contenente l'operazione aggiunta.

Tipo di restituzione

DAGOpNode

Aumenti

• DAGCircuitError – Se l'operazione di sostituzione fosse incompatibile con
• posizione ** del nodo di destinazione **. –

substitute_node_with_dag(node, input_dag, wires=None, propagate_condition=None)

Sostituire un nodo con dag.

Parametri

• node (DAGOpNode) – per sostituire il nodo
• input_dag (DAGCircuit) – che sostituirà il nodo
• wires (list[Bit] | Dict[Bit, Bit]) – fornisce un comando per i (qu)bit nel circuito di ingresso. input_dagSe si tratta di un elenco, i bit si riferiscono a quelli presenti nell'elenco, e l'ordine viene abbinato ai collegamenti del nodo prima in base a qargs, poi a cargs e infine alle condizioni. Se si tratta di un dizionario, allora una corrispondenza tra i input_dag bit in e quelli su cui agisce il node .
• propagate_condition (bool) – DEPRECATA un'opzione legacy che controllava il comportamento della gestione del flusso di controllo. Non ha più alcun effetto, è stato lasciato per la retrocompatibilità. Verrà rimosso in Qiskit 3.0.

Risultati

mappa gli ID dei nodi da input_dag alle loro nuove incarnazioni in self.

Tipo di restituzione

dict

Aumenti

DAGCircuitError – nel caso in cui si incontrino predecessori o successori inaspettati

successors(node)

Restituisce l'iteratore dei successori di un nodo come DAGOpNodes e DAGOutNodes.

swap_nodes(node1, node2)

Scambio di nodi connessi, ad esempio a causa della commutazione.

Parametri

• node1 (OpNode) – nodo predecessore
• node2 (OpNode) – nodo successore

Aumenti

DAGCircuitError – se uno dei due nodi non è un “ OpNode ” oppure se i nodi non sono collegati

to_circuit(*, copy_operations=True)

Converti questo DAG in un QuantumCircuit.

Si tratta di un semplice wrapper attorno a dag_to_circuit().

Parametri

copy_operations – se eseguire la copia profonda delle singole istruzioni. Se impostato su False, l'operazione è più economica ma le mutazioni alle istruzioni nel circuito influenzeranno il circuito originale.

Risultati

a QuantumCircuit che rappresenta questo stesso DAG.

topological_nodes(key=None, reverse=False)

Rendere i nodi in ordine topologico.

Parametri

• key (Callable) – Una callable che accetta un oggetto DAGNode e restituisce una chiave di ordinamento stringa. Se non viene specificato, i bit qarg e cargs di un nodo saranno utilizzati per l'ordinamento.
• reverse (bool) – Se vero, restituisce i nodi in ordine topologico inverso.

Risultati

nodo in ordine topologico

Tipo di restituzione

generatore (DAGOpNode, DAGInNode, o DAGOutNode )

topological_op_nodes(key=None, reverse=False)

Rendimento dei nodi op in ordine topologico.

Permesso di passare in chiave specifica per rompere i legami nell'ordine superiore

Parametri

• key (Callable) – Una callable che accetta un oggetto DAGNode e restituisce una chiave di ordinamento stringa. Se non viene specificato, per l'ordinamento verranno utilizzati i qarg e i carg di un nodo.
• reverse (bool) – Se vero, restituisce i nodi op in ordine topologico inverso.

Risultati

nodo op in ordine topologico

Tipo di restituzione

generatore( DAGOpNode )

two_qubit_ops()

Ottenere l'elenco delle operazioni a 2 qubit. Ignorare le direttive come snapshot e barrier.

width()

Restituisce il numero totale di qubit + clbit utilizzati dal circuito. Questa funzione in precedenza restituiva il numero di qubit con il calcolo return len( self._wires ) - self.num_clbits (), ma è stata modificata dal problema #2564 per restituire il numero di qubit + clbit con la nuova funzione DAGCircuit.num_qubits che sostituisce la precedente semantica di DAGCircuit.width ().