Qiskit 0.40 Versionshinweise

0.40.0

Mit dieser Version wird das Qiskit IBMQ-Provider-Projekt als Teil des Qiskit-Metapakets offiziell abgeschafft. Das bedeutet, dass pip install qiskit in einer zukünftigen Version nicht mehr automatisch qiskit-ibmq-provider enthalten wird. Wenn Sie derzeit qiskit als Abhängigkeit installieren oder auflisten, um qiskit-ibmq-provider zu erhalten, sollten Sie aktualisieren, um auch qiskit-ibmq-provider explizit einzuschließen. Dies geschieht in dem Maße, in dem sich das Qiskit-Projekt auf ein Modell zubewegt, bei dem das Paket qiskit nur noch die gemeinsame Kernfunktionalität für die Erstellung und Kompilierung von Quantenschaltungen, Programmen und Anwendungen enthält. Pakete, die auf diesem Kern aufbauen oder Qiskit mit Hardware oder Simulatoren verbinden, können als separate Pakete installiert werden.

Terra- 0.23.0

Vorspiel

Qiskit Terra 0.23.0 ist eine neue Version, die eine Vielzahl von neuen Funktionen und Fehlerbehebungen enthält. Die Highlights dieser Veröffentlichung sind:

Unterstützung für den Import von OpenQASM 3 Programmen und die Erstellung von QuantumCircuit objekten aus dem Eingabeprogramm über zwei neue Funktionen qiskit.qasm3.load() und qiskit.qasm3.loads().

Verbesserungen an der Bibliothek der in Qiskit enthaltenen Synthesealgorithmen. Dazu gehören die folgenden neuen Synthesefunktionen:

Clifford-Synthese

synth_clifford_layers()

synth_clifford_greedy()

Lineare Funktionssynthese:

synth_cnot_depth_line_kms()

synth_cnot_count_full_pmh()

Permutationssynthese:

synth_permutation_basic()

synth_permutation_acg()

synth_permutation_depth_lnn_kms()

SolovayKitaevDecomposition ausführlich in: https://arxiv.org/abs/quant-ph/0505030

Neue Plugins für HighLevelSynthesis:

ACGSynthesisPermutation

KMSSynthesisPermutation

BasicSynthesisPermutation

Neues Plugin für UnitarySynthesis

SolovayKitaevSynthesis

Leistungsverbesserungen für SabreLayout. Der Pass ist nun hauptsächlich in Rust geschrieben, was zu einer Laufzeitverbesserung führen kann, aber die größere Verbesserung liegt in der Qualität der Ausgabe (im Durchschnitt werden weniger SwapGate gatter, die durch SabreSwap). Zum Beispiel, wenn Sie SabreLayout und SabreSwap auf Bernstein-Vazirani-Schaltungen, die auf das FakeSherbrooke backend die folgenden Ergebnisse:

Mit dieser Version wird auch die Unterstützung für die Ausführung mit Python 3.7 veraltet. Ein DeprecationWarning wird nun ausgegeben, wenn Sie Qiskit mit Python 3.7 ausführen. Die Unterstützung für Python 3.7 wird im Rahmen der Veröffentlichung von 0.25.0 (derzeit geplant für Juli 2023) entfernt werden. Zu diesem Zeitpunkt benötigen Sie Python 3.8 oder neuer, um Qiskit zu verwenden.

Neue Funktionen

Die Impulse in qiskit.pulse.library
kann mit dem neuen Parameter angle initialisiert werden, so dass zwei Float-Parameter bereitgestellt werden können: amp und angle. Die Initialisierung mit komplexen amp wird weiterhin unterstützt.

Die Klasse AdaptVQE klasse hat ein neues Attribut, eigenvalue_history, das dazu dient, die niedrigste erreichte Energie pro Iteration der AdaptVQE zu verfolgen. Zum Beispiel:

from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.minimum_eigensolvers.adapt_vqe import AdaptVQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import EvolvedOperatorAnsatz
from qiskit.opflow import PauliSumOp
from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp
from qiskit.utils import algorithm_globals

excitation_pool = [
    PauliSumOp(
        SparsePauliOp(["IIIY", "IIZY"], coeffs=[0.5 + 0.0j, -0.5 + 0.0j]), coeff=1.0
    ),
    PauliSumOp(
        SparsePauliOp(["ZYII", "IYZI"], coeffs=[-0.5 + 0.0j, 0.5 + 0.0j]), coeff=1.0
    ),
    PauliSumOp(
        SparsePauliOp(
            ["ZXZY", "IXIY", "IYIX", "ZYZX", "IYZX", "ZYIX", "ZXIY", "IXZY"],
            coeffs=[
                -0.125 + 0.0j,
                0.125 + 0.0j,
                -0.125 + 0.0j,
                0.125 + 0.0j,
                0.125 + 0.0j,
                -0.125 + 0.0j,
                0.125 + 0.0j,
                -0.125 + 0.0j,
            ],
        ),
        coeff=1.0,
    ),
]
ansatz = EvolvedOperatorAnsatz(excitation_pool, initial_state=self.initial_state)
optimizer = SLSQP()
h2_op = PauliSumOp.from_list(
    [
        ("IIII", -0.8105479805373266),
        ("ZZII", -0.2257534922240251),
        ("IIZI", +0.12091263261776641),
        ("ZIZI", +0.12091263261776641),
        ("IZZI", +0.17218393261915543),
        ("IIIZ", +0.17218393261915546),
        ("IZIZ", +0.1661454325638243),
        ("ZZIZ", +0.1661454325638243),
        ("IIZZ", -0.2257534922240251),
        ("IZZZ", +0.16892753870087926),
        ("ZZZZ", +0.17464343068300464),
        ("IXIX", +0.04523279994605788),
        ("ZXIX", +0.04523279994605788),
        ("IXZX", -0.04523279994605788),
        ("ZXZX", -0.04523279994605788),
    ]
)

algorithm_globals.random_seed = 42
calc = AdaptVQE(VQE(Estimator(), ansatz, self.optimizer))
res = calc.compute_minimum_eigenvalue(operator=h2_op)

print(calc.eigenvalue_history)

der zurückgegebene Wert von calc.history sollte ungefähr [-1.85727503] sein, da es sich um eine einzige Iteration handelt.

Die Laufzeitprotokollierung bei der Ausführung des Programms AdaptVQE wurde verbessert. Wenn die Klasse jetzt ausgeführt wird, werden Protokollmeldungen der Ebenen DEBUG und INFO ausgegeben, während die Klasse läuft.
Es wurde ein neuer Transpiler-Durchgang CollectAndCollapse hinzugefügt, um Blöcke von Knoten in einem Schaltkreis zu sammeln und zu konsolidieren. Dieser Pass ist als allgemeine Basisklasse für die kombinierte Sammlung und Konsolidierung von Blöcken gedacht. Um ganz allgemein zu sein, wird die Arbeit des Sammelns und Zusammenlegens der Blöcke durch Funktionen erledigt, die bei der Instanziierung des Passes bereitgestellt werden. Zum Beispiel wurde die CollectLinearFunctions wurde aktualisiert, um von CollectAndCollapse zu erben und sammelt Blöcke von CXGate und SwapGate toren und ersetzt jeden Block durch ein LinearFunction. Das Programm CollectCliffords das nun ebenfalls auf CollectAndCollapse basiert, sammelt Blöcke von "Clifford"-Gattern und ersetzt jeden Block durch ein Clifford.

Die Schnittstelle unterstützt auch die Option do_commutative_analysis, die es ermöglicht, die Kommutativität zwischen Gattern auszunutzen, um größere Blöcke von Knoten zu sammeln. Zum Beispiel, das Sammeln von Blöcken von CX-Gattern in der folgenden Schaltung:
```
qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.z(0)
qc.cx(1, 0)
```
die Verwendung von do_commutative_analysis ermöglicht die Konsolidierung der beiden CX-Tore, da das erste CX-Tor und das Z-Tor pendeln.
Hinzufügen einer neuen Klasse BlockCollector , die verschiedene Sammelstrategien implementiert, und einer neuen Klasse BlockCollapser , die verschiedene Kollabierungsstrategien implementiert. Derzeit umfasst BlockCollector die Strategie, alle Gatter, die einer bestimmten Filterfunktion entsprechen, gierig zu sammeln (z. B. alle Clifford-Gatter), und BlockCollapser umfasst die Strategie, alle Gatter in einem Block zu einem einzigen Objekt zu konsolidieren (z. B. kann ein Block von Clifford-Gattern zu einem einzigen Objekt konsolidiert werden Clifford).
Hinzufügen eines neuen CollectCliffords transpiler-Durchgang hinzugefügt, der Blöcke von Clifford-Gattern sammelt und diese Blöcke zu qiskit.quantum_info.Clifford objekten zusammenfasst. Dieser Pass erbt von CollectAndCollapse und unterstützt insbesondere die Option do_commutative_analysis. Es unterstützt auch zwei zusätzliche Optionen split_blocks und min_block_size. Siehe die Versionshinweise für CollectAndCollapse und CollectLinearFunctions für zusätzliche Details.
Der CollectLinearFunctions transpiler-Pass hat mehrere neue Argumente in seinem Konstruktor:
- do_commutative_analysis: ermöglicht die Ausnutzung der Kommutativität zwischen den Gattern, um größere Blöcke von Knoten zu sammeln.
- split_blocks: ermöglicht die Aufteilung gesammelter Blöcke in Unterblöcke über disjunkte Teilmengen von Qubits. Zum Beispiel in der folgenden Schaltung:
```
qc = QuantumCircuit(4)
qc.cx(0, 2)
qc.cx(1, 3)
qc.cx(2, 0)
qc.cx(3, 1)
qc.cx(1, 3)
```
  kann der einzelne Block von CX-Gattern über Qubits {0, 1, 2, 3} in zwei disjunkte Teilblöcke aufgeteilt werden, einen über Qubits {0, 2} und den anderen über Qubits {1, 3}.
- min_block_size: Ermöglicht die Angabe der Mindestgröße des zu konsolidierenden Blocks; Blöcke mit weniger Gates werden nicht geändert. Zum Beispiel in der folgenden Schaltung:
```
qc = QuantumCircuit(4)
qc.cx(1, 2)
qc.cx(2, 1)
```
  die beiden CX-Gatter werden zusammengelegt, wenn min_block_size 1 oder 2 ist, und bleiben unverändert, wenn min_block_size 3 oder größer ist.
