Notes de publication de Qiskit 0.15

0.15.0

Terra 0.12.0

Prélude

La version 0.12.0 comprend plusieurs nouvelles fonctionnalités et corrections de bogues. La plus grande nouveauté de cette version est l'ajout de la prise en charge des impulsions paramétriques à OpenPulse. Il s'agit de commandes d'impulsion qui utilisent des paramètres plutôt que des points d'échantillonnage pour décrire une impulsion. 0.12.0 est également la première version à inclure la prise en charge de Python 3.8. Il marque également le début de la dépréciation du support de Python 3.5, qui sera supprimé lorsque la communauté en amont cessera de le supporter.

Nouvelles fonctions

La passe qiskit.transpiler.passes.CSPLayout a été complété par deux nouveaux paramètres : call_limit et time_limit. Ces options permettent de limiter la durée de la passe. L'option call_limit limite le nombre de fois où la fonction récursive du solveur de backtracking peut être appelée. De même, time_limit limite la durée (en secondes) d'exécution du solveur. Les valeurs par défaut sont respectivement 1000 appels et 10 secondes.
qiskit.pulse.Acquire peut maintenant être appliquée à un seul qubit. Cela rend la programmation des impulsions plus cohérente et plus facile à raisonner, car toutes les opérations s'appliquent désormais à un seul canal. Par exemple :
```
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)))
```
Une nouvelle méthode qiskit.transpiler.CouplingMap.draw() a été ajoutée à qiskit.transpiler.CouplingMap pour générer une image graphviz à partir du graphique de la carte de couplage. Par exemple :
```
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()
```
Des impulsions paramétriques ont été ajoutées à OpenPulse. Il s'agit de commandes d'impulsion qui sont paramétrées et comprises par le backend. Les formes d'impulsion arbitraires sont toujours prises en charge par la commande SamplePulse. Les nouvelles classes d'impulsion prises en charge sont les suivantes :
- qiskit.pulse.ConstantPulse
- qiskit.pulse.Drag
- qiskit.pulse.Gaussian
- qiskit.pulse.GaussianSquare
Elles peuvent être utilisées comme n'importe quelle autre commande Pulse. Exemple :
```
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
```
Le programme résultant sera similaire à un programme SamplePulse construit à l'aide de qiskit.pulse.pulse_lib, mais l'échantillonnage des formes d'onde sera effectué par le backend. La méthode qiskit.pulse.Schedule.draw() peut toujours être utilisée comme d'habitude. Cependant, la commande sera convertie en SamplePulse avec la méthode qiskit.pulse.ParametricPulse.get_sample_pulse() , de sorte que l'impulsion affichée peut ne pas échantillonner la fonction continue de la même manière que le backend.

Cette fonction peut être utilisée pour construire des programmes d'impulsions pour n'importe quel backend, mais les impulsions seront converties en objets SamplePulse si le backend ne prend pas en charge les impulsions paramétriques. Les backends qui les prennent en charge auront le nouvel attribut suivant :
```
backend.configuration().parametric_pulses: List[str]
# e.g. ['gaussian', 'drag', 'constant']
```
Notez que le backend ne doit pas nécessairement prendre en charge toutes les impulsions paramétriques définies dans Qiskit.

Lorsque le backend prend en charge les impulsions paramétriques et que le programme d'impulsions est construit avec elles, le Qobj assemblé est nettement plus petit. La taille d'un site PulseQobj construit entièrement avec des impulsions paramétriques ne dépend que du nombre d'instructions, alors que la taille d'un site PulseQobj construit autrement augmentera avec la durée des instructions (puisque chaque échantillon doit être spécifié avec une valeur).

Ajout des fonctions utilitaires qiskit.scheduler.measure() et qiskit.scheduler.measure_all() au module qiskit.scheduler. Ces fonctions renvoient un objet qiskit.pulse.Schedule qui mesure les qubits à l'aide de OpenPulse. Par exemple :

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})

