Limiti

compute_forward_bounds(circuit, noise_model_paulis, /, observable, *, evolution_max_terms=1000000, eigval_max_qubits=14, atol=1e-08, atol_simplify=1e-08, atol_eigenvalue=1e-08, **kwargs)

Calcolare i limiti del commutatore a tempi disuguali ottenuti mediante evoluzione in avanti.

Partendo dalla fine del circuito, calcolare i limiti del commutatore a tempi disuguali ottenuti tramite evoluzione in avanti per tutti i termini di errore di Pauli di ciascun livello soggetto a rumore nel circuito di destinazione.

Cioè, calcolare $\| \left[ E_F, A_F \right] \|_2$ per tutti i termini di errore, $E_F$, dove $A_F$ è il valore target observable da misurare su circuit.

I termini di errore, $E_I$, sono determinati da noise_model_paulis. Questo dizionario associa gli identificatori dei modelli di rumore (samplomatic.InjectNoise.ref) a un elenco di termini di errore di Pauli. I termini corrispondenti verranno utilizzati ogni volta che, durante l'iterazione su, si incontrerà un BoxOp con un'annotazione InjectNoise corrispondente circuit.

Parametri

• circuit (QuantumCircuit) – il circuito di destinazione.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – i termini di errore di Pauli da considerare per ciascun modello di rumore.
• observable (Pauli |PauliList |SparseObservable |SparsePauliOp) – la grandezza osservabile da misurare alla fine del circuito.
• evolution_max_terms (int) – il numero massimo di termini dell'operatore da tenere sotto controllo durante l'evoluzione.
• eigval_max_qubits (int) – il numero massimo di qubit di un commutatore per i quali si tenterà comunque di calcolare l'autovalore. Quando questo valore viene superato, il limite viene approssimato tramite una disuguaglianza triangolare più semplice e meno rigorosa.
• atol (float) – USO OBSOLETO: usa e atol_simplify atol_eigenvalue al suo posto!
• atol_simplify (float) – la tolleranza assoluta utilizzata per l'eliminazione dei termini dal commutatore. Allentare questa tolleranza comporterà un maggiore troncamento dei termini del commutatore, rendendo il calcolo dei suoi autovalori più veloce ma meno accurato.
• atol_eigenvalue (float) – la tolleranza assoluta utilizzata per rilevare la convergenza dell'autovalore del commutatore. Allentando questa tolleranza, si otterrà un autovalore meno accurato, calcolato dall'algoritmo iterativo di Davidson per la risoluzione degli autovalori.
• kwargs – eventuali argomenti chiave aggiuntivi verranno inoltrati a compute_bounds().

Risultati

Il limite del commutatore a tempi disuguali.

Aumenti

NotImplementedError – quando il contiene observable più di un termine di Pauli. Se ti capita questa situazione, dovrai chiamare questa funzione separatamente per ciascun Pauli di destinazione.

Tipo di restituzione

dict [ str, PauliLindbladMap ]

tighten_with_speed_limit(bounds, circuit, noise_model_paulis, /, observable)

Restringere i limiti previsti applicando restrizioni alla velocità di propagazione delle informazioni.

Ispirata alle idee alla base dei limiti di Lieb-Robinson, questa funzione sfrutta i limiti alla velocità di propagazione dell’informazione per restringere i limiti del commutatore a tempi disuguali calcolati in precedenza mediante evoluzione in avanti (vedi anche compute_forward_bounds()).

Parametri

• bounds (dict[str, PauliLindbladMap]) – i limiti del commutatore a tempi disuguali, calcolati in precedenza mediante evoluzione in avanti.
• circuit (QuantumCircuit) – il circuito di destinazione.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – i termini di errore di Pauli da considerare per ciascun modello di rumore.
• observable (Pauli |PauliList |SparseObservable |SparsePauliOp) – la grandezza osservabile da misurare alla fine del circuito.

Risultati