Hinzufügen eines tiefenwirksamen Synthesealgorithmus synth_cnot_depth_line_kms() für lineare reversible Schaltungen LinearFunction über die lineare Nearest-Neighbor-Architektur, in Anlehnung an das Papier: https://arxiv.org/abs/quant-ph/0701194.
Die Methode DAGCircuit.replace_block_with_op() methode gibt nun den neuen DAGOpNode zurück, das beim Ersetzen des Blocks erstellt wird. Zuvor gab der Aufruf dieser Methode nichts zurück.
Hinzufügen eines tiefenwirksamen Synthesealgorithmus synth_permutation_depth_lnn_kms() für Permutation über die lineare Nearest-Neighbor-Architektur, in Anlehnung an das Papier: https://arxiv.org/abs/quant-ph/0701194
Hinzufügen einer neuen Klasse PermutationGate zur Darstellung von Permutationslogik als Schaltungselement. Im Gegensatz zu dem bestehenden Permutation schaltungsbibliothekselement, das eine statische Definition hatte, vermeidet diese neue Klasse die Synthese einer Permutationsschaltung, wenn sie deklariert wird. Dadurch wird die eigentliche Synthese zum Transpiler verzögert. Es ermöglicht auch die Verwendung verschiedener Algorithmen zur Synthese von Permutationen, die als High-Level-Synthese-Plugins für Permutationen verfügbar sind.

Ein weiteres Hauptmerkmal der PermutationGate ist die Implementierung der Schnittstelle __array__ zur effizienten Rückgabe einer unitären Matrix für eine Permutation.

Mehrere High-Level-Synthese-Plugins für die Synthese von Permutationen hinzugefügt:

BasicSynthesisPermutation: gilt für vollständig vernetzte Architekturen und basiert auf Sortierung. Dies ist der bisher verwendete Algorithmus zur Konstruktion von Quantenschaltungen für Permutationen.

ACGSynthesisPermutation: gilt für vollständig verbundene Architekturen, basiert aber auf der Methode von Alon, Chung und Graham. Es synthetisiert jede Permutation in der Tiefe 2 (gemessen in SWAPs).

KMSSynthesisPermutation: gilt für lineare Architekturen mit nächsten Nachbarn und entspricht der kürzlich hinzugefügten Methode von Kutin, Moulton und Smithline.

Zum Beispiel:

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PermutationGate
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig, HighLevelSynthesis
from qiskit.transpiler.passes.synthesis.plugin import HighLevelSynthesisPluginManager

# Create a permutation and add it to a quantum circuit
perm = PermutationGate([4, 6, 3, 7, 1, 2, 0, 5])
qc = QuantumCircuit(8)
qc.append(perm, range(8))

# Print available plugin names for synthesizing permutations
# Returns ['acg', 'basic', 'default', 'kms']
print(HighLevelSynthesisPluginManager().method_names("permutation"))

# Default plugin for permutations
# Returns a quantum circuit with size 6 and depth 3
qct = PassManager(HighLevelSynthesis()).run(qc)
print(f"Default: {qct.size() = }, {qct.depth() = }")

# KMSSynthesisPermutation plugin for permutations
# Returns a quantum circuit with size 18 and depth 6
# but adhering to the linear nearest-neighbor architecture.
qct = PassManager(HighLevelSynthesis(HLSConfig(permutation=[("kms", {})]))).run(qc)
print(f"kms: {qct.size() = }, {qct.depth() = }")

# BasicSynthesisPermutation plugin for permutations
# Returns a quantum circuit with size 6 and depth 3
qct = PassManager(HighLevelSynthesis(HLSConfig(permutation=[("basic", {})]))).run(qc)
print(f"basic: {qct.size() = }, {qct.depth() = }")

# ACGSynthesisPermutation plugin for permutations
# Returns a quantum circuit with size 6 and depth 2
qct = PassManager(HighLevelSynthesis(HLSConfig(permutation=[("acg", {})]))).run(qc)
print(f"acg: {qct.size() = }, {qct.depth() = }")

Neue Klassen für die Algorithmen Quantum Fisher Information (QFI) und Quantum Geometric Tensor (QGT) mit primitives, qiskit.algorithms.gradients.QFI und qiskit.algorithms.gradients.LinCombQGTzum Modul Gradienten hinzugefügt: qiskit.algorithms.gradients. Zum Beispiel:

from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.algorithms.gradients import LinCombQGT, QFI

estimator = Estimator()
a, b = Parameter("a"), Parameter("b")
qc = QuantumCircuit(1)
qc.h(0)
qc.rz(a, 0)
qc.rx(b, 0)

parameter_value = [[np.pi / 4, 0]]

qgt = LinCombQGT(estimator)
qgt_result = qgt.run([qc], parameter_value).result()

qfi = QFI(qgt)
qfi_result = qfi.run([qc], parameter_value).result()

Ein neues Schlüsselwortargument, derivative_type, wurde dem Konstruktor für die LinCombEstimatorGradient. Dieses Argument nimmt ein DerivativeType enum auf, mit dem angegeben werden kann, ob nur die realen oder imaginären Teile des Gradienten berechnet werden sollen.
Eine neue Option circuit_reverse_bits wurde zur Benutzerkonfigurationsdatei hinzugefügt. Dies ermöglicht es den Benutzern, einen Booleschen Wert für das bevorzugte Standardverhalten des reverse_bits Arguments der Schaltkreiszeichner zu setzen QuantumCircuit.draw() und circuit_drawer(). Fügen Sie z. B. der Benutzerkonfigurationsdatei am Standardspeicherort ~/.qiskit/settings.conf einen Abschnitt mit hinzu:
```
[default]
circuit_reverse_bits = True
```
ändert die Standardeinstellung so, dass die Bits in umgekehrter Reihenfolge angezeigt werden.
Eine neue Klasse hinzugefügt Z2Symmetries zu qiskit.quantum_info hinzugefügt, die verwendet wird, um alle $Z_2$ Symmetrien aus einer Eingabe zu identifizieren SparsePauliOp.
Eine neue Impulsrichtlinie hinzugefügt TimeBlockade. Diese Anweisung verhält sich fast genauso wie die Anweisung delay, wird aber vor der Ausführung entfernt. Diese Richtlinie ist für die interne Verwendung im Pulse Builder vorgesehen und hilft ScheduleBlock anweisungen mit absoluten Zeitintervallen darzustellen. Dies ermöglicht es dem Pulsersteller, Schedule in ScheduleBlock umzuwandeln, anstatt mit Call anweisungen.

Hinzufügen von primitiv-aktivierten Algorithmen für die Variationsquantenzeitentwicklung, die die Schnittstelle für die Quantenzeitentwicklung implementieren. Die qiskit.algorithms.VarQRTE klasse wird für reelle und die qiskit.algorithms.VarQITE klasse wird für die imaginäre Quantenzeitentwicklung nach einem übergebenen Variationsprinzip verwendet.

Jeder Algorithmus akzeptiert ein Variationsprinzip, das die ImaginaryVariationalPrinciple abstrakte Schnittstelle implementiert. Die folgenden Implementierungen sind enthalten:

ImaginaryMcLachlanPrinciple

RealMcLachlanPrinciple

Zum Beispiel:

from qiskit.algorithms import TimeEvolutionProblem, VarQITE
from qiskit.algorithms.time_evolvers.variational import ImaginaryMcLachlanPrinciple
from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import SparsePauliOp
import numpy as np

observable = SparsePauliOp.from_list(
    [
        ("II", 0.2252),
        ("ZZ", 0.5716),
        ("IZ", 0.3435),
        ("ZI", -0.4347),
        ("YY", 0.091),
        ("XX", 0.091),
    ]
)

ansatz = EfficientSU2(observable.num_qubits, reps=1)
init_param_values = np.zeros(len(ansatz.parameters))
for i in range(len(ansatz.parameters)):
    init_param_values[i] = np.pi / 2
var_principle = ImaginaryMcLachlanPrinciple()
time = 1
evolution_problem = TimeEvolutionProblem(observable, time)
var_qite = VarQITE(ansatz, var_principle, init_param_values)
evolution_result = var_qite.evolve(evolution_problem)

Regeln für die Konvertierung von XXPlusYYGate und XXMinusYYGate in andere Gates auf der SessionEquivalenceLibrary. Dies ermöglicht die Ausführung transpile() die auf ein Backend oder Target das diese Gates verwendet.
Zwei neue Fake-Backends hinzugefügt, FakePrague und FakeSherbrooke zum qiskit.providers.fake_provider modul. FakePrague bietet ein Backend mit einem Schnappschuss der Eigenschaften des IBM Prague Egret R1 Backends und FakeSherbrooke bietet ein Backend mit einem Schnappschuss der Eigenschaften des IBM Sherbrooke Eagle R3 Backends.
Ein neues Schlüsselwortargument, allow_unknown_parameters, wurde zu den ParameterExpression.bind() und ParameterExpression.subs() methoden. Wenn dieses neue Argument gesetzt ist, kann ein Wörterbuch mit unbekannten Parametern an diese Methoden übergeben werden, ohne dass ein Fehler ausgelöst wird. Zuvor führte dies immer zu einer Fehlermeldung, ohne dass es eine Möglichkeit gab, dieses Verhalten zu deaktivieren.
Die Methode BaseEstimator.run() das Argument observables der Methode akzeptiert nun zusätzlich zu den anderen bereits akzeptierten Typen den Eingabetyp str oder eine Folge von str . Wenn sie verwendet wird, sollte das Format der Eingabestrings mit der Pauli-String-Darstellung übereinstimmen, die vom Konstruktor für Pauli objekte akzeptiert.

Hinzufügen einer neuen Konstruktor-Methode QuantumCircuit.from_instructions() hinzugefügt, die die Erstellung eines QuantumCircuit objekts aus einer Iterable von Anweisungen ermöglicht. Zum Beispiel:

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.quantumcircuitdata import CircuitInstruction
from qiskit.circuit import Measure
from qiskit.circuit.library import HGate, CXGate


qr = QuantumRegister(2)
cr = ClassicalRegister(2)
instructions = [
    CircuitInstruction(HGate(), [qr[0]], []),
    CircuitInstruction(CXGate(), [qr[0], qr[1]], []),
    CircuitInstruction(Measure(), [qr[0]], [cr[0]]),
    CircuitInstruction(Measure(), [qr[1]], [cr[1]]),
]
circuit = QuantumCircuit.from_instructions(instructions)
circuit.draw("mpl")