Les objets Pulse qiskit.pulse.Schedule ont désormais de meilleures représentations qui, pour les calendriers simples, devraient être des expressions Python valides.
Les qiskit.circuit.QuantumCircuit méthodes qiskit.circuit.QuantumCircuit.measure_active(), qiskit.circuit.QuantumCircuit.measure_all(), et qiskit.circuit.QuantumCircuit.remove_final_measurements() ont maintenant un kwarg supplémentaire inplace. Lorsque inplace est défini sur False , la fonction renvoie une copie modifiée du circuit. Ceci est différent du comportement par défaut qui modifie l'objet circuit sur place et ne renvoie rien.
Plusieurs nouvelles méthodes de construction ont été ajoutées à la classe qiskit.transpiler.CouplingMap pour construire des objets avec des graphes de couplage de qubits de base. Les nouvelles méthodes de construction sont les suivantes
Par exemple, pour utiliser les nouveaux constructeurs afin d'obtenir une carte de couplage de 5 qubits connectés dans une chaîne linéaire, vous pouvez maintenant exécuter :
```
from qiskit.transpiler import CouplingMap

coupling_map = CouplingMap.from_line(5)
coupling_map.draw()
```
Introduction d'un nouveau laissez-passer qiskit.transpiler.passes.CrosstalkAdaptiveSchedule. Cette passe vise à réduire l'impact du bruit de diaphonie sur un programme. Il utilise les données de caractérisation de la diaphonie provenant du backend pour programmer les portes. Lorsqu'une paire de portes présente une forte diaphonie, elles sont sérialisées à l'aide d'une barrière. La sérialisation naïve est nuisible car elle entraîne des erreurs de décohérence. Par conséquent, ce passage utilise une approche d'optimisation SMT pour calculer un programme qui minimise l'impact de la diaphonie ainsi que les erreurs de décohérence.

La passe prend en entrée un circuit déjà transposé dans le backend, c'est-à-dire que le circuit est exprimé en termes de qubits physiques et que les portes de permutation ont été insérées et décomposées en CNOT si nécessaire. En utilisant ce circuit et les données de caractérisation de la diaphonie, une optimisation Z3 est utilisée pour construire un nouveau circuit programmé en sortie.

Pour utiliser la passe sur un circuit 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 est un objet qiskit.providers.models.BackendProperties pour le backend cible. crosstalk_prop est un dict qui spécifie les taux d'erreur conditionnels. Pour deux portes g1 et g2, crosstalk_prop[g1][g2] spécifie le taux d'erreur conditionnel de g1 lorsque g1 et g2 sont exécutés simultanément. Une méthode pour générer crosstalk_prop sera ajoutée dans une prochaine version de qiskit-ignis. En attendant, vous devrez soit connaître les propriétés de diaphonie de votre appareil, soit réaliser manuellement vos propres expériences de caractérisation de l'appareil.
Dans le gestionnaire de passes prédéfinies pour le niveau d'optimisation 1, qiskit.transpiler.preset_passmanagers.level_1_pass_manager() si qiskit.transpiler.passes.TrivialLayout n'est pas une correspondance parfaite pour un circuit particulier, alors qiskit.transpiler.passes.DenseLayout est utilisé à la place.
Ajout d'une nouvelle méthode abstraite qiskit.quantum_info.Operator.dot() à la classe abstraite BaseOperator , de sorte qu'elle est incluse dans toutes les implémentations de cette classe abstraite, y compris les classes qiskit.quantum_info.Operator et QuantumChannel (par exemple, qiskit.quantum_info.Choi). Cette méthode renvoie l'opérateur droit de multiplication a.dot(b) $= a \cdot b$ . Cela équivaut à appeler la méthode operator qiskit.quantum_info.Operator.compose() avec le kwarg front fixé à True.
Ajouté qiskit.quantum_info.average_gate_fidelity() et qiskit.quantum_info.gate_error() au module qiskit.quantum_info pour travailler avec qiskit.quantum_info.Operator et QuantumChannel (par exemple, qiskit.quantum_info.Choi).

Ajout de la fonction qiskit.quantum_info.partial_trace() à la fonction qiskit.quantum_info qui fonctionne avec qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix les classes d'états quantiques. Par exemple :

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])

Quand qiskit.circuit.QuantumCircuit.draw() ou qiskit.visualization.circuit_drawer() est appelé avec le kwarg with_layout fixé à True (par défaut), la visualisation de sortie affichera désormais les qubits physiques sous forme d'entiers afin de les distinguer clairement des qubits virtuels.

Par exemple :
```
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')
```
Ajout de nouvelles fonctions de mesure de l'état au module qiskit.quantum_info module : qiskit.quantum_info.entropy(), qiskit.quantum_info.mutual_information(), qiskit.quantum_info.concurrence(), et qiskit.quantum_info.entanglement_of_formation(). Ces fonctions fonctionnent avec les boutons qiskit.quantum_info.Statevector et qiskit.quantum_info.DensityMatrix et.
Les méthodes de décomposition pour les portes à un seul qubit en qiskit.quantum_info.synthesis.one_qubit_decompose.OneQubitEulerDecomposer ont été étendues pour inclure maintenant la base 'ZXZ' , caractérisée par trois rotations autour de l'axe Z, X, Z. Cela signifie maintenant qu'un opérateur général 2x2 peut être décomposé dans les bases suivantes : U3, U1X, ZYZ, ZXZ, XYX, ZXZ.

