Note di rilascio di Qiskit SDK 2.0

---

2.0.3

Preludio

Qiskit v2.0.3 è una release di correzione di bug per la serie di versioni minori v2.0.

Correzioni di bug

• ApplyLayout ora gestirà correttamente il caso dell'applicazione di uno zero-qubit Layout. In precedenza, si affermava che non era stato impostato alcun layout, anche se il campo "layout" dell'oggetto PropertySet era uguale a Layout().

• È stato risolto un problema nel passaggio ElidePermutations in cui la permutazione in uscita non veniva aggiornata correttamente in presenza di operazioni PermutationGate operazioni. In questo modo si otterrebbe un circuito di uscita errato e l'impostazione di una proprietà virtual_permutation_layout errata nel sito property_set . Se eseguito come parte di un progetto più ampio PassManager questo risulterebbe anche in un'errata TranspileLayout nel circuito di uscita QuantumCircuit.layout nel circuito di uscita.

• Corretto un bug nel passaggio HighLevelSynthesis quando si srotolano oggetti annidati/personalizzati Instruction oggetti annidati/personalizzati. Se i dati QuantumCircuit restituito da Instruction.definition di un oggetto personalizzato contenesse qualsiasi oggetto Clbit questi bit classici utilizzerebbero erroneamente l'indice interno all'oggetto Instruction.definition QuantumCircuit invece di mapparli all'indice corrispondente nell'oggetto esterno QuantumCircuit.

• È stato risolto un bug nel menu PauliEvolutionSynthesisDefault e PauliEvolutionSynthesisRustiq che modificava l'attributo.synthesis del circuito originale quando si impostava preserve_order=False. Il comportamento dei plugin è stato ripristinato e il circuito originale è ora conservato in tutta la pipeline di transpilazione.

• È stato risolto un problema di compatibilità con la versione minima supportata di rustworkx, 0.15. Con determinati input i parametri VF2Layout e VF2PostLayout utilizzavano in precedenza un metodo rustworkx aggiunto in rustworkx 0.16.0, che causava un errore quando si utilizzava una vecchia versione di rustworkx, elencata come supportata.

• SabreLayout e SabreSwap non andrà più in panico quando si applica il risultato dell'instradamento a un circuito che usa expr.Var o Stretch in un ambito di flusso di controllo annidato.

• qiskit.circuit.library.quantum_volume() è stato aggiornato per gestire un parametro numpy.random.Generator come input per il suo argomento seed . In precedenza, un simile argomento generatore dava come risultato TypeError.

---

2.0.2

Preludio

Qiskit v2.0.2 è una release di correzione di bug per la serie di versioni minori v2.0.

Correzioni di bug

• È stato corretto l'attributo name della classe OrGate in modo che sia impostato su "or" per identificare in modo univoco questo gate. In precedenza era erroneamente impostato su "and" , il che rendeva impossibile distinguerlo da AndGate o far sì che i plugin di sintesi sintetizzassero un file OrGate.

• È stato risolto un problema nel passaggio ConsolidateBlocks in cui non riusciva a consolidare alcuni blocchi se il gate KAK selezionato (direttamente o tramite il target) era supercontrollato e non CXGate. Corretto #14413

• Corretto un bug nelle funzioni del circuito evolved_operator_ansatz(), qaoa_ansatz() e hamiltonian_variational_ansatz()in cui i parametri avevano una componente complessa pari a zero. In genere questo non è un problema, a meno che il parametro non sia stato tradotto in SymPy usando il metodo ParameterExpression.sympify() che avrebbe dato luogo a un errore.

---

2.0.1

Preludio

Qiskit v2.0.1 è una release di correzione di bug minori per la serie di release v2.0.x.

Correzioni di bug

• È stato risolto un bug di visualizzazione nel cassetto dei circuiti di testo in cui le operazioni di flusso di controllo post-traspilazione potevano avere la loro "parentesi" di chiusura resa verticalmente fuori ordine. Vedere #14271 per maggiori dettagli.

• Corretto un bug nel passaggio UnitarySynthesis in cui il passaggio ignorava il parametro synth_gates e sintetizzava solo le porte unitary . Il passaggio ora sintetizza correttamente tutti i gate specificati nel parametro synth_gates . Corretto #14343.

• Aggiunto il supporto mancante a repr per Duration.

• Aggiunto il supporto mancante per il decapaggio di Python di Duration. Questo impediva la trasposizione in parallelo di circuiti con delay() istruzioni che utilizzano espressioni di durata.

• È stato risolto un problema nel HighLevelSynthesis che causava l'erronea terminazione anticipata di alcuni circuiti con operazioni di flusso di controllo. Corretto #14338

• Fissata la costruzione di circuiti istantanei a tempo polinomiale quantistico (IQP) in IQP e da iqp(). L'implementazione precedente utilizzava erroneamente le potenze della porta $\sqrt{T}$ invece delle potenze della porta $T$.

• SabreLayout ora propagherà correttamente i valori di name e metadata quando viene eseguito come passaggio congiunto di layout e instradamento.

• È stato risolto un problema nel plugin SolovayKitaevSynthesis in cui l'esecuzione ripetuta del plugin con diverse porte di base riutilizzava erroneamente solo le porte di base della prima esecuzione. Questo problema era dovuto al fatto che si ignoravano le porte di base quando si memorizzavano le approssimazioni di base.

• È stato risolto un problema nel passaggio SolovayKitaev in cui il passaggio poteva bloccarsi a causa di una rotazione di 180 gradi nella ricorsione interna, che non veniva gestita correttamente.

• È stato risolto un problema nel passaggio SolovayKitaev in cui l'approssimazione generata poteva avere una fase che differiva di $\pi$ dal valore corretto. Ciò è dovuto alla rappresentazione interna $SO(3)$, che richiede una gestione aggiuntiva per ottenere il segno corretto della matrice di gate dei qubit. Corretto #9552

• I circuiti che contengono ritardi con allungamenti (vedi QuantumCircuit.add_stretch()) possono ora essere compilati con successo utilizzando i pass-manager preimpostati (transpile() e generate_preset_pass_manager()) quando si punta a un backend che ha vincoli di allineamento, ad esempio i dispositivi IBM Quantum Eagle come ibm_sherbrooke.

• L'euristica dell'errore di ripiego in VF2Layout e VF2PostLayoututilizzata quando non erano stati segnalati tassi di errore, poteva in precedenza assegnare errori maggiori di uno e avere effetti imprevedibili sui punteggi di layout risultanti.

---

2.0.0

Preludio

Siamo lieti di rilasciare Qiskit v2.0.0, con nuove funzionalità che ne migliorano le prestazioni e le capacità. Le caratteristiche principali di Qiskit v2.0.0 includono:

• L'introduzione di un' API C per la costruzione e l'interazione con gli oggetti SparseObservable oggetti. Questa prima interfaccia in linguaggio compilato rappresenta un'importante pietra miliare nell'evoluzione di Qiskit e la sua portata crescerà nel corso della serie di release v2.x. L'iterazione iniziale dell'API C è una funzione sperimentale e nelle versioni minori potrebbero essere apportate modifiche all'API seguendo la nostra strategia di versione.
• L'aggiunta di un nuovo BoxOp che si rifà al concetto di scatola di OpenQASM 3 e consente di raggruppare serie di istruzioni per un'elaborazione successiva e una programmazione personalizzata. Questo operatore è utile per applicazioni come il twirling, l'apprendimento del rumore e la programmazione basata sul tratto.
• La possibilità di creare durate stretch per le Delay istruzioni, che consentono di esprimere relazioni tra istruzioni consapevoli dei tempi. Il nuovo Stretch estende il sistema di espressione classico esistente, consentendo di catturare l'intento progettuale al momento della costruzione del circuito e di risolverlo al momento della compilazione. Per i dettagli, consultare la documentazione di OpenQASM.
• Sintesi migliorata quando un Target contiene porte a base frazionaria a due qubit con supporto per angoli arbitrari, come ad esempio RZXGate o RZZGateche riduce significativamente il numero di porte nei circuiti sintetizzati.
• Migliori prestazioni di runtime, in particolare durante la fase di costruzione del circuito, dove il benchmark mostra un aumento di velocità di 2x rispetto a Qiskit v1.3. Questo miglioramento si ottiene grazie a una combinazione di contributi, tra cui lo sfruttamento di ulteriori rappresentazioni native del gate di Rust, come ad esempio UnitaryGatee la rimozione degli elementi del modello di dati legacy.

In linea con la nostra politica di versionamento semantico, documentata al momento del rilascio di v1.0.0, questa major release include anche modifiche alle API che non sono retrocompatibili con la serie di release v1.x. In particolare, sono stati rimossi diversi componenti deprecati del modello di dati Qiskit, come il metodo .c_if() , il modulo qobj , BackendV1, e qiskit.pulse, nonché le implementazioni di riferimento primitive deprecate V1. Per maggiori dettagli su tutte queste rimozioni e modifiche dell'API, è possibile consultare le sezioni delle note di aggiornamento. Le API rimosse sono ancora supportate nella release di Qiskit v1.4.x che riceverà correzioni di bug per altri sei mesi e aggiornamenti di sicurezza per un anno.

Nuove funzioni

• Il supporto per la piattaforma Linux aarch64 è stato promosso a supporto di livello 1, come documentato nel documento:

  /guide/installazione-qiskit#supporto-sistema operativo

  dal precedente livello di supporto del livello 2 nella serie di rilasci v1.x.

• Introdotta una nuova API C per costruire e interagire con gli osservabili sparsi. Sebbene la superficie dell'API in questa release sia piuttosto ridotta - coprendo solo la classe SparseObservable rappresenta un'importante pietra miliare nell'evoluzione di Qiskit, in quanto è la prima volta che l'SDK espone un'interfaccia pubblica in C e pone le basi per futuri ampliamenti dell'interfaccia C di Qiskit. Trattandosi della prima interfaccia pubblica in C, si tratta di una funzione sperimentale e, se necessario, l'API può essere modificata in una versione minore.

  La sintassi dettagliata e ulteriori informazioni sono disponibili nella documentazione dell'API C. Un esempio minimo per costruire l'osservabile a 100-qubit 2 X0 Y1 Z2 è:

  #include <complex.h>
  #include <qiskit.h>
  #include <stdint.h>
  #include <stdio.h>
  
  int main(int argc, char *argv[]) {
      // build a 100-qubit empty observable
      uint32_t num_qubits = 100;
      QkObs *obs = qk_obs_zero(num_qubits);
  
      // add the term 2 * (X0 Y1 Z2) to the observable
      complex double coeff = 2;
      QkBitTerm bit_terms[3] = {QkBitTerm_X, QkBitTerm_Y, QkBitTerm_Z};
      uint32_t indices[3] = {0, 1, 2};
      QkObsTerm term = {coeff, 3, bit_terms, indices, num_qubits};
      qk_obs_add_term(obs, &term);
  
      // print some properties
      printf("num_qubits: %u\n", qk_obs_num_qubits(obs));
      printf("num_terms: %lu\n", qk_obs_num_terms(obs));
  
      // free the memory allocated for the observable
      qk_obs_free(obs);
  
      return 0;
  }