Die Klasse Clifford klasse nimmt jetzt ein optionales copy Schlüsselwortargument in ihrem Konstruktor auf. Bei False wird ein StabilizerTable als Eingabe nicht kopiert, sondern direkt verwendet. Dies kann Leistungsvorteile bringen, wenn die Daten in der Tabelle niemals auf andere Weise verändert werden.
Die Leistung von Clifford.compose() wurde für alle Zahlen von Qubits erheblich verbessert. Für Operatoren mit 20 Qubits liegt die Beschleunigung in der Größenordnung des 100-fachen.

Hinzufügen einer neuen Synthesefunktion synth_clifford_layers()zum Synthetisieren einer Clifford in Schichten. Der Algorithmus basiert auf S. Bravyi, D. Maslov, Hadamard-freie Schaltungen legen die Struktur der Clifford-Gruppe offen, arxiv:2003.09412. Dadurch wird der Clifford-Baustein in 8 Schichten von Gattern zerlegt, darunter zwei Schichten von CZ-Gattern und eine Schicht von CX-Gattern. Eine 5-Qubit-Clifford-Schaltung wird beispielsweise in die folgenden Schichten zerlegt:

     ┌─────┐┌─────┐┌────────┐┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0       ├┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1       ├┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_2: ┤2 S2 ├┤2 CZ ├┤2 CX_dg ├┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3       ├┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4       ├┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
     └─────┘└─────┘└────────┘└─────┘└─────┘└─────┘└─────┘└────────┘

Diese Methode ermöglicht die Zerlegung von a Clifford in die 2-Qubit-Tiefe $7n+2$ für die LNN-Konnektivität (Linear Nearest Neighbour) zu zerlegen.

Die Rückgabetypen für die power() methoden mehrerer Standardbibliotheks-Gate-Klassen wurden aktualisiert, um spezifischere Gate-Objekte zurückzugeben, die zu einer weniger verlustbehafteten und effizienteren Ausgabe führen. Zum Beispiel gibt die Ausführung von power() gibt jetzt eine IGate instanz anstelle von UnitaryGate zurück, wie es vorher der Fall war.

Die vollständige Liste der verbesserten Nachrichtenarten lautet wie folgt:

Tor-Klasse	Ausgabeklasse von `power()`
`CPhaseGate`	`CPhaseGate`
`CSGate`	`CPhaseGate`
`CSdgGate`	`CPhaseGate`
`IGate`	`IGate`.
`PhaseGate`	`PhaseGate`
`RGate`	`RGate`
`RXGate`	`RXGate`
`RXXGate`	`RXXGate`
`RYGate`	`RYGate`
`RYYGate`	`RYYGate`
`RZGate`	`RZGate`
`RZXGate`	`RZXGate`
`RZZGate`	`RZZGate`
`SdgGate`	`PhaseGate`
`SGate`	`PhaseGate`
`TdgGate`	`PhaseGate`
`TGate`	`PhaseGate`
`XXMinusYYGate`	`XXMinusYYGate`
`XXPlusYYGate`	`XXPlusYYGate`
`ZGate`	`PhaseGate`
`iSwapGate`	`XXPlusYYGate`

Die EquivalenceLibrary wird nun intern als PyDiGraph dargestellt. Auf dieses zugrunde liegende Graph-Objekt kann über das neue graph attribut zugreifen. Dieses Attribut ist für die interne Verwendung in Qiskit vorgesehen und sollte daher immer kopiert werden, bevor es vom Benutzer geändert wird, um eine mögliche Beschädigung des internen Äquivalenzgraphen zu verhindern.
Die Operator.from_circuit() konstruktormethode kehrt nun die durch die Routing/Swap-Mapping-Phase des Transpilers verursachte Ausgabe-Permutation um. Wenn in eine transpilierte Schaltung Swap-Gatter eingefügt wurden, wird die Ausgangsmatrix standardmäßig die umgekehrte Permutation aufweisen, so dass die zurückgegebene Matrix der ursprünglichen, nicht transpilierten Schaltung entspricht. Wenn Sie dieses Standardverhalten deaktivieren möchten, kann das Schlüsselwortargument ignore_set_layout auf True gesetzt werden, um dies zu tun (zusätzlich zum vorherigen Verhalten, das ursprüngliche Layout aus der Transpilierung zu ignorieren). Wenn Sie ein endgültiges Layout manuell festlegen möchten, können Sie das neue Schlüsselwortargument final_layout verwenden, um ein Layout objekt übergeben, das für die Ausgabe-Permutation verwendet wird.
Unterstützung für den GateDirection transpilerpasses zur Behandlung der symmetrischen RXXGate, RYYGate, und RZZGate gatter. Der Pass behandelt diese Gates nun korrekt und kehrt die qargs-Reihenfolge einfach um, ohne weitere Änderungen vorzunehmen.
Unterstützung für die Verwendung des Python Potenzierungsoperators, **, mit Gate objekten wird nun unterstützt. Dies ist gleichbedeutend mit der Ausführung der Gate.power() methode auf das Objekt anzuwenden.

Zum Beispiel:
```
from qiskit.circuit.library import XGate

sx = XGate() ** 0.5
```
Neue Impulsform GaussianSquareDrag zum Modul hinzugefügt qiskit.pulse.library modul. Diese Impulsform ist ähnlich wie GaussianSquare verwendet aber die Drag form während des Anstiegs und Abfalls. Die Korrektur der DRAG-Pulsform kann einen Teil des Frequenzspektrums des Pulsanstiegs und -abfalls unterdrücken, was dazu beitragen kann, die Anregung von Spektator-Qubits zu vermeiden, wenn deren Frequenz nahe bei der Antriebsfrequenz des Pulses liegt.

Ein neues Schlüsselwortargument, method, wurde zu den Konstruktoren für die FiniteDiffEstimatorGradient und FiniteDiffSamplerGradient klassen. Das Argument method akzeptiert eine Zeichenkette zur Angabe der Berechnungsmethode, die für den Gradienten verwendet werden soll. Es stehen drei Methoden zur Verfügung: "central", "forward" und "backward". Die Definition der Methoden sind:

Methode	Berechnung
`"central"`	$\frac{f(x+e)-f(x-e)}{2e}$
`"forward"`	$\frac{f(x+e) - f(x)}{e}$
`"backward"`	$\frac{f(x)-f(x-e)}{e}$

wobei $e$ das Offset-Epsilon ist.

Alle Gradientenklassen in qiskit.algorithms.gradients behalten nun unparametrisierte Operationen bei, anstatt zu versuchen, sie abzurollen. Dadurch können Gradienten auf benutzerdefinierten, undurchsichtigen Gattern ausgewertet werden, die von einzelnen Primitiven verarbeitet werden können, und es wird eine höhere Abstraktionsebene für optimierte Synthese und Kompilierung beibehalten, nachdem die Gradientenschaltungen konstruiert wurden.
Hinzugefügt wurde ein TranslateParameterizedGates durchgang hinzugefügt, um nur parametrisierte Gatter in einer Schaltung auf eine bestimmte Basis abzubilden, nicht parametrisierte Gatter jedoch unberührt zu lassen. Der Durchlauf versucht zunächst das Abrollen und übersetzt schließlich, wenn ein parametrisiertes Tor nicht weiter abgerollt werden kann.

Der CollectCliffords transpiler-Pass wurde erweitert, um Blöcke von "Clifford-Gattern" zu sammeln und zu kombinieren Clifford objekten zu sammeln und zu kombinieren, wobei "clifford gates" nun auch Objekte des Typs LinearFunction, Clifford, und PauliGate. Zum Beispiel:

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import LinearFunction, PauliGate
from qiskit.quantum_info.operators import Clifford
from qiskit.transpiler.passes import CollectCliffords
from qiskit.transpiler import PassManager

# Create a Clifford
cliff_circuit = QuantumCircuit(2)
cliff_circuit.cx(0, 1)
cliff_circuit.h(0)
cliff = Clifford(cliff_circuit)

# Create a linear function
lf = LinearFunction([[0, 1], [1, 0]])

# Create a pauli gate
pauli_gate = PauliGate("XYZ")

# Create a quantum circuit with the above and also simple clifford gates.
qc = QuantumCircuit(4)
qc.cz(0, 1)
qc.append(cliff, [0, 1])
qc.h(0)
qc.append(lf, [0, 2])
qc.append(pauli_gate, [0, 2, 1])
qc.x(2)

# Run CollectCliffords transpiler pass
qct = PassManager(CollectCliffords()).run(qc)

Alle Gates werden gesammelt und zu einem einzigen zusammengefasst Clifford. Die endgültige Schaltung besteht also aus einem einzigen Clifford objekt.

CouplingMap ist nun implizit iterierbar, wobei die Iteration identisch ist mit der Iteration durch die Ausgabe von CouplingMap.get_edges(). Mit anderen Worten,
```
from qiskit.transpiler import CouplingMap
coupling = CouplingMap.from_line(3)
list(coupling) == list(coupling.get_edges())
```
wird nun wie erwartet funktionieren, ebenso wie andere Iterationen. Dies ist eine rein syntaktische Vereinfachung.
Eine neue Funktion wurde hinzugefügt synth_cnot_count_full_pmh() hinzugefügt, die zur Synthese von linearen reversiblen Schaltungen für All-to-All-Architekturen unter Verwendung der Patel-, Markov- und Hayes-Methode verwendet wird. Diese Funktion ist identisch mit der verfügbaren Funktion qiskit.transpiler.synthesis.cnot_synth() , hat aber einen aussagekräftigeren Namen und ist logischer im Paketbaum platziert. Diese neue Funktion ersetzt die alte Funktion, die wahrscheinlich in einer zukünftigen Version veraltet sein wird.
InstructionScheduleMap wurde aktualisiert, um Backend-Kalibrierungsdaten im Format PulseQobj JSON zu speichern und die Konvertierung aufzurufen, wenn zum ersten Mal auf die Daten zugegriffen wird, d. h. eine "Lazy Conversion". Diese interne Logikaktualisierung verbessert die Leistung des Lade-Backends drastisch, insbesondere bei vielen Kalibrierungseinträgen.
Es wurde ein neues Modul qiskit.pulse.calibration_entries hinzugefügt. Diese enthält mehrere Wrapper-Klassen für verschiedene Impulsplan-Darstellungen.
- ScheduleDef
- CallableDef
- PulseQobjDef
Diese Klassen implementieren die Methoden get_schedule() und get_signature() , die den Impulsplan bzw. die zuzuweisenden Parameternamen zurückgeben. Diese Klassen werden intern von der InstructionScheduleMap oder Backend Targetverwaltet und werden daher in einem typischen Benutzerprogramm nicht angezeigt.
Es wurde eine neue Unterklasse ScalableSymbolicPulse eingeführt, die eine Unterklasse von SymbolicPulse. Die neue Unterklasse verhält sich genauso wie SymbolicPulsemit der Ausnahme, dass sie davon ausgeht, dass die Hüllkurve des Impulses einen komplexen Amplituden-Vorfaktor der Form $\text{amp} * e^{i \times \text{angle}}$ enthält. Diese Hüllkurvenform passt zu vielen gängigen Impulsen, einschließlich aller Impulse in der Qiskit Pulse-Bibliothek (die in dieser Version auch in die Darstellung amp, angle konvertiert wurden).