Una versione più rigorosa dei limiti del commutatore a tempo diseguale.

Aumenti

• NotImplementedError – quando il contiene observable più di un termine di Pauli. Se ti capita questa situazione, dovrai chiamare questa funzione separatamente per ciascun Pauli di destinazione.
• ValueError – quando si incontra un gate che agisce su più di 2 qubit.

Tipo di restituzione

dict [ str, PauliLindbladMap ]

compute_backward_bounds(circuit, noise_model_paulis, /, *, evolution_max_terms=1000000, **kwargs)

Calcolare i limiti del commutatore a tempi disuguali ottenuti mediante evoluzione a ritroso.

A partire dall’inizio del circuito, calcolare i limiti del commutatore a tempi disuguali ottenuti tramite evoluzione a ritroso per tutti i termini di errore di Pauli di ciascun livello soggetto a rumore nel circuito di destinazione.

In altre parole, calcolare $\| \left[ E_I, \rho_I \right] \|_1$ (utilizzando la norma 1 di Schatten, nota anche come norma nucleare) per tutti i termini di errore, $E_I$, dove si ipotizza che $\rho_I$ sia lo stato tutto a zero, $\ket{0 \ldots 0}$, su tutti i qubit attivi in circuit.

I termini di errore, $E_I$, sono determinati da noise_model_paulis. Questo dizionario associa gli identificatori dei modelli di rumore (samplomatic.InjectNoise.ref) a un elenco di termini di errore di Pauli. I termini corrispondenti verranno utilizzati ogni volta che, durante l'iterazione su, si incontrerà un BoxOp con un'annotazione InjectNoise corrispondente circuit.

Parametri