Caratteristiche dei circuiti

• Aggiunta una nuova get_control_flow_name_mapping() che restituisce una mappatura dei nomi delle operazioni del flusso di controllo di Qiskit alle classi corrispondenti.

  Utilizzo di esempio:

  from qiskit.circuit import get_control_flow_name_mapping
  
  ctrl_flow_name_map = get_control_flow_name_mapping()
  if_else_object = ctrl_flow_name_map["if_else"]
  
  print(if_else_object)

  <class 'qiskit.circuit.controlflow.if_else.IfElseOp'>

• Aggiunto un nuovo metodo di circuito, QuantumCircuit.estimate_duration()per stimare la durata di un circuito programmato dopo la transpilazione. La durata del circuito viene stimata trovando il percorso più lungo su un circuito programmato in base alle durate fornite da un dato Target. Questo metodo funziona solo per circuiti semplici che non contengono flussi di controllo o altre operazioni classiche di feed-forward.

  Utilizzare questo metodo invece dell'attributo deprecato QuantumCircuit.duration se si ha bisogno di una stima della durata dell'intero circuito.

  Utilizzo di esempio:

  from qiskit import QuantumCircuit, transpile
  from qiskit.providers.fake_provider import GenericBackendV2
  
  backend = GenericBackendV2(num_qubits=3, seed=42)
  
  circ = QuantumCircuit(3)
  circ.cx(0, 1)
  circ.measure_all()
  circ.delay(1e15, 2)
  
  circuit_dt = transpile(circ, backend, scheduling_method="asap")
  duration = circuit_dt.estimate_duration(backend.target, unit="s")
  print("Estimated duration: ", duration)

• Aggiunte due nuove classi: BitFlipOracleGate e PhaseOracleGate. BitFlipOracleGate è stato introdotto come alternativa alla sintesi diretta di BooleanExpression, che è stato rimosso in Qiskit v2.0. PhaseOracleGate è stato aggiunto come alternativa a PhaseOracle, dato che quest'ultimo sarà deprecato nel corso delle versioni di v2.x. Entrambe le classi condividono l'interfaccia di PhaseOracle, tranne che per il metodo evaluate_bitstring , che non è più presente.

  BitFlipOracleGate sintetizza un oracolo bit-flip invece di un oracolo phase-flip, ovvero agisce su un qubit aggiuntivo e può essere visto come l'applicazione di un'operazione controlled-X, dove il controllo è determinato dal valore dell'espressione codificata dall'oracolo.

  from qiskit import QuantumCircuit
  from qiskit.circuit.library.bit_flip_oracle import BitFlipOracleGate
  qc = QuantumCircuit(5)
  bool_expr = "(x0 & x1 | ~x2) & x4"
  oracle = BitFlipOracleGate(bool_expr)
  qc.compose(oracle, inplace=True)
  qc.draw('mpl')
  qc.decompose().draw('mpl')

  
  from qiskit import QuantumCircuit
  from qiskit.circuit.library.phase_oracle import PhaseOracleGate
  qc = QuantumCircuit(5)
  bool_expr = "(x0 & x1 | ~x2) & x4"
  oracle = PhaseOracleGate(bool_expr)
  qc.compose(oracle, inplace=True)
  qc.draw('mpl')
  qc.decompose().draw('mpl')

  