Die neue Unterklasse beseitigt die nicht eindeutige Natur der Darstellung amp, angle und vergleicht die Impulse korrekt nach ihrer komplexen Amplitude.
Ein neues Schlüsselwortargument, dtype, wurde der PauliSumOp.from_list() methode. Wenn angegeben, kann dieses Argument verwendet werden, um die dtype des Numpy-Arrays anzugeben, das für die SparsePauliOp das intern von der konstruierten PauliSumOp.
Es wurde Unterstützung für den Import von OpenQASM 3 Programmen in Qiskit hinzugefügt. Dies ist am einfachsten mit den Funktionen qasm3.loads() und qasm3.load()um ein Programm direkt aus einer Zeichenkette bzw. indirekt aus einem Dateinamen zu laden. Zum Beispiel kann man jetzt tun:
```
from qiskit import qasm3

circuit = qasm3.loads("""
  OPENQASM 3.0;
  include "stdgates.inc";

  qubit q;
  qubit[5] qr;
  bit c;
  bit[5] cr;

  h q;
  c = measure q;

  if (c) {
    h qr[0];
    cx qr[0], qr[1];
    cx qr[0], qr[2];
    cx qr[0], qr[3];
    cx qr[0], qr[4];
  } else {
    h qr[4];
    cx qr[4], qr[3];
    cx qr[4], qr[2];
    cx qr[4], qr[1];
    cx qr[4], qr[0];
  }
  cr = measure qr;
""")
```
Dadurch wird das Programm in eine QuantumCircuit instanz in die Variable circuit.

Zunächst werden nicht alle Funktionen von OpenQASM 3 unterstützt, da Qiskit noch nicht über eine Möglichkeit verfügt, fortgeschrittene klassische Datenverarbeitung darzustellen. Die Fähigkeiten des Importeurs werden zusammen mit den Fähigkeiten des restlichen Qiskit wachsen. Die anfängliche Merkmalsmenge des Importeurs entspricht ungefähr der Menge der Merkmale, die der Exporteur ausgeben würde (qasm3.dump() und qasm3.dumps()).

Beachten Sie, dass die Unterstützung von OpenQASM 3 durch Qiskit nicht dazu gedacht ist, eine völlig verlustfreie Darstellung von QuantumCircuits. Ziehen Sie dafür die Verwendung von qiskit.qpy.
Die primitives-basierten Gradientenklassen, die durch die BaseEstimatorGradient und BaseSamplerGradient definierten abstrakten Klassen wurden aktualisiert, um die Erweiterung der Basisschnittstelle zu vereinfachen. Es gibt drei neue interne Methoden, die überschrieben werden können: _preprocess(), _postprocess(), und _run_unique(). _preprocess() ermöglicht einer Unterklasse die Anpassung der Eingangsgradientenschaltungen und -parameter, _postprocess ermöglicht die Anpassung des Ausgangsergebnisses, und _run_unique ermöglicht die Berechnung des Gradienten einer Schaltung mit eindeutigen Parametern.
Der SabreLayout transpiler-Pass hat seine Leistung erheblich verbessert, da er in Rust neu geschrieben wurde. Im Rahmen dieser Neufassung wurde der Durchlauf von einem Analysedurchlauf in einen Transformationsdurchlauf umgewandelt, der sowohl Layout als auch Routing durchführt. Dies wurde getan, um nicht nur die Laufzeitleistung, sondern auch die Qualität der Ergebnisse zu verbessern. Die bisherige Funktionalität des Durchlaufs als Analysedurchlauf kann beibehalten werden, indem das Argument routing_pass manuell gesetzt oder das neue Argument skip_routing verwendet wird.
Der SabreLayout transpilerpass hat ein neues Konstruktorargument layout_trials. Dieses Argument wird verwendet, um zu kontrollieren, wie viele Zufallszahlengenerator-Samen versucht werden SabreLayout mit. Wenn diese Option aktiviert ist, wird der SABRE-Layout-Algorithmus layout_trials so oft wie möglich ausgeführt, und die beste Qualität (gemessen an der geringsten Anzahl der hinzugefügten Swap-Gates) wird ausgewählt. Diese Seed-Versuche werden parallel unter Verwendung von Multithreading ausgeführt, um den potenziellen Leistungsaufwand zu minimieren, der durch die mehrfache Ausführung des Layouts entsteht. Wenn dies nicht angegeben ist, wird standardmäßig die SabreLayout pass standardmäßig die Anzahl der physischen CPUs, die auf dem lokalen System verfügbar sind.

Zwei neue Klassen hinzugefügt SciPyRealEvolver und SciPyImaginaryEvolver die Integrationsmethoden für die zeitliche Entwicklung eines Quantenzustandes implementieren. Der Wert und die Standardabweichung der Observablen sowie die Zeitpunkte, zu denen sie ausgewertet werden, können abgefragt werden als TimeEvolutionResult.observables und TimeEvolutionResult.times. Zum Beispiel:

from qiskit.algorithms.time_evolvers.time_evolution_problem import TimeEvolutionProblem
from qiskit.quantum_info import SparsePauliOp
from qiskit.quantum_info.states.statevector import Statevector
from qiskit.algorithms import SciPyImaginaryEvolver

initial_state = Statevector.from_label("+++++")
hamiltonian = SparsePauliOp("ZZZZZ")
evolution_problem = TimeEvolutionProblem(hamiltonian, 100, initial_state, {"Energy":hamiltonian})
classic_evolver = SciPyImaginaryEvolver(num_timesteps=300)
result = classic_evolver.evolve(evolution_problem)
print(result.observables)

Hinzufügen des SolovayKitaev transpiler-Passus hinzugefügt, um den Solovay-Kitaev-Algorithmus zur Annäherung von Ein-Qu-Bit-Unitarien unter Verwendung einer diskreten Gattermenge auszuführen. In Kombination mit dem Basisübersetzer kann so jede unitäre Schaltung in eine universelle diskrete Gattermenge umgewandelt werden, die fehlertolerant implementiert werden kann.

Dieser Pass kann z.B. nach dem Kompilieren zu U- und CX-Toren verwendet werden:

from qiskit import transpile
from qiskit.circuit.library import QFT
from qiskit.transpiler.passes.synthesis import SolovayKitaev

qft = QFT(3)

# optimize to general 1-qubit unitaries and CX
transpiled = transpile(qft, basis_gates=["u", "cx"], optimization_level=1)

skd = SolovayKitaev()  # uses T Tdg and H as default basis
discretized = skd(transpiled)

print(discretized.count_ops())

Die Zerlegung kann auch mit dem unitären Synthese-Plugin verwendet werden, da die Methode "sk" im UnitarySynthesis transpiler-Durchgang:

from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
from qiskit.transpiler.passes import UnitarySynthesis

circuit = QuantumCircuit(1)
circuit.rx(0.8, 0)
unitary = Operator(circuit).data

unitary_circ = QuantumCircuit(1)
unitary_circ.unitary(unitary, [0])

synth = UnitarySynthesis(basis_gates=["h", "s"], method="sk")
out = synth(unitary_circ)

out.draw('mpl')

Die Erzeugung von Zufallsschaltungen mit qiskit.circuit.random.random_circuit() ist jetzt bei großen Schaltungen deutlich schneller.
Die Erzeugung von Zufallsschaltungen mit qiskit.circuit.random.random_circuit() gibt nun alle "Standard"-Gatter in Qiskits Schaltkreisbibliothek (qiskit.circuit.library). Dazu gehören zwei 4-Qubit-Gatter C3SXGate und RC3XGateund die erlaubten Werte von max_operands wurden entsprechend erweitert.
Der Optimize1qGatesDecomposition transpilerpass hat ein neues Schlüsselwortargument, target, in seinem Konstruktor. Dieses Argument kann verwendet werden, um ein Target objekt anzugeben, das das Kompilierungsziel repräsentiert. Wenn es verwendet wird, überlagert es das Argument basis , um festzustellen, ob eine Anweisung in der Schaltung auf dem Ziel-Backend vorhanden ist.
Der UnrollCustomDefinitions transpilerpass hat ein neues Schlüsselwortargument, target, in seinem Konstruktor. Dieses Argument kann verwendet werden, um ein Target objekt anzugeben, das das Kompilierungsziel repräsentiert. Wenn es verwendet wird, überlagert es das Argument basis_gates , um festzustellen, ob eine Anweisung in der Schaltung auf dem Ziel-Backend vorhanden ist.

Hinzufügen der ReverseEstimatorGradient klasse für eine klassische, schnelle Auswertung von Erwartungswertgradienten auf Basis von Backpropagation oder Reverse-Mode-Gradienten. Diese Klasse verwendet Zustandsvektoren und liefert somit exakte Gradienten, skaliert aber exponentiell mit der Systemgröße. Es ist für die schnelle Referenzberechnung kleinerer Systemgrößen konzipiert. Es kann zum Beispiel verwendet werden als:

from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import SparsePauliOp
from qiskit.algorithms.gradients import ReverseEstimatorGradient

observable = SparsePauliOp.from_sparse_list([("ZZ", [0, 1], 1)], num_qubits=10)
circuit = EfficientSU2(num_qubits=10)
values = [i / 100 for i in range(circuit.num_parameters)]
gradient = ReverseEstimatorGradient()

result = gradient.run([circuit], [observable], [values]).result()

