Note di rilascio di Qiskit 0.15

0.15.0

Terra 0.12.0

Preludio

La release 0.12.0 include diverse nuove funzionalità e correzioni di bug. Il cambiamento più importante di questa versione è l'aggiunta del supporto per gli impulsi parametrici a OpenPulse. Si tratta di comandi Pulse, che per descrivere un impulso utilizzano parametri anziché punti di campionamento. 0.12.0 è anche la prima versione ad includere il supporto per Python 3.8. Inoltre segna l'inizio della deprecazione del supporto a Python 3.5, che sarà rimosso quando la comunità upstream smetterà di supportarlo.

Nuove funzioni

Il passaggio qiskit.transpiler.passes.CSPLayout è stato ampliato con due nuovi parametri: call_limit e time_limit. Queste opzioni consentono di limitare la durata del passaggio. L'opzione call_limit limita il numero di volte in cui la funzione ricorsiva del risolutore backtracking può essere chiamata. Allo stesso modo, time_limit limita la durata (in secondi) dell'esecuzione del solutore. I valori predefiniti sono rispettivamente 1000 chiamate e 10 secondi.
qiskit.pulse.Acquire può ora essere applicato a un singolo qubit. Questo rende la programmazione degli impulsi più coerente e più facile da ragionare, poiché ora tutte le operazioni si applicano a un singolo canale. Ad esempio:
```
acquire = Acquire(duration=10)
schedule = Schedule()
schedule.insert(60, acquire(AcquireChannel(0), MemorySlot(0), RegisterSlot(0)))
schedule.insert(60, acquire(AcquireChannel(1), MemorySlot(1), RegisterSlot(1)))
```
Un nuovo metodo qiskit.transpiler.CouplingMap.draw() è stato aggiunto a qiskit.transpiler.CouplingMap per generare un'immagine graphviz dal grafico della mappa di accoppiamento. Ad esempio:
```
from qiskit.transpiler import CouplingMap

coupling_map = CouplingMap(
    [[0, 1], [1, 0], [1, 2], [1, 3], [2, 1], [3, 1], [3, 4], [4, 3]])
coupling_map.draw()
```
Gli impulsi parametrici sono stati aggiunti a OpenPulse. Si tratta di comandi a impulsi che vengono parametrizzati e compresi dal backend. Le forme d'impulso arbitrarie sono ancora supportate dal comando SamplePulse. Le nuove classi di impulsi supportate sono:
- qiskit.pulse.ConstantPulse
- qiskit.pulse.Drag
- qiskit.pulse.Gaussian
- qiskit.pulse.GaussianSquare
Possono essere utilizzati come qualsiasi altro comando Pulse. Un esempio:
```
from qiskit.pulse import (Schedule, Gaussian, Drag, ConstantPulse,
                          GaussianSquare)

sched = Schedule(name='parametric_demo')
sched += Gaussian(duration=25, sigma=4, amp=0.5j)(DriveChannel(0))
sched += Drag(duration=25, amp=0.1, sigma=5, beta=4)(DriveChannel(1))
sched += ConstantPulse(duration=25, amp=0.3+0.1j)(DriveChannel(1))
sched += GaussianSquare(duration=1500, amp=0.2, sigma=8,
                        width=140)(MeasureChannel(0)) << sched.duration
```
Il programma risultante sarà simile a un programma SamplePulse costruito con qiskit.pulse.pulse_lib, tuttavia il campionamento delle forme d'onda sarà eseguito dal backend. Il metodo qiskit.pulse.Schedule.draw() può essere utilizzato come di consueto. Tuttavia, il comando verrà convertito in SamplePulse con il metodo qiskit.pulse.ParametricPulse.get_sample_pulse() , quindi l'impulso mostrato potrebbe non campionare la funzione continua nello stesso modo in cui lo farà il backend.