Problèmes connus

L'exécution des fonctions qui utilisent qiskit.tools.parallel_map() (par exemple qiskit.execute.execute(), qiskit.compiler.transpile(), et qiskit.transpiler.PassManager.run()) peuvent ne pas fonctionner lorsqu'elles sont appelées à partir d'un script s'exécutant en dehors d'un bloc if __name__ == '__main__': lors de l'utilisation de Python 3.8 sur MacOS. Les autres environnements ne sont pas concernés par ce problème. Ceci est dû à des changements dans la façon dont les processus parallèles sont lancés par Python 3.8 sur MacOS. Si RuntimeError ou AttributeError sont soulevés par des scripts qui appellent directement parallel_map() ou lors de l'appel d'une fonction qui l'utilise en interne avec Python 3.8 sur MacOS, l'intégration des appels de script dans if __name__ == '__main__': devrait permettre de résoudre le problème. Par exemple :
```
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'))
```
Doit être remplacée par :
```
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()
```
si des erreurs sont rencontrées avec Python 3.8 sur MacOS.

Mise à niveau

La valeur du paramètre rep_time de l'objet de configuration du backend Pulse est désormais exprimée en secondes et non en microsecondes. La première fois qu'un objet PulseBackendConfiguration est initialisé, un avertissement unique est envoyé à l'utilisateur pour l'en avertir.
L'argument rep_time pour qiskit.compiler.assemble() prend désormais une valeur en secondes, et non en microsecondes. Cela a été fait pour que les unités soient compatibles avec tous les autres éléments de l'impulsion. Si vous avez transmis une valeur pour rep_time , veillez à mettre à jour la valeur pour tenir compte de ce changement.
La valeur de la propriété base_gate des objets qiskit.circuit.ControlledGate est passée de la classe de la porte de base à une instance de la classe de la porte de base.

La propriété base_gate_name de qiskit.circuit.ControlledGate a été supprimée; vous pouvez obtenir le nom de la porte de base en accédant à base_gate.name sur l'objet. Par exemple :

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

Modifié qiskit.quantum_info.Operator afin que __mul__ (qui est exécuté par l'opération de multiplication de Python, si le côté gauche de l'opération est défini) mette en œuvre la multiplication matricielle droite (c.-à-d. qiskit.quantum_info.Operator.dot()), et __rmul__ (qui est exécuté par l'opération de multiplication de Python à partir du côté droit de l'opération si le côté gauche n'a pas défini __mul__ ) met en œuvre la multiplication scalaire (c'est-à-dire qiskit.quantum_info.Operator.multiply()). Auparavant, les deux méthodes mettaient en œuvre la multiplication scalaire.
Le deuxième argument de la fonction qiskit.quantum_info.process_fidelity()target , est désormais facultatif. Si aucune unité cible n'est spécifiée, la fidélité du processus du canal d'entrée avec l'opérateur d'identité sera renvoyée.
qiskit.compiler.assemble() respectera désormais la valeur de max_shots configurée pour un backend. Si une valeur pour le kwarg shots est spécifiée et qu'elle dépasse les tirs maximaux définis dans la configuration du backend, la fonction lèvera désormais une exception QiskitError . En outre, si aucun argument de tir n'est fourni, la valeur par défaut est soit 1024 (comportement précédent), soit max_shots à partir du backend, selon la valeur la plus basse.

Remarques concernant la dépréciation

Les méthodes d'ajout de portes à un qiskit.circuit.QuantumCircuit dont les arguments sont des mots-clés abrégés (par exemple ctl, tgt) ont été renommées pour être plus descriptives (par exemple control_qubit, target_qubit). Les anciens noms ont été abandonnés. Un tableau reprenant les anciennes et nouvelles signatures d'appel pour les méthodes QuantumCircuit est inclus ci-dessous.