Ein neues Schlüsselwortargument, use_dag , wurde zum Konstruktor für die OneQubitEulerDecomposer klasse. Wenn use_dag auf True gesetzt ist, ist die Ausgabe des Dekomposers ein DAGCircuit objekt statt eines QuantumCircuit objekt. Dies ist nützlich für Transpilerübergänge, die OneQubitEulerDecomposer (wie zum Beispiel Optimize1qGatesDecomposition), da das direkte Arbeiten mit einer DAGCircuit den Overhead der Konvertierung zwischen QuantumCircuit und DAGCircuit.
Für Analysedurchläufe wurde die Möglichkeit hinzugefügt, benutzerdefinierte heuristische Gewichtungen für die VF2Layout und VF2PostLayout transpiler-Durchläufe festzulegen. Wenn ein Analysedurchgang den Schlüssel vf2_avg_error_map im Eigenschaftssatz setzt, wird sein Wert für die Fehlergewichte anstelle der Fehlerquoten aus dem Backend verwendet Target (oder BackendProperties für BackendV1). Der Wert sollte eine ErrorMap Instanz sein, wobei jeder Wert die durchschnittliche Fehlerrate für alle 1 oder 2 Qubit Operationen auf diesen Qubits darstellt. Wenn ein Wert NaN ist, wird die entsprechende Kante als ideale Kante (oder Qubit für 1q Operationen) behandelt. Zum Beispiel wird eine Fehlerkarte erstellt als:
```
from qiskit.transpiler.passes.layout.vf2_utils import ErrorMap

error_map = ErrorMap(3)
error_map.add_error((0, 0), 0.0024)
error_map.add_error((0, 1), 0.01)
error_map.add_error((1, 1), 0.0032)
```
beschreibt ein 2-Qubit-Target, bei dem die durchschnittliche 1q -Fehlerrate 0.0024 auf Qubit 0 und 0.0032 auf Qubit 1 ist, die durchschnittliche 2q -Fehlerrate für Gatter, die auf (0, 1) arbeiten, ist 0.01, und (1, 0) wird vom Target nicht unterstützt. Dies wird für die Bewertung verwendet, wenn es für den Schlüssel vf2_avg_error_map in der Eigenschaft festgelegt ist, wenn VF2Layout und VF2PostLayout ausgeführt werden. Zum Beispiel:
```
from qiskit.transpiler import AnalysisPass, PassManager, Target
from qiskit.transpiler.passes import VF2Layout
from qiskit.transpiler.passes.layout.vf2_utils import ErrorMap
from qiskit.circuit.library import CZGate, UGate
from qiskit.circuit import Parameter

class CustomVF2Scoring(AnalysisPass):
  """Set custom score for vf2."""

  def run(self, dag):
    error_map = ErrorMap(3)
    error_map.add_error((0, 0), 0.0024)
    error_map.add_error((0, 1), 0.01)
    error_map.add_error((1, 1), 0.0032)
    self.property_set["vf2_avg_error_map"] = error_map


target = Target(num_qubits=2)
target.add_instruction(
    UGate(Parameter('theta'), Parameter('phi'), Parameter('lam')),
    {(0,): None, (1,): None}
)
target.add_instruction(
    CZGate(), {(0, 1): None}
)

vf2_pass = VF2Layout(target=target, seed=1234568942)
pm = PassManager([CustomVF2Scoring(), vf2_pass])
```
Das wird laufen VF2Layout mit dem benutzerdefinierten Scoring von error_map für ein 2-Qubit Target das keine Fehlerraten enthält.

Anmerkungen zu Upgrades

Bei der Initialisierung einer der Pulsklassen in qiskit.pulse.library:
ein komplexes Argument amp mit einem endlichen angle ergibt PulseError jetzt. Zum Beispiel sollte man statt Gaussian(duration=100,sigma=20,amp=0.5j) jetzt Gaussian(duration=100,sigma=20,amp=0.5,angle=np.pi/2) verwenden. Die Impulseinhüllende, die früher als amp * ... definiert war, ist nun wiederum als amp * exp(1j * angle) * ... definiert. Diese Änderung wurde vorgenommen, um Qiskit-Experimente besser zu unterstützen, bei denen die Amplitude und der Winkel von Impulsen in separaten Experimenten kalibriert werden.
Für Python 3.7 ist singledispatchmethod jetzt eine Abhängigkeit. Dies wurde hinzugefügt, um den Methodenversandmechanismus in der Standardbibliothek neuerer Versionen von Python nutzen zu können. Wenn Sie mit Python >= 3.8 arbeiten, ist keine zusätzliche Abhängigkeit erforderlich.
Der zuvor veraltete MSBasisDecomposer Transpiler-Pass, der über das qiskit.transpiler.passes modul verfügbar war, wurde entfernt. Ursprünglich wurde es mit der Veröffentlichung von Qiskit Terra 0.16.0 (16.10.2020) veraltet. Stattdessen sollte der BasisTranslator transpiler-Pass verwendet werden, um eine Schaltung in eine geeignete Basis mit einer RXXGate
EquivalenceLibrary objekte, die mit dem Attribut base initialisiert werden, haben keine gemeinsame Referenz mehr mit dem EquivalenceLibrary übergeben. Wenn Sie in früheren Versionen base mutierten, nachdem es zur Erstellung einer neuen Instanz verwendet wurde EquivalenceLibrary instanz verwendet wurde, würden beide Instanzen diese Änderung widerspiegeln. Dies ist nicht mehr der Fall, und Aktualisierungen von base werden nicht mehr in der neuen EquivalenceLibrary. Zum Beispiel, wenn Sie eine Äquivalenzbibliothek mit:
```
import math

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import XGate
from qiskit.circuit.equivalence import EquivalenceLibrary

original_lib = EquivalenceLibrary()
qc = QuantumCircuit(1)
qc.rx(math.pi, 0)
original_lib.add_equivalence(XGate(), qc)
new_lib = EquivalenceLibrary(base=original_lib)
```
wenn Sie original_lib mit geändert haben:
```
import from qiskit.circuit.library import SXGate

qc = QuantumCircuit(1)
qc.rx(math.pi / 2, 0)
original_lib.add_equivalence(SXGate(), qc)
```
in früheren Versionen enthielt new_lib auch die Definition von SXGate , nachdem sie zu original_lib hinzugefügt worden war, aber in dieser Version wird dies nicht mehr der Fall sein. Diese Änderung wurde vorgenommen, weil die interne Datenstruktur in einen Graphen umgewandelt wurde, was die Leistung der EquivalenceLibrary klasse verbessert, insbesondere wenn mehrere Durchläufe des BasisTranslator transpiler-Durchlaufs.
Das Argument initial_state für den Konstruktor der Klasse NLocal klasse sowie die direkte Zuweisung an das Attribut NLocal.initial_state muss ein QuantumCircuit sein. Die Unterstützung für die Verwendung anderer Typen für dieses Argument und Attribut wird nicht mehr unterstützt. Die Unterstützung für andere Typen wurde im Rahmen der Veröffentlichung von Qiskit Terra 0.18.0 (Juli 2021) veraltet.
Die LaTeX Array-Schubladen (z.B. array_to_latex, Statevector.draw('latex')) verwenden jetzt die gleiche sympy-Funktion wie die ket-Konventionsschublade. Das bedeutet, dass einige Zahlen anders dargestellt werden können als in früheren Versionen, aber sie werden eine einheitlichere Darstellung bieten. So können beispielsweise neue Faktoren identifiziert oder Nenner rationalisiert werden, die zuvor nicht bekannt waren. Die Standardeinstellung precision wurde von 5 auf 10 geändert.
Die Version des QPY-Versionsformats, die von dump() ausgegeben wird, wurde auf Version 6 erhöht. Diese neue Formatversion ist inkompatibel mit den Vorgängerversionen und führt zu einem Fehler, wenn versucht wird, sie mit einem Deserialisierer zu laden, der nicht in der Lage ist, QPY Version 6 zu verarbeiten. Diese Änderung war notwendig, um die Einführung von ScalableSymbolicPulse zu unterstützen, die durch Hinzufügen eines class_name_size -Attributs zum Header der gedumpten SymbolicPulse objekte.
Die Methode __hash__ für die SymbolicPulse wurde entfernt. Dies geschah, um die veränderliche Natur (über die Parameterzuweisung) dieser Klasse widerzuspiegeln, die zu Fehlern führen konnte, wenn man SymbolicPulse in Situationen, in denen ein hashfähiges Objekt benötigt wird. Das bedeutet, dass die eingebaute Methode hash() und die Verwendung von SymbolicPulse als Schlüssel in Wörterbüchern oder Mengenmitgliedern wird nicht mehr funktionieren.
Die Namen der Register instanzen (einschließlich der Instanzen von QuantumRegister und ClassicalRegigster) müssen nicht mehr zwangsläufig gültige OpenQASM 2 Bezeichner sein. Dies geschieht, da die Einschränkung zu streng ist, da Qiskit immer mehr von OpenQASM 2 entkoppelt wird und sogar die OpenQASM 3 Spezifikation nicht so restriktiv ist. Wenn Sie sich darauf verlassen haben, dass die Register gültige OpenQASM 2 Bezeichnernamen haben, müssen Sie damit beginnen, die Namen zu escapen. Eine vereinfachte Version dieses Vorgangs könnte zum Beispiel wie folgt aussehen:
```
import re
import string

def escape(name: str) -> str:
  out = re.sub(r"\W", "_", name, flags=re.ASCII)
  if not out or out[0] not in string.ascii_lowercase:
    return "reg_" + out
  return out
```
Die Methoden QuantumCircuit methoden u1, u2, u3, und ihre kontrollierten Varianten cu1, cu3 und mcu1 wurden entfernt, nachdem sie in Qiskit Terra 0.16.0 veraltet sind. Damit wurden die üblicherweise IBM -spezifischen Gatternamen zugunsten der allgemeineren Methoden p(), u(), cp() und cu(). Die Gatterklassen U1Gate, U2Gate und U3Gate sind weiterhin für die Verwendung mit QuantumCircuit.append()verfügbar, so dass Backends weiterhin Basen mit diesen explizit angegebenen Gates unterstützen können.
Die Methoden QuantumCircuit methoden combine und extend wurden entfernt, nachdem sie in Qiskit Terra 0.17.0 veraltet sind. Dies wurde getan, weil diese Funktionen einfach weniger leistungsfähige Versionen von QuantumCircuit.compose()waren, die stattdessen verwendet werden sollten.