• Un nuovo flusso di controllo op, BoxOpe il suo metodo associato QuantumCircuit.box() e il gestore del contesto sono ora disponibili da qiskit.circuit.

  Il modo normale per costruire una casella è quello di utilizzare il gestore di contesto QuantumCircuit.box() gestore del contesto:

  from qiskit.circuit import QuantumCircuit
  
  qc = QuantumCircuit(5)
  
  with qc.box():
    # This box "uses" qubits 0 and 1.
    qc.x(0)
    qc.z(1)
  
  # Boxes can be assigned a duration.
  with qc.box(duration=100, unit="ms"):
    # This box "uses" qubits 2, 3 and 4.
    # Qubit 4 undergoes no operations.
    qc.cx(2, 3)
    qc.noop(4)

  La "scatola" di Qiskit si rifà quasi direttamente al concetto di scatola di OpenQASM 3.

  Tutti i qubit "utilizzati" dalla scatola sono sincronizzati all'inizio e alla fine della scatola. In altre parole, la scatola ha la stessa "durata" per ogni qubit che utilizza e i punti di partenza sono sincronizzati. Le altre operazioni con lo stesso ambito dell'operazione BoxOp vedono il riquadro come atomico; è valido commutare un'operazione oltre un intero riquadro se l'operazione commuta con l'azione dell'intero riquadro, ma non è generalmente valido spostare un'operazione dentro o fuori un riquadro.

  Gli usi principali di un box sono il raggruppamento di una serie di istruzioni per un'elaborazione successiva (come il raggruppamento di uno strato parziale di porte a due qubit) e la programmazione di un blocco composto in un unico ambito, utilizzando al contempo una programmazione relativa all'interno del blocco (come il disaccoppiamento dinamico di diversi qubit in un gruppo). Il compilatore di Qiskit non dispone ancora di passaggi incorporati che raggruppano le istruzioni o programmano le istruzioni con un BoxOp.

  Il transpiler supporta l'instradamento e il layout in presenza di box e ottimizza all'interno del box (fino all'impostazione optimization_level ), ma non esegue ancora ottimizzazioni intorno alla struttura atomica dei box. Il box di supporto per i cassetti dei circuiti basato su testo e Matplotlib. L'esportazione in QPY e in OpenQASM 3 è supportata, anche se OpenQASM 3 non ha attualmente la possibilità di designare i qubit inattivi all'interno di un box (si prevede che una modifica delle specifiche lo aggiungerà nel prossimo futuro: si veda la relativa proposta di funzionalità ).

• Aggiunto un nuovo argomento approximation_degree a CommutationChecker.commute() e CommutationChecker.commute_nodes(). Questo argomento consente di impostare la soglia di approssimazione per la valutazione delle porte come pendolari. Per ulteriori informazioni, consultare la documentazione di CommutationChecker per ulteriori informazioni.

• Aggiunto un nuovo metodo di circuito, QuantumCircuit.noop()che consente di contrassegnare esplicitamente i qubit come utilizzati all'interno di un ambito del costruttore di flussi di controllo senza aggiungere un'operazione corrispondente.

• Il modulo classico delle espressioni in tempo reale qiskit.circuit.classical può ora rappresentare espressioni costanti. La classe Expr ha ora un attributo booleano const che indica la costanza dell'espressione. Questo ci permette di imporre che le espressioni in determinati contesti debbano poter essere valutate in tempo di compilazione.

  Tutte le Var sono considerate non costanti, mentre tutte le espressioni Value sono costanti.

  Un'espressione composta solo da altre espressioni const è anch'essa const:

  from qiskit.circuit.classical import expr
  
  assert expr.bit_and(5, 6).const

  Un'espressione che contiene un'espressione non-const è non-const:

  from qiskit.circuit.classical import expr, types
  
  assert not expr.bit_and(5, expr.Var.new("a", types.Uint(5)).const

• Il modulo classico delle espressioni in tempo reale qiskit.circuit.classical può ora rappresentare le durate utilizzando il nuovo tipo Duration.

  Il modulo qiskit.circuit ha anche una nuova classe Duration che può essere utilizzata come valore letterale all'interno di espressioni classiche.

  La funzione lift() può essere utilizzata per creare un'espressione di valore a partire da un'istanza Duration istanza:

  from qiskit.circuit import Duration
  from qiskit.circuit.classical import expr
  
  expr.lift(Duration.dt(1000))
  # Value(Duration.dt(1000), Duration())

• Il modulo classico delle espressioni in tempo reale qiskit.circuit.classical può ora rappresentare IEEE-754 valori in virgola mobile a doppia precisione utilizzando il nuovo tipo Float.

  La funzione lift() può essere utilizzata per creare un'espressione di valore a partire da un float Python :

  from qiskit.circuit.classical import expr
  
  expr.lift(5.0)
  # >>> Value(5.0, Float())

  Questo tipo è destinato principalmente all'uso in espressioni legate alla tempistica (duration e stretch). Non è compatibile con le operazioni bitwise o logiche, anche se può essere utilizzata con queste ultime se prima vengono esplicitamente trasformate in qualcos'altro.

• Riduzione del numero di porte a due equbit nella decomposizione di porte unitarie a singolo equbit a controllo multiplo. Ad esempio:

  • Per il controllo multiplo YGate su 10 qubit, il CXGate è stato ridotto del 56%.
  • Per il controllo multiplo HGate su 10 qubit, il CXGate è stato ridotto del 56%.
  • Per i sistemi multicontrollo SXGate e SXdgGate su 10 qubit, il CXGate è stato ridotto dell'80%.
  • Per il controllo multiplo UGate su 10 qubit, il CXGate è stato ridotto del 31%.

• Il modulo classico delle espressioni in tempo reale qiskit.circuit.classical può ora rappresentare operazioni aritmetiche add(), sub(), mul(), e div() su operandi numerici e temporali.

  Ad esempio:

  from qiskit.circuit import QuantumCircuit, ClassicalRegister, Duration
  from qiskit.circuit.classical import expr
  
  # Subtract two integers
  cr = ClassicalRegister(4, "cr")
  qc = QuantumCircuit(cr)
  with qc.if_test(expr.equal(expr.sub(cr, 2), 3)):
      pass
  
  # Multiply a Duration by a Float
  with qc.if_test(expr.less(expr.mul(Duration.dt(200), 2.0), Duration.ns(500))):
      pass
  
  # Divide a Duration by a Duration to get a Float
  with qc.if_test(expr.greater(expr.div(Duration.dt(200), Duration.dt(400)), 0.5)):
      pass

  Per ulteriori esempi, si veda la documentazione a livello di modulo linkata sopra.

• Il costruttore per UCGate ha ora un nuovo argomento opzionale, mux_simp, che assume un valore booleano che abilita la ricerca delle semplificazioni di Carvalho et al. Questa ottimizzazione, abilitata per impostazione predefinita, identifica e rimuove i controlli non necessari dal multiplexer, riducendo il numero di porte CX e la profondità del circuito, in particolare nella preparazione a stati separabili con Initialize.

• Il PauliEvolutionGate ora supporta nativamente SparseObservablecome input. Ciò consente di gestire in modo efficiente l'evoluzione sotto proiettori, che sono implementati come controlli di una rotazione di fase e richiedono meno porte rispetto all'espansione esplicita del proiettore in termini di Paulis. Ad esempio:

  from qiskit.circuit.library import PauliEvolutionGate
  from qiskit.quantum_info import SparseObservable
  
  obs = SparseObservable("001")
  evo_proj = PauliEvolutionGate(obs, time=1)
  print(evo_proj.definition.draw())

• Un nuovo nodo di espressione Stretch è stato aggiunto al sistema di espressione classico per rappresentare le variabili di stretch . Per creare una nuova variabile stretch , si può usare QuantumCircuit.add_stretch(). L'espressione risultante è un'espressione costante di tipo Durationche può essere usata come argomento duration di un'espressione di tipo delay().

  Ad esempio, per garantire che una sequenza di varchi tra due barriere sia allineata a sinistra, indipendentemente dalla loro durata effettiva, si può procedere come segue:

  from qiskit import QuantumCircuit
  from numpy import pi
  
  qc = QuantumCircuit(5)
  qc.barrier()
  qc.cx(0, 1)
  qc.u(pi/4, 0, pi/2, 2)
  qc.cx(3, 4)
  
  a = qc.add_stretch("a")
  b = qc.add_stretch("b")
  c = qc.add_stretch("c")
  
  # Use the stretches as Delay duration.
  qc.delay(a, [0, 1])
  qc.delay(b, 2)
  qc.delay(c, [3, 4])
  qc.barrier()

  L'espressione Stretch è molto simile all'espressione esistente Var utilizzata per rappresentare le variabili classiche in un circuito, tranne per il fatto che è costante ed è sempre di tipo Duration. Può essere utilizzato in altre espressioni (ad esempio, è possibile moltiplicarlo per una costante numerica) e QuantumCircuit fornisce un supporto completo per lo scoping (ad esempio, può essere catturato da o dichiarato all'interno di un ambito del flusso di controllo).

  Per ulteriori contesti ed esempi, consultare le specifiche del linguaggio OpenQASM 3.

• Aggiunte Gate versioni delle porte aritmetiche a registro singolo che permettono al transpiler di eseguire ottimizzazioni di alto livello rispetto alle loro QuantumCircuit varianti. E sono i seguenti:

  • ExactReciprocalGate (sostituendo ExactReciprocal)
  • IntegerComparatorGate (sostituendo IntegerComparator)
  • LinearPauliRotationsGate (sostituendo LinearPauliRotations)
  • PiecewiseLinearPauliRotationsGate (sostituendo PiecewiseLinearPauliRotations)
  • PiecewiseChebyshevGate (sostituendo PiecewiseChebyshev)
  • PiecewisePolynomialPauliRotationsGate (sostituendo PiecewisePolynomialPauliRotations)
  • PolynomialPauliRotationsGate (sostituendo PolynomialPauliRotations)
  • LinearAmplitudeFunctionGate (sostituendo LinearAmplitudeFunction)
  • QuadraticFormGate (sostituendo QuadraticForm)
  • WeightedSumGate (sostituendo WeightedAdder)

Caratteristiche primitive

• Aggiunto un nuovo metodo to_bool_array() alla classe BitArray che restituisce l'array di bit come array booleano NumPy. L'argomento order può essere utilizzato per specificare l'endianness della matrice di output.

Funzionalità dei fornitori

• Aggiunta la possibilità di impostare la proprietà dt di GenericBackendV2 nell'inizializzatore della classe con un nuovo argomento dt . Utilizzo di esempio:

  from qiskit.providers.fake_provider import GenericBackendV2
  
  backend = GenericBackendV2(
    num_qubits = 5,
    basis_gates = ["cx", "id", "rz", "sx", "x"],
    dt = 2.22*e-10,
    seed = 42
  )

Caratteristiche dell'informazione quantistica

• Aggiunto un nuovo metodo SparseObservable.to_sparse_list() per ottenere una rappresentazione a liste rade di un oggetto SparseObservable. Ad esempio:

  from qiskit.quantum_info import SparseObservable
  
  obs = SparseObservable.from_list([("+II", 1), ("-II", 1)])
  print(obs.to_sparse_list())  # [("+", [2], 1), ("-", [2], 1)]

• Aggiunto un nuovo SparseObservable.as_paulis() per esprimere un'osservabile rada solo in termini di Paulis, espandendo tutti i proiettori. Ad esempio:

  from qiskit.quantum_info import SparseObservable
  
  obs = SparseObservable("+-")
  obs_paulis = obs.as_paulis()  # 1/4 ( II + XI - IX - XX )

• Qiskit v2.0.0 supporta la costruzione di un oggetto SparsePauliOp da un elemento SparseObservable utilizzando il nuovo metodo SparsePauliOp.from_sparse_observable(). È importante ricordare che SparseObservable possono rappresentare in modo efficiente i proiettori, che richiedono un numero esponenziale di termini nella formula SparsePauliOp.

• SparseObservable supporta ora la composizione di operatori utilizzando il metodo compose() in modo simile a quello di altre classi quantum_info classi. Si tratta di un metodo analogo alla moltiplicazione di matrici, ma completamente privo di matrici.

• SparseObservable.BitTerm ha un nuovo attributo, labelche contiene la stringa di un solo carattere Python usata per rappresentare il termine nelle etichette delle stringhe.

• Il metodo StabilizerState.expectation_value() può ora accettare un operatore di tipo SparsePauliOp.

Caratteristiche della sintesi

• Aggiunta una nuova TwoQubitControlledUDecomposer che decompone qualsiasi unitario a due-qubit in termini di porte frazionarie a due-qubit di base, come ad esempio RZZGate (o porte a due qubit localmente equivalenti a RZZGatefino a porte a un qubit).

  Ad esempio:

  from qiskit.circuit.library import RZZGate
  from qiskit.synthesis import TwoQubitControlledUDecomposer
  from qiskit.quantum_info import random_unitary
  
  unitary = random_unitary(4, seed=1)
  decomposer = TwoQubitControlledUDecomposer(RZZGate, euler_basis="ZXZ")
  circ = decomposer(unitary)
  circ.draw(output='mpl')

• Il passaggio synth_cnot_depth_line_kms() è stato portato in Rust e i benchmark preliminari indicano un fattore di accelerazione pari a 20x.

• Il passaggio synth_cx_cz_depth_line_my() è stato portato in Rust e i benchmark preliminari indicano un fattore di accelerazione pari a 70x.

• Aggiunta di funzioni di sintesi synth_integer_comparator_2s() e synth_integer_comparator_greedy() per la compilazione di porte che implementano un confronto tra numeri interi, come ad esempio IntegerComparatorGate. I corrispondenti plugin di sintesi ad alto livello sono IntComparatorSynthesis2s e IntComparatorSynthesisNoAux. Per consentire al compilatore di selezionare la decomposizione ottimale in base ai qubit ausiliari disponibili, usare IntComparatorSynthesisDefault.

• Aggiunto synth_weighted_sum_carry() per sintetizzare gli oggetti WeightedSumGate oggetti. Questo è attualmente l'unico metodo di sintesi disponibile per WeightedSumGatecon il corrispondente plugin di sintesi di alto livello WeightedSumSynthesisDefault.

Funzionalità del transpiler

• È stato aggiunto il supporto per lavorare con Target che contengono porte di base a due qubit che contengono angoli arbitrari, come ad esempio RZZGate, al passaggio di ConsolidateBlocks al passaggio del transpiler. Il passaggio precedente non stimava correttamente il numero di porte necessarie per una decomposizione, con il risultato che i blocchi non venivano consolidati laddove UnitarySynthesis potrebbe ottimizzare il blocco. Internamente, la stima del numero di porte viene effettuata utilizzando la classe TwoQubitControlledUDecomposer classe.

  Ad esempio:

  from qiskit import QuantumCircuit
  from qiskit.transpiler import generate_preset_pass_manager
  from qiskit.transpiler.passes import ConsolidateBlocks
  
  qc = QuantumCircuit(2)
  qc.rzz(0.1, 0, 1)
  qc.rzz(0.2, 0, 1)
  # basis_gates contains fractional gate (rzz)
  consolidate_pass = ConsolidateBlocks(basis_gates=["rz", "rzz", "sx", "x", "rx"])
  block = consolidate_pass(qc)  # consolidate the circuit into a single unitary block
  block.draw(output='mpl')
  
  pm = generate_preset_pass_manager(
      optimization_level=2, basis_gates=["rz", "rzz", "sx", "x", "rx"]
  )
  tqc = pm.run(qc)  # synthesizing the circuit into basis gates
  tqc.draw(output='mpl')

• È stato aggiunto il supporto per le porte a base frazionaria a due qubit, come ad esempio RZZGate, al passaggio UnitarySynthesis al passaggio del transpiler. La decomposizione viene effettuata utilizzando la funzione TwoQubitControlledUDecomposere supporta sia le porte di base standard che quelle personalizzate.

  Ad esempio:

  from qiskit import QuantumCircuit
  from qiskit.quantum_info import random_unitary
  from qiskit.transpiler.passes import UnitarySynthesis
  from qiskit.converters import circuit_to_dag, dag_to_circuit
  
  unitary = random_unitary(4, seed=1)
  qc = QuantumCircuit(2)
  qc.append(unitary, [0, 1])
  dag = circuit_to_dag(qc)
  
  # basis_gates contains fractional gate (rzz)
  circ = UnitarySynthesis(basis_gates=['rzz', 'rx', 'rz']).run(dag)
  dag_to_circuit(circ).draw(output='mpl')

• Aggiunto un nuovo passaggio del transpiler, LightConeche restituisce la lightcone di un circuito quando si misura un sottoinsieme di qubit o una specifica stringa di Pauli.

  Ad esempio, per il seguente circuito:

  

  l'esecuzione del passaggio eliminerebbe le porte che non influiscono sul risultato:

  from qiskit.transpiler.passes.optimization.light_cone import LightCone
  from qiskit.transpiler.passmanager import PassManager
  from qiskit.circuit import QuantumCircuit
  
  qc = QuantumCircuit(3,1)
  qc.h(range(3))
  qc.cx(0,1)
  qc.cx(2,1)
  qc.h(range(3))
  qc.measure(0,0)
  
  pm = PassManager([LightCone()])
  new_circuit = pm.run(qc)
  new_circuit.draw("mpl")

  

• Aggiunto un nuovo argomento max_block_width alla classe BlockCollector e alle classi CollectLinearFunctions e CollectCliffords del transpiler. Questo argomento consente di limitare il numero massimo di qubit su cui viene definito un blocco di nodi.

  Ad esempio:

  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler.passes import CollectLinearFunctions
  
  qc = QuantumCircuit(5)
  qc.h(0)
  qc.cx(0, 1)
  qc.cx(1, 2)
  qc.cx(2, 3)
  qc.cx(3, 4)
  
  # Collects all CX-gates into a single block 
  qc1 = CollectLinearFunctions()(qc)
  qc1.draw(output='mpl')
  
  # Collects CX-gates into two blocks of width 3 
  qc2 = CollectLinearFunctions(max_block_width=3)(qc)
  qc2.draw(output='mpl')

• Aggiunta una nuova opzione, collect_from_back, al passaggio di transpiler CollectMultiQBlocks al passaggio del transpiler. Quando è impostato su True, i blocchi vengono raccolti nella direzione inversa, dalle uscite verso gli ingressi del circuito. I blocchi sono ancora riportati secondo il normale ordine topologico. Ciò comporta un'ulteriore flessibilità del passaggio e ulteriori opportunità di ottimizzazione se combinato con un metodo di risintesi del circuito.

• Aggiunto un nuovo argomento approximation_degree a CommutationAnalysis. Questo argomento consente di impostare la soglia di approssimazione per la valutazione delle porte in base alla commutazione. Per ulteriori informazioni, consultare la documentazione della classe.

• Un nuovo transpiler pass, ContractIdleWiresInControlFlowè disponibile in qiskit.transpiler.passes. Questo passaggio rimuove i qubit dai blocchi di flusso di controllo se la semantica lo consente e se il qubit rimane inattivo durante l'operazione di flusso di controllo. In precedenza, la fase di routing dei gestori dei passaggi prestabiliti poteva rimuovere i qubit inattivi come effetto collaterale involontario del funzionamento dei passaggi. Ora questo comportamento viene gestito correttamente come parte di un passaggio di ottimizzazione.

• È stato aggiunto un nuovo stadio plugin di routing "default" . In Qiskit v2.0.0, questo è semplicemente un alias del precedente default "sabre". L'algoritmo di base predefinito potrebbe cambiare nel corso della serie di release di Qiskit v2.x per alcuni o tutti i target, ma è sempre possibile impostare esplicitamente routing_method="sabre" per mantenere il comportamento attuale.

• Aggiunta di una nuova fase del plugin di traduzione "default" . In Qiskit v2.0.0 è un alias del precedente default "translator". L'algoritmo di base predefinito può cambiare nel corso della serie Qiskit 2.x per alcuni o tutti i target, ma è sempre possibile impostare esplicitamente translation_method="translator" per mantenere il comportamento attuale.

• Il passaggio HighLevelSynthesis sintetizza ora oggetti di tipo AnnotatedOperation attraverso l'interfaccia del plugin.

• PassManager.run() accetta ora un argomento property_set , che può essere impostato su un oggetto Mapping-per fornire i valori iniziali degli oggetti della pipeline PropertySet. Questo può essere usato per ricominciare una compilazione parzialmente applicata o per riutilizzare alcune analisi di una compilazione precedente in una nuova posizione.

• La programmazione passa PadDelay e PadDynamicalDecoupling hanno ora nuovi argomenti nei loro costruttori: target e durations. Vengono utilizzati per specificare l'opzione Target o InstructionDurations rispettivamente. Per accedere alle durate delle istruzioni durante l'esecuzione del passaggio, è necessario uno degli argomenti.

• Aggiunto un nuovo metodo seconds_to_dt() alla classe Target della classe. Viene utilizzato per tradurre una durata in secondi in un numero di passi temporali discretizzati della risoluzione temporale del sistema specificata nell'attributo Target.dt specificato nell'attributo. Questo è tipicamente utile per convertire il valore InstructionProperties.duration in unità di dt.

• Il Split2QUnitaries il passaggio del transpiler è stato aggiornato per gestire il caso in cui l'unitario in esame può essere scritto come un SwapGate e due porte a singolo qubit. In questo caso, divide l'unitario e applica anche lo swapping virtuale, in modo simile a quanto avviene in ElidePermutations. Questa funzionalità può essere controllata con un nuovo argomento, split_swap, nel costruttore di :class`.Split2QUnitaries`, che può essere utilizzato per disabilitare la divisione di porte equivalenti allo scambio.

Varie Funzioni

• qiskit.utils contiene ora delle utility che permettono di controllare e verificare meglio le impostazioni di Qiskit per la multiprocessing parallelizzazione di Qiskit. In particolare, è possibile utilizzare should_run_in_parallel() per chiedere se parallel_map() (e i gestori di passaggi) lanceranno sottoprocessi per input adeguati e utilizzare il gestore di contesto should_run_in_parallel.override() per sovrascrivere temporaneamente la maggior parte della configurazione del sistema e dell'utente intorno a questa decisione.

  Una funzione aggiuntiva, default_num_processes()legge il numero massimo predefinito di sottoprocessi che Qiskit utilizzerà per il parallelismo basato sui processi.

• Una nuova variabile d'ambiente, QISKIT_IGNORE_USER_SETTINGS, controlla se leggere o meno il file delle impostazioni utente su import qiskit. Se impostato sulla stringa true, il file delle impostazioni non verrà letto. Questo è utile per isolare alcune istanze di Qiskit dall'ambiente di sistema, ad esempio per i test.

Note sull'aggiornamento

• Qiskit v2.0 ha abbandonato il supporto per Linux i686 e Windows a 32 bit. A partire da Qiskit v2.0.0, per eseguire Qiskit è necessaria una piattaforma a 64 bit. Questo è in linea con la tendenza della comunità scientifica di Python e consente a Qiskit di concentrarsi sul miglioramento delle prestazioni per l'hardware di calcolo quantistico sempre più complesso.

  Qiskit v1.4 continuerà a supportare le piattaforme a 32 bit fino alla fine del ciclo di vita (settembre 2025), ma a partire da questa release 2.0.0, Qiskit non pubblicherà più i binari precompilati per queste piattaforme e non offre alcuna garanzia di successo per la compilazione dei sorgenti su piattaforme a 32 bit.

• La versione minima supportata di Rust per costruire Qiskit dai sorgenti è ora v1.79. È stata aumentata rispetto a v1.70, la precedente versione minima supportata di Rust nella serie di release di Qiskit v1.x.

• Qiskit Pulse è stato completamente rimosso in questa versione, in seguito alla sua deprecazione in Qiskit v1.3. Questo include tutti i file del modulo impulsi, la funzionalità di visualizzazione degli impulsi, il supporto per la serializzazione e la deserializzazione di ScheduleBlock e pulse-gate in QPY, la gestione delle calibrazioni in QuantumCircuit, Target e DAGCircuite i backend falsi basati sugli impulsi. Per maggiori dettagli sui componenti rimossi relativi agli impulsi, vedere le sezioni corrispondenti di seguito.

  Si noti che la migrazione di Pulse a Qiskit Dynamics, come previsto inizialmente dopo la deprecazione di Pulse, è stata sospesa a causa delle priorità di sviluppo di Qiskit Dynamics. Gli utenti che desiderano utilizzare Qiskit Pulse come frontend per i backend di supporto o in altri casi d'uso possono continuare a utilizzarlo nelle versioni di Qiskit precedenti a v2.0.0, che includono la funzionalità Pulse.

• Le funzioni sequence e schedule del modulo compiler sono state rimosse in seguito alla loro deprecazione in Qiskit v1.3. Si basavano sulla possibilità di tradurre i circuiti in componenti a impulsi utilizzando le definizioni di backend, una capacità che non è più presente. Per questo motivo sono stati rimossi senza alcuna proposta alternativa. Si noti che queste rimozioni riguardano il pacchetto Pulse, che viene rimosso anche in Qiskit 2.0.

Note sull'aggiornamento dei circuiti

• Bit e Register e le loro sottoclassi non sono più garantite come comparabili utilizzando i controlli di is , a causa delle conversioni da e verso Python che possono riallocare ogni istanza esposta a Python.

• Bit e Register (e le loro sottoclassi) non possono più essere sottoclassificati. Questo non è mai stato inteso come un comportamento supportato e ciò causerebbe un comportamento non specificato in Qiskit. Non è più possibile farlo come dettaglio di implementazione delle classi.

• Non è più possibile creare istanze della base Bit e Register e delle classi. L'istanziazione diretta di queste classi era chiaramente documentata come qualcosa di non supportato e la possibilità di farlo era solo un artefatto di implementazione della gerarchia delle classi nelle versioni precedenti. A partire da Qiskit v2.0.0 non è più possibile farlo.

• Il modulo qiskit.circuit.classicalfunction è stato rimosso in seguito alla sua deprecazione in Qiskit v1.4. Questo include la classe ClassicalFunction , la funzione correlata classical_function e la classe BooleanExpression . Questa modifica è stata apportata per rimuovere la dipendenza dalla libreria tweedledum , che non è più compatibile con tutte le piattaforme e le versioni di Python supportate da Qiskit. ClassicalFunction era utilizzato esclusivamente in PhaseOracleche è stato aggiornato per accettare solo espressioni in formato string (vedere la nota di rilascio seguente). BooleanExpression è stata sostituita dalla nuova classe BitFlipOracleGate classe.

• La classe PhaseOracle non dipende più dalla libreria tweedledum , poiché la dipendenza non viene mantenuta attivamente. L'interfaccia è stata semplificata: non accetta più il parametro synthesizer e il parametro expression può essere solo una stringa. Il tipo ClassicalFunction precedentemente accettato, deprecato in Qiskit v1.4, è stato rimosso in Qiskit v2.0.

  Nonostante questi aggiornamenti, l'uso standard della classe PhaseOracle rimane invariato:

  from qiskit.circuit.library.phase_oracle import PhaseOracle
  bool_expr = "(x0 & x1 | ~x2) & x4"
  oracle = PhaseOracle(bool_expr)
  oracle.draw('mpl')

  

  Si noti che questa modifica può influire sull'efficacia della sintesi, ma era necessaria per la compatibilità con tutte le piattaforme e le versioni di Python supportate da Qiskit.

• Aggiornata la metrica utilizzata per verificare le commutazioni in CommutationChecker. Si presume che due porte si commutino se la fedeltà media della porta di commutazione è superiore a (1 - 1e-12). Questo valore è stato scelto per tenere conto degli errori di arrotondamento nel calcolo della fedeltà e per coerenza con i dati di RemoveIdentityEquivalent e TwoQubitWeylDecomposition. Per ulteriori informazioni, consultare la documentazione della classe.

• Il metodo QuantumCircuit.measure_active() ha cambiato il nome del registro classico che crea, poiché il nome precedente era in conflitto con una parola riservata OpenQASM . Invece di measure, ora si chiama meas, allineandosi al nome del registro utilizzato da measure_all().

• Il metodo DAGCircuit.control_flow_op_nodes() è stato aggiornato per restituire sempre un elenco, anche se vuoto. In precedenza, restituiva None se era vuoto e non restituiva mai un elenco vuoto, il che richiedeva una gestione speciale. Se avete bisogno di testare esplicitamente la vacuità sia in Qiskit v1.x che in v2.x, potete farlo:

  control_flow_nodes = dag.control_flow_op_nodes()
  if not control_flow_nodes:
      # There are no control-flow nodes.
      pass

• BlueprintCircuit.copy_empty_like() restituisce ora un circuito vuoto QuantumCircuit con lo stesso numero di qubit e clbit e gli stessi metadati del circuito originale, invece di un BlueprintCircuit. Questa modifica risolve un comportamento imprevisto per cui, trattando una copia "vuota" di un circuito blueprint, i dati del circuito venivano ricostruiti. Si noti che BlueprintCircuit.copy() restituisce comunque un BlueprintCircuit. Sebbene BlueprintCircuit non sia una classe pubblica, in quanto è un tipo interno usato per costruire le voci legacy di qiskit.circuit.library questo ha un impatto sulle sue sottoclassi come NLocal e ZZFeatureMap. Per un elenco completo delle classi interessate da questa modifica, consultare la pagina qiskit.circuit.library per un elenco completo delle classi interessate da questa modifica. Corretto #13535

• La funzione interna qiskit.circuit.add_control.add_control è stata rimossa. Questa funzione non faceva parte dell'API pubblica, aveva precondizioni fragili da rispettare ed era una fonte comune di bug. Gli usi di add_control(SomeGate(...), ...) dovrebbero essere modificati in SomeGate(...).control(...) usando Gate.control() che è molto più sicuro.

• Il metodo ParameterExpression.sympify() può ora sollevare un'eccezione MissingOptionalLibrary se sympy non è installato. Nelle versioni di Qiskit v1.x, l'installazione di sympy era sempre garantita, ma a partire da v2.0.0 questo non è più un requisito fondamentale e può essere necessario solo se si utilizza questo metodo. Poiché questa funzionalità richiede esplicitamente sympy , è necessario assicurarsi di avere installato sympy per utilizzare il metodo.

• L'argomento deprecato DAGNode dag è stato rimosso dalla classe DAGNode e dalle sue sottoclassi: DAGOpNode, DAGOutNode, e DAGInNode.

  Il parametro dag era un argomento opzionale per la costruzione di questi oggetti, ma è stato inutilizzato e ignorato dalla versione v1.3 e deprecato dalla versione v1.4.

• I seguenti QuantumCircuit metodi:

  • cast
  • cbit_argument_conversion
  • cls_instances
  • cls_prefix
  • qbit_argument_conversion

  sono stati rimossi, in seguito alla loro deprecazione in Qiskit 1.2. Questi metodi erano funzioni interne di aiuto e non sono mai stati concepiti come API pubbliche. Non è prevista alcuna sostituzione.

• Gli attributi deprecati per Instruction e Gateduration e unit sono stati rimossi, pertanto non è più possibile impostare gli argomenti unit o duration per qualsiasi classe o sottoclasse qiskit.circuit.Instruction o sottoclasse. Questi attributi sono stati deprecati in Qiskit v1.3.0 e venivano utilizzati per associare una durata di esecuzione personalizzata e un'unità per tale durata a una singola istruzione. Tuttavia, la fonte di verità della durata di un cancello è la BackendV2 Targetche contiene la durata di ogni istruzione supportata dal backend. La durata di un'istruzione non è tipicamente regolabile dall'utente ed è una proprietà immutabile del backend. Se in precedenza si è utilizzata questa funzionalità per sperimentare diverse durate del gate, è possibile modificare il campo InstructionProperties.duration in un dato campo Target per impostare una durata personalizzata per un'istruzione su un backend. (L'unità di misura è sempre in secondi nel campo Target.)

• L'attributo deprecato per qiskit.circuit.Instruction e Gate: condition è stato rimosso. Questa funzionalità è stata sostituita dalla classe IfElseOp che può essere utilizzata per descrivere una condizione classica in un circuito. Questo attributo è stato deprecato nella versione v1.3.0.

• I metodi deprecati per Instruction e Gate: c_if e condition_bits sono stati rimossi. Questi metodi sono stati deprecati nella versione v1.3.0. Questa funzionalità è stata sostituita dalla classe IfElseOp che può essere utilizzata per descrivere una condizione classica in un circuito. Ad esempio, un circuito che in precedenza utilizzava Instruction.c_if() come:

  from qiskit.circuit import QuantumCircuit
  
  qc = QuantumCircuit(2, 2)
  qc.h(0)
  qc.x(0).c_if(0, 1)
  qc.z(1.c_if(1, 0)
  qc.measure(0, 0)
  qc.measure(1, 1)

  Può essere riscritto come:

  qc = QuantumCircuit(2, 2)
  qc.h(0)
  with expected.if_test((expected.clbits[0], True)):
      qc.x(0)
  with expected.if_test((expected.clbits[1], False)):
      qc.z(1)
  qc.measure(0, 0)
  qc.measure(1, 1)

• Il metodo deprecato InstructionSet.c_if è stato rimosso. Questo metodo è stato deprecato nella versione 1.3.0. Questa funzionalità è stata sostituita dalla classe IfElseOp che può essere utilizzata per descrivere una condizione classica in un circuito.

• Come parte della rimozione di Pulse in Qiskit v2.0.0, la proprietà calibrations è stata rimossa dall'elemento QuantumCircuit, DAGCircuit e DAGDependency e alle classi. Inoltre, il metodo has_calibration_for è stato rimosso dagli elementi QuantumCircuit e DAGCircuit e add_calibration è stato rimosso da QuantumCircuit.

• Il modulo qiskit.circuit.classicalfunction è stato rimosso. Questo modulo dipendeva dalla libreria tweedledum che non è compatibile con le nuove versioni di Python. In alternativa, gli elementi PhaseOracleGate e BitFlipOracleGate possono essere utilizzate per generare circuiti da espressioni booleane.

• La rappresentazione interna di UnitaryGate quando viene aggiunto a un elemento QuantumCircuit è cambiata. L'oggetto memorizzato nel circuito non avrà più necessariamente un riferimento comune con l'oggetto aggiunto al circuito. Questo comportamento non è mai stato garantito e la mutazione dell'oggetto UnitaryGate direttamente o per riferimento era sempre scorretto e rischiava di danneggiare il circuito, soprattutto quando si modificava la matrice. Se è necessario mutare un elemento del circuito (operazione sconsigliata perché inefficiente e soggetta a errori), si può fare qualcosa come:

  from qiskit.circuit import QuantumCircuit
  from qiskit.quantum_info import random_unitary
  from qiskit.circuit.library import UnitaryGate
  import numpy as np
  
  qc = QuantumCircuit(2)
  qc.unitary(np.eye(2, dtype=complex))
  
  new_op = UnitaryGate(random_unitary(2))
  qc.data[0] = qc.data[0].replace(operation=new_op)

  Questo vale anche per DAGCircuit, ma si può usare DAGCircuit.substitute_node() al suo posto.

• L'attributo CircuitInstruction.params per un elemento CircuitInstruction che contiene un elemento UnitaryGate per il suo operation non conterrà più la matrice unitaria sottostante per il gate. Questo perché la rappresentazione interna del gate non tratta più l'oggetto matrice come un parametro. Se è necessario accedere alla matrice del cancello, è possibile farlo tramite il tasto CircuitInstruction.matrix o il campo UnitaryGate.params del campo CircuitInstruction.operation.

Note sull'aggiornamento delle primitive

• Come conseguenza della rimozione del modello BackendV1 , i valori di BackendSamplerV2 e BackendEstimatorV2 non accettano più ingressi di tipo BackendV1 nei loro argomenti di ingresso backend .

• Sono state rimosse le implementazioni primitive di V1 e gli alias di tipo V1-exclusive non convertiti, deprecati in Qiskit v1.2. Queste interfacce sono state sostituite dalle loro controparti V2. La rimozione include le seguenti classi che implementano le interfacce di V1 :

  • Estimator, a favore dell'equivalente V2, StatevectorEstimator
  • Sampler, a favore dell'equivalente V2, StatevectorSampler
  • BackendEstimator, a favore dell'equivalente V2, BackendEstimatorV2
  • BackendSampler, a favore dell'equivalente V2, BackendSamplerV2

  Oltre ai seguenti alias di tipo non aggiornato:

  • BaseEstimator, alias per BaseEstimatorV1
  • BaseSampler, alias per BaseSamplerV1

  Questa rimozione NON riguarda le definizioni delle interfacce astratte BaseEstimatorV1 e BaseSamplerV1 , esplicitamente modificate, né le relative classi di risultati e lavori, che sono state mantenute per mantenere la compatibilità all'indietro. Se si utilizza un alias non versionato di V1-type, come BaseEstimator, è possibile sostituirlo direttamente con il tipo versionato (BaseEstimatorV1).

  Inoltre, sono state eliminate le seguenti funzioni di utilità. Queste funzioni sono state utilizzate solo nelle implementazioni di Primitive V1 :

  • init_circuit: per inizializzare un circuito a partire da un Statevector, utilizzare QuantumCircuit.initialize() al suo posto.
  • init_observable: utilizzare il costruttore di SparsePauliOp al suo posto.
  • final_measurement_mapping: utilizzare QuantumCircuit.layout() e SparsePauliOp.apply_layout() per regolare un operatore per un layout. Altrimenti, utilizzare mthree.utils.final_measurement_mapping. Per maggiori dettagli, vedere le funzioni di utilità di Mthree.

Note sull'aggiornamento dei provider

• Il metodo configuration di BasicSimulator è stato rimosso in seguito alla sua deprecazione in Qiskit v1.3. Questo metodo restituisce un'istanza di BackendConfiguration , una classe che faceva parte del flusso di lavoro interrotto di BackendV1 e che è stata rimossa anche in Qiskit v2.0.0. I singoli elementi di configurazione possono ora essere recuperati direttamente dal backend o dall'istanza contenuta Target (backend.target).

• Il metodo run_experiment di BasicSimulator è stato rimosso. Questo metodo prendeva come argomento di input un'istanza della classe QasmQobjExperiment , una classe che è stata deprecata da Qiskit v1.2 ed è stata rimossa con il flusso di lavoro Qobj in Qiskit v2.0.0.

• Il modello BackendV1 è stato rimosso in seguito alla sua deprecazione in Qiskit 1.2.0. Questo include la classe BackendV1 e i relativi moduli e utilità, poiché sono stati sostituiti dal modello BackendV2 modello. L'elenco degli articoli rimossi comprende:

  • BackendV1 classe: il nucleo del modello rimosso

  • Tutti gli elementi di qiskit/providers/models, in quanto utilizzati per rappresentare i componenti del modello BackendV1 :

    • BackendConfiguration
    • BackendProperties
    • BackendStatus
    • QasmBackendConfiguration
    • PulseBackendConfiguration
    • UchannelLO
    • GateConfig
    • PulseDefaults
    • PulseQobjDef
    • Command
    • GateProperties
    • Nduv
    • JobStatus: Questa classe è stata sostituita dalla più utilizzata JobStatus
    • PulseDefaults

  • BackendV2Converter classe: utilizzata per convertire da BackendV1 a BackendV2

  • convert_to_target funzione: utilizzata per costruire un'istanza Target dai componenti legacy di BackendV1 (come BackendConfiguration o BackendProperties)

  • BackendPropertyError e BackendConfigurationError: eccezioni legate alle classi rimosse

• Il BasicSimulator non può più simulare il flusso di controllo classico. Supportava solo l'uso di .c_if()/.condition per la modellazione del flusso di controllo, ma questa costruzione è stata ora rimossa dal modello di dati di Qiskit.

• Tutte le false classi di backend basate sul deprecato BackendV1 sono state rimosse dal modulo providers.fake_provider del modulo. Queste classi sono state deprecate a partire da Qiskit 1.2 e facevano parte del flusso di lavoro deprecato BackendV1 . Il loro uso nei test è stato sostituito dalla classe GenericBackendV2 che permette di creare istanze personalizzate di BackendV2 che implementano una simulazione di BackendV2.run(). La rimozione riguarda:

  • Classi base:

    • FakeBackend
    • FakePulseBackend
    • FakeQasmBackend

  • Backend falsi per scopi speciali di test:

    • Fake1Q
    • FakeOpenPulse2Q
    • FakeOpenPulse3Q

  • Backend legacy falsi:

    • Fake5QV1
    • Fake20QV1
    • Fake7QPulseV1
    • Fake27QPulseV1
    • Fake127QPulseV1

• Nell'ambito della rimozione degli impulsi in Qiskit v2.0.0, sono stati rimossi i seguenti metodi:

  • qiskit.providers.BackendV2.instruction_schedule_map
  • qiskit.providers.BackendV2.drive_channel
  • qiskit.providers.BackendV2.measure_channel
  • qiskit.providers.BackendV2.acquire_channel
  • qiskit.providers.BackendV2.control_channel

• Come parte della rimozione degli impulsi in Qiskit v2.0.0, il supporto per gli impulsi è stato rimosso da GenericBackendV2. Questo include la possibilità di inizializzare il backend con calibrazioni personalizzate (argomentocalibrate_instructions ) e attributi del canale degli impulsi (drive_channel, measure_channel, acquire_channel, control_channel).

• Rimosse le classi base astratte Provider e ProviderV1, che sono state deprecate da Qiskit v1.1.0. L'astrazione fornita da queste definizioni di interfaccia non offriva un valore significativo, includendo solo gli attributi name, backends e un metodo get_backend() .

  Un rovider, come concetto, continuerà a esistere come una collezione di backend. Se si sta implementando un provider, si può modificare il codice semplicemente rimuovendo ProviderV1 come classe padre della propria implementazione.

  Come parte di questa modifica, probabilmente si vorrà aggiungere un'implementazione di get_backend per la compatibilità all'indietro. Ad esempio:

  def get_backend(self, name=None, **kwargs):
    backend = self.backends(name, **kwargs)
    if len(backends) > 1:
      raise QiskitBackendNotFoundError("More than one backend matches the criteria")
    if not backends:
      raise QiskitBackendNotFoundError("No backend matches the criteria")
    return backends[0]

Note sull'aggiornamento QPY

• La funzione qpy.load() può ora sollevare un'eccezione MissingOptionalLibrary se viene passato un payload QPY v10, v11 o v12 che utilizza le espressioni simboliche symengine e symengine non è installato. L'eccezione viene sollevata anche se sympy non è installato per qualsiasi altro payload QPY precedente a v13. Nelle versioni di Qiskit v1.x, symengine e sympy erano sempre garantiti per l'installazione. Tuttavia, a partire da v2.x questo non è più un requisito fondamentale e può essere necessario solo se si sta deserializzando un file QPY generato con symengine. Il parsing di questi payload QPY richiede symengine , poiché il suo utilizzo fa parte delle specifiche di formato per i QPY v10, v11 e v12. Se il carico utile lo richiede, l'installazione di una versione compatibile di symengine (0.11.0 o 0.13.0) è l'unica opzione. Allo stesso modo, sympy è stato utilizzato per la ParameterExpression per la codifica di tutte le versioni di QPY da 1 a 12.

• La versione minima di compatibilità con QPY, QPY_COMPATIBILITY_VERSIONè stata portata da 10 (il requisito della release v1.x ) a 13. Questa versione controlla la versione minima di QPY che può essere emessa dalla funzione qpy.dump() funzione. Ciò significa che qpy.dump() può emettere solo QPY v13 e v14 in questa versione. QPY v13 è ancora compatibile con Qiskit v1.3.x e v1.4.x, il che significa che i payload generati in Qiskit v2.x con QPY v13 possono essere caricati con la serie di release Qiskit v1.x.

  Questa modifica si è resa necessaria perché le versioni 10-12 di QPY richiedono le librerie sympy o symengine per generare la serializzazione degli oggetti ParameterExpression ma in Qiskit 2.x nessuna delle due librerie è richiesta per gli oggetti ParameterExpression oggetto.

• Con la rimozione di pulse in Qiskit v2.0.0, è stato rimosso il supporto per la serializzazione dei programmi ScheduleBlock tramite la funzione qiskit.qpy.dump() è stato rimosso. Gli utenti possono comunque caricare payload contenenti porte ad impulsi utilizzando la funzione qiskit.qpy.load() ma saranno trattati come istruzioni personalizzate opache. Il caricamento dei payload di ScheduleBlock non è più supportato e causerà un'eccezione QpyError eccezione.

Note sull'aggiornamento della sintesi

• L'argomento atomic_evolution richiamabile di ProductFormula (e le sue sottoclassi QDrift, LieTrotter, e SuzukiTrotter ) ha una nuova firma di funzione. La vecchia firma prendeva un operatore di Pauli e un coefficiente temporale e restituiva il circuito di evoluzione:

  def atomic_evolution(pauli_op: SparsePauliOp, time: float) -> QuantumCircuit:
    evol_circuit = QuantumCircuit(pauli_op.num_qubits)
    # append operators to circuit
    return evol_circuit

  La nuova firma prende direttamente in considerazione un circuito esistente e deve aggiungere a questo circuito l'evoluzione del Pauli fornito e del tempo dato:

  def atomic_evolution(evol_circuit: QuantumCircuit, pauli_op: SparsePauliOp, time: float):
    # append operators to circuit, in-place modification

  Questa nuova implementazione offre prestazioni nettamente migliori.

Note sull'aggiornamento del transpiler

• Aumento della soglia minima per l'assunzione dell'identità dei gate in RemoveIdentityEquivalent da epsilon macchina a 1e-12 per tenere conto degli errori di arrotondamento nel calcolo della fedeltà e per coerenza con le altre classi, come ad esempio CommutationAnalysis e TwoQubitWeylDecomposition.

• Il nome d 'arte del plugin di routing default è ora riservato all'omonimo plugin integrato in Qiskit.

• La fase predefinita del plugin di routing è ora "default". In Qiskit v2.0.0, questo è semplicemente un alias del precedente default "sabre". L'algoritmo di base predefinito potrebbe cambiare nel corso della serie di release di Qiskit v2.x per alcuni o tutti i target, ma è sempre possibile impostare esplicitamente routing_method="sabre" per mantenere il comportamento attuale.

• Il nome d'arte del plugin di traduzione default è ora riservato all'omonimo plugin integrato in Qiskit.

• La fase predefinita del plugin di traduzione è ora "default". In Qiskit 2.0, questo è semplicemente un alias del precedente default "translator". L'algoritmo di base predefinito può cambiare nel corso della serie Qiskit 2.x per alcuni o tutti i target, ma è sempre possibile impostare esplicitamente translation_method="translator" per mantenere il comportamento attuale.

• I passaggi di schedulazione precedenti ASAPSchedule, ALAPSchedule, DynamicalDecoupling e AlignMeasures sono stati eliminati a favore delle alternative aggiornate ALAPScheduleAnalysis, ASAPScheduleAnalysis, PadDynamicalDecoupling, e ConstrainedReschedule rispettivamente. Questi sono stati deprecati in Qiskit v1.1 dopo che il nuovo flusso di lavoro di pianificazione ha sostituito quello precedente.

• Nel caso in cui non siano specificati né target né un insieme di basis_gates , il passaggio di transpiler sintetizza i circuiti con le operazioni annotate con meno strati di prima (questo accade, ad esempio, per i circuiti prodotti da ) HighLevelSynthesis sintetizza circuiti con operazioni annotate con meno strati di wrapping rispetto a prima (questo accade, ad esempio, per il circuito prodotto da multiplier_cumulative_h18()).

• L'argomento della parola chiave property_set è ora riservato in BasePassManager.run()e non può essere usato come kwarg che sarà inoltrata alla conversione della sottoclasse dalla rappresentazione front-end alla rappresentazione interna.

• I seguenti usi deprecati dell'oggetto BackendProperties nella pipeline di transpilazione sono stati rimossi in Qiskit 2.0:

  • backend_properties argomento di ingresso in transpile()
  • backend_properties argomento di ingresso in PassManagerConfig
  • backend_properties argomento di ingresso in generate_preset_pass_manager()
  • backend_properties argomento di ingresso in generate_routing_passmanager()
  • backend_properties argomento di ingresso in generate_translation_passmanager()
  • backend_properties argomento di ingresso Target.from_configuration()

  Anche i passaggi seguenti sono stati aggiornati per accettare solo un target invece di:

  • backend_prop argomento di ingresso in DenseLayout
  • properties argomento di ingresso in VF2Layout
  • properties e coupling_map argomenti di input in VF2PostLayout
  • backend_props argomento di ingresso in UnitarySynthesis

  La classe BackendProperties è stata deprecata da Qiskit v1.2, perché faceva parte del flusso di lavoro BackendV1 . Le proprietà di istruzioni specifiche, come gli errori di gate o le durate, possono essere aggiunte a un'istruzione Target al momento della costruzione attraverso il metodo Target.add_instruction() e comunicate ai relativi passaggi di transpiler attraverso l'argomento di ingresso target .

• In seguito alla rimozione del modello BackendV1 , sono stati aggiornati i tipi di input accettati dai seguenti oggetti transpiler:

  • Il generate_preset_pass_manager() e transpile() non accettano più ingressi di tipo BackendV1 nel loro argomento di ingresso backend .
  • Il metodo Target.from_configuration() non accetta più l'argomento backend_properties
  • Il metodo Target.target_to_backend_properties() è stato rimosso

• Il ResetAfterMeasureSimplification utilizza ora un parametro IfElseOp per condizionare l'esecuzione del metodo XGate invece di impostare un attributo condition sul gate. Questo perché l'attributo condition è stato rimosso dal modello di dati Qiskit.

• Il passaggio deprecato del transpiler ConvertConditionsToIfOps è stato rimosso. L'attributo sottostante condition di Instruction è stato rimosso, quindi questo passaggio del transpiler non ha più nulla da convertire. Si dovrebbe invece usare direttamente IfElseOp per condizionare classicamente l'esecuzione di un'operazione.

• Il PadDelay e PadDynamicalDecoupling richiedono ora un nuovo argomento quando vengono costruiti. Sia target che durations devono essere specificati con un Target o InstructionDurations rispettivamente. Senza di essi, i passaggi non sono in grado di determinare la durata delle istruzioni nel circuito e si verificano errori. In precedenza, questi passaggi determinavano questi valori dall'attributo duration degli oggetti, ora rimosso Instruction degli oggetti.

• Il passaggio di transpiler AlignMeasures , precedentemente deprecato, è stato rimosso. Questo passaggio è stato deprecato in Qiskit v1.1.0. Al contrario, si deve utilizzare il metodo ConstrainedReschedule deve essere utilizzato. ConstrainedReschedule svolge la stessa funzione e supporta anche l'allineamento a vincoli temporali aggiuntivi.

• Quando si pianifica utilizzando generate_preset_pass_manager() o transpile(), se viene specificato l'argomento instruction_durations , le durate sono formattate come list, e sono in unità di dt. È necessario impostare anche l'argomento di ingresso dt della funzione di transpilazione.

• Rimosso l'attributo deprecato DAGNode.sort_key. Questo attributo è stato deprecato nella versione di Qiskit v1.4.0. Poiché l'ordinamento topologico lessicografico viene eseguito internamente a Rust e l'attributo chiave di ordinamento era inutilizzato, questo attributo è stato rimosso per evitare l'overhead della creazione di nodi DAG. Se ci si è affidati alla chiave di ordinamento, è possibile riprodurla da un dato nodo utilizzando qualcosa come:

  def get_sort_key(node: DAGNode):
      if isinstance(node, (DAGInNode, DAGOutNode)):
          return str(node.wire)
      return ",".join(
          f"{dag.find_bit(q).index:04d}" for q in itertools.chain(node.qargs, node.cargs)
      )

• Il seguente transpile() e generate_preset_pass_manager() deprecati a partire da Qiskit 1.3, sono stati rimossi dall'API:

  • instruction_durations
  • timing_constraints

  Inoltre, la specificazione di porte di base personalizzate attraverso l'argomento basis gate di transpile() e generate_preset_pass_manager(), anch'esso deprecato in Qiskit 1.3, non è più consentito e in questi casi verrà sollevato un ValueError problema.

  Le informazioni precedentemente fornite attraverso questi argomenti possono ancora essere specificate attraverso gli argomenti backend o target . È possibile creare un'istanza Target con durate di istruzione definite facendo:

  Target.from_configuration(..., instruction_durations=...)

  Per vincoli temporali specifici:

  Target.from_configuration(..., timing_constraints=...)

  Per le porte di base personalizzate, è possibile aggiungerle manualmente alla destinazione o utilizzare .from_configuration con una mappatura dei nomi personalizzata, ad esempio:

  from qiskit.circuit.library import XGate
  from qiskit.transpiler.target import Target
  
  basis_gates = ["my_x", "cx"]
  custom_name_mapping = {"my_x": XGate()}
  target = Target.from_configuration(
      basis_gates=basis_gates, num_qubits=2, custom_name_mapping=custom_name_mapping
  )

• Il transpile() e generate_preset_pass_manager() sollevano un UserWarning quando forniscono un coupling_map e/o un basis_gates insieme a un backend. In questi casi ci sono più fonti di verità, le intenzioni dell'utente non sono sempre chiare e possono esserci conflitti che non si sa come risolvere generate_preset_pass_manager() possono non sapere come risolverli. L'alternativa suggerita è quella di definire un obiettivo personalizzato che combini i vincoli scelti.

  Una di queste situazioni è la specifica di un gate con 3 o più qubit in backend o basis_gates insieme a un coupling_map personalizzato. La mappa di accoppiamento non fornisce i dettagli di connettività necessari per determinare l'azione del gate. In questi casi, transpile() e generate_preset_pass_manager() sollevano ora un ValueError.

• Come parte della rimozione degli impulsi in Qiskit 2.0, tutte le funzionalità relative agli impulsi e alla calibrazione nel transpiler sono state rimosse.

  I seguenti passaggi e funzioni sono stati rimossi:

  • qiskit.transpiler.passes.PulseGates superato
  • qiskit.transpiler.passes.ValidatePulseGates superato
  • qiskit.transpiler.passes.RXCalibrationBuilder superato
  • qiskit.transpiler.passes.RZXCalibrationBuilder superato
  • qiskit.transpiler.passes.RZXCalibrationBuilderNoEcho superato
  • qiskit.transpiler.passes.EchoRZXWeylDecomposition superato
  • qiskit.transpiler.passes.NoramlizeRXAngle superato
  • qiskit.transpiler.passes.rzx_templates() funzione

  L'argomento inst_map è stato rimosso dai seguenti elementi:

  • Il generate_preset_pass_manager() e transpile() funzioni
  • Il Target.from_configuration() metodo
  • Il costruttore della classe PassManagerConfig classe

  Il supporto per la calibrazione è stato rimosso:

  • calibration è stato rimosso dal costruttore InstructionProperties e non è più una proprietà della classe.
  • I metodi has_calibration, get_calibration, instruction_schedule_map e update_from_instruction_schedule_map sono stati rimossi dalla classe Target classe.

• Il passaggio deprecato del transpiler StochasticSwap e il relativo plugin integrato per lo stadio di routing "stochastic" sono stati rimossi. Questi sono stati contrassegnati come deprecati nella versione di Qiskit v1.3.0. Il pass è stato sostituito dalla classe SabreSwap che dovrebbe essere utilizzata al suo posto, in quanto offre prestazioni e qualità di output migliori. Ad esempio, se il passaggio è stato precedentemente invocato attraverso la funzione transpile, come:

  from qiskit import transpile
  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler import CouplingMap
  from qiskit.providers.fake_provider import GenericBackendV2
  
  
  qc = QuantumCircuit(4)
  qc.h(0)
  qc.cx(0, range(1, 4))
  qc.measure_all()
  
  cmap = CouplingMap.from_heavy_hex(3)
  backend = GenericBackendV2(num_qubits=cmap.size(), coupling_map=cmap)
  
  tqc = transpile(
      qc,
      routing_method="stochastic",
      layout_method="dense",
      seed_transpiler=12342,
      target=backend.target
  )

  questo dovrebbe essere sostituito con:

  tqc = transpile(
      qc,
      routing_method="sabre",
      layout_method="dense",
      seed_transpiler=12342,
      target=backend.target
  )

• Il pass qiskit.transpiler.passes.CXCancellation è stato rimosso. È stato deprecato in favore di class:.InverseCancellation,, che è più generico. CXCancellation() è del tutto semanticamente equivalente a InverseCancellation([CXGate()]).

• Il passaggio del SolovayKitaev non solleva più un'eccezione sui circuiti che contengono operazioni a singolo bit senza un metodo to_matrix (come misure, barriere e operazioni di flusso di controllo) o operazioni a singolo bit parametrizzate, ma le lascia invariate.

• I plugin per lo stadio di traduzione dei gestori di passaggi preimpostati sono ora tenuti a rispettare la Target la direzionalità del gate nella loro uscita. In precedenza, transpile() e generate_preset_pass_manager() avrebbe generato un file PassManager che conteneva passaggi di correzione, se necessario. A questo punto è necessario includere questi elementi nel proprio stage personalizzato, se lo stage non garantisce il rispetto della direzionalità.

  È possibile utilizzare il GateDirection per eseguire le stesse correzioni che Qiskit faceva. Ad esempio:

  from qiskit.transpiler import PassManager
  from qiskit.transpiler.passes import GateDirection
  from qiskit.transpiler.preset_passmanagers.plugin import PassManagerStagePlugin
  
  class YourTranslationPlugin(PassManagerStagePlugin):
      def pass_manager(self, pass_manager_config, optimization_level):
          pm = PassManager([
              # ... whatever your current setup is ...
          ])
          # Add the two-qubit directionality-fixing pass.
          pm.append(GateDirection(
              pass_manager_config.coupling_map,
              pass_manager_config.target,
          ))
          return pm

• I gestori di passaggi preimpostati non popolano più lo stadio implicito pre_optimization della loro uscita StagedPassManager. Ora è possibile assegnare in modo sicuro il proprio PassManager a questo campo. In precedenza si poteva solo aggiungere al file PassManager.

• Il valore predefinito per l'argomento generate_routing_passmanager()seed_transpiler è cambiato da None a -1. Questa modifica è stata apportata perché questo flag è stato utilizzato solo per configurare il passaggio di VF2PostLayout e per questo passaggio la randomizzazione tipicamente degrada le prestazioni e non è desiderabile. Se ci si è affidati al precedente valore predefinito, è possibile ripristinare questo comportamento impostando esplicitamente l'argomento seed_transpiler=None. Se si impostava esplicitamente un valore di seme per questo parametro, il comportamento non cambia.

Note sull'aggiornamento della visualizzazione

• Il parametro idle_wires in tutti i cassetti dei circuiti è stato ampliato con una nuova opzione, "auto", che ora è il comportamento predefinito. Se si desidera visualizzare i fili senza istruzioni, impostare esplicitamente idle_wires=True.

  Quando è impostato su "auto", il comportamento è il seguente:

  • Se il circuito ha un attributo definito .layout , idle_wires è automaticamente impostato su False (nasconde i fili inattivi)
  • Altrimenti, idle_wires rimane True (mostrando tutti i fili, come era stato impostato in precedenza)

  L'esempio seguente mostra un circuito senza layout visualizzato con idle_wires="auto":

  qr_0: ────────
        ┌───┐┌─┐
  qr_1: ┤ H ├┤M├
        └───┘└╥┘
  cr_0: ══════╬═
              ║
  cr_1: ══════╩═

  Una volta applicato un layout, idle_wires="auto" imposta idle_wires su False, nascondendo i fili inattivi:

            ┌───┐┌─┐
  qr_1 -> 1 ┤ H ├┤M├
            └───┘└╥┘
      cr_1: ══════╩═

  Se si desidera visualizzare tutti i fili di un circuito, impostare esplicitamente idle_wires=True :

       qr_0 -> 0 ────────
                 ┌───┐┌─┐
       qr_1 -> 1 ┤ H ├┤M├
                 └───┘└╥┘
  ancilla_0 -> 2 ──────╫─
                       ║
           cr_0: ══════╬═
                       ║
           cr_1: ══════╩═

  Man mano che i computer quantistici scalano verso un numero maggiore di qubit, anche i circuiti più piccoli possono produrre rappresentazioni circuitali di grandi dimensioni dopo la transpilazione. L'impostazione "auto" contribuisce a migliorare la leggibilità nascondendo, quando possibile, i fili non necessari.

• La array_to_latex() e il metodo Operator.draw() possono ora sollevare un'eccezione MissingOptionalLibrary se la libreria sympy non è installata. Nelle versioni di Qiskit v1.x, symengine e sympy erano sempre garantiti per l'installazione, ma a partire da v2.0.0 questo non è più un requisito indispensabile. La visualizzazione di LaTeX per una matrice si basa sulla libreria sympy ; pertanto, se si utilizza questa funzionalità, è necessario assicurarsi che sia installata sympy .

• Come conseguenza dell'eliminazione del modello BackendV1 , i valori di plot_gate_map(), plot_error_map() e plot_circuit_layout() non accettano più ingressi di tipo BackendV1 nei loro argomenti di ingresso backend .

• Il cassetto della linea temporale ora richiede che l'argomento target sia specificato quando viene chiamato. Poiché le istruzioni non contengono più attributi di durata, questo argomento aggiuntivo è necessario per specificare le durate di tutte le istruzioni supportate. Senza l'argomento, il cassetto della cronologia non ha accesso a queste informazioni.

• Nell'ambito della rimozione di Pulse in Qiskit 2.0, è stato rimosso il supporto per il disegno degli impulsi tramite qiskit.visualization.pulse_drawer .

Varie Note sull'aggiornamento

• I decoratori deprecate_function e deprecate_arguments , deprecati da Qiskit v0.24 (maggio 2023), sono stati rimossi in Qiskit v2.0.0. L'attuale deprecate_func() sostituisce @deprecate_function e l'attuale deprecate_arg() sostituisce @deprecate_arguments.

• La funzione assemble e le relative funzionalità (contenute nel modulo assembler ) sono state rimosse dal codice in seguito alla loro deprecazione in Qiskit v1.2. assemble è stato usato per generare un Qobj nel contesto del flusso di lavoro deprecato BackendV1 . La conversione non è più necessaria, in quanto la pipeline di transpilazione e primitive gestisce direttamente i circuiti quantistici, rendendo obsoleto il sito Qobj .

  La rimozione include i seguenti componenti API pubblici:

  • qiskit.compiler.assemble funzione
  • qiskit.assembler.assemble_circuits funzione
  • qiskit.assembler.assemble_schedules funzione
  • qiskit.assembler.disassemble funzione
  • qiskit.assembler.RunConfig classe
  • qiskit.circuit.Instruction.assemble metodo

• La struttura Qobj e le relative classi, deprecate in Qiskit v1.2.0, sono state rimosse. Sono stati introdotti come parte del flusso di lavoro di BackendV1 e non sono più necessari per interagire con BackendV2 backend. Questa rimozione riguarda le seguenti classi:

  • QobjExperimentHeader
  • QobjHeader
  • QasmQobj
  • QasmQobjInstruction
  • QasmQobjExperimentConfig
  • QasmQobjExperiment
  • QasmQobjConfig
  • QasmExperimentCalibrations
  • GateCalibration
  • PulseQobj
  • PulseQobjInstruction
  • PulseQobjExperimentConfig
  • PulseQobjExperiment
  • PulseQobjConfig
  • QobjMeasurementOption
  • PulseLibraryItem

• Le classi MeasLevel e MeasReturnType , precedentemente definite in qobj/utils.py, sono state migrate in result/models.py a seguito della rimozione del modulo qobj . Queste classi non facevano parte dell'API pubblica. Il percorso di importazione è stato aggiornato da: from qiskit.qobj.utils import MeasLevel, MeasReturnType a: from qiskit.result import MeasLevel, MeasReturnType.

• L'uso di argomenti posizionali nel costruttore di Result è stato disabilitato. Impostare tutti gli argomenti usando la sintassi kwarg, cioè: Result(backend_name="name", ....). Inoltre, l'argomento qobj_id non sarà più utilizzato nella costruzione del file Result interni. È ancora possibile impostare qobj_id come kwarg generico, che finirà nel campo dei metadati insieme agli altri kwarg generici.

• Nell'ambito della rimozione degli impulsi in Qiskit 2.0.0, le funzioni sequence e schedule_circuit di qiskit.scheduler e la classe ScheduleConfig sono state rimosse.

• Il modulo qiskit.result.mitigation è stato rimosso in seguito alla sua deprecazione in Qiskit v1.3. La rimozione include le classi LocalReadoutMitigator e CorrelatedReadoutMitigator e gli strumenti associati. Non esiste un percorso alternativo in Qiskit, poiché la sua funzionalità è stata sostituita dall'addon `mthree . <https://github.com/Qiskit/qiskit-addon-mthree> `__

Circuiti deprecati

• L'attributo deprecato QuantumCircuit.duration non è stato rimosso in questa versione come inizialmente previsto. Verrà invece rimosso con il rilascio di Qiskit v3.0.0. Questa funzionalità è stata sostituita dal metodo QuantumCircuit.estimate_duration() che deve essere utilizzato al suo posto.

• L'interfaccia deprecata simile a una tupla per il metodo CircuitInstruction non è stata rimossa in questa versione come inizialmente previsto. Verrà invece rimosso in Qiskit v3.0.0. Utilizzare invece i tasti operation, qubits, e clbits con i nomi degli attributi.

• La classe di circuito Multiple-Control-Multiple-Target MCMT è ora deprecata ed è stata sostituita da MCMTGateche è una vera e propria Gate una vera e propria sottoclasse. L'uso di un gate al posto di un circuito consente al compilatore di ragionare sull'oggetto a un livello di astrazione superiore e permette di applicare più plugin di sintesi.

Deprecazioni del transpiler

• L'attributo deprecato DAGCircuit.duration non è stato rimosso in questa versione come inizialmente previsto. Verrà invece rimosso con il rilascio di Qiskit v3.0.0. Questa funzionalità è stata sostituita dal metodo QuantumCircuit.estimate_duration() che deve essere utilizzato al suo posto.

• L'argomento propagate_condition di DAGCircuit.substitute_node() e DAGCircuit.substitute_node_with_dag() è stato deprecato. Con la rimozione di Instruction.condition dal modello di dati di Qiskit, questa opzione non ha più alcuna utilità. Se è impostato, non ha più alcun effetto. Non viene rimosso dalla firma per mantenere la compatibilità durante la migrazione da Qiskit 1.x -> 2.0. Questa opzione sarà rimossa in Qiskit 3.0.

• La funzione generate_pre_op_passmanager() è deprecata. Non è più utilizzato nei gestori dei passaggi di preset di Qiskit e il suo scopo è defunto; originariamente generava uno stadio di correzione per i plugin di traduzione che non rispettavano la direzionalità ISA. Gli stadi di traduzione sono ora tenuti a rispettare la direzionalità, quindi la funzionalità non è necessaria e, molto probabilmente, non è necessario sostituirla.

Problemi di sicurezza

• Corretta una vulnerabilità di sicurezza in qpy.load() durante il caricamento di payload che utilizzano sympy per serializzare ParameterExpression e altre espressioni simboliche. Questo include potenzialmente qualsiasi payload QPY che utilizzi la versione QPY < 10, e facoltativamente 10, 11 e 12, a seconda della codifica simbolica utilizzata nella fase di serializzazione (qpy.dump()).

Correzioni di bug

• È stata corretta un'incoerenza nel processo di transpilazione quando si gestiscono porte di identità stretta, in cui queste porte venivano valutate per commutare con tutto da CommutationAnalysisma non venivano rimosse da RemoveIdentityEquivalent. Il problema di fondo è stato causato da RemoveIdentityEquivalent e CommutationAnalysis (e, per estensione, CommutativeInverseCancellation) che utilizzano metriche diverse. Entrambi ora utilizzano la fedeltà media del gate e la stessa soglia per valutare se un gate deve essere trattato come identità (ad esempio un gate di rotazione con un angolo molto piccolo). Per ulteriori informazioni, consultare le documentazioni di queste classi. Corretto #13547.

• È stato risolto un bug in QuantumCircuit.assign_parameters()che si verificava quando si assegnavano parametri a porte standard la cui definizione era già stata attivata. In questo caso, i nuovi valori non sono stati propagati correttamente alle istanze del gate. Mentre il circuito stesso veniva compilato come previsto, ispezionando le singole operazioni si notava ancora il vecchio parametro.

  Ad esempio:

  from qiskit.circuit.library import EfficientSU2
  
  circuit = EfficientSU2(2, flatten=True)
  circuit.assign_parameters([1.25] * circuit.num_parameters, inplace=True)
  print(circuit.data[0].operation.params)  # would print θ[0] instead of 1.25

  Corretto #13478.

• Corretto un bug in DAGCircuit che faceva sì che i nodi di uscita Var diventassero nodi di ingresso durante deepcopy e il decapaggio.

• È stata corretta una svista nella classe Target in cui l'impostazione di un nuovo valore per l'attributo dt e la successiva chiamata a target.durations() non mostrava il valore aggiornato di dt nell'oggetto restituito InstructionDurations restituito. Questo problema è stato risolto invalidando la cache interna delle durate delle istruzioni di destinazione nel setter dt .

• È stato risolto un problema nel passaggio BasisTranslator in cui la fase globale del DAG non veniva aggiornata correttamente. Corretto #14074.

• È stato risolto un bug nel passaggio del HighLevelSynthesis in cui sintetizzava qualsiasi istruzione per la quale fosse disponibile un plugin di sintesi, indipendentemente dal fatto che l'istruzione fosse già supportata dal target o facesse parte del passaggio esplicito basis_gates. Questo comportamento è stato corretto, in modo che tali istruzioni già supportate non vengano più sintetizzate.

• Il passaggio di InverseCancellation il passaggio di transpilazione viene ora eseguito all'interno di blocchi di flusso di controllo. In precedenza, ignorava le coppie di porte che potevano essere annullate quando erano definite all'interno di blocchi classici. Per maggiori dettagli, consultare il numero #13437.

• È stato risolto un bug con le rotazioni multicontrollate in cui l'angolo di rotazione era un ParameterExpression. In questo caso, il tentativo di sintesi provocherebbe un errore che indica che il gate non può essere sintetizzato con un parametro non vincolato. Questo bug riguardava i metodi del circuito di rotazione multicontrollato QuantumCircuit.mcrx(), :meth:.QuantumCircuit.mcry, e QuantumCircuit.mcrz(), così come quando si chiamava RXGate.control(), RYGate.control(), o RZGate.control() quando l'angolo di rotazione era un valore ParameterExpression. Ora, questi circuiti di rotazione multicontrollati possono essere sintetizzati senza generare errori.

• Corretto un bug in QPY (qiskit.qpy) in cui i circuiti contenenti porte di classe MCMTGate non venivano serializzati. Vedere #13965.

• Corretto un bug che faceva sì che Statevector.expectation_value() dava risultati errati per l'operatore identità quando il vettore di stato non era normalizzato. Corretto #13029

• La conversione di un circuito quantistico in un gate con converters.circuit_to_instruction() ora fallisce correttamente quando il circuito dato contiene istruzioni di flusso di controllo.

• Chiamare un AnalysisPass o a TransformationPass come una funzione (come in pass_ = MyPass(); pass_(qc)) ora rispetterà qualsiasi requisito che il passaggio potrebbe avere. Ad esempio, i passaggi di programmazione come ALAPScheduleAnalysis richiedono che TimeUnitConversion venga eseguito prima di essi. L'esecuzione del passaggio tramite un elemento PassManager rispetta sempre questo requisito, ma finora non veniva rispettato quando si chiamava direttamente il passaggio.

• Quando una TranspilerError viene sollevata da un passaggio all'interno di una chiamata a PassManger.run(), l'eccezione sarà ora propagata senza perdite, invece di diventare un'eccezione concatenata con un tipo cancellato.

• SabreSwap non contrarrà più i fili dei qubit inattivi fuori dai blocchi di flusso di controllo durante l'instradamento. In genere si tratta di un'ottimizzazione valida, ma non di un effetto collaterale atteso di un passaggio di routing. Ora è possibile utilizzare il passaggio ContractIdleWiresInControlFlow per eseguire questa contrazione.

• Corretto un non-determinismo per-processo in SparsePauliOp.to_matrix. L'ordine esatto delle operazioni in virgola mobile nella somma variava in precedenza per ogni processo, ma ora sarà identico tra le diverse invocazioni dello stesso script. Vedere #13413.