• circuit (QuantumCircuit) – il circuito di destinazione.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – i termini di errore di Pauli da considerare per ciascun modello di rumore.
• evolution_max_terms (int) – il numero massimo di termini dell'operatore da tenere sotto controllo durante l'evoluzione. (Se l'operatore supera tale dimensione, i termini più piccoli vengono troncati).
• kwargs – eventuali argomenti chiave aggiuntivi verranno inoltrati a compute_bounds().

Risultati

I limiti del commutatore a tempo diseguale derivati a ritroso.

Tipo di restituzione

dict [ str, PauliLindbladMap ]

merge_bounds(circuit, forward_bounds, backward_bounds, /, noise_rates=None, *, is_clifford_circuit=False)

Unire i limiti anteriore e posteriore.

Il livello al quale avviene il passaggio dall'uso dei limiti posteriori a quello dei limiti anteriori sarà lo stesso per tutti i qubit. Viene determinato tenendo conto dei dati di addestramento forniti noise_rates. Se tali dati non vengono forniti, si ipotizzano livelli di rumore uniformi. Sebbene si tratti di un'ipotesi non realistica, potrebbe comunque essere utile visualizzare in anteprima i confini risultanti dalla fusione.

Parametri

• circuit (QuantumCircuit) – il circuito di destinazione.
• forward_bounds (dict[str, PauliLindbladMap] | None) – i limiti superiori (vedi anche compute_forward_bounds()).
• backward_bounds (dict[str, PauliLindbladMap] | None) – i limiti inferiori (vedi anche compute_backward_bounds()).
• noise_rates (dict[str, PauliLindbladMap | None] | None) – i livelli di rumore appresi sul backend di destinazione.
• is_clifford_circuit (bool) – se il circuito di destinazione sia interamente di Clifford.

Risultati

I limiti unificati.

Aumenti

• ValueError – quando entrambi i limiti specificati sono None.
• KeyError – quando i bounds contengono una chiave InjectNoise.modifier_ref che non compare nel di destinazione o circuit il cui non InjectNoise.ref viene trovato.
• ValueError – se i termini di Pauli del modello di rumore, i cui limiti sono calcolati per un dato, non InjectNoise.modifier_ref coincidono tra e forward_bounds backward_bounds.
• NotImplementedError – quando è is_clifford_circuit True.

Tipo di restituzione

dict [ str, PauliLindbladMap ] | None

compute_local_scales(circuit, bounds, /, noise_rates, *, sampling_cost_budget=inf, bias_tolerance=0.0)

Calcola l'argomento local_scales di un Samplex.

Questo parametro local_scales serve a specificare quali singoli termini di errore si desidera mitigare.

È bias_tolerance necessario specificare o o sampling_cost_budget . Il primo stabilisce un limite massimo per il costo di campionamento, mentre il secondo stabilisce un limite massimo per la distorsione residua tollerabile.

Parametri

• circuit (QuantumCircuit) – il circuito di destinazione.
• bounds (dict[str, PauliLindbladMap]) – i limiti del cono di luce ombreggiato.
• noise_rates (dict[str, PauliLindbladMap | None]) – i valori stimati dal modello di rumore.
• sampling_cost_budget (float) – il costo massimo di campionamento consentito.
• bias_tolerance (float) – il bias massimo tollerabile.

Risultati

• il local_scales dizionario da fornire come input diretto al samplomatic.samplex.Samplex.inputs().
• i costi generali di campionamento ( $\gamma^2$ ) necessari per eseguire il campionamento di local_scales.
• il bias residuo sui valori attesi calcolati con questi limiti.

Tipo di restituzione

Una tupla di lunghezza 3, i cui elementi sono

Aumenti

• ValueError – se per entrambi vengono specificati valori diversi da quelli predefiniti, il sampling_cost_budget e il bias_tolerance.
• KeyError – se noise_rates manca una voce relativa a un identificatore di modello di rumore (InjectNoise.ref) rilevato in circuit.

compute_bounds(circuit, noise_model_paulis, light_cone, norm_fn, *, backwards, max_num_boxes=None, num_processes=1, timeout=None)

Calcola i limiti disuguali del commutatore temporale.

Dato un circuito con BoxOp istruzioni con InjectNoise annotazioni e una mappatura degli identificatori del modello di rumore (InjectNoise.ref) su un elenco di termini di errore di Pauli (noise_model_paulis), questa funzione calcola i limiti del commutatore a tempo diseguale (i cui dettagli sono implementati da norm_fn). Nel farlo, prende in considerazione solo i gate che si trovano all’interno del cono di luce dell’osservabile (inizializzato da light_cone). Questi limiti calcolati costituiscono la base del cono di luce ombreggiato.

Poiché questa funzione esegue un calcolo di lunga durata, gestisce in modo corretto le eccezioni KeyboardInterrupt , consentendo all'utente di interrompere il calcolo in un momento qualsiasi e di ottenere comunque i risultati calcolati fino a quel momento.

Parametri

• circuit (QuantumCircuit) – il circuito di destinazione.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – i termini di errore di Pauli da considerare per ciascun modello di rumore.
• light_cone (LightCone) – il tracker LightCone inizializzato e con stato.
• norm_fn (Callable[[Pauli, RotationGates], CommutatorBounds]) – la funzione che implementa il commutatore a tempi disuguali specifico.
• backwards (bool) – se eseguire l'iterazione in circuit ordine inverso.
• max_num_boxes (int | None) – il numero massimo di caselle per le quali calcolare i limiti. Ai limiti di eventuali caselle aggiuntive verrà assegnato il valore limite superiore banale di $2.0$.
• num_processes (int) – il numero di processi paralleli da utilizzare.
• timeout (float | None) – un timeout facoltativo (in secondi) al termine del quale tutti i livelli rimanenti vengono riempiti con valori numerici banali pari a 2.0. Si noti che non si tratta di un timeout rigido e che il livello in fase di elaborazione al momento del raggiungimento di tale timeout verrà completato normalmente.

Risultati

I limiti calcolati per il commutatore a tempi disuguali.

Tipo di restituzione

dict [ str, PauliLindbladMap ]