Die Entfernung von extend bedeutet auch, dass die Operatoren + und += nicht mehr definiert sind für QuantumCircuit. Stattdessen können Sie die Operatoren & und &= verwenden, die mit QuantumCircuit.compose().
Die zuvor veralteten Funktionen qiskit.circuit.measure.measure() und qiskit.circuit.reset.reset() wurden entfernt. Diese Funktionen wurden in der Version Qiskit Terra 0.19.0 (Dezember 2021) veraltet. Stattdessen sollten Sie die QuantumCircuit.measure() und QuantumCircuit.reset() methoden des QuantumCircuit objekts verwenden, an das Sie eine Measure oder Reset operation anhängen möchten.
Die zuvor veralteten Methoden von ParameterView , die von set geerbt wurden, wurden aus ParameterView entfernt, der Typ, der von QuantumCircuit.parameters. Die folgenden spezifischen Methoden wurden gestrichen:
- add()
- difference()
- difference_update()
- discard()
- intersection()
- intersection_update()
- issubset()
- issuperset()
- symmetric_difference()
- symmetric_difference_update()
- union()
- update()
zusammen mit der Unterstützung für die Betreiber von Python :
- ixor: ^=
- isub: -=
- ior: |=
Diese wurden in der Version Qiskit Terra 0.17.0 (April 2021) veraltet. Der Typ ParameterView ist jetzt ein allgemeiner Sequenzansichtstyp und unterstützt diese set Operationen nicht mehr.
Die zuvor veralteten NetworkX konvertierungsmethoden für die DAGCircuit und DAGDependency klassen: DAGCircuit.to_networkx(), DAGCircuit.from_networkx(), und DAGDependency.to_networkx() wurden entfernt. Diese Methoden wurden ursprünglich als Teil der Qiskit Terra 0.21.0 Version (Juni 2022) veraltet. Qiskit verwendet rustworkx als Graphenbibliothek seit der Veröffentlichung von qiskit-terra 0.12.0 und seither ist die Konvertierungsfunktion NetworkX ein verlustbehafteter Prozess. Sie wurden ursprünglich hinzugefügt, damit Benutzer die NetworkX’s Algorithmen-Bibliothek nutzen können, um Funktionen zu verwenden, die in DAGCircuit und/oder rustworkx vorhanden sind. Seit dieser Zeit sind jedoch sowohl DAGCircuit und rustworkx ausgereift und bieten mehr Funktionalität, und die DAGCircuit ist für seinen Betrieb eng an rustworkx gekoppelt, und diese Konvertermethoden boten nur begrenzte Funktionalität und wurden daher entfernt.
tweedledum wurde als Kernanforderung von Qiskit Terra gestrichen. Die bereitgestellte Funktionalität (qiskit.circuit.classicalfunction) ist weiterhin verfügbar, wenn tweedledum manuell installiert wird, z. B. durch:
```
pip install tweedledum
```
Diese Änderung wurde vorgenommen, weil sich die Entwicklung von tweedledum verlangsamt hat und nicht mehr mit den neuen Versionen von Python und Betriebssystemen mithalten konnte, was einige Qiskit-Benutzer an der Installation von Qiskit hinderte.
Die faule optionale Kontrolleure HAS_MATPLOTLIB, HAS_PIL, HAS_PYLATEX und HAS_PDFTOCAIRO werden nicht mehr von qiskit.visualization, da sie in Qiskit Terra 0.21 veraltet sind. Der kanonische Ort für diese (und viele andere faule Prüfer) ist qiskit.utils.optionalsund alle vier Objekte können dort gefunden werden.
Das zuvor veraltete Argument gate für den Konstruktor des Decompose transpilerpasses wurde zusammen mit dem dazugehörigen Attribut Decompose.gate entfernt. Das Argument und das Attribut wurden mit dem Release von Qiskit Terra 0.19.0 (Dezember 2021) veraltet. Stattdessen sollte das Argument gates_to_decompose für den Konstruktor zusammen mit dem Attribut Decompose.gates_to_decompose verwendet werden. Das Argument und Attribut gates_to_decompose sollte die gleiche Funktion haben, hat aber einen eindeutigeren Namen und ermöglicht auch die Angabe von Listen von Gattern, anstatt nur ein einzelnes Gatter zu unterstützen.
Das zuvor veraltete label Argument für den Konstruktor der MCMT und MCMTVChain klassen wurde entfernt. Sie wurde mit der Veröffentlichung von Qiskit Terra 0.19.0 (Dezember 2021) veraltet. Die Verwendung des Arguments label für diese Klassen war undefiniertes Verhalten, da sie Unterklassen von QuantumCircuit anstatt von Instruction. Dies würde dazu führen, dass das zugewiesene Etikett im Allgemeinen ignoriert wird. Wenn Sie einer Instanz von label zuweisen müssen MCMT oder MCMTVChain zuweisen müssen, sollten Sie sie in eine Gate instanz mit to_gate() umwandeln und dann das gewünschte Label dem label attribut zu. Zum Beispiel:
```
from qiskit.circuit.library import MCMT, XGate

mcmt_circuit = MCMT(XGate(), 3, 2)
mcmt_gate = mcmt_circuit.to_gate()
mcmt_gate.label = "Custom MCMT X"
```
Die Abhängigkeit von retworkx für Qiskit wurde entfernt und durch die Bibliothek rustworkx ersetzt. Es handelt sich um dieselben Pakete, aber rustworkx ist der neue Name für retworkx , das im Rahmen der gemeinsamen Veröffentlichung von 0.12.0 umbenannt wurde. Wenn Sie zuvor retworkx 0.12.0 mit Qiskit verwendet haben, dann haben Sie bereits rustworkx installiert (retworkx 0.12.0 war nur ein redirect shim für die Abwärtskompatibilität). Diese Änderung wurde vorgenommen, um auf den neuen Paketnamen zu migrieren, der in Zukunft das einzige unterstützte Paket sein wird.
Das Standardverhalten des SabreLayout compilerpasses hat sich geändert. Der Durchlauf ist nicht länger ein AnalysisPass und berechnet standardmäßig das ursprüngliche Layout, wendet es auf die Schaltung an und führt außerdem SabreSwap intern und wendet die Swap-Zuordnung an und setzt die Eigenschaft final_layout mit der durch die Swap-Einfügungen verursachten Permutation. Dies bedeutet für Benutzer, die SabreLayout als Teil eines benutzerdefinierten PassManager laufen, müssen den Passmanager anpassen, um dies zu berücksichtigen (es sei denn, sie haben das Argument routing_pass für SabreLayout). Diese Änderung wurde vorgenommen, um die Qualität der Ausgabe zu verbessern, da Layout und Routingqualität eng miteinander verbunden sind SabreLayout führt nun mehrere parallele Seed-Versuche durch, und um zu berechnen, welches Seed die besten Ergebnisse liefert, müssen sowohl das Layout als auch das Routing zusammen durchgeführt werden. Es gibt drei Möglichkeiten, wie Sie die Verwendung Ihres benutzerdefinierten Pass-Managers anpassen können. Die erste besteht darin, dass Sie die Einbettung in Ihrem Preset-Pass-Manager vermeiden. Wenn Sie zuvor etwas wie:
```
from qiskit.transpiler import PassManager
from qiskit.transpiler.preset_passmanagers import common
from qiskit.transpiler.passes.SabreLayout

pm = PassManager()
pm.append(SabreLayout(coupling_map)
pm += common.generate_embed_passmanager(coupling_map)
```
um das Layout zu berechnen und es dann anzuwenden (worauf in der Regel das Routing folgte), können Sie die Verwendung so anpassen, dass sie einfach ist:
```
from qiskit.transpiler import PassManager
from qiskit.transpiler.preset_passmanagers import common
from qiskit.transpiler.passes.SabreLayout

pm = PassManager()
pm.append(SabreLayout(coupling_map)
```
als SabreLayout wendet das Layout an und Sie brauchen die Einbettungsphase nicht mehr. Alternativ können Sie auch das Argument routing_pass angeben, das SabreLayout zu seinem vorherigen Verhalten zurückkehrt. Wenn Sie zum Beispiel das Programm SabreLayout wie in früheren Versionen ausführen möchten, können Sie etwas wie folgt tun:
```
from qiskit.transpiler.passes import SabreSwap, SabreLayout
routing_pass = SabreSwap(
    coupling_map, "decay", seed=seed, fake_run=True
)
layout_pass = SabreLayout(coupling_map, routing_pass=routing_pass, seed=seed)
```
die dann SabreLayout als Analysedurchlauf ausgeführt und nur die Eigenschaft layout eingestellt. Der letzte Ansatz besteht darin, das Argument skip_routing auf SabreLayout zu nutzen. Wenn dieses Argument auf True gesetzt ist, wird die Anwendung des gefundenen Layouts und das Einfügen der Swap-Gates aus dem Routing übersprungen. Dies geht jedoch zu Lasten der Laufzeit, da SabreLayout weiterhin das Routing berechnet und diese Daten einfach nicht verwendet. Die beiden erstgenannten Ansätze sind mit keinem zusätzlichen Aufwand verbunden.
Die Layouts, die durch den SabreLayout pass (wenn ohne das Argument routing_pass ausgeführt) mit einem festen Seed-Wert berechnet werden, können sich gegenüber früheren Versionen ändern. Dies ist auf die Verwendung eines neuen Zufallszahlengenerators zurückzuführen, der im Rahmen der Neuschreibung des SabreLayout passes in Rust verwendet wird, der die Leistung erheblich verbessert hat. Wenn Sie auf eine konsistente Ausgabe angewiesen sind, können Sie den Durchlauf in einer früheren Version von Qiskit durchführen und die Funktion qiskit.qpy verwenden, um den Schaltkreis zu speichern und ihn dann mit der aktuellen Version zu laden. Alternativ dazu können Sie das Argument routing_pass explizit auf eine Instanz von SabreSwap setzen, um das vorherige Verhalten von SabreLayout:
```
from qiskit.transpiler.passes import SabreSwap, SabreLayout


routing_pass = SabreSwap(
    coupling_map, "decay", seed=seed, fake_run=True
)
layout_pass = SabreLayout(coupling_map, routing_pass=routing_pass, seed=seed)
```
die das Verhalten des Passes in der vorherigen Version widerspiegelt. Beachten Sie, dass Sie, wenn Sie das Argument swap_trials auf SabreLayout in früheren Versionen verwendet haben, wenn Sie die Verwendung an diese Form anpassen, müssen Sie das Argument trials für den SabreSwap konstruktor setzen müssen, wenn Sie die vorherige Ausgabe mit einem festen Seed beibehalten wollen.
Der genaue Schaltkreis, der von qiskit.circuit.random.random_circuit für ein bestimmtes Saatgut zurückgegeben wird, hat sich geändert. Dies ist auf Effizienzsteigerungen bei der internen Zufallszahlengenerierung für die Funktion zurückzuführen.
Die Versionsanforderung für das optionale Funktionspaket qiskit-toqm, das über pip install qiskit-terra[toqm] installiert werden kann, wurde von der Version 0.0.4 auf 0.1.0 angehoben. Um die toqm Routing-Methode mit transpile() zu verwenden, müssen Sie jetzt qiskit-toqm Version 0.1.0 oder neuer verwenden. Ältere Versionen sind für den Transpiler nicht mehr auffindbar.
Die Ausgabe QuasiDistribution der Methode Sampler.run wurde aktualisiert, um alle Zustände mit einer Wahrscheinlichkeit von Null herauszufiltern. Wenn nun ein gültiger Zustand in der Wörterbuchausgabe fehlt, kann davon ausgegangen werden, dass er eine Wahrscheinlichkeit von 0 hat. Zuvor wurden alle möglichen Ergebnisse für eine bestimmte Anzahl von Bits (z. B. für ein 3-Bit-Ergebnis 000, 001, 010, 011, 100, 101, 110 und 111) angezeigt, selbst wenn die Wahrscheinlichkeit eines bestimmten Zustands 0 war. Diese Änderung wurde vorgenommen, um die Größe der Ausgabe zu verringern, da bei einer größeren Anzahl von Bits die Ausgabegröße recht groß werden kann. Durch das Filtern der Nullwahrscheinlichkeitsresultate ist die Ausgabe auch mit anderen Implementierungen von BaseSampler.
Das Verhalten des Pulse Builders beim Aufruf von Schedule aufgerufen wird, wurde verbessert. Aufgerufene Zeitpläne werden intern in eine ScheduleBlock repräsentation umgewandelt und es wird nun immer ein Referenzmechanismus angewandt, anstatt die von der Anweisung umschlossenen Call anweisung. Beachten Sie, dass der konvertierte Block nicht unbedingt den ursprünglichen Ausrichtungskontext wiederherstellt. Dabei handelt es sich einfach um eine ASAP-ausgerichtete Folge von Impulsanweisungen mit absoluten Zeitabständen. Dies ist ein Upgrade der internen Darstellung von aufgerufenen Pulsprogrammen und somit keine API-Änderung. Allerdings ist die Call anweisung und Schedule nicht mehr im Pulsprogramm des Erbauers erscheinen. Diese Änderung garantiert, dass die generierten Fahrplanblöcke immer QPY-kompatibel sind. Wenn Sie die Ausgabeplananweisungen nach Callfiltern, können Sie stattdessen auf die ScheduleBlock.references zugreifen, um das aufgerufene Programm abzurufen.
RZXCalibrationBuilder und RZXCalibrationBuilderNoEcho transpiler pass wurden aktualisiert, um Folgendes zu erzeugen ScheduleBlock. Diese Änderung garantiert, dass die umgesetzten Schaltungen immer QPY-kompatibel sind. Wenn Sie direkt die Methode rescale_cr_inst()methode aus einem anderen Programm oder einer Pass-Subklasse verwenden, um den Kreuzresonanzimpuls des Geräts neu zu skalieren, wird diese Methode jetzt zu einem Pulsbuilder-Makro, und Sie müssen diese Methode im Pulsbuilder-Kontext verwenden, um die neue Version anzunehmen. Der Methodenaufruf injiziert eine Abspielanweisung in das Kontextimpulsprogramm, anstatt eine Play anweisung mit dem gestreckten Impuls zurückzugeben.