Type d'instruction	Ancienne signature	Nouvelle signature
`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'exécution de qiskit.pulse.Acquire sur plusieurs qubits a été dépréciée et sera supprimée dans une prochaine version. En outre, les paramètres qiskit.pulse.AcquireInstruction mem_slots et reg_slots ont été supprimés. Il convient d'utiliser plutôt reg_slot et mem_slot .
L'attribut de la classe qiskit.providers.models.PulseDefaultscircuit_instruction_map est obsolète et sera supprimé dans une prochaine version. Au lieu de cela, vous devez utiliser le nouvel attribut instruction_schedule_map. Ceci a été fait pour correspondre au type de la valeur de l'attribut, qui est un InstructionScheduleMap.

La commande qiskit.pulse.PersistentValue est obsolète et sera supprimée dans une prochaine version. Une fonctionnalité similaire peut être obtenue avec la commande qiskit.pulse.ConstantPulse (l'une des nouvelles impulsions paramétriques). Comparez les éléments suivants :

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 dans qiskit-terra est obsolète. La prise en charge sera supprimée dans la première version après la date de fin de vie de la version de la communauté Python en amont, qui est le 13 septembre 2020.
Le kwarg require_cptp de la fonction qiskit.quantum_info.process_fidelity() est obsolète et sera supprimée dans une prochaine version. Il est remplacé par deux kwargs distincts require_cp et require_tp.
Réglage du paramètre scale pour qiskit.circuit.QuantumCircuit.draw() et qiskit.visualization.circuit_drawer() comme premier argument positionnel est déprécié et sera supprimé dans une prochaine version. Au lieu de cela, vous devez utiliser scale comme mot-clé.

Le module qiskit.tools.qi.qi est obsolète et sera supprimé dans une prochaine version. Les anciennes fonctions du module ont toutes été remplacées par des fonctions et des classes du module qiskit.quantum_info module. Vous trouverez ci-dessous un tableau des fonctions obsolètes et de leur remplacement :

Obsolète	Remplacement
`qiskit.tools.partial_trace()`	`qiskit.quantum_info.partial_trace()`
`qiskit.tools.choi_to_pauli()`	`qiskit.quantum_info.Choi` et `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`

Le module qiskit.quantum_info.states.states est obsolète et sera supprimé dans une prochaine version. Les anciennes fonctions du module ont toutes été remplacées par des fonctions et des classes du module qiskit.quantum_info module.

Obsolète
Remplacement
qiskit.quantum_info.states.states.basis_state qiskit.quantum_info.Statevector.from_label()
qiskit.quantum_info.states.states.projector qiskit.quantum_info.DensityMatrix
Le paramètre scaling de la méthode draw() pour les objets Schedule et Pulse est obsolète et sera supprimé dans une prochaine version. Le nouveau paramètre scale doit être utilisé à la place. Ceci a été fait afin d'avoir une argumentation cohérente entre les dessins d'impulsions et les dessins de circuits. Par exemple :
```
#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)
```

Obsolète	Remplacement
`qiskit.quantum_info.states.states.basis_state`	`qiskit.quantum_info.Statevector.from_label()`
`qiskit.quantum_info.states.states.projector`	`qiskit.quantum_info.DensityMatrix`

Corrections des erreurs

Auparavant, l'appel à qiskit.circuit.QuantumCircuit.bind_parameters() avant de décomposer un circuit, les valeurs liées n'étaient pas correctement substituées dans les portes décomposées. Ce problème a été résolu de manière à ce que la liaison et la décomposition puissent se produire dans n'importe quel ordre. Corrige le problème #2482 et le problème #3509
Jusqu'à présent, le site Collect2qBlocks pass n'avait pas pris en compte les conditions classiques pour déterminer s'il convenait d'inclure un portail dans un bloc existant. Dans certains cas, les conditions classiques ont été perdues lors de la transposition avec optimization_level=3. Ce problème a été résolu de manière à ce que les portes conditionnées de manière classique ne soient jamais incluses dans un bloc. Corrige le problème #3215
Tous les types de sortie pour les tiroirs du circuit dans qiskit.circuit.QuantumCircuit.draw() et qiskit.visualization.circuit_drawer() ont un support fixe et/ou amélioré pour les portes personnalisées contrôlées par dessin. Corrige le problème #3546, le problème #3763, et le problème #3764
Des explications et des exemples ont été ajoutés à la documentation sur les qiskit.circuit.QuantumCircuit pour l'ajout de portes : 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(). Corrige le problème #3400
Correction de la gestion du paramètre des nombres complexes dans la visualisation des circuits. Corrige le problème #3640

Autres remarques

Les passes de transpilation du répertoire qiskit.transpiler.passes ont été organisées en sous-répertoires afin de mieux les classer par fonctionnalité. Ils sont toujours accessibles sous l'espace de noms qiskit.transpiler.passes .

Aer 0.4.0

Ajouté

Ajout de NoiseModel.from_backend pour construire un modèle de bruit de base pour un backend IBMQ (#569)

Ajout de méthodes de simulation compatibles avec le multi-GPU aux sites QasmSimulator, StatevectorSimulator, et UnitarySimulator. Le simulateur qasm dispose d'une version gpu des méthodes de la matrice de densité et du vecteur d'état et est accessible en utilisant "method": "density_matrix_gpu" ou "method": "statevector_gpu" dans backend_options. La méthode du simulateur de vecteur d'état gpu est accessible à l'aide de "method": "statevector_gpu". La méthode GPU du simulateur unitaire est accessible à l'aide de "method": "unitary_gpu". Ces backends utilisent CUDA et nécessitent un GPU NVidia (#544)

Ajout du backend PulseSimulator (#542)

Ajout des classes PulseSystemModel et HamiltonianModel pour représenter les modèles à utiliser dans PulseSimulator (#496, #493)

Ajout de duffing_model_generators pour générer des objets PulseSystemModel à partir d'une liste de paramètres (#516)

Migration du solveur de fonctions ODE en C++ (#442, #350)

Ajout de tests de haut niveau pour le simulateur d'impulsion (#379)

Drapeau CMake BLAS_LIB_PATH pour définir le chemin de recherche de la librairie BLAS (#543)

Changé

Modification de la structure du répertoire src pour organiser le code source du simulateur. Les en-têtes du contrôleur du simulateur ont été déplacés vers src/controllers et les en-têtes de l'état de la méthode du simulateur sont dans src/simulators (#544)

Déplacement de l'emplacement de plusieurs fonctions (#568) : * Déplacement du contenu de qiskit.provider.aer.noise.errors dans le module qiskit.providers.noise * Déplacement du contenu de qiskit.provider.aer.noise.utils dans le module qiskit.provider.aer.utils .

Activation de l'optimisation pour agréger des portes consécutives dans un circuit (fusion) par défaut (#579).

Obsolète

Fonctions utils.qobj_utils obsolètes (#568)

Déclassé qiskit.providers.aer.noise.device.basic_device_noise_model. Elle est remplacée par la méthode NoiseModel.from_backend (#569)

Supprimé

Suppression des méthodes NoiseModel.as_dict, QuantumError.as_dict, ReadoutError.as_dict, et QuantumError.kron qui étaient obsolètes dans 0.3 (#568).

Ignis 0.2

Aucun changement

Aqua 0.6

Aucun changement

IBM 0.4.6 du fournisseur Q

Ajouté

Plusieurs nouvelles méthodes ont été ajoutées à IBMQBackend:
- wait_for_final_state() jusqu'à ce que le travail soit terminé. Il prend une fonction de rappel qu'il invoquera après chaque requête pour fournir un retour d'information.
- active_jobs() renvoie les travaux soumis à un backend qui sont actuellement dans un état non terminé.
- job_limit() renvoie la limite de travail pour un backend.
- remaining_jobs_count() renvoie le nombre de travaux que vous pouvez soumettre au backend avant que la limite de travaux ne soit atteinte.
QueueInfo dispose désormais d'une nouvelle méthode format() qui renvoie une chaîne formatée d'informations sur la file d'attente.
IBMQJob dispose désormais de trois nouvelles méthodes : done(), running(), et cancelled() qui sont utilisées pour indiquer le statut de l'emploi.
qiskit.providers.ibmq.ibmqbackend.IBMQBackend.run() accepte désormais un paramètre facultatif job_tags. Si elles sont spécifiées, les étiquettes du travail sont attribuées au travail, ce qui peut être utilisé ultérieurement comme filtre dans qiskit.providers.ibmq.ibmqbackend.IBMQBackend.jobs().
IBMQJobManager dispose désormais d'une nouvelle méthode retrieve_job_set() qui vous permet de récupérer un ensemble de travaux précédemment soumis en utilisant l'identifiant de l'ensemble de travaux.

Changé

La hiérarchie du site Exception a été affinée avec des classes plus spécialisées. Vous pouvez cependant continuer à attraper leurs exceptions parentales (telles que IBMQAccountError). De même, la classe d'exception IBMQApiUrlError a été remplacée par IBMQAccountCredentialsInvalidUrl et IBMQAccountCredentialsInvalidToken.

Obsolète

L'utilisation d'urls proxy sans protocole (par exemple http://) est obsolète en raison des récents changements apportés à Python.

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.