Questa funzione può essere utilizzata per costruire programmi di impulsi per qualsiasi backend, ma gli impulsi saranno convertiti in oggetti SamplePulse se il backend non supporta gli impulsi parametrici. I backend che li supportano avranno il seguente nuovo attributo:
```
backend.configuration().parametric_pulses: List[str]
# e.g. ['gaussian', 'drag', 'constant']
```
Si noti che non è necessario che il backend supporti tutti gli impulsi parametrici definiti in Qiskit.

Quando il backend supporta gli impulsi parametrici e il programma degli impulsi viene costruito con essi, il Qobj assemblato è significativamente più piccolo. La dimensione di un PulseQobj costruito interamente con impulsi parametrici dipende solo dal numero di istruzioni, mentre la dimensione di un PulseQobj costruito diversamente crescerà con la durata delle istruzioni (poiché ogni campione deve essere specificato con un valore).

Aggiunte le funzioni di utilità qiskit.scheduler.measure() e qiskit.scheduler.measure_all() al modulo qiskit.scheduler. Queste funzioni restituiscono un qiskit.pulse.Schedule che misura i qubit utilizzando OpenPulse. Ad esempio:

from qiskit.scheduler import measure, measure_all

measure_q0_schedule = measure(qubits=[0], backend=backend)
measure_all_schedule = measure_all(backend)
measure_custom_schedule = measure(qubits=[0],
                                  inst_map=backend.defaults().instruction_schedule_map,
                                  meas_map=[[0]],
                                  qubit_mem_slots={0: 1})

Impulso qiskit.pulse.Schedule hanno ora rappresentazioni migliori che per i programmi semplici dovrebbero essere espressioni valide di Python.
I qiskit.circuit.QuantumCircuit metodi qiskit.circuit.QuantumCircuit.measure_active(), qiskit.circuit.QuantumCircuit.measure_all(), e qiskit.circuit.QuantumCircuit.remove_final_measurements() hanno ora un'aggiunta kwarg inplace. Quando inplace è impostato su False , la funzione restituisce una copia modificata del circuito. Questo è diverso dal comportamento predefinito, che modifica l'oggetto circuito sul posto e non restituisce nulla.
Sono stati aggiunti diversi nuovi metodi di costruzione alla classe qiskit.transpiler.CouplingMap per costruire oggetti con grafici di accoppiamento dei qubit di base. I nuovi metodi del costruttore sono:
Ad esempio, per utilizzare i nuovi costruttori per ottenere una mappa di accoppiamento di 5 qubit collegati in una catena lineare, si può ora eseguire:
```
from qiskit.transpiler import CouplingMap

coupling_map = CouplingMap.from_line(5)
coupling_map.draw()
```
Introdotto un nuovo passaggio qiskit.transpiler.passes.CrosstalkAdaptiveSchedule. Questo passaggio mira a ridurre l'impatto del rumore di diafonia su un programma. Utilizza i dati di caratterizzazione della diafonia provenienti dal backend per programmare i gate. Quando una coppia di porte presenta un'elevata diafonia, viene serializzata mediante una barriera. La serializzazione ingenua è dannosa perché comporta errori di decoerenza. Pertanto, questo passaggio utilizza un approccio di ottimizzazione SMT per calcolare un programma che minimizzi l'impatto della diafonia e degli errori di decoerenza.

Il passaggio prende in input un circuito già transpilato sul backend, ossia il circuito è espresso in termini di qubit fisici e le porte di scambio sono state inserite e decomposte in CNOT, se necessario. Utilizzando questo circuito e i dati di caratterizzazione della diafonia, viene utilizzata un' ottimizzazione Z3 per costruire un nuovo circuito programmato come uscita.