Hinweise zu veralteten Versionen

Die Unterstützung für die Ausführung von Qiskit mit Python 3.7 ist veraltet und wird in der Version qiskit-terra 0.25.0 entfernt. Das bedeutet, dass Sie ab der Version 0.25.0 die Version Python, die Sie verwenden, auf Python 3.8 oder höher aktualisieren müssen.
Die Klasse LinearFunctionsSynthesis ist jetzt veraltet und wird in einer zukünftigen Version entfernt werden. Sie wurde ersetzt durch die allgemeinere HighLevelSynthesis klasse ersetzt, die stattdessen verwendet werden sollte. Sie können zum Beispiel eine Instanz von HighLevelSynthesis instanziieren, die sich genauso verhält wie LinearFunctionSynthesis mit:
```
from qiskit.transpiler.passes import HighLevelSynthesis
from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig

HighLevelSynthesis(
    HLSConfig(
        linear_function=[("default", {})],
        use_default_on_unspecified=False,
    )
)
```

Die Unterstützung für die Übergabe von Listen von Argumentwerten an die transpile() funktion ist veraltet und wird in der Version 0.25.0 entfernt werden. Dies geschieht, um den Aufwand für die parallele Ausführung bei der gleichzeitigen Umsetzung mehrerer Schaltkreise erheblich zu reduzieren. Wenn Sie diese Funktion derzeit verwenden, können Sie stattdessen transpile() stattdessen mehrere Male aufrufen. Zum Beispiel, wenn Sie vorher etwas getan haben wie:

from qiskit.transpiler import CouplingMap
from qiskit import QuantumCircuit
from qiskit import transpile

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
results = transpile([qc] * 6, coupling_map=cmaps)

stattdessen sollten Sie etwas wie folgt ausführen:

from itertools import cycle
from qiskit.transpiler import CouplingMap
from qiskit import QuantumCircuit
from qiskit import transpile

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]

results = []
for qc, cmap in zip(cycle([qc]), cmaps):
    results.append(transpile(qc, coupling_map=cmap))

Sie können auch parallel_map() oder multiprocessing aus der Python Standardbibliothek verwenden, wenn Sie dies parallel ausführen möchten.

Die alte Version der Impulsschublade auf qiskit.visualization.pulse ist veraltet und wird in einer zukünftigen Version entfernt werden. Dazu gehören die Klassen ScheduleDrawer und :class`WaveformDrawer`. Dieses Modul wurde durch die Schublade qiskit.visualization.pulse_v2 abgelöst, und die typische Benutzer-API pulse_drawer() und PulseBlock.draw() sind bereits intern aktualisiert worden, um qiskit.visualization.pulse_v2 zu verwenden.
Die Methode pulse.Instruction.draw() ist veraltet und wird in einer zukünftigen Version entfernt. Die Notwendigkeit dieser Methode wurde durch die qiskit.visualization.pulse_v2 Schublade abgelöst, die keine Instrucion Objekte benötigt, um ihre eigene Zeichnungsmethode zu haben. Wenn Sie eine Impulsanweisung zeichnen müssen, sollten Sie die pulse_drawer() stattdessen verwenden.
Der Import qiskit.circuit.qpy_serialization ist veraltet, da QPY zur obersten Ebene aufgestiegen ist. Sie sollten die gleichen Objekte aus qiskit.qpy stattdessen importieren. Der alte Pfad wird in einer zukünftigen Version von Qiskit Terra entfernt werden.
Das Objekt qiskit.IBMQ ist veraltet. Dieses Alias-Objekt leitet den Zugriff auf Attribute auf qiskit.providers.ibmq.IBMQ um. Da das Paket qiskit-ibmq-provider durch das Paket qiskit-ibm-provider ersetzt wurde, das seinen eigenen Namensraum unterhält, ist die Beibehaltung dieses Alias mit dem neuen Paket nicht mehr relevant. Wenn Sie sich auf den Alias qiskit.IBMQ verlassen haben, sollten Sie Ihre Verwendung aktualisieren und stattdessen qiskit.providers.ibmq.IBMQ direkt verwenden (und auch eine Migration zu qiskit-ibm-provider in Betracht ziehen, siehe Migrationsleitfaden für weitere Einzelheiten).
Mehrere öffentliche Methoden der Puls Qobj Konverter wurden veraltet und werden in einer zukünftigen Version nicht mehr direkt aufrufbar sein. Die Liste der Methoden lautet:

Unter InstructionToQobjConverter,
- convert_acquire()
- convert_bundled_acquires()
- convert_set_frequency()
- convert_shift_frequency()
- convert_set_phase()
- convert_shift_phase()
- convert_delay()
- convert_play()
- convert_snapshot()
Unter QobjToInstructionConverter,
- convert_acquire()
- convert_set_phase()
- convert_shift_phase()
- convert_set_frequency()
- convert_shift_frequency()
- convert_delay()
- bind_pulse()
- convert_parametric()
- convert_snapshot()
Anstatt eine dieser Methoden direkt aufzurufen, werden sie implizit ausgewählt, wenn eine Konverterinstanz direkt aufgerufen wird. Zum Beispiel:
```
converter = QobjToInstructionConverter()
converter(pulse_qobj)
```
Die Funktionen qiskit.visualization.state_visualization.num_to_latex_ket() und qiskit.visualization.state_visualization.num_to_latex_terms() sind veraltet und werden in einer zukünftigen Version entfernt. Diese Funktionen wurden in erster Linie intern von der LaTeX Ausgabe von Statevector.draw() und DensityMatrix.draw() die diese Funktionen nicht mehr verwenden und stattdessen Sympy dafür einsetzen. Wenn Sie diese Funktionen verwendet haben, sollten Sie die nsimplify() -Latex() -Funktionen von Sympy verwenden.
Die Methode Register.qasm() ist veraltet und wird in einer zukünftigen Version entfernt werden. Diese Methode findet sich in den Unterklassen QuantumRegister und ClassicalRegister. Der Grund für die Ablehnung ist, dass die Methode qasm() eine falsche Sichtweise des Verantwortlichen für die sichere Konvertierung in OpenQASM 2 fördert; ein einzelnes Objekt allein verfügt nicht über den Kontext, um eine sichere Konvertierung zu gewährleisten, z. B. ob sein Name nach dem Escapen kollidiert, um einen gültigen Bezeichner zu erzeugen.
Der reguläre Ausdruck class-variable Register.name_format ist veraltet und wird in einer zukünftigen Version entfernt werden. Die Namen von Registern dürfen jetzt jede gültige Python Zeichenkette sein, so dass der reguläre Ausdruck keine Verwendung mehr hat.
Die Funktionen qiskit.quantum_info.synthesis.decompose_clifford() und qiskit.quantum_info.synthesis.decompose_cnot_dihedral() sind veraltet und werden in einer zukünftigen Version entfernt. Sie werden ersetzt durch die beiden Funktionen qiskit.synthesis.synth_clifford_full() und qiskit.synthesis.synth_cnotdihedral_full() ersetzt.