Per utilizzare il pass su un circuito circ:
```
dag = circuit_to_dag(circ)
pass_ = CrosstalkAdaptiveSchedule(backend_prop, crosstalk_prop)
scheduled_dag = pass_.run(dag)
scheduled_circ = dag_to_circuit(scheduled_dag)
```
backend_prop è un oggetto qiskit.providers.models.BackendProperties per il backend di destinazione. crosstalk_prop è un dict che specifica i tassi di errore condizionati. Per due porte g1 e g2, crosstalk_prop[g1][g2] specifica il tasso di errore condizionale di g1 quando g1 e g2 vengono eseguiti simultaneamente. Un metodo per generare crosstalk_prop sarà aggiunto in una prossima versione di qiskit-ignis. Fino ad allora dovrete conoscere già le proprietà di diafonia del vostro dispositivo, oppure scrivere manualmente i vostri esperimenti di caratterizzazione del dispositivo.
Nel gestore dei passaggi di preselezione per il livello di ottimizzazione 1, qiskit.transpiler.preset_passmanagers.level_1_pass_manager() se qiskit.transpiler.passes.TrivialLayout non corrisponde perfettamente a un determinato circuito, si utilizza invece qiskit.transpiler.passes.DenseLayout viene utilizzato il layout pass.
Aggiunto un nuovo metodo astratto qiskit.quantum_info.Operator.dot() alla classe astratta BaseOperator , in modo che sia incluso in tutte le implementazioni di tale classe astratta, comprese le classi qiskit.quantum_info.Operator e QuantumChannel (ad esempio, qiskit.quantum_info.Choi). Questo metodo restituisce l'operatore giusto di moltiplicazione a.dot(b) $= a \cdot b$ . Ciò equivale a chiamare il metodo operatore qiskit.quantum_info.Operator.compose() con il kwarg front impostato su True.
Aggiunto qiskit.quantum_info.average_gate_fidelity() e qiskit.quantum_info.gate_error() al modulo qiskit.quantum_info per lavorare con qiskit.quantum_info.Operator e QuantumChannel (es, qiskit.quantum_info.Choi) gli oggetti.

È stata aggiunta la funzione qiskit.quantum_info.partial_trace() alla funzione qiskit.quantum_info che funziona con qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix classi di stati quantici. Ad esempio:

from qiskit.quantum_info.states import Statevector
from qiskit.quantum_info.states import DensityMatrix
from qiskit.quantum_info.states import partial_trace

psi = Statevector.from_label('10+')
partial_trace(psi, [0, 1])
rho = DensityMatrix.from_label('10+')
partial_trace(rho, [0, 1])