Fehlerkorrekturen

Es wurde ein Problem in der PauliOp.adjoint() methode behoben, bei der der korrekte Wert für Paulis mit komplexen Koeffizienten zurückgegeben wurde, zum Beispiel: PauliOp(Pauli("iX")). Behoben #9433.
Es wurde ein Problem mit den Algorithmen zur Amplitudenschätzung im Modul qiskit.algorithms.amplitude_estimators behoben (siehe amplitude_estimators), das bei der Verwendung von Primitiven, die aus dem abstrakten BaseSampler primitiven (wie z.B Sampler und BackendSampler). Bisher wurden die Messergebnisse auf mehr Bits ausgedehnt, als tatsächlich gemessen wurden, was bei Orakeln mit mehr als einem Qubit zu potenziellen Fehlern bei der Erkennung der "guten" Quantenzustände von Orakeln führte.
Es wurde ein Problem behoben, bei dem die Methoden QuantumCircuit.add_calibrations() und DAGCircuit.add_calibrations() sich in Bezug auf die Logik der Parameterformatierung nicht richtig verhielten. Zuvor versuchte DAGCircuit.add_calibrations() , jeden Parameter in float zu übertragen. QuantumCircuit.add_calibrations() verwendete die gegebenen Parameter so, wie sie sind. Dies würde möglicherweise einen Fehler verursachen, wenn die transpile() auf einem QuantumCircuit mit Impulstoren führen, da die Parameter der Kalibrierungen als ParameterExpresion Objekte gehalten werden könnten.
Es wurde ein Deserialisierungsproblem in QPYs (qiskit.qpy) load() funktion, bei der Schaltungen, die Gatter der Klasse MCXGate, MCXGrayCode, MCXRecursive, und MCXVChain enthalten, nicht deserialisiert werden können. Behoben #9390.
Ein Problem wurde behoben in TensoredOp.to_matrix() wo der globale Koeffizient des Operators mehr als einmal mit der Endmatrix multipliziert wurde. Jetzt wird der globale Koeffizient korrekt angewendet, unabhängig von der Anzahl der gespannten Operatoren oder Zustände. Behoben #9398.
Die Ausgabe der run() methode der Klasse BackendSampler klasse setzt nun die Attribute shots und stddev_upper_bound der zurückgegebenen QuasiDistribution. Zuvor fehlten diese Attribute, was einige Nachbearbeitungen der Ausgabe verhinderte. Behoben #9311
Die Exporter-Methode OpenQASM 2 QuantumCircuit.qasm() gibt nun standardmäßig Fließkommazahlen höherer Genauigkeit für Gatterparameter aus. Außerdem wird eine engere Schranke ( $1e-12$ anstelle von $1e-6$ ) verwendet, um zu prüfen, ob ein bestimmter Parameter nahe an einem Bruchteil/einer Potenz von $\pi$ liegt. #7166 behoben.
Feste Unterstützung im primitives modul für die Ausführung von QuantumCircuit objekten mit Kontrollflussanweisungen (z. B. IfElseOp). Zuvor konnten die Basisklassen BaseSampler und BaseEstimator solche Schaltungen nicht korrekt normalisieren. Die Ausführung dieser Schaltungen hängt jedoch von der jeweiligen Implementierung der primitiven, den Kontrollfluss unterstützenden Anweisungen ab. Damit wurde lediglich die Unterstützung festgelegt, die es einer bestimmten Implementierung von BaseSampler oder BaseEstimator ermöglicht, Kontrollflussanweisungen zu verwenden.
Es wurde ein Problem mit der Methode PauliOp.matmul() behoben, das bei iI zu falschen Ergebnissen führte. Behoben #8680.
Es wurde ein Problem mit der Klasse Approximate Quantum Compiler (AQC) behoben, der dazu führte, dass ein falscher Schaltkreis zurückgegeben wurde, wenn die Eingabe-Unitarie eine Determinante von -1 hatte. Behoben #9327
Es wurde ein Problem mit der QuantumCircuit.compose() methode, die fälschlicherweise gültige Qubit- oder Clbit-Spezifikationen zurückwies. Dies wurde korrigiert, so dass die Methode nun denselben Satz von qubit- und clbit-Spezifikationen akzeptiert wie andere QuantumCircuit methoden, wie zum Beispiel append(). Behoben #8691.
Es wurde ein Problem mit der QuantumCircuit.compose() methode behoben, bei der Register in Bedingungen auf der gegebenen Schaltung fälschlicherweise vollständigen Registern auf der Basis zugeordnet wurden. Zuvor war die Zuordnung sehr ungenau; die in jeder Bedingung verwendeten Bits waren nicht Gegenstand der Zuordnung, und stattdessen wurde ein ungenauer Versuch unternommen, ein entsprechendes Register zu finden. Dies könnte auch dazu führen, dass eine Bedingung in einem kleineren Register zu einer Bedingung in einem größeren Register erweitert wird, was keine gültige Umwandlung ist. Jetzt wird eine Bedingung für ein einzelnes Bit oder ein Register so zusammengesetzt, dass sie sich auf genau die Bits bezieht, die durch das Argument clbits definiert sind. Um dies zu erleichtern, wird der Basisschaltung gegebenenfalls ein neues Aliasing-Register hinzugefügt. Behoben #6583.
Es wurde ein Problem mit der Funktion transpile() funktion, wenn optimization_level auf 1, 2 oder 3 gesetzt wird und kein backend, basis_gates oder target Argument angegeben wird. Wenn der Eingangsschaltkreis Läufe von Einzel-Qubit-Gattern enthielte, die vereinfacht werden könnten, wäre der Ausgangsschaltkreis nicht so optimal wie möglich, da diese Läufe von Einzel-Qubit-Gattern nicht entfernt worden wären. Dies hätte früher durch die Angabe der Argumente backend, basis_gates oder target beim Aufruf der Funktion korrigiert werden können transpile() aufrufs, aber jetzt wird die Ausgabe so vereinfacht, wie es ohne Kenntnis der erlaubten Zielgatter möglich ist. Behoben #9217
Es wurde ein Problem mit der Funktion transpile() funktion, wenn sie mit optimization_level=3 ausgeführt wird und kein backend, basis_gates oder target Argument angegeben wird. Wenn die Eingangsschaltung beliebige 2-Qubit-Blöcke enthielte, die einer Identitätsmatrix entsprechen, wäre die Ausgangsschaltung nicht so optimal wie möglich und würde immer noch diesen Identitätsblock enthalten. Dies hätte früher durch die Angabe der Argumente backend, basis_gates oder target beim Aufruf der Funktion korrigiert werden können transpile() aufrufs, aber jetzt wird die Ausgabe so vereinfacht, wie es ohne Kenntnis der erlaubten Zielgatter möglich ist. Behoben #9217
Es wurde ein Problem mit LinCombSamplerGradient das möglicherweise einen Fehler auslöste, wenn es mit der Sampler klasse von qiskit-aer ausgeführt wurde.
Ein Problem wurde behoben mit NumPyEigensolver und durch Erweiterung NumPyMinimumEigensolver wo die Lösung für BaseOperator Unterklassen, die nicht Operator sind, einen Fehler verursachte.
Es wurde ein Problem in der Metadatenausgabe von primitives behoben, bei dem die Liste Kopien per Verweis erstellte und alle Elemente bei jeder Iteration mit demselben Wert aktualisiert wurden.
Ein Problem mit QobjToInstructionConverter wurde behoben, das auftrat, wenn mehrere Backends aufgerufen wurden und diese versehentlich denselben Pulsnamen in der Pulsbibliothek hatten. Dies war ein Randfall, der nur dann auftreten konnte, wenn eine Konverterinstanz über mehrere Backends hinweg wiederverwendet wurde (dies war kein typisches Nutzungsmuster).
Es wurde ein Problem mit der PVQD klasse, bei dem die Verlustfunktion fälschlicherweise die Treue quadriert hat. Dies wurde korrigiert, so dass die Verlustfunktion mit der Definition in der ursprünglichen Algorithmusdefinition übereinstimmt.
Es wurde ein Fehler in QPY (qiskit.qpy), bei dem Schaltungen, die Register enthalten, deren Bits in der Schaltung nach losen Bits auftraten, nicht deserialisiert werden konnten. Siehe #9094.
Die Klasse TwoQubitWeylDecomposition ist jetzt mit dem Protokoll pickle kompatibel. Zuvor konnte die Deserialisierung nicht durchgeführt werden und es wurde ein TypeError ausgegeben. Siehe #7312.
Es wurde ein Problem mit der LocalReadoutMitigator.quasi_probabilities() methode, bei der das Argument shots nicht verwendet wurde. Sie wird nun verwendet, um die Anzahl der Schüsse im Rückgabeobjekt festzulegen.
Eine Regression in der Konstruktion von Clifford objekten aus QuantumCircuits , die andere Clifford objekte enthalten.
Ein Problem mit der Klasse TwoQubitWeylDecomposition (und ihren Unterklassen) wurde behoben, damit die Standardbibliothek Python pickle diese Klassen serialisieren kann. Dies behebt teilweise #7312
QuantumCircuit.qasm() wird nun Gatter- und Registernamen, die mit reservierten OpenQASM 2 Schlüsselwörtern kollidieren, korrekt umgehen. Behebt #5043.
Es wurde ein Problem im Programm RZXCalibrationBuilder bei dem die ECR-Impulsfolge falsch ausgerichtet war. Behoben #9013.
Es wurde ein Problem mit dem Programm pulse_drawer() wo in einigen Fällen die Ausgabevisualisierung einige der Kanäle in einem Zeitplan ausließ. Behoben #8981.

Aer- 0.11.2

Keine Änderung

IBM Q Anbieter 0.19.2

Keine Änderung

War diese Seite hilfreich?

Melden Sie auf GitHub einen Fehler, einen Tippfehler oder fordern Sie Inhalte an.