Quando qiskit.circuit.QuantumCircuit.draw() o qiskit.visualization.circuit_drawer() con il kwarg with_layout impostato su True (l'impostazione predefinita), la visualizzazione dell'output mostrerà i qubit fisici come numeri interi per distinguerli chiaramente dai qubit virtuali.

Ad esempio:
```
from qiskit import QuantumCircuit
from qiskit import transpile
from qiskit.test.mock import FakeVigo

qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
transpiled_qc = transpile(qc, FakeVigo())
transpiled_qc.draw(output='mpl')
```
Aggiunte nuove funzioni di misura dello stato al modulo qiskit.quantum_info al modulo: qiskit.quantum_info.entropy(), qiskit.quantum_info.mutual_information(), qiskit.quantum_info.concurrence(), e qiskit.quantum_info.entanglement_of_formation(). Queste funzioni funzionano con gli elementi qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix e le classi.
I metodi di decomposizione per le porte a singolo qubit in qiskit.quantum_info.synthesis.one_qubit_decompose.OneQubitEulerDecomposer sono stati ampliati per includere anche la base 'ZXZ' , caratterizzata da tre rotazioni attorno agli assi Z,X,Z. Ciò significa che un operatore generale 2x2 può essere scomposto nelle seguenti basi: U3, U1X, ZYZ, ZXZ, XYX, ZXZ.

Problemi noti

Esecuzione di funzioni che utilizzano qiskit.tools.parallel_map() (ad esempio qiskit.execute.execute(), qiskit.compiler.transpile(), e qiskit.transpiler.PassManager.run()) potrebbero non funzionare se chiamate da uno script in esecuzione al di fuori di un blocco if __name__ == '__main__': quando si usa Python 3.8 su MacOS. Gli altri ambienti non sono interessati da questo problema. Ciò è dovuto a cambiamenti nel modo in cui i processi paralleli vengono lanciati da Python 3.8 su MacOS. Se RuntimeError o AttributeError vengono sollevati da script che chiamano direttamente parallel_map() o quando si chiama una funzione che lo usa internamente con Python 3.8 e MacOS l'incorporazione delle chiamate agli script all'interno di if __name__ == '__main__': dovrebbe risolvere il problema. Ad esempio:
```
from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, BasicAer

qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure([0,1], [0,1])
# making another circuit: superpositions
qc2 = QuantumCircuit(2, 2)
qc2.h([0,1])
qc2.measure([0,1], [0,1])
execute([qc1, qc2], BasicAer.get_backend('qasm_simulator'))
```
Dovrebbe essere modificata in:
```
from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, BasicAer

def main():
    qc1 = QuantumCircuit(2, 2)
    qc1.h(0)
    qc1.cx(0, 1)
    qc1.measure([0,1], [0,1])
    # making another circuit: superpositions
    qc2 = QuantumCircuit(2, 2)
    qc2.h([0,1])
    qc2.measure([0,1], [0,1])
    execute([qc1, qc2], BasicAer.get_backend('qasm_simulator'))

if __name__ == '__main__':
    main()
```
se si verificano errori con Python 3.8 su MacOS.

Note sull'aggiornamento

Il valore del parametro rep_time per l'oggetto di configurazione del backend Pulse è ora in unità di secondi, non di microsecondi. La prima volta che un oggetto PulseBackendConfiguration viene inizializzato, viene emesso un singolo avviso all'utente per indicare questo.
L'argomento rep_time per qiskit.compiler.assemble() accetta ora un valore in unità di secondi, non di microsecondi. Questo è stato fatto per rendere le unità con tutto il resto in polso. Se si sta passando un valore per rep_time , assicurarsi di aggiornare il valore per tenere conto di questa modifica.
Il valore della proprietà base_gate degli oggetti qiskit.circuit.ControlledGate è stato cambiato dalla classe del gate di base a un'istanza della classe del gate di base.

La proprietà base_gate_name di qiskit.circuit.ControlledGate è stata rimossa; è possibile ottenere il nome del gate di base accedendo a base_gate.name sull'oggetto. Ad esempio:

from qiskit import QuantumCircuit
from qiskit.extensions import HGate

qc = QuantumCircuit(3)
cch_gate = HGate().control(2)
base_gate_name = cch_gate.base_gate.name

Modificato qiskit.quantum_info.Operator in modo che __mul__ (che viene eseguito dall'operazione di moltiplicazione di python, se il lato sinistro dell'operazione è stato definito) implementi la moltiplicazione della matrice destra (ovvero qiskit.quantum_info.Operator.dot()), e __rmul__ (che viene eseguito dall'operazione di moltiplicazione di python dal lato destro dell'operazione se il lato sinistro non ha definito __mul__ ) implementa la moltiplicazione scalare (cioè qiskit.quantum_info.Operator.multiply()). In precedenza entrambi i metodi implementavano la moltiplicazione scalare.
Il secondo argomento della funzione qiskit.quantum_info.process_fidelity()target , è ora opzionale. Se non viene specificato un target unitario, verrà restituita la fedeltà di processo del canale di ingresso con l'operatore di identità.
qiskit.compiler.assemble() rispetterà ora il valore configurato di max_shots per un backend. Se viene specificato un valore per il kwarg shots che supera gli scatti massimi impostati nella configurazione del backend, la funzione solleverà un'eccezione QiskitError . Inoltre, se non viene fornito alcun argomento per gli shots, il valore predefinito è 1024 (il comportamento precedente) o max_shots dal backend, a seconda di quale sia il valore più basso.

Note di deprecazione

I metodi per aggiungere porte a un file qiskit.circuit.QuantumCircuit con argomenti di parole chiave abbreviate (ad esempio ctl, tgt) hanno avuto i loro argomenti di parole chiave rinominati in modo da essere più descrittivi (ad esempio control_qubit, target_qubit). I vecchi nomi sono stati deprecati. Di seguito è riportata una tabella con le firme di chiamata vecchie e nuove per i metodi di QuantumCircuit .

Tipo di istruzione	Precedente Firma	Nuova firma
`qiskit.extensions.HGate`	`qc.h(q)`	`qc.h(qubit)`
`qiskit.extensions.CHGate`	`qc.ch(ctl, tgt)`	`qc.ch((control_qubit, target_qubit))`
`qiskit.extensions.IdGate`	`qc.iden(q)`	`qc.iden(qubit)`
`qiskit.extensions.RGate`	`qc.iden(q)`	`qc.iden(qubit)`
`qiskit.extensions.RGate`	`qc.r(theta, phi, q)`	`qc.r(theta, phi, qubit)`
`qiskit.extensions.RXGate`	`qc.rx(theta, q)`	`qc.rx(theta, qubit)`
`qiskit.extensions.CrxGate`	`qc.crx(theta, ctl, tgt)`	`qc.crx(theta, control_qubit, target_qubit)`
`qiskit.extensions.RYGate`	`qc.ry(theta, q)`	`qc.ry(theta, qubit)`
`qiskit.extensions.CryGate`	`qc.cry(theta, ctl, tgt)`	`qc.cry(theta, control_qubit, target_qubit)`
`qiskit.extensions.RZGate`	`qc.rz(phi, q)`	`qc.rz(phi, qubit)`
`qiskit.extensions.CrzGate`	`qc.crz(theta, ctl, tgt)`	`qc.crz(theta, control_qubit, target_qubit)`
`qiskit.extensions.SGate`	`qc.s(q)`	`qc.s(qubit)`
`qiskit.extensions.SdgGate`	`qc.sdg(q)`	`qc.sdg(qubit)`
`qiskit.extensions.FredkinGate`	`qc.cswap(ctl, tgt1, tgt2)`	`qc.cswap(control_qubit, target_qubit1, target_qubit2)`
`qiskit.extensions.TGate`	`qc.t(q)`	`qc.t(qubit)`
`qiskit.extensions.TdgGate`	`qc.tdg(q)`	`qc.tdg(qubit)`
`qiskit.extensions.U1Gate`	`qc.u1(theta, q)`	`qc.u1(theta, qubit)`
`qiskit.extensions.Cu1Gate`	`qc.cu1(theta, ctl, tgt)`	`qc.cu1(theta, control_qubit, target_qubit)`
`qiskit.extensions.U2Gate`	`qc.u2(phi, lam, q)`	`qc.u2(phi, lam, qubit)`
`qiskit.extensions.U3Gate`	`qc.u3(theta, phi, lam, q)`	`qc.u3(theta, phi, lam, qubit)`
`qiskit.extensions.Cu3Gate`	`qc.cu3(theta, phi, lam, ctl, tgt)`	`qc.cu3(theta, phi, lam, control_qubit, target_qubit)`
`qiskit.extensions.XGate`	`qc.x(q)`	`qc.x(qubit)`
`qiskit.extensions.CnotGate`	`qc.cx(ctl, tgt)`	`qc.cx(control_qubit, target_qubit)`
`qiskit.extensions.ToffoliGate`	`qc.ccx(ctl1, ctl2, tgt)`	`qc.ccx(control_qubit1, control_qubit2, target_qubit)`
`qiskit.extensions.YGate`	`qc.y(q)`	`qc.y(qubit)`
`qiskit.extensions.CyGate`	`qc.cy(ctl, tgt)`	`qc.cy(control_qubit, target_qubit)`
`qiskit.extensions.ZGate`	`qc.z(q)`	`qc.z(qubit)`
`qiskit.extensions.CzGate`	`qc.cz(ctl, tgt)`	`qc.cz(control_qubit, target_qubit)`

L'esecuzione di qiskit.pulse.Acquire su più qubit è stata deprecata e sarà rimossa in una versione futura. Inoltre, i parametri qiskit.pulse.AcquireInstruction mem_slots e reg_slots sono stati deprecati. Al loro posto vanno utilizzati reg_slot e mem_slot .
L'attributo della qiskit.providers.models.PulseDefaults della classe circuit_instruction_map è stato deprecato e sarà rimosso in una prossima versione. Si deve invece utilizzare il nuovo attributo instruction_schedule_map. Questo è stato fatto per far corrispondere il tipo di valore dell'attributo, che è un InstructionScheduleMap.

Il comando qiskit.pulse.PersistentValue è deprecato e sarà rimosso in una versione futura. Una funzionalità simile può essere ottenuta con il comando qiskit.pulse.ConstantPulse (uno dei nuovi impulsi parametrici). Confrontate quanto segue:

from qiskit.pulse import Schedule, PersistentValue, ConstantPulse, \
                         DriveChannel

# deprecated implementation
sched_w_pv = Schedule()
sched_w_pv += PersistentValue(value=0.5)(DriveChannel(0))
sched_w_pv += PersistentValue(value=0)(DriveChannel(0)) << 10

# preferred implementation
sched_w_const = Schedule()
sched_w_const += ConstantPulse(duration=10, amp=0.5)(DriveChannel(0))

Python 3.5 in qiskit-terra è deprecato. Il supporto sarà rimosso nella prima versione dopo la data di fine vita della comunità upstream di Python, che è il 13/09/2020.
Il kwarg require_cptp della funzione qiskit.quantum_info.process_fidelity() è stata deprecata e sarà rimossa in una prossima versione. È sostituita da due kwarg separati require_cp e require_tp.
Impostazione del parametro scale per qiskit.circuit.QuantumCircuit.draw() e qiskit.visualization.circuit_drawer() come primo argomento posizionale è deprecato e sarà rimosso in una prossima versione. Si deve invece usare scale come argomento della parola chiave.

Il modulo qiskit.tools.qi.qi è deprecato e sarà rimosso in una prossima versione. Le funzioni legacy del modulo sono state tutte sostituite da funzioni e classi del modulo qiskit.quantum_info modulo. Di seguito è riportata una tabella delle funzioni deprecate e della loro sostituzione:

Obsoleto	Sostituzione
`qiskit.tools.partial_trace()`	`qiskit.quantum_info.partial_trace()`
`qiskit.tools.choi_to_pauli()`	`qiskit.quantum_info.Choi` e `quantum_info.PTM`
`qiskit.tools.chop()`	`numpy.round`
`qiskit.tools.qi.qi.outer`	`numpy.outer`
`qiskit.tools.concurrence()`	`qiskit.quantum_info.concurrence()`
`qiskit.tools.shannon_entropy()`	`qiskit.quantum_info.shannon_entropy()`
`qiskit.tools.entropy()`	`qiskit.quantum_info.entropy()`
`qiskit.tools.mutual_information()`	`qiskit.quantum_info.mutual_information()`
`qiskit.tools.entanglement_of_formation()`	`qiskit.quantum_info.entanglement_of_formation()`
`qiskit.tools.is_pos_def()`	`quantum_info.operators.predicates.is_positive_semidefinite_matrix`

Il modulo qiskit.quantum_info.states.states è deprecato e sarà rimosso in una prossima versione. Le funzioni legacy del modulo sono state tutte sostituite da funzioni e classi del modulo qiskit.quantum_info modulo.

Obsoleto
Sostituzione
qiskit.quantum_info.states.states.basis_state qiskit.quantum_info.Statevector.from_label()
qiskit.quantum_info.states.states.projector qiskit.quantum_info.DensityMatrix
Il parametro scaling del metodo draw() per gli oggetti Schedule e Pulse è stato deprecato e sarà rimosso in una prossima versione. Si deve invece utilizzare il nuovo parametro scale . Questo è stato fatto per avere un argomento coerente tra i disegni degli impulsi e dei circuiti. Ad esempio:
```
#The consistency in parameters is seen below
#For circuits
circuit = QuantumCircuit()
circuit.draw(scale=0.2)
#For pulses
pulse = SamplePulse()
pulse.draw(scale=0.2)
#For schedules
schedule = Schedule()
schedule.draw(scale=0.2)
```

Obsoleto	Sostituzione
`qiskit.quantum_info.states.states.basis_state`	`qiskit.quantum_info.Statevector.from_label()`
`qiskit.quantum_info.states.states.projector`	`qiskit.quantum_info.DensityMatrix`

Correzioni di bug

In precedenza, chiamando qiskit.circuit.QuantumCircuit.bind_parameters() prima della scomposizione di un circuito, i valori vincolati non venivano sostituiti correttamente nelle porte scomposte. Questo problema è stato risolto in modo che il legame e la decomposizione possano avvenire in qualsiasi ordine. Corregge il problema #2482 e il problema #3509
In precedenza, il sito Collect2qBlocks non aveva considerato le condizioni classiche quando si trattava di decidere se inserire un cancello in un blocco esistente. In alcuni casi, ciò ha comportato la perdita delle condizioni classiche durante la trasposizione con optimization_level=3. Questo problema è stato risolto in modo che le porte condizionate in modo classico non siano mai incluse in un blocco. Corregge il problema #3215
Tutti i tipi di uscita per i cassetti del circuito in qiskit.circuit.QuantumCircuit.draw() e qiskit.visualization.circuit_drawer() hanno un supporto fisso e/o migliorato per le porte personalizzate controllate dal disegno. Corregge il problema #3546, il problema #3763 e il problema #3764
Sono stati aggiunti spiegazioni ed esempi alla documentazione dei metodi qiskit.circuit.QuantumCircuit per l'aggiunta di porte: qiskit.circuit.QuantumCircuit.ccx(), qiskit.circuit.QuantumCircuit.ch(), qiskit.circuit.QuantumCircuit.crz(), qiskit.circuit.QuantumCircuit.cswap(), qiskit.circuit.QuantumCircuit.cu1(), qiskit.circuit.QuantumCircuit.cu3(), qiskit.circuit.QuantumCircuit.cx(), qiskit.circuit.QuantumCircuit.cy(), qiskit.circuit.QuantumCircuit.cz(), qiskit.circuit.QuantumCircuit.h(), qiskit.circuit.QuantumCircuit.iden(), qiskit.circuit.QuantumCircuit.rx(), qiskit.circuit.QuantumCircuit.ry(), qiskit.circuit.QuantumCircuit.rz(), qiskit.circuit.QuantumCircuit.s(), qiskit.circuit.QuantumCircuit.sdg(), qiskit.circuit.QuantumCircuit.swap(), qiskit.circuit.QuantumCircuit.t(), qiskit.circuit.QuantumCircuit.tdg(), qiskit.circuit.QuantumCircuit.u1(), qiskit.circuit.QuantumCircuit.u2(), qiskit.circuit.QuantumCircuit.u3(), qiskit.circuit.QuantumCircuit.x(), qiskit.circuit.QuantumCircuit.y(), qiskit.circuit.QuantumCircuit.z(). Corregge il problema #3400
Correzioni per la gestione del parametro numero complesso nella visualizzazione dei circuiti. Corregge il problema #3640

Altre note

I passaggi del transpiler nella cartella qiskit.transpiler.passes sono stati organizzati in sottodirectory per meglio classificarli per funzionalità. Sono ancora tutti accessibili nello spazio dei nomi qiskit.transpiler.passes .

Aer 0.4.0

Aggiunto

Aggiunto NoiseModel.from_backend per la costruzione di un modello di rumore di base del dispositivo per un backend IBMQ (#569)

Aggiunti metodi di simulazione multi-GPU a QasmSimulator, StatevectorSimulator e UnitarySimulator. Il simulatore qasm ha una versione gpu dei metodi della matrice di densità e del vettore di stato e vi si può accedere usando "method": "density_matrix_gpu" o "method": "statevector_gpu" in backend_options. Il metodo statevector simulator gpu è accessibile tramite "method": "statevector_gpu". Il metodo GPU del simulatore unitario è accessibile tramite "method": "unitary_gpu". Questi backend utilizzano CUDA e richiedono una GPU NVidia.(#544)

Aggiunto il backend PulseSimulator (#542)

Aggiunte le classi PulseSystemModel e HamiltonianModel per rappresentare i modelli da usare in PulseSimulator (#496, #493)

Aggiunto duffing_model_generators per generare oggetti PulseSystemModel da un elenco di parametri (#516)

Migrazione del solutore di funzioni ODE a C++ (#442, #350)

Aggiunti test del simulatore di impulsi di alto livello (#379)

Flag CMake BLAS_LIB_PATH per impostare il percorso in cui cercare la libreria BLAS (#543)

Modificato

Modificata la struttura della directory src per organizzare il codice sorgente del simulatore. Le intestazioni del controllore del simulatore sono state spostate in src/controllers e le intestazioni dello Stato del metodo del simulatore sono in src/simulators (#544)

Spostata la posizione di alcune funzioni (#568): * Spostato il contenuto di qiskit.provider.aer.noise.errors nel modulo qiskit.providers.noise * Spostato il contenuto di qiskit.provider.aer.noise.utils nel modulo qiskit.provider.aer.utils .

Abilitata l'ottimizzazione per aggregare porte consecutive in un circuito (fusione) per impostazione predefinita (#579).

Obsoleto

Funzioni deprecate di utils.qobj_utils (#568)

Deprecato qiskit.providers.aer.noise.device.basic_device_noise_model. È sostituito dal metodo NoiseModel.from_backend (#569)

Rimosso

Rimossi i metodi NoiseModel.as_dict, QuantumError.as_dict, ReadoutError.as_dict e QuantumError.kron , deprecati in 0.3 (#568).

Ignis 0.2

Nessuna modifica

Acqua 0.6

Nessuna modifica

IBM Q Fornitore 0.4.6

Aggiunto

A IBMQBackend sono stati aggiunti diversi nuovi metodi:
- wait_for_final_state() fino al termine del lavoro. Prende una funzione di callback che invocherà dopo ogni query per fornire un feedback.
- active_jobs() restituisce i lavori inviati a un backend che sono attualmente in uno stato non completato.
- job_limit() restituisce il limite dei lavori per un backend.
- remaining_jobs_count() restituisce il numero di lavori che è possibile inviare al backend prima che venga raggiunto il limite di lavori.
QueueInfo ha ora un nuovo metodo format() che restituisce una stringa formattata delle informazioni sulla coda.
IBMQJob ha ora tre nuovi metodi: done(), running(), e cancelled() che vengono utilizzati per indicare lo stato del lavoro.
qiskit.providers.ibmq.ibmqbackend.IBMQBackend.run() accetta ora un parametro opzionale job_tags. Se specificati, i job_tag vengono assegnati al lavoro, che può essere successivamente utilizzato come filtro in qiskit.providers.ibmq.ibmqbackend.IBMQBackend.jobs().
IBMQJobManager dispone di un nuovo metodo retrieve_job_set() che consente di recuperare un job set precedentemente inviato utilizzando l'ID del job set.

Modificato

La gerarchia di Exception è stata perfezionata con classi più specializzate. Tuttavia, è possibile continuare a catturare le loro eccezioni genitore (come IBMQAccountError). Inoltre, la classe di eccezione IBMQApiUrlError è stata sostituita da IBMQAccountCredentialsInvalidUrl e IBMQAccountCredentialsInvalidToken.

Obsoleto

L'uso di URL proxy senza protocollo (ad es. http://) è deprecato a causa delle recenti modifiche di Python.

Questa pagina è stata utile?

Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.