`QuantumCircuit` classe

class qiskit.circuit.QuantumCircuit(*regs, name=None, global_phase=0, metadata=None, inputs=(), captures=(), declarations=())

GitHub

Bases : object

Représentation du noyau Qiskit d'un circuit quantique.

Remarque

Pour plus de détails sur la mise en place du QuantumCircuit dans le contexte de toutes les structures de données qui l'accompagnent, comment il s'intègre dans le reste du paquetage qiskit et les différents régimes de descriptions de circuits quantiques dans Qiskit, voir la documentation au niveau du module de qiskit.circuit.

Exemple :

from qiskit import QuantumCircuit

# Create a new circuit with two qubits
qc = QuantumCircuit(2)

# Add a Hadamard gate to qubit 0
qc.h(0)

# Perform a controlled-X gate on qubit 1, controlled by qubit 0
qc.cx(0, 1)

# Return a text drawing of the circuit.
qc.draw()

     ┌───┐
q_0: ┤ H ├──■──
     └───┘┌─┴─┐
q_1: ─────┤ X ├
          └───┘

Attributs du circuit

QuantumCircuit possède un petit nombre d'attributs publics, qui sont pour la plupart d'anciennes fonctionnalités. La plupart de ses fonctionnalités sont accessibles par le biais de méthodes.

Une petite poignée d'attributs sont intentionnellement mutables, les autres sont des attributs de données qui doivent être considérés comme immuables.

Attribut mutable	Récapitulatif
`global_phase`	La phase globale du circuit, mesurée en radians.
`metadata`	Mappage arbitraire de l'utilisateur, que Qiskit préservera par le biais du transpilateur, mais qu'il ignorera complètement par ailleurs.
`name`	Un nom de chaîne facultatif pour le circuit.

Attribut de données immuable	Récapitulatif
`ancillas`	Liste des `AncillaQubit`suivis par le circuit.
`cregs`	Liste des `ClassicalRegister`suivis par le circuit.
`clbits`	Liste des `Clbit`suivis par le circuit.
`data`	`CircuitInstruction`Liste des personnes qui composent le circuit.
`_data`	Python - un descripteur d'espace pour l'objet `QkCircuit` de l'API C.
`duration`	Durée totale du circuit, ajoutée à la programmation des passages du transpondeur. Cet attribut est obsolète et `estimate_duration()` doit être utilisé à la place.
`layout`	Informations relatives à la disposition du matériel et au routage ajoutées par le transpondeur.
`num_ancillas`	Le nombre de qubits ancillaires dans le circuit.
`num_clbits`	Le nombre de clbits dans le circuit.
`num_captured_vars`	Nombre de variables classiques en temps réel capturées.
`num_captured_stretches`	Nombre d'étirements capturés.
`num_declared_vars`	Nombre de variables classiques en temps réel déclarées localement dans le champ d'application du circuit extérieur.
`num_declared_stretches`	Nombre d'étirements déclarés localement dans le champ d'application du circuit extérieur.
`num_input_vars`	Nombre de variables classiques en temps réel.
`num_parameters`	`Parameter`Nombre de « s » présents dans le circuit au moment de la compilation.
`num_qubits`	Nombre de qubits dans le circuit.
`num_vars`	Nombre total de variables classiques en temps réel dans l'étendue du circuit extérieur.
`num_stretches`	Nombre total de tronçons dans le périmètre du circuit extérieur.
`num_identifiers`	Nombre total de variables et d'étirements dans le circuit extérieur.
`op_start_times`	Heures de début des opérations programmées, ajoutées par l'ordonnancement des passages du transpondeur.
`parameters`	`Parameter`Vue ordonnée, de type « ensemble », des s suivis par le circuit lors de la compilation.
`qregs`	Liste des `QuantumRegister`suivis par le circuit.
`qubits`	Liste des `Qubit`suivis par le circuit.
`unit`	L'unité du champ `duration` champ.

L'attribut principal est data. Il s'agit d'un objet de type séquence qui expose les éléments CircuitInstructions contenus sous une forme ordonnée. En règle générale, vous ne devez pas modifier cet objet directement; QuantumCircuit il est uniquement conçu pour les opérations d'ajout (pour lesquelles il convient d'utiliser append()). La plupart des opérations qui modifient des circuits in situ doivent être implémentées sous forme de passes de transpileur (qiskit.transpiler). L'API C interagit avec un objet interne, appelé _data, qui ne fait pas partie de l'API publique Python, si ce n'est en tant que descripteur à transmettre aux appels de l'API C.

data

Les données du circuit (instructions et contexte).

Exemple

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2)
qc.measure([0], [1])
print(qc.data)

[CircuitInstruction(operation=Instruction(name='measure', num_qubits=1,
num_clbits=1, params=[]), qubits=(Qubit(QuantumRegister(2, 'q'), 0),),
clbits=(Clbit(ClassicalRegister(2, 'c'), 1),))]

Retours

Un objet de type liste contenant les CircuitInstruction instances du circuit.

Outre le data, la global_phase d'un circuit peut avoir une certaine incidence sur sa sortie, si le circuit sert à décrire un Gate pouvant être commandé. Cette valeur est exprimée en radians et peut être réglée directement.

global_phase

La phase globale de l'étendue du circuit actuel en radians.

Exemple

from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
print(circuit.global_phase)

0.0

from numpy import pi

circuit.global_phase = pi/4
print(circuit.global_phase)

0.7853981633974483

Le name nom d'un circuit correspond au nom de la fonction Instruction ou Gate de l'expression résultant des to_instruction() appels à et to_gate() , ce qui peut s'avérer pratique pour les visualisations.

name

Type : str

Un nom lisible par l'homme pour le circuit.

Exemple

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2, name="my_circuit")
print(qc.name)

my_circuit

Vous pouvez attacher un nombre arbitraire de metadata à un circuit. Aucune partie du noyau de Qiskit ne l'inspectera ou ne changera son comportement en fonction des métadonnées, mais elles seront fidèlement passées à travers le transpilateur, de sorte que vous puissiez étiqueter vos circuits vous-même. Lors de la sérialisation d'un circuit avec QPY (voir qiskit.qpy), les métadonnées seront sérialisées en JSON et vous devrez peut-être passer un sérialiseur personnalisé pour gérer les objets non compatibles JSON à l'intérieur du circuit (voir qpy.dump() pour plus de détails). Ce champ est ignoré lors de l'exportation vers OpenQASM 2 ou 3.

metadata

Dictionnaire arbitraire de métadonnées pour le circuit, défini par l'utilisateur.

Qiskit n'examinera pas le contenu de ce mapping, mais il le passera à travers le transpiler et le rattachera à la sortie, de sorte que vous puissiez suivre vos propres métadonnées.

Exemple

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2, metadata={'experiment_type': 'Bell state experiment'})

print(qc.metadata)

{'experiment_type': 'Bell state experiment'}

QuantumCircuit expose des attributs de données en suivant ses bits et registres quantiques et classiques internes. Ils apparaissent sous la forme de Python listmais vous devez les considérer comme immuables; les modifier n'aura au mieux aucun effet, et plus probablement corrompra simplement les données internes de la base de données QuantumCircuit.

qregs

Une liste de Qubitdans l'ordre dans lequel ils ont été ajoutés. Il ne faut pas le faire muter.

cregs

Une liste de Clbitdans l'ordre dans lequel ils ont été ajoutés. Il ne faut pas le faire muter.

qubits

Une liste de Qubitdans l'ordre dans lequel ils ont été ajoutés. Il ne faut pas le faire muter.

ancillas

Une liste de AncillaQubitdans l'ordre dans lequel ils ont été ajoutés. Il ne faut pas le faire muter.

clbits

Une liste de Clbitdans l'ordre dans lequel ils ont été ajoutés. Il ne faut pas le faire muter.

Exemple

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

qr1 = QuantumRegister(2)
qr2 = QuantumRegister(1)
cr1 = ClassicalRegister(2)
cr2 = ClassicalRegister(1)
qc = QuantumCircuit(qr1, qr2, cr1, cr2)

print("List the qubits in this circuit:", qc.qubits)
print("List the classical bits in this circuit:", qc.clbits)

List the qubits in this circuit: [Qubit(QuantumRegister(2, 'q0'), 0),
Qubit(QuantumRegister(2, 'q0'), 1), Qubit(QuantumRegister(1, 'q1'), 0)]
List the classical bits in this circuit: [Clbit(ClassicalRegister(2, 'c0'), 0),
Clbit(ClassicalRegister(2, 'c0'), 1), Clbit(ClassicalRegister(1, 'c1'), 0)]

Les paramètres de compilation présents dans les instructions du circuit sont disponibles dans parameters. setCette structure suit un ordre canonique (principalement lexical, sauf dans le cas de ParameterVector), qui correspond à l'ordre dans lequel les paramètres seront attribués lors de l'utilisation des formes listes de assign_parameters(), mais prend également en charge la vérification d'appartenance en temps constant, à l'instar de.

parameters

Les paramètres définis dans le circuit.

Cet attribut renvoie les Parameter objets du circuit classés par ordre alphabétique. Notez que les paramètres instanciés avec un ParameterVector sont toujours triés par ordre numérique.

Exemples

L'extrait ci-dessous montre que l'ordre d'insertion des paramètres n'a pas d'importance.

>>> from qiskit.circuit import QuantumCircuit, Parameter
>>> a, b, elephant = Parameter("a"), Parameter("b"), Parameter("elephant")
>>> circuit = QuantumCircuit(1)
>>> circuit.rx(b, 0)
>>> circuit.rz(elephant, 0)
>>> circuit.ry(a, 0)
>>> circuit.parameters  # sorted alphabetically!
ParameterView([Parameter(a), Parameter(b), Parameter(elephant)])

Gardez à l'esprit que le tri alphabétique peut ne pas être intuitif lorsqu'il s'agit de nombres. Le "10" littéral vient avant le "2" dans le classement alphabétique strict.

>>> from qiskit.circuit import QuantumCircuit, Parameter
>>> angles = [Parameter("angle_1"), Parameter("angle_2"), Parameter("angle_10")]
>>> circuit = QuantumCircuit(1)
>>> circuit.u(*angles, 0)
>>> circuit.draw()
   ┌─────────────────────────────┐
q: ┤ U(angle_1,angle_2,angle_10) ├
   └─────────────────────────────┘
>>> circuit.parameters
ParameterView([Parameter(angle_1), Parameter(angle_10), Parameter(angle_2)])

Pour respecter le tri numérique, on peut utiliser un ParameterVector .

>>> from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector
>>> x = ParameterVector("x", 12)
>>> circuit = QuantumCircuit(1)
>>> for x_i in x:
...     circuit.rx(x_i, 0)
>>> circuit.parameters
ParameterView([
    ParameterVectorElement(x[0]), ParameterVectorElement(x[1]),
    ParameterVectorElement(x[2]), ParameterVectorElement(x[3]),
    ..., ParameterVectorElement(x[11])
])

Retours

Les objets classés Parameter dans le circuit.

Si vous avez transposé votre circuit, de sorte que vous avez un circuit physique, vous pouvez inspecter l'attribut layout des informations stockées par le transpileur sur la façon dont les qubits virtuels du circuit source correspondent aux qubits matériels de votre circuit physique, à la fois au début et à la fin du circuit.

layout

Renvoie toutes les informations de mise en page associées au circuit.

Cet attribut contient un objet facultatif TranspileLayout . Ce paramètre est généralement défini sur la sortie de transpile() ou PassManager.run() afin de conserver les informations relatives aux permutations provoquées sur le circuit d'entrée par la transpilation.

Il existe deux types de permutations générées par la transpile() fonction : une configuration initiale qui permute les qubits en fonction des qubits physiques sélectionnés sur la Target, et une configuration finale, qui correspond à une permutation de sortie résultant de l'insertion de SwapGate s lors du routage.

Exemple

from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import generate_preset_pass_manager

# Create circuit to test transpiler on
qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.swap(1, 2)
qc.cx(0, 1)

# Add measurements to the circuit
qc.measure([0, 1, 2], [0, 1, 2])

# Specify the QPU to target
backend = GenericBackendV2(3)

# Transpile the circuit
pass_manager = generate_preset_pass_manager(
optimization_level=1, backend=backend
)
transpiled = pass_manager.run(qc)

# Print the layout after transpilation
print(transpiled.layout.routing_permutation())

[0, 1, 2]

Si votre circuit a également été programmé dans le cadre d'une transpilation, il exposera les minutages individuels de chaque instruction, ainsi que le total duration du circuit.

duration

La durée totale du circuit, fixée par une passe du transpondeur d'ordonnancement. Son unité est spécifiée par unit.

Déclassé depuis la version 1.3.0

La propriété qiskit.circuit.quantumcircuit.QuantumCircuit.duration est obsolète depuis Qiskit 1.3.0. Elle sera supprimée à Qiskit 3.0.0.

unit

L'unité qui duration est spécifiée.

Déclassé depuis la version 1.3.0

La propriété qiskit.circuit.quantumcircuit.QuantumCircuit.unit est obsolète depuis Qiskit 1.3.0. Elle sera supprimée à Qiskit 3.0.0.

op_start_times

Renvoie une liste des heures de début des opérations.

Remarque

Cet attribut calcule l'heure de début estimée des opérations dans le circuit programmé et ne fonctionne que pour les circuits simples qui n'ont pas de flux de contrôle ou d'autres opérations classiques en amont.

Cet attribut est activé lorsque l'une des passes d'analyse de l'ordonnancement s'exécute sur le circuit quantique.

Exemple

from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import generate_preset_pass_manager

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Print the original circuit
print("Original circuit:")
print(qc)

# Transpile the circuit with a specific basis gates list and print the resulting circuit
backend = GenericBackendV2(2, basis_gates=['u1', 'u2', 'u3', 'cx'])
pm = generate_preset_pass_manager(
    optimization_level=1, backend=backend, scheduling_method="alap"
)
transpiled_qc = pm.run(qc)
print("Transpiled circuit with basis gates ['u1', 'u2', 'u3', 'cx']:")
print(transpiled_qc)

# Print the start times of each instruction in the transpiled circuit
print("Start times of instructions in the transpiled circuit:")
for instruction, start_time in zip(transpiled_qc.data, transpiled_qc.op_start_times):
    print(f"{instruction.operation.name}: {start_time}")

Original circuit:
        ┌───┐      ░ ┌─┐
q_0: ┤ H ├──■───░─┤M├───
        └───┘┌─┴─┐ ░ └╥┘┌─┐
q_1: ─────┤ X ├─░──╫─┤M├
            └───┘ ░  ║ └╥┘
meas: 2/══════════════╩══╩═
                    0  1

Transpiled circuit with basis gates ['u1', 'u2', 'u3', 'cx']:
            ┌─────────┐          ░ ┌─────────────────┐┌─┐
q_0 -> 0 ───┤ U2(0,π) ├──────■───░─┤ Delay(1255[dt]) ├┤M├
        ┌──┴─────────┴───┐┌─┴─┐ ░ └───────┬─┬───────┘└╥┘
q_1 -> 1 ┤ Delay(196[dt]) ├┤ X ├─░─────────┤M├─────────╫─
        └────────────────┘└───┘ ░         └╥┘         ║
meas: 2/═══════════════════════════════════╩══════════╩═
                                            1          0

Start times of instructions in the transpiled circuit:
u2: 0
delay: 0
cx: 196
barrier: 2098
delay: 2098
measure: 3353
measure: 2098

Retours

Liste d'entiers représentant les heures de début estimées des instructions. L'indice correspond à l'indice de l'instruction dans QuantumCircuit.data.

Augmentations

AttributeError - Lorsque le circuit n'est pas programmé.

Enfin, QuantumCircuit expose plusieurs propriétés simples sous forme d'attributs numériques dynamiques en lecture seule.

num_ancillas

Retourne le nombre de qubits ancillaires.

Exemple

from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister

# Create a 2-qubit quantum circuit
reg = QuantumRegister(2)
qc = QuantumCircuit(reg)

# Create an ancilla register with 1 qubit
anc = AncillaRegister(1)
qc.add_register(anc)  # Add the ancilla register to the circuit

print("Number of ancilla qubits:", qc.num_ancillas)

Number of ancilla qubits: 1

num_clbits

Renvoie le nombre de bits classiques.

Exemple

from qiskit import QuantumCircuit

# Create a new circuit with two qubits and one classical bit
qc = QuantumCircuit(2, 1)
print("Number of classical bits:", qc.num_clbits)

Number of classical bits: 1

num_captured_vars

Le nombre de variables classiques en temps réel dans le circuit marquées comme capturées à partir d'un champ d'application englobant.

Il s'agit de la longueur de l iter_captured_vars() itérable. Si cette valeur n'est pas nulle, num_input_vars doit être égal à zéro.

num_captured_stretches

Le nombre de tronçons dans le circuit marqués comme capturés à partir d'un champ d'application englobant.

Il s'agit de la longueur de l iter_captured_stretches() itérable. Si cette valeur n'est pas nulle, num_input_vars doit être égal à zéro.

num_declared_vars

Le nombre de variables classiques en temps réel dans le circuit qui sont déclarées par cette portée de circuit, à l'exclusion des entrées ou des captures.

Il s'agit de la longueur de l iter_declared_vars() itérable.

num_declared_stretches

Le nombre d'étirements dans le circuit qui sont déclarés par cette portée de circuit, à l'exclusion des captures.

Il s'agit de la longueur de l iter_declared_stretches() itérable.

num_input_vars

Le nombre de variables classiques en temps réel dans le circuit marquées comme entrées du circuit.

Il s'agit de la longueur de l iter_input_vars() itérable. Si cette valeur n'est pas nulle, num_captured_vars doit être égal à zéro.

num_identifiers

Le nombre de variables classiques en temps réel et d'étirements dans le circuit.

Cela équivaut à num_vars() + num_stretches().

num_parameters

Le nombre d'objets de paramètres dans le circuit.

num_qubits

Renvoie le nombre de qubits.

num_stretches

Le nombre de tronçons dans le circuit.

Il s'agit de la longueur de l iter_stretches() itérable.

num_vars

Le nombre de variables classiques en temps réel dans le circuit.

Il s'agit de la longueur de l iter_vars() itérable.

Création de nouveaux circuits

Méthode	Récapitulatif
`__init__()`	Constructeur par défaut des circuits sans instruction.
`copy()`	Faire une copie complète d'un circuit existant.
`copy_empty_like()`	Copier des objets de données d'un circuit dans un nouveau sans aucune instruction.
`from_instructions()`	Déduire les objets de données nécessaires à partir d'une liste d'instructions.
`from_qasm_file()`	L'interface patrimoniale à `qasm2.load()`.
`from_qasm_str()`	L'interface patrimoniale à `qasm2.loads()`.

Le constructeur par défaut (QuantumCircuit(...)) produit un circuit sans instructions initiales. Les arguments du constructeur par défaut peuvent être utilisés pour ensemencer le circuit avec un stockage de données quantiques et classiques, et pour fournir un nom, une phase globale et des métadonnées arbitraires. Tous ces champs peuvent être complétés ultérieurement.

init

__init__(*regs, name=None, global_phase=0, metadata=None, inputs=(), captures=(), declarations=())

GitHub

Constructeur par défaut de QuantumCircuit.

Paramètres

regs (Register |int |Sequence[Bit]) –

Les registres à inclure dans le circuit.
- Si une liste d'objets Register représente les objets QuantumRegister et/ou ClassicalRegister à inclure dans le circuit.
  
  Par exemple :
  - QuantumCircuit(QuantumRegister(4))
  - QuantumCircuit(QuantumRegister(4), ClassicalRegister(3))
  - QuantumCircuit(QuantumRegister(4, 'qr0'), QuantumRegister(2, 'qr1'))
- Si une liste de int, la quantité de qubits et/ou de bits classiques à inclure dans le circuit. Il peut s'agir d'un seul int pour le nombre de bits quantiques, ou de 2 ints pour le nombre de bits quantiques et de bits classiques, respectivement.
  
  Par exemple :
  - QuantumCircuit(4) # A QuantumCircuit with 4 qubits
  - QuantumCircuit(4, 3) # A QuantumCircuit with 4 qubits and 3 classical bits
- Si une liste de listes python contenant Bit objets, une collection de Bit à ajouter au circuit.
name (str | None) – le nom du circuit quantique. Si elle n'est pas définie, une chaîne générée automatiquement sera attribuée.
global_phase (ParameterExpression |float) – La phase globale du circuit, exprimée en radians.
metadata (dict | None) – Métadonnées arbitraires de valeur clé à associer au circuit. Il est stocké sous forme de données libres dans un dict dans l'attribut metadata attribut. Il ne sera pas directement utilisé dans le circuit.
inputs (Iterable[Var]) – aucune variable à déclarer comme variable input d'exécution pour ce circuit. Il devrait s'agir de nœuds déjà expr.Var existants que vous avez créés ailleurs; si vous devez également créer les entrées, utilisez QuantumCircuit.add_input(). Les variables fournies dans cet argument seront transmises directement à add_input(). Un circuit ne peut pas avoir à la fois inputs et captures.
captures (Iterable[Var |Stretch]) – toutes les variables que cette portée de circuit doit hériter d'une portée parente. Les variables indiquées ici seront transmises directement à add_capture(). Un circuit ne peut pas avoir à la fois inputs et captures.
declarations (Mapping[Var, Expr] | Iterable[tuple[Var, Expr]]) –

toutes les variables que ce circuit doit déclarer et initialiser immédiatement. Vous pouvez ordonner cette entrée de manière à ce que les déclarations ultérieures dépendent des déclarations antérieures (y compris les entrées ou les captures). Si vous devez dépendre de valeurs qui seront calculées ultérieurement au moment de l'exécution, utilisez add_var() à un moment approprié de l'exécution du circuit.

Cet argument est destiné à faciliter l'initialisation du circuit lorsque vous disposez déjà d'un ensemble de variables créées. Les variables utilisées ici seront directement passées à add_var()que vous pouvez utiliser directement si c'est la première fois que vous créez la variable.

Augmentations

CircuitError - si le nom du circuit, s'il est donné, n'est pas valide.
CircuitError - si les adresses inputs et captures sont toutes deux indiquées.

Si vous disposez d'un circuit existant, vous pouvez en produire une copie à l'aide de copy()avec toutes ses instructions. C'est utile si vous souhaitez conserver des circuits partiels tout en en étendant d'autres, ou si vous souhaitez disposer d'une version que vous pouvez modifier sur place tout en laissant la version précédente intacte.

copy

copy(name=None)

GitHub

Copier le circuit.

Paramètres

name (str) – nom à donner au circuit copié. S'il n'y en a pas, le nom reste inchangé.

Retours

une copie profonde du circuit actuel, avec le nom spécifié

Type de retour

QuantumCircuit

De même, si vous souhaitez un circuit contenant tous les mêmes objets de données (bits, registres, variables, etc.), mais sans aucune instruction, vous pouvez utiliser copy_empty_like(). C'est assez courant lorsqu'on souhaite créer une nouvelle couche d'un circuit pour l'appliquer ensuite au verso à l'aide de compose(), ou pour réécrire entièrement les instructions d'un circuit.

copy_empty_like

copy_empty_like(name=None, *, vars_mode='alike')

GitHub

Renvoie une copie de self avec la même structure mais vide.

Cette structure comprend

nom et autres métadonnées
phase globale
tous les qubits et clbits, y compris les registres
les variables temps réel définies dans le circuit, traitées conformément à l'argument du mot-clé vars .

Avertissement

Si le circuit contient des déclarations de variables locales (celles ajoutées par l'argument declarations au constructeur du circuit, ou en utilisant add_var()), elles peuvent être non initialisées dans le circuit de sortie. Vous devrez ajouter manuellement des instructions de stockage pour eux (voir Store et QuantumCircuit.store()) pour les initialiser.

Paramètres

name (str | None) – Nom du circuit copié. S'il n'y en a pas, le nom reste inchangé.
vars_mode (Literal['alike', 'captures', 'drop']) –

Le mode de gestion des variables en temps réel.

semblables

Les variables du circuit de sortie auront la même sémantique de déclaration que dans le circuit d'origine. Par exemple, input variables dans la source seront input variables dans le circuit de sortie. Notez que les variables locales ne sont pas initialisées, car les mémoires ne sont pas copiées. Cela peut laisser le circuit dans un état potentiellement dangereux pour les utilisateurs s'ils ne rajoutent pas les magasins d'initialisation.

captures

Toutes les variables seront converties en variables capturées. Ceci est utile lorsque vous construisez une nouvelle couche pour un circuit existant que vous voudrez placer sur la base compose() sur la base, puisque compose() peut intégrer des captures dans le circuit de base (mais pas d'autres variables).

SUPPRIMER

Le circuit de sortie n'aura aucune variable définie.

Retours

Une copie vide de soi.

Type de retour

QuantumCircuit

Dans certains cas, il est plus pratique de générer une liste de CircuitInstructions indépendamment du contexte global du circuit, puis de construire un circuit à partir de celle-ci. Le from_instructions() constructeur capturera automatiquement toutes Qubit les instances et Clbit utilisées dans les instructions, puis créera un nouvel QuantumCircuit objet disposant des ressources appropriées et de l'ensemble des instructions.

from_instructions

static from_instructions(instructions, *, qubits=(), clbits=(), name=None, global_phase=0, metadata=None)

GitHub

Construire un circuit à partir d'un itérable de CircuitInstructions.

Paramètres

instructions (Iterable[CircuitInstruction |tuple[qiskit.circuit.Instruction] | tuple[qiskit.circuit.Instruction, Iterable[Qubit]] | tuple[qiskit.circuit.Instruction, Iterable[Qubit], Iterable[Clbit]]]) – Les instructions à ajouter au circuit.
qubits (Iterable[Qubit]) – Tous les qubits à ajouter au circuit. Cet argument peut être utilisé, par exemple, pour imposer un ordre particulier des qubits.
clbits (Iterable[Clbit]) – Tout élément classique à ajouter au circuit. Cet argument peut être utilisé, par exemple, pour imposer un ordre particulier des bits classiques.
name (str | None) – Le nom du circuit.
global_phase (ParameterValueType) – La phase globale du circuit en radians.
metadata (dict | None) – Métadonnées arbitraires de valeur clé à associer au circuit.

Retours

Le circuit quantique.

Type de retour

QuantumCircuit

QuantumCircuit possède encore deux méthodes de construction qui sont des enveloppes héritées autour des importateurs de la norme qiskit.qasm2. Ceux-ci appliquent automatiquement les paramètres de compatibilité hérités de load() et loads().

from_qasm_file

static from_qasm_file(path)

GitHub

Lire un programme OpenQASM 2.0 à partir d'un fichier et le convertir en une instance de QuantumCircuit.

Paramètres

path (str |PathLike) – Chemin d'accès au fichier d'un programme d' OpenQASM 2

Retours

L'objet QuantumCircuit pour l'entrée OpenQASM 2.

Type de retour

QuantumCircuit

Voir aussi

qasm2.load(): l'interface complète de l'importateur OpenQASM 2.

from_qasm_str

static from_qasm_str(qasm_str)

GitHub

Convertir une chaîne de caractères contenant un programme OpenQASM 2.0 en un programme QuantumCircuit.

Paramètres

qasm_str (str) – Une chaîne contenant un programme OpenQASM 2.0.

Retours

L'objet QuantumCircuit pour l'entrée OpenQASM 2

Type de retour

QuantumCircuit

Voir aussi

qasm2.loads(): l'interface complète de l'importateur OpenQASM 2.

Objets de données sur les circuits

Ajout d'objets de données

Méthode	Ajoute ce type de données
`add_bits()`	`Qubit`et `Clbit`s.
`add_register()`	`QuantumRegister` et `ClassicalRegister`.
`add_var()`	`Var` avec une portée locale et des initialisateurs.
`add_stretch()`	`Stretch` les nœuds de portée locale.
`add_input()`	`Var` qui sont traités comme des entrées de circuit.
`add_capture()`	`Var` ou `Stretch` les nœuds capturés dans les champs d'application contenant des données.
`add_uninitialized_var()`	`Var` avec une portée locale et un état indéfini.

En règle générale, vous ajoutez la plupart des objets de données (Qubit, Clbit, ClassicalRegister) au circuit dans le cadre de l'utilisation du constructeur par défaut de __init__() le constructeur par défaut, ou copy_empty_like(). Toutefois, il est également possible de les ajouter par la suite. Les données classiques typées, telles que les nœuds autonomes (voir Calcul classique en temps réel), peuvent être construites et ajoutées avec des méthodes distinctes Var (voir Calcul classique en temps réel ), peuvent être construites et ajoutées avec des méthodes distinctes.

Nouveau système sans registre Qubit et Clbit sont ajoutés à l'aide de add_bits(). Ces objets ne doivent pas être déjà présents dans le circuit. Vous pouvez vérifier si un bit existe déjà dans le circuit en utilisant find_bit().

add_bits

add_bits(bits)

GitHub

Ajouter des bits au circuit.

Avertissement

Si le circuit quantique possède un attribut layout existant, l'ajout d'un Qubit ne fera qu'augmenter le nombre de qubits. La mise en page n'est pas mise à jour.

Paramètres

bits (Iterable[Bit])

Type de retour

Aucun

Les registres sont ajoutés au circuit avec add_register(). Dans cette méthode, ce n'est pas une erreur si certains bits sont déjà présents dans le circuit. Dans ce cas, le registre sera un "alias" sur les bits. Cette fonction n'est généralement pas bien supportée par les backends matériels; il est probablement préférable de ne pas s'y fier. Les registres dans lesquels se trouve un bit donné font partie du retour de find_bit().

add_register

add_register(*regs)

GitHub

Ajouter des registres.

Avertissement

Si le circuit quantique possède un attribut layout existant, l'ajout d'un QuantumRegister ne fera qu'augmenter le nombre de qubits. La mise en page n'est pas mise à jour.

Paramètres

regs (Register |int |Sequence[Bit])

Type de retour

Aucun

Les données classiques typées en temps réel sont représentées sur le circuit par des Var des nœuds avec un Type. Il est possible de les instancier séparément dans un circuit (voir Var.new()), mais il est souvent plus pratique d'utiliser des méthodes de circuit qui gèrent automatiquement les types et l'initialisation des expressions pour vous. Les deux méthodes les plus courantes sont add_var() (variables à portée locale) et add_input() (entrées dans le circuit). En outre, la méthode add_stretch() peut être utilisée pour ajouter des étirements au circuit.

add_var

add_var(name_or_var, /, initial)

GitHub

Ajoutez à ce circuit une variable classique avec stockage automatique et portée.

La variable est considérée comme ayant été "déclarée" au début du circuit, mais elle n'est initialisée qu'au moment du circuit où vous appelez cette méthode, de sorte qu'elle peut dépendre des variables définies avant elle.

Paramètres

name_or_var (str |Var) – soit une chaîne contenant le nom de la variable, soit une instance existante de Var à réutiliser. Les variables ne peuvent pas masquer les noms déjà utilisés dans le circuit.
initial (Any) –

la valeur avec laquelle cette variable doit être initialisée. Si le premier argument est une chaîne de caractères, le type de la variable résultante est déduit de l'expression initiale; pour contrôler cela plus manuellement, il faut soit utiliser Var.new() pour construire manuellement une nouvelle variable avec le type désiré, ou utiliser expr.cast() pour convertir l'initialisateur au type désiré.

Il doit s'agir soit d'un nœud Expr ou une valeur qui peut être élevée à un nœud en utilisant expr.lift.

Retours

La variable créée. Si une instance Var a été donnée, c'est exactement le même objet qui sera renvoyé.

Augmentations

CircuitError - si la variable ne peut être créée en raison de l'utilisation d'un identificateur existant.

Type de retour

Var

Exemples

Définir une nouvelle variable à partir d'un nom et d'une expression d'initialisation :

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2)
my_var = qc.add_var("my_var", False)

Réutiliser une variable qui peut avoir été tirée d'un circuit apparenté ou construite manuellement, et l'initialiser à une expression plus complexe :

from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.classical import expr, types

my_var = expr.Var.new("my_var", types.Uint(8))

cr1 = ClassicalRegister(8, "cr1")
cr2 = ClassicalRegister(8, "cr2")
qc = QuantumCircuit(QuantumRegister(8), cr1, cr2)

# Get some measurement results into each register.
qc.h(0)
for i in range(1, 8):
    qc.cx(0, i)
qc.measure(range(8), cr1)

qc.reset(range(8))
qc.h(0)
for i in range(1, 8):
    qc.cx(0, i)
qc.measure(range(8), cr2)

# Now when we add the variable, it is initialized using the real-time state of the
# two classical registers we measured into above.
qc.add_var(my_var, expr.bit_and(cr1, cr2))

add_input

add_input(name_or_var: str, type_: Type, /) → Var

add_input(name_or_var: Var, type_: None = None, /) → Var

GitHub

Enregistrer une variable comme entrée du circuit.

Paramètres

name_or_var (str |Var) – soit un nom sous forme de chaîne, soit un nœud Var existant à utiliser comme variable d'entrée.
type - si le nom est donné sous la forme d'une chaîne, il doit s'agir d'un type de Type à utiliser pour la variable. Si la variable est donnée sous la forme d'un Varexistante, celle-ci ne doit pas être indiquée et sera lue à partir de l'objet lui-même.
type_ (Type | None)

Retours

la variable créée, ou la même variable que celle qui a été transmise.

Augmentations

CircuitError - si la variable ne peut pas être créée parce qu'elle fait partie d'une variable existante.

Type de retour

Var

add_stretch

add_stretch(name_or_stretch)

GitHub

Déclare un nouvel étirement pour ce circuit.

Paramètres

name_or_stretch (str |Stretch) – soit une chaîne contenant le nom de l'extension, soit une instance existante de Stretch à réutiliser. Les extensions ne peuvent pas utiliser des noms déjà utilisés au sein du circuit.

Retours

L'étirement créé. Si une instance Stretch a été donnée, c'est exactement le même objet qui sera renvoyé.

Augmentations

CircuitError - si le tronçon ne peut être créé en raison de l'ombre d'un identifiant existant.

Type de retour

Étirement

Exemples

Définir et utiliser un nouvel étirement à partir d'un simple nom :

from qiskit.circuit import QuantumCircuit, Duration
from qiskit.circuit.classical import expr

qc = QuantumCircuit(2)
my_stretch = qc.add_stretch("my_stretch")

qc.delay(expr.add(Duration.dt(200), my_stretch), 1)

En outre, deux méthodes de niveau inférieur peuvent être utiles pour la génération programmatique de circuits. Lorsque vous travaillez de manière interactive, vous n'en aurez probablement pas besoin; la plupart des utilisations de add_uninitialized_var() font partie de copy_empty_like()et la plupart des utilisations de add_capture() seraient mieux d'utiliser l 'interface de construction de flux de contrôle.

add_uninitialized_var

add_uninitialized_var(var, /)

GitHub

Ajouter une variable sans initialisateur.

Dans la plupart des cas, vous devez utiliser add_var() pour initialiser la variable. Pour utiliser cette fonction, vous devez déjà détenir une instance de Var car l'utilisation de cette fonction n'a généralement de sens que dans des contextes de copie.

Avertissement

Qiskit ne fait aucune affirmation sur ce qu'une variable non initialisée évaluera au moment de l'exécution, et certains matériels peuvent rejeter cela comme une erreur.

Cette fonction doit être considérée avec prudence et comme une primitive de bas niveau qui n'est utile que dans les cas particuliers de reconstruction programmatique de deux circuits similaires.

Paramètres

var (Var) – la variable à ajouter.

add_capture

add_capture(var: Var)

add_capture(stretch: Stretch)

GitHub

Ajouter un identifiant au circuit qu'il doit capturer à partir d'un champ d'application dans lequel il sera contenu.

Cette méthode nécessite un Var ou Stretch pour s'assurer que l'on dispose d'un identifiant, car il faudra déclarer le même identifiant en utilisant le même objet dans le circuit extérieur.

Il s'agit d'une méthode de bas niveau, qui n'est vraiment utile que si vous construisez manuellement des opérations de flux de contrôle. Vous n'aurez généralement pas besoin d'appeler cette méthode, en supposant que vous utilisez l'interface du constructeur pour les portées du flux de contrôle (with context-manager statements for if_test() et les autres constructions de portée). L'interface de construction rendra automatiquement les scopes internes fermés en votre nom en capturant tous les identifiants qui sont utilisés dans ces scopes.

Paramètres

var (Union[expr.Var, expr.Stretch]) – la variable ou le tronçon à capturer dans un champ d'application englobant.

Augmentations

CircuitError - si l'identifiant ne peut être créé en raison de l'ombre d'un identifiant existant.

Travailler avec des bits et des registres

Une Bit instance n'est, en soi, qu'un identifiant unique que les circuits peuvent utiliser dans leur propre contexte. Si vous disposez d'une Bit instance et d'un circuit, vous pouvez déterminer les contextes dans lesquels ce bit est présent find_bit(), notamment son index entier dans le circuit et les registres dans lesquels il se trouve.

find_bit

find_bit(bit)

GitHub

Trouver des emplacements dans le circuit qui peuvent être utilisés pour référencer une valeur donnée Bit.

En particulier, cette fonction permet de trouver l'indice entier d'un qubit, qui correspond à son indice matériel pour un circuit transposé.

Remarque

L'indice de circuit d'un AncillaQubit sera son indice dans qubitset non ancillas.

Paramètres

bit (Bit) – Le bit à localiser.

Retours

Un 2-tuple. Le premier élément (index) contient l'indice auquel le site Bit peut être trouvé (dans l'un ou l'autre des cas suivants qubits, clbitsselon son type). Le deuxième élément (registers) est une liste de paires (register, index) avec une entrée pour chaque Register dans le circuit qui contient le Bit (et l'index dans le Register où il peut être trouvé).

Type de retour

namedtuple (int, List[Tuple (Register, int )])

Augmentations

CircuitError - Si le produit fourni Bit est d'un type inconnu.
CircuitError - Si l'alimentation Bit n'a pas été trouvé sur le circuit.

Exemples

Bouclez un circuit, en obtenant les indices qubit et clbit de chaque opération :

from qiskit.circuit import QuantumCircuit, Qubit

qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)
qc.measure([0, 1, 2], [0, 1, 2])

# The `.qubits` and `.clbits` fields are not integers.
assert isinstance(qc.data[0].qubits[0], Qubit)
# ... but we can use `find_bit` to retrieve them.
assert qc.find_bit(qc.data[0].qubits[0]).index == 0

simple = [
    (
        instruction.operation.name,
        [qc.find_bit(bit).index for bit in instruction.qubits],
        [qc.find_bit(bit).index for bit in instruction.clbits],
    )
    for instruction in qc.data
]

De même, vous pouvez interroger un circuit pour savoir si un registre y a déjà été ajouté en utilisant la commande has_register().

has_register

has_register(register)

GitHub

Testez si ce circuit possède le registre r.

Paramètres

register (Register) – un registre quantique ou classique.

Retours

Vrai si le registre est contenu dans ce circuit.

Type de retour

booléen

Utilisation des paramètres de compilation

Voir aussi

Paramétrage au moment de la compilation

Une discussion plus complète sur ce qu'est la paramétrisation à la compilation, et comment elle s'intègre dans le modèle de données de Qiskit.

Contrairement aux bits, aux registres et aux données classiques typées en temps réel, les paramètres symboliques à la compilation ne sont pas ajoutés manuellement à un circuit. Leur présence est déduite du fait qu'ils sont contenus dans les opérations ajoutées aux circuits et à la phase globale. Une liste ordonnée de tous les paramètres présents dans un circuit se trouve à l'adresse suivante QuantumCircuit.parameters.

L'opération la plus courante sur Parameter les instances consiste à les remplacer, dans des opérations symboliques, par une valeur numérique ou par une autre expression symbolique. Cela se fait avec assign_parameters().

assign_parameters

assign_parameters(parameters: Mapping[Parameter, ParameterExpression | float] | Iterable[ParameterExpression | float], inplace: Literal[False] = False, *, flat_input: bool = False, strict: bool = True) → QuantumCircuit

assign_parameters(parameters: Mapping[Parameter, ParameterExpression | float] | Iterable[ParameterExpression | float], inplace: Literal[True] = False, *, flat_input: bool = False, strict: bool = True) → None

GitHub

Attribuer des paramètres à de nouveaux paramètres ou valeurs.

Si parameters est passé sous forme de dictionnaire, les clés doivent être Parameter des instances du circuit actuel. Les valeurs du dictionnaire peuvent être soit des valeurs numériques, soit de nouveaux objets paramètres.

Si parameters est passé sous forme de liste ou de tableau, les éléments sont affectés aux paramètres actuels dans l'ordre de parameters , qui est trié par ordre alphabétique (tout en respectant l'ordre des ParameterVector objets dans ).

Les valeurs peuvent être affectées à l'objet circuit actuel ou à une copie de celui-ci.

Remarque

Lorsque parameters est défini comme une application, il est possible d'utiliser comme clés des chaînes de caractères correspondant aux noms des paramètres; celles-ci seront recherchées à l'aide de get_parameter(). Vous pouvez également avoir des clés qui sont ParameterVector des instances; dans ce cas, la valeur du dictionnaire doit être une séquence de valeurs de même longueur que le vecteur.

flat_input=FalseSi vous utilisez l'un ou l'autre de ces cas, vous devez conserver le paramètre tel True quel; le modifier active le « chemin rapide », dans lequel toutes les clés doivent être Parameter des instances.

Paramètres

parameters (Mapping[Parameter, ParameterExpression |float] | Iterable[ParameterExpression |float]) – Soit un dictionnaire, soit un objet itérable spécifiant les nouvelles valeurs des paramètres.
inplace (bool) – Si la valeur est « False », une copie du circuit avec les paramètres liés est renvoyée. Si la valeur est True, l'instance du circuit elle-même est modifiée.
flat_input (bool) – Si True et parameters est un type de correspondance, on suppose qu'il s'agit précisément d'une correspondance de {parameter: value}. Par défaut (False), le mappage peut également contenir ParameterVector des clés pointant vers une séquence de valeurs correspondante, lesquelles seront développées lors du mappage, ou des clés de type chaîne de caractères, qui seront converties en Parameter instances à l'aide de get_parameter().
strict (bool) – Si tel est le cas False, tous les paramètres spécifiés dans le mappage qui ne sont pas utilisés dans le circuit seront ignorés. Si True (par défaut), une erreur sera générée pour signaler une erreur logique.

Augmentations

CircuitError - Si paramètres est un dict et contient des paramètres non présents dans le circuit.
ValueError - Si les paramètres sont une liste/un tableau et que la longueur ne correspond pas au nombre de paramètres libres dans le circuit.

Retours

Une copie du circuit avec les paramètres liés si inplace est False, sinon None.

Type de retour

QuantumCircuit | Aucun

Exemples

Créer un circuit paramétré et attribuer les paramètres sur place.

from qiskit.circuit import QuantumCircuit, Parameter

circuit = QuantumCircuit(2)
params = [Parameter('A'), Parameter('B'), Parameter('C')]
circuit.ry(params[0], 0)
circuit.crx(params[1], 0, 1)
circuit.draw('mpl')
circuit.assign_parameters({params[0]: params[2]}, inplace=True)
circuit.draw('mpl')

Schéma de circuit produit par le code précédent.

Liez les valeurs déplacées par liste et obtenez une copie du circuit original.

from qiskit.circuit import QuantumCircuit, ParameterVector

circuit = QuantumCircuit(2)
params = ParameterVector('P', 2)
circuit.ry(params[0], 0)
circuit.crx(params[1], 0, 1)

bound_circuit = circuit.assign_parameters([1, 2])
bound_circuit.draw('mpl')

circuit.draw('mpl')

Le circuit gère les paramètres au niveau Parameter des instances elles-mêmes et interdit l'existence de plusieurs paramètres portant le même nom afin d'éviter certains problèmes lors de l'interopérabilité avec OpenQASM ou d'autres formats externes. Vous pouvez utiliser has_parameter() et get_parameter() pour interroger le circuit afin d'obtenir un paramètre dont le nom correspond à la chaîne de caractères indiquée.

has_parameter

has_parameter(name_or_param, /)

GitHub

Vérifier si un objet paramètre existe dans ce circuit.

Paramètres

name_or_param (str |Parameter) – le paramètre, ou le nom d'un paramètre à vérifier. S'il s'agit d'un Parameter nœud, le paramètre doit correspondre exactement à celui indiqué pour que cette fonction renvoie True.

Retours

si un paramètre d'adaptation est assignable dans ce circuit.

Type de retour

booléen

Voir aussi

QuantumCircuit.get_parameter()

Récupérer l'instance Parameter de ce circuit par son nom.

QuantumCircuit.has_var()

ParameterUne méthode similaire à celle-ci, mais qui concerne les variables d'exécution expr.Var plutôt que celles de compilation.

get_parameter

get_parameter(name: str, default: T) → Parameter | T

get_parameter(name: str, default: builtin_types.EllipsisType = Ellipsis) → Parameter

GitHub

Récupérer un paramètre de compilation accessible par son nom dans l'étendue du circuit.

Paramètres

name (str) – le nom du paramètre à récupérer.
default (Any) – si elle est fournie, cette valeur sera renvoyée en l'absence du paramètre. Si cette valeur n'est pas fournie, une exception KeyError est levée à la place.

Retours

Le paramètre correspondant.

Augmentations

KeyError - si aucune valeur par défaut n'est indiquée, mais que le paramètre n'existe pas dans le circuit.

Type de retour

Paramètre

Exemples

Récupérer un paramètre par son nom dans un circuit :

from qiskit.circuit import QuantumCircuit, Parameter

my_param = Parameter("my_param")

# Create a parametrized circuit.
qc = QuantumCircuit(1)
qc.rx(my_param, 0)

# We can use 'my_param' as a parameter, but let's say we've lost the Python object
# and need to retrieve it.
my_param_again = qc.get_parameter("my_param")

assert my_param == my_param_again

Obtenir une variable d'un circuit par son nom, en renvoyant une valeur par défaut si elle n'est pas présente :

assert qc.get_parameter("my_param", None) == my_param
assert qc.get_parameter("unknown_param", None) is None

Voir aussi

get_var()

Une méthode similaire, mais qui concerne expr.Var les variables d'exécution plutôt que Parameter les paramètres de compilation.

Travailler avec des données classiques saisies en temps réel

Voir aussi

qiskit.circuit.classical

Documentation au niveau du module sur le fonctionnement des systèmes de variables, d'expressions et de types, sur les objets utilisés pour les représenter et sur les opérations classiques disponibles.

Calcul classique en temps réel

Une discussion sur la façon dont les données en temps réel s'intègrent dans l'ensemble du modèle de données qiskit.circuit modèle de données dans son ensemble.

Ajout d'objets de données

Les méthodes d'ajout de nouveaux Var ou Stretch à un circuit après l'initialisation.

Vous pouvez récupérer les identifiants attachés à un circuit (par exemple un Var ou Stretch) par leur nom avec les méthodes get_var(), get_stretch(), ou get_identifier(). Vous pouvez également vérifier si un circuit contient un identificateur donné avec has_var(), has_stretch(), ou has_identifier().

get_var

get_var(name: str, default: T) → Var | T

get_var(name: str, default: builtin_types.EllipsisType = Ellipsis) → Var

GitHub

Récupérer une variable qui est accessible dans l'étendue du circuit par son nom.

Paramètres

name (str) – le nom de la variable à récupérer.
default (Any) – si elle est fournie, cette valeur sera renvoyée si la variable n'existe pas. Si cette valeur n'est pas fournie, une exception KeyError est levée à la place.

Retours

La variable correspondante.

Augmentations

KeyError - si aucune valeur par défaut n'est indiquée, mais que la variable n'existe pas.

Exemples

Récupérer une variable par son nom dans un circuit :

from qiskit.circuit import QuantumCircuit

# Create a circuit and create a variable in it.
qc = QuantumCircuit()
my_var = qc.add_var("my_var", False)

# We can use 'my_var' as a variable, but let's say we've lost the Python object and
# need to retrieve it.
my_var_again = qc.get_var("my_var")

assert my_var == my_var_again

Obtenir une variable d'un circuit par son nom, en renvoyant une valeur par défaut si elle n'est pas présente :

assert qc.get_var("my_var", None) == my_var
assert qc.get_var("unknown_variable", None) is None

Voir aussi

get_parameter()

Une méthode similaire, mais qui Parameter concerne les paramètres de compilation plutôt que expr.Var les variables d'exécution.

get_stretch

get_stretch(name: str, default: T) → Stretch | T

get_stretch(name: str, default: builtin_types.EllipsisType = Ellipsis) → Stretch

GitHub

Récupérer un tronçon accessible dans cette portée de circuit par son nom.

Paramètres

name (str) – le nom du segment à récupérer.
default (Any) – si elle est fournie, cette valeur sera renvoyée si la variable n'existe pas. Si cette valeur n'est pas fournie, une exception KeyError est levée à la place.

Retours

L'étirement correspondant.

Augmentations

KeyError - si aucune valeur par défaut n'est indiquée, mais que la variable n'existe pas.

Exemples

Récupérer un tronçon par son nom à partir d'un circuit :

from qiskit.circuit import QuantumCircuit

# Create a circuit and create a variable in it.
qc = QuantumCircuit()
my_stretch = qc.add_stretch("my_stretch")

# We can use 'my_stretch' as a variable, but let's say we've lost the Python object and
# need to retrieve it.
my_stretch_again = qc.get_stretch("my_stretch")

assert my_stretch == my_stretch_again

Obtenir une variable d'un circuit par son nom, en renvoyant une valeur par défaut si elle n'est pas présente :

assert qc.get_stretch("my_stretch", None) == my_stretch
assert qc.get_stretch("unknown_stretch", None) is None

get_identifier

get_identifier(name: str, default: T) → Var | Stretch | T

get_identifier(name: str, default: builtin_types.EllipsisType = Ellipsis) → Var | Stretch

GitHub

Récupérer un identificateur accessible par son nom dans l'étendue du circuit.

Il s'agit actuellement de variables classiques en temps réel et d'étirements.

Paramètres

name (str) – le nom de l'identifiant à récupérer.
default (Any) – si elle est fournie, cette valeur sera renvoyée si la variable n'existe pas. Si cette valeur n'est pas fournie, une exception KeyError est levée à la place.

Retours

La variable correspondante.

Augmentations

KeyError - si aucune valeur par défaut n'est indiquée, mais que l'identifiant n'existe pas.

Voir aussi

get_var()

Obtient un identifiant connu comme étant une expr.Var instance.

get_stretch()

Obtient un identifiant connu comme étant une expr.Stretch instance.

get_parameter()

Une méthode similaire, mais qui Parameter concerne les paramètres de compilation plutôt que expr.Var les variables d'exécution.

has_var

has_var(name_or_var, /)

GitHub

Vérifier si une variable est accessible dans ce champ d'application.

Paramètres

name_or_var (str |Var) – la variable ou le nom d'une variable à vérifier. S'il s'agit d'un expr.Var nœud, la variable doit être exactement celle qui est donnée pour que cette fonction renvoie True.

Retours

si une variable correspondante est accessible.

Type de retour

booléen

Voir aussi

QuantumCircuit.get_var()

Récupérer l'instance expr.Var de ce circuit par son nom.

QuantumCircuit.has_parameter()

ParameterUne méthode similaire à celle-ci, mais qui concerne les variables définies à la compilation plutôt que celles définies à l'exécution expr.Var .

has_stretch

has_stretch(name_or_stretch, /)

GitHub

Vérifier si un tronçon est accessible dans ce champ d'application.

Paramètres

name_or_stretch (str |Stretch) – le segment ou le nom d'un segment à vérifier. S'il s'agit d'un expr.Stretch nœud, l'étirement doit être exactement celui donné pour que cette fonction renvoie True.

Retours

si un tronçon correspondant est accessible.

Type de retour

booléen

Voir aussi

QuantumCircuit.get_stretch()

Récupérer l'instance expr.Stretch de ce circuit par son nom.

has_identifier

has_identifier(name_or_ident, /)

GitHub

Vérifier si un identifiant est accessible dans ce champ d'application.

Paramètres

name_or_ident (str |Var |Stretch) – l'instance ou le nom de l'identifiant à vérifier. S'il s'agit d'un nœud expr.Varexpr.Stretch ou, l'instance correspondante doit être exactement celle donnée pour que cette fonction renvoie True.

Retours

si l'identifiant correspondant est accessible.

Type de retour

booléen

Voir aussi

QuantumCircuit.get_identifier()

Récupérer le expr.Var ou expr.Stretch de ce circuit par son nom.

QuantumCircuit.has_var()

La même chose que cette méthode, mais en ignorant tout ce qui n'est pas une variable d'exécution expr.Var .

QuantumCircuit.has_stretch()

La même chose que cette méthode, mais en ignorant tout ce qui n'est pas une variable d'exécution expr.Stretch .

QuantumCircuit.has_parameter()

ParameterUne méthode similaire à celle-ci, mais qui concerne les variables définies à la compilation plutôt que celles définies à l'exécution expr.Var .

Il existe également plusieurs méthodes d'itération que vous pouvez utiliser pour obtenir l'ensemble des identifiants suivis par un circuit. Au moins un des éléments suivants iter_input_vars() et iter_captured_vars() sera vide, car les entrées et les captures s'excluent mutuellement. Tous les itérateurs ont des propriétés dynamiques correspondantes sur QuantumCircuit qui contiennent leur longueur : num_vars, num_stretches, num_input_vars, num_captured_vars, num_captured_stretches, num_declared_varsou num_declared_stretches.

iter_vars

iter_vars()

GitHub

Obtenir un itérable sur toutes les variables classiques en temps réel dans le champ d'application de ce circuit.

Cette méthode passe en revue toutes les variables dans le champ d'application. Pour des itérateurs plus fins, voir iter_declared_vars(), iter_input_vars() et iter_captured_vars().

Type de retour

Itérable[* Var* ]

iter_stretches

iter_stretches()

GitHub

Obtenir un itérable sur tous les étirements en cours dans ce circuit.

Cette méthode itère sur tous les étirements dans le champ d'application. Pour des itérateurs plus fins, voir iter_declared_stretches() et iter_captured_stretches().

Type de retour

Iterable[* Stretch* ]

iter_input_vars

iter_input_vars()

GitHub

Obtenir un itérable sur toutes les variables classiques en temps réel qui sont déclarées comme entrées dans cette fenêtre de circuit. Cela exclut les variables déclarées localement (voir iter_declared_vars()) et les variables capturées (voir iter_captured_vars()).

Type de retour

Itérable[* Var* ]

iter_captured_vars

iter_captured_vars()

GitHub

Obtenir un itérable sur toutes les variables classiques en temps réel qui sont capturées par cet oscilloscope de circuit à partir d'un oscilloscope contenant. Cela exclut les variables d'entrée (voir iter_input_vars()) et les variables déclarées localement (voir iter_declared_vars()).

Type de retour

Itérable[* Var* ]

iter_captured_stretches

iter_captured_stretches()

GitHub

Obtenir une table itérative sur les étirements capturés par cette fenêtre de circuit à partir d'une fenêtre de contenu. Cela exclut les tronçons déclarés localement (voir iter_declared_stretches()).

Type de retour

Iterable[* Stretch* ]

iter_declared_vars

iter_declared_vars()

GitHub

Obtenir un itérable sur toutes les variables classiques en temps réel qui sont déclarées avec une durée de stockage automatique dans ce champ d'application. Cela exclut les variables d'entrée (voir iter_input_vars()) et les variables capturées (voir iter_captured_vars()).

Type de retour

Itérable[* Var* ]

iter_declared_stretches

iter_declared_stretches()

GitHub

Obtenir un itérable sur tous les étirements déclarés dans ce champ d'application. Cela exclut les tronçons capturés (voir iter_captured_stretches()).

Type de retour

Iterable[* Stretch* ]

Ajout d'opérations aux circuits

Vous pouvez ajouter à un circuit, en une seule instruction, tout élément qui implémente l'interface Operation , même si la plupart des éléments que vous souhaiterez ajouter seront des instances de Instruction ou Gate de.

Voir aussi

Opérations, instructions et barrières

La documentation de haut niveau sur les différentes interfaces que Qiskit utilise pour définir les instructions au niveau du circuit qiskit.circuit-est une documentation de haut niveau sur les différentes interfaces utilisées par Qiskit pour définir les instructions au niveau du circuit.

Méthodes pour ajouter des opérations générales

Il s'agit des méthodes de base qui permettent d'ajouter n'importe quel objet, y compris ceux définis par l'utilisateur, aux circuits.

Méthode	Quant l'utiliser
`append()`	Ajouter une instruction en tant qu'objet unique sur un circuit.
`_append()`	Identique à `append()`mais une interface de bas niveau qui élimine presque toutes les vérifications d'erreurs.
`compose()`	Inline les instructions d'un circuit sur un autre.
`tensor()`	Comme `compose()`mais strictement pour joindre des circuits qui agissent sur des qubits disjoints.

QuantumCircuit il y a deux façons principales d'ajouter des opérations à un circuit. Le choix de l'option dépend du fait que vous souhaitez ajouter votre objet sous la forme d'une "instruction" unique (append()), ou si vous voulez joindre les instructions de deux circuits (compose()).

Une instruction ou une opération apparaît sous la forme d'une entrée unique dans le data schéma du circuit, et sous la forme d'une case unique lorsqu'elle est représentée dans les outils de visualisation de circuits (voir draw()). Une instruction est l'« unité » en fonction de laquelle un backend matériel peut être défini (voir Target). Un Instruction peut être accompagné d'un definition, ce qui constitue une règle sur laquelle le transpileur (voir qiskit.transpiler) pourra s'appuyer pour le décomposer en vue de l'exécution matérielle, si nécessaire. Un Operation qui n'est pas également un Instruction ne peut être décomposé que s'il est associé à une méthode de synthèse de haut niveau enregistrée (voir qiskit.transpiler.passes.synthesis.plugin).

Un QuantumCircuit « A » n'est pas à lui seul un « single » Instruction; c'est en réalité plus complexe, car il peut, en général, représenter un programme complet avec des entrées et sorties de mémoire classiques typées, ainsi qu'un flux de contrôle. Le modèle de données de Qiskit (et de la plupart des matériels) ne prend pas encore en charge le concept de sous-routines réutilisables et appelables avec des opérandes quantiques virtuels. Vous pouvez convertir des circuits simples qui n'agissent que sur des qubits à l'aide d'opérations unitaires en un Gate à l'aide de to_gate(), et des circuits simples agissant uniquement sur des qubits et des clbits en un Instruction à l'aide de to_instruction().

Lorsque vous disposez d'un Operation, Instruction, ou Gate, ajoutez-le au circuit en précisant les arguments « qubit » et « clbit » avec append().

append

append(instruction, qargs=None, cargs=None, *, copy=True)

GitHub

Ajouter une ou plusieurs instructions à la fin du circuit, en modifiant le circuit en place.

InstructionLes éléments qargs et cargs seront développés et diffusés conformément aux règles du donné, et tout spécificateur nonBit (tel qu'un indice entier) sera résolu en instances pertinentes.

Si un CircuitInstruction est fourni, il sera « déballé », vérifié dans le contexte de ce circuit, puis un nouvel objet sera ajouté au circuit. Dans ce cas, vous ne pouvez pas passer qargs ou cargs séparément.

Paramètres

instruction (Operation |CircuitInstruction) –Instruction une instance à ajouter, ou un CircuitInstruction avec tout son contexte. Les objets implémentant to_instruction sont également pris en charge, mais il est généralement préférable de passer un Instruction directement, car cela permet d'éviter le coût lié aux conversions répétées.
qargs (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]] | None) – les Qubitspécificateurs auxquels associer l'instruction
cargs (Sequence[Clbit |ClassicalRegister |int |slice |Sequence[Clbit |int]] | None) – les Clbitspécificateurs auxquels associer l'instruction
copy (bool) – si True (par défaut), l'instruction entrante instruction est copiée avant d'être ajoutée au circuit si elle contient des paramètres symboliques, de sorte qu'elle puisse être mutée en toute sécurité sans affecter d'autres circuits dans lesquels la même instruction pourrait se trouver. Si vous êtes sûr que cette instruction ne sera pas utilisée dans d'autres circuits, vous pouvez définir cette adresse False pour une petite accélération.

Retours

CircuitInstructionune référence aux composants qui ont effectivement été ajoutés au circuit.

Type de retour

qiskit.circuit.InstructionSet

Augmentations

CircuitError – si l'opération transmise n'est pas une instance de Instruction, ou ne peut pas être convertie en une telle instance en lui appliquant to_instruction la méthode.

append() effectue un contrôle d'erreur assez important pour s'assurer que vous ne pouvez pas accidentellement casser le modèle de données de QuantumCircuit. Si vous générez par programme un circuit à partir de données connues, vous pouvez éviter une grande partie de ce contrôle d'erreur en utilisant l'appendice fast-path _append()mais au risque que l'appelant soit responsable de s'assurer qu'il ne transmet que des données valides.

_append

_append(instruction: CircuitInstruction, *, _standard_gate: bool) → CircuitInstruction

_append(instruction: Operation, qargs: Sequence[Qubit], cargs: Sequence[Clbit]) → Operation

GitHub

Ajouter une instruction à la fin du circuit, en modifiant le circuit en place.

Avertissement

Il s'agit d'une fonction interne à accès rapide, et il incombe à l'appelant de s'assurer que tous les arguments sont valides; il n'y a pas de contrôle d'erreur ici. Notamment :

tous les qubits et clbits doivent déjà exister dans le circuit et il ne peut y avoir de doublons dans la liste.
toutes les instructions relatives aux opérations de contrôle-flux doivent agir uniquement sur les variables présentes dans le circuit.
le circuit ne doit pas se trouver dans un contexte de construction de flux de contrôle.

Remarque

Cette fonction peut être utilisée par des appelants autres que QuantumCircuit lorsque l'appelant est sûr que tous les contrôles d'erreur, la diffusion et le cadrage ont déjà été effectués, et que la seule référence au circuit auquel les instructions sont ajoutées se trouve dans cette même fonction. En particulier, il n'est pas sûr d'appeler QuantumCircuit._append() sur un circuit reçu par un argument de fonction. Cela est dû au fait que QuantumCircuit._append() ne reconnaît pas les constructions de portée de l'interface du constructeur de flux de contrôle.

Paramètres

instruction -

Une description complète et bien formée CircuitInstruction de l'opération et de son contexte à ajouter.

Dans le formulaire de compatibilité avec les versions antérieures, il peut s'agir d'un simple Operation, auquel cas qargs et cargs doivent être explicitement indiqués.
qargs – Argument hérité permettant aux qubits de s'attacher au « bare Operation ». Ignoré si le premier argument est sous la forme préférentielle CircuitInstruction .
cargs – Argument hérité de clbits permettant d'y associer le « bare Operation ». Ignoré si le premier argument est sous la forme préférentielle CircuitInstruction .
_standard_gate (bool)

Retours

une poignée vers l'instruction qui vient d'être ajoutée.

Type de retour

CircuitInstruction

Dans d'autres cas, vous pouvez souhaiter relier deux circuits entre eux, en appliquant les instructions d'un circuit sur des qubits et des clbits spécifiques d'un autre circuit. Cette opération d'"inlining" est appelée compose() dans Qiskit. compose() est, en général, plus puissant qu'un to_instruction()-plus-append() pour relier deux circuits, car elle peut également relier des données classiques typées et permet de relier des opérations de flux de contrôle de circuit à un autre circuit.

Les inconvénients de compose() sont qu'il s'agit d'une opération plus complexe qui peut impliquer davantage de réécriture de l'opérande, et qu'elle doit nécessairement déplacer des données d'un objet du circuit à un autre. Si vous construisez un circuit pour vous-même et que la performance brute est un objectif essentiel, envisagez de faire circuler votre circuit de base et de faire en sorte que les différentes parties de votre algorithme écrivent directement sur le circuit de base, plutôt que de construire un circuit de couche temporaire.

compose

GitHub

Appliquer les instructions d'un circuit sur des qubits et/ou des clbits spécifiques d'un autre circuit.

Remarque

Par défaut, un nouvel objet circuit est créé, laissant self intact. Pour la plupart des utilisations de cette fonction, il est beaucoup plus efficace de définir inplace=True et de modifier le circuit de base sur place.

Lorsqu'il s'agit de variables en temps réel (expr.Var et expr.Stretch ), il existe deux stratégies principales pour l'utilisation de la méthode compose():

Le circuit other est traité comme entièrement additif, y compris ses variables. Les variables de other doivent être entièrement distinctes de celles de self (utilisez var_remap pour vous aider), et toutes les variables de other seront déclarées à nouveau dans la sortie avec un champ d'application input/capture/local correspondant à celui qu'elles ont dans other. C'est généralement ce qu'il faut faire si l'on veut relier deux circuits non apparentés.
Le circuit other a été créé comme une extension exacte de self pour y être intégré, y compris en agissant sur les variables existantes dans leur état à la fin de self. Dans ce cas, il convient de créer other avec toutes les variables à intégrer déclarées comme "captures", puis d'utiliser inline_captures=True dans cette méthode pour les lier. C'est généralement ce que vous voulez si vous construisez un circuit en définissant des couches à la volée, ou si vous reconstruisez un circuit en utilisant des couches qui lui sont propres. L'argument vars_mode="captures" de copy_empty_like() pour créer la base de chaque couche, dans ce cas.

Paramètres

other (qiskit.circuit.Instruction orQuantumCircuit) – (sous-)circuit ou instruction à intégrer à soi-même. Si ce n'est pas un QuantumCircuit, cela peut être n'importe quoi qui append acceptera.
qubits (list[Qubit|int]) – qubits de soi à composer.
clbits (list[Clbit|int]) – clbits of self to compose onto.
front (bool) – Si True, la composition frontale sera effectuée. Cela n'est pas possible avec les gestionnaires de contexte des constructeurs de flux de contrôle.
inplace (bool) – Si True, modifier l'objet. Dans le cas contraire, retourner le circuit composé.
copy (bool) – Si True (par défaut), l'entrée est traitée comme partagée et toutes les instructions qu'elle contient sont copiées si elles doivent être modifiées à l'avenir. Vous pouvez mettre cette valeur à False si l'entrée doit être considérée comme appartenant au circuit de base, afin d'éviter les copies inutiles; dans ce cas, il n'est pas valable d'utiliser other par la suite, et certaines instructions peuvent avoir été mutées sur place.
var_remap (Mapping) –

mapping à utiliser pour réécrire expr.Var et expr.Stretch dans other au fur et à mesure qu'ils sont intégrés dans self. Cela permet d'éviter les conflits de noms.

Les clés et les valeurs peuvent être données sous forme de chaînes de caractères ou d'instances d'identifiants directs. Si une clé est une chaîne de caractères, elle correspond à n'importe quelle chaîne de caractères Var ou Stretch portant le même nom. Si une valeur est une chaîne de caractères, chaque fois qu'une nouvelle clé correspond à cette valeur, un nouvel élément Var ou Stretch est créé avec le bon type. Si une valeur est a Varsa valeur type doit correspondre exactement à celle de la variable qu'elle remplace.
inline_captures (bool) –

si True, tous les nœuds d'identificateurs "capturés" dans la base de données other QuantumCircuit sont supposés faire référence à des identificateurs déjà déclarés dans self (comme tout type d'entrée/capture/local), et les utilisations dans other s'appliqueront aux identificateurs existants. Si vous voulez construire une couche pour un circuit existant à utiliser avec compose()vous pourriez trouver utile l'argument vars_mode="captures" de copy_empty_like() utile. Tout remappage dans vars_remap a lieu avant l'évaluation de cette variable d'inlining.

S'il s'agit de False (valeur par défaut), tous les identificateurs de other devront être distincts de ceux de self, et de nouvelles déclarations seront faites pour eux.
wrap (bool) – Si True, l'autre circuit est transformé en porte (ou en instruction, selon qu'il ne contient que des instructions unitaires ou non) avant d'être intégré à soi. Plutôt que d'utiliser cette option, il est presque toujours préférable de contrôler manuellement cette fonction en utilisant les touches to_instruction() ou to_gate()et d'appeler ensuite append().

Retours

le circuit composé (renvoie à None si inplace==True).

Type de retour

QuantumCircuit

Augmentations

CircuitError - s'il n'est pas possible d'établir une correspondance correcte entre les deux circuits, par exemple si other est plus large que self.
CircuitError - si l'on essaie d'émettre un nouveau circuit alors que self a un contexte de flux de contrôle partiellement construit actif, comme les formes de gestionnaire de contexte de if_test(), for_loop() et while_loop().
CircuitError - si l'on essaie de composer à l'avant d'un circuit lorsqu'un bloc de construction de flux de contrôle est actif; il n'y a pas de signification claire à cette action.

Exemples

>>> lhs.compose(rhs, qubits=[3, 2], inplace=True)

            ┌───┐                   ┌─────┐                ┌───┐
lqr_1_0: ───┤ H ├───    rqr_0: ──■──┤ Tdg ├    lqr_1_0: ───┤ H ├───────────────
            ├───┤              ┌─┴─┐└─────┘                ├───┤
lqr_1_1: ───┤ X ├───    rqr_1: ┤ X ├───────    lqr_1_1: ───┤ X ├───────────────
         ┌──┴───┴──┐           └───┘                    ┌──┴───┴──┐┌───┐
lqr_1_2: ┤ U1(0.1) ├  +                     =  lqr_1_2: ┤ U1(0.1) ├┤ X ├───────
         └─────────┘                                    └─────────┘└─┬─┘┌─────┐
lqr_2_0: ─────■─────                           lqr_2_0: ─────■───────■──┤ Tdg ├
            ┌─┴─┐                                          ┌─┴─┐        └─────┘
lqr_2_1: ───┤ X ├───                           lqr_2_1: ───┤ X ├───────────────
            └───┘                                          └───┘
lcr_0: 0 ═══════════                           lcr_0: 0 ═══════════════════════

lcr_1: 0 ═══════════                           lcr_1: 0 ═══════════════════════

Si vous essayez de joindre deux circuits, cela s'appliquera à des qubits et clbits complètement disjoints, tensor() est une enveloppe pratique qui permet d'ajouter manuellement des objets binaires et d'appeler compose().

tensor

tensor(other, inplace=False)

GitHub

Tenseur self avec other.

Rappelez-vous que dans la convention little-endian, l'opération la plus à gauche se trouve en bas du circuit. Voir aussi la documentation pour plus d'informations.

     ┌────────┐        ┌─────┐          ┌─────┐
q_0: ┤ bottom ├ ⊗ q_0: ┤ top ├  = q_0: ─┤ top ├──
     └────────┘        └─────┘         ┌┴─────┴─┐
                                  q_1: ┤ bottom ├
                                       └────────┘

Paramètres

other (QuantumCircuit) – L'autre circuit avec lequel tensoriser ce circuit.
inplace (bool) – Si True, modifier l'objet. Dans le cas contraire, le circuit composé est renvoyé.

Type de retour

QuantumCircuit | Aucun

Exemples

from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
tensored = bottom.tensor(top)
tensored.draw('mpl')

Retours

Le circuit tensoriel (renvoie None si inplace=True).

Type de retour

QuantumCircuit

Paramètres

other (QuantumCircuit)
inplace (bool)

Voici quelques règles empiriques :

Si vous avez un seul Operation, Instruction ou Gate, vous devriez absolument utiliser append() ou _append().
Si vous avez un QuantumCircuit qui représente une instruction atomique unique pour un circuit plus large que vous souhaitez réutiliser, vous voudrez probablement appeler to_instruction() ou to_gate()puis d'appliquer le résultat de cette instruction au circuit à l'aide de append().
Si vous avez un circuit QuantumCircuit qui représente une "couche" plus large d'un autre circuit, ou qui contient des variables classiques typées ou un flux de contrôle, vous devez utiliser compose() pour le fusionner avec un autre circuit.
tensor() est recherché beaucoup plus rarement que l'un ou l'autre append() ou compose(). En interne, il s'agit principalement d'une enveloppe autour de add_bits() et compose().

Quelques pièges potentiels à éviter :

Même si vous réutilisez un élément personnalisé Instruction lors de la construction d'un circuit, le transpileur devra généralement « dérouler » chaque invocation de cet élément pour en obtenir la décomposition interne avant de pouvoir commencer à le traiter. to_instruction()Cela ne devrait pas vous empêcher d'utiliser le modèle « -plus-append() », car le transpileur s'améliorera à cet égard au fil du temps.
compose() produira, par défaut, un nouveau circuit pour des raisons de compatibilité ascendante. C'est plus cher et ce n'est généralement pas ce que vous voulez, vous devriez donc régler inplace=True.
Les fonctions et compose() (mais pas _append()) possèdent toutes append() deux un copy argument de mot-clé dont la valeur par défaut est True. Dans ces cas-là, les instances entrantes Operation seront copiées si Qiskit détecte que les objets sont modifiables (par exemple, lorsqu’ils contiennent des paramètres de porte). Si vous êtes certain de ne pas réutiliser ces objets ailleurs, vous devriez configurer copy=False pour empêcher cette copie, ce qui peut permettre un gain de vitesse considérable pour les objets volumineux.

Méthodes pour ajouter des instructions standard

Cette QuantumCircuit classe dispose de méthodes d'aide permettant d'ajouter à un circuit un grand nombre d'instructions et de portes issues de la bibliothèque standard de Qiskit. Cela revient généralement à créer manuellement une instance de l'objet qiskit.circuit.library concerné, puis à la transmettre à append() en plaçant les arguments restants dans les champs qargs cargs et comme il convient.

Les méthodes suivantes appliquent des opérations spéciales non unitaires Instruction au circuit :

`QuantumCircuit` méthode	`qiskit.circuit` `Instruction`
`barrier()`	`Barrier`
`delay()`	`Delay`
`initialize()`	`Initialize`
`measure()`	`Measure`
`reset()`	`Reset`
`store()`	`Store`

Ces méthodes appliquent des instances unitaires Gate non contrôlées au circuit :

`QuantumCircuit` méthode	`qiskit.circuit.library` `Gate`
`dcx()`	`DCXGate`
`ecr()`	`ECRGate`
`h()`	`HGate`
`id()`	`IGate`
`iswap()`	`iSwapGate`
`ms()`	`MSGate`
`p()`	`PhaseGate`
`pauli()`	`PauliGate`
`prepare_state()`	`StatePreparation`
`r()`	`RGate`
`rcccx()`	`RC3XGate`
`rccx()`	`RCCXGate`
`rv()`	`RVGate`
`rx()`	`RXGate`
`rxx()`	`RXXGate`
`ry()`	`RYGate`
`ryy()`	`RYYGate`
`rz()`	`RZGate`
`rzx()`	`RZXGate`
`rzz()`	`RZZGate`
`s()`	`SGate`
`sdg()`	`SdgGate`
`swap()`	`SwapGate`
`sx()`	`SXGate`
`sxdg()`	`SXdgGate`
`t()`	`TGate`
`tdg()`	`TdgGate`
`u()`	`UGate`
`unitary()`	`UnitaryGate`
`x()`	`XGate`
`y()`	`YGate`
`z()`	`ZGate`

Les méthodes suivantes s'appliquent Gate aux instances qui sont également des portes contrôlées, et constituent donc des sous-classes directes de ControlledGate:

`QuantumCircuit` méthode	`qiskit.circuit.library` `ControlledGate`
`ccx()`	`CCXGate`
`ccz()`	`CCZGate`
`ch()`	`CHGate`
`cp()`	`CPhaseGate`
`crx()`	`CRXGate`
`cry()`	`CRYGate`
`crz()`	`CRZGate`
`cs()`	`CSGate`
`csdg()`	`CSdgGate`
`cswap()`	`CSwapGate`
`csx()`	`CSXGate`
`cu()`	`CUGate`
`cx()`	`CXGate`
`cy()`	`CYGate`
`cz()`	`CZGate`

Enfin, ces méthodes appliquent au circuit des portes généralisées multipliées contrôlées particulières, souvent avec des synthèses rapides. Ils sont répertoriés en fonction de la porte de base qu'ils contrôlent, car leur sortie exacte est souvent une version synthétisée d'une porte.

`QuantumCircuit` méthode	Base `qiskit.circuit.library` `Gate`
`mcp()`	`PhaseGate`
`mcrx()`	`RXGate`
`mcry()`	`RYGate`
`mcrz()`	`RZGate`
`mcx()`	`XGate`

Le reste de cette section est la liste des API de toutes les méthodes individuelles; les tableaux ci-dessus sont des résumés dont les liens vous renvoient au bon endroit.

barrier

barrier(*qargs, label=None)

GitHub

Postuler Barrier. Si qargs est vide, s'applique à tous les qubits du circuit.

Paramètres

qargs (QubitSpecifier) – Spécification pour un ou plusieurs arguments qubit.
label (str) – L'étiquette de la chaîne de la barrière.

Retours

aux instructions ajoutées.

Type de retour

qiskit.circuit.InstructionSet

ccx

ccx(control_qubit1, control_qubit2, target_qubit, ctrl_state=None)

GitHub

CCXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme premier contrôle.
control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme deuxième commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

ccz

ccz(control_qubit1, control_qubit2, target_qubit, label=None, ctrl_state=None)

GitHub

CCZGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme premier contrôle.
control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme deuxième commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '10'). La valeur par défaut est le contrôle de l'état "11".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

ch

ch(control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CHGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

cp

cp(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CPhaseGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

crx

crx(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CRXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

cry

cry(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CRYGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

crz

crz(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CRZGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

cs

cs(control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CSGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

csdg

csdg(control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CSdgGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

cswap

cswap(control_qubit, target_qubit1, target_qubit2, label=None, ctrl_state=None)

GitHub

CSwapGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
target_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). La valeur par défaut est le contrôle de l'état '1' .

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

csx

csx(control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CSXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

cu

cu(theta, phi, lam, gamma, control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CUGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation de la vanne, exprimé en $\theta$ .
phi (ParameterExpression |float) – L'angle de rotation de la vanne, exprimé en $\phi$ .
lam (ParameterExpression |float) – L'angle de rotation de la vanne, exprimé en $\lambda$ .
gamma (ParameterExpression |float) – La phase globale appliquée à la porte U, le cas échéant.
control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

cx

cx(control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

cy

cy(control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CYGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme témoins.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

cz

cz(control_qubit, target_qubit, label=None, ctrl_state=None)

GitHub

CZGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme témoins.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

dcx

dcx(qubit1, qubit2)

GitHub

DCXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.
qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

delay

delay(duration, qarg=None, unit=None)

GitHub

Appliquer Delay. Si qarg est None, s'applique à tous les qubits. Lors de l'application à plusieurs qubits, des retards de même durée seront créés.

Paramètres

duration (Object) – la durée du délai. S'il s'agit d'un Expril doit s'agir d'une expression constante de type Duration.
qarg (Object) – pour appliquer ce délai.
unit (str | None) – unité de la durée, sauf si duration est un Expr auquel cas elle ne doit pas être spécifiée. Unités soutenues : 's', 'ms', 'us', 'ns', 'ps', et 'dt'. La valeur par défaut est 'dt', c'est-à-dire une unité de temps entière dépendant du backend cible.

Retours

aux instructions ajoutées.

Type de retour

qiskit.circuit.InstructionSet

Augmentations

CircuitError - si les arguments ont un mauvais format.

ecr

ecr(qubit1, qubit2)

GitHub

ECRGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le premier qubit auquel appliquer la porte.
qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le deuxième qubit auquel appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

h

h(qubit)

GitHub

HGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

id

id(qubit)

GitHub

IGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

initialize

initialize(params, qubits=None, normalize=False)

GitHub

Initialiser les qubits dans un état spécifique.

L'initialisation des qubits s'effectue d'abord en les remettant à l'état « $|0\rangle$ », puis en appelant StatePreparation la classe afin de les préparer dans un état spécifié. Ces deux étapes sont décrites dans le Initialize mode d'emploi.

Paramètres

params (Statevector | Sequence[complex] | str |int) –

L'état à initialiser peut être l'un des suivants.
- Vecteur d'état ou vecteur d'amplitudes complexes à initialiser.
- Étiquettes des états de base des états propres de Pauli Z, X, Y. Voir Statevector.from_label(). Notez que l'ordre des étiquettes est inversé par rapport à l'indice du qubit auquel elles s'appliquent. L'étiquette '01' « Example » initialise le qubit zéro à $|1\rangle$ et le qubit un à $|0\rangle$ .
- Un entier qui est utilisé comme un bitmap indiquant les qubits à initialiser à $|1\rangle$ . Exemple : en réglant params à 5, le qubit 0 et le qubit 2 seront initialisés à $|1\rangle$ et le qubit 1 à $|0\rangle$ .
qubits (Sequence[QubitSpecifier] | None) – Qubits à initialiser. Si None , l'initialisation est appliquée à tous les qubits du circuit.
normalize (bool) – Normaliser ou non un tableau d'entrée en un vecteur unitaire.

Retours

Une poignée pour les instructions créées.

Exemples

Préparer un qubit dans l'état $(|0\rangle - |1\rangle) / \sqrt{2}$ .

import numpy as np
from qiskit import QuantumCircuit

circuit = QuantumCircuit(1)
circuit.initialize([1/np.sqrt(2), -1/np.sqrt(2)], 0)
circuit.draw()

Sortie :

     ┌──────────────────────────────┐
q_0: ┤ Initialize(0.70711,-0.70711) ├
     └──────────────────────────────┘

Initialiser, à partir d'une chaîne de caractères, deux qubits dans l'état $|10\rangle$ . L'ordre des étiquettes est inversé par rapport à l'index des qubits. Vous trouverez plus d'informations sur les étiquettes des états de base dans Statevector.from_label().

import numpy as np
from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.initialize('01', circuit.qubits)
circuit.draw()

Sortie :

     ┌──────────────────┐
q_0: ┤0                 ├
     │  Initialize(0,1) │
q_1: ┤1                 ├
     └──────────────────┘

Initialiser deux qubits à partir d'un tableau d'amplitudes complexes.

import numpy as np
from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.initialize([0, 1/np.sqrt(2), -1.j/np.sqrt(2), 0], circuit.qubits)
circuit.draw()

Sortie :

     ┌────────────────────────────────────┐
q_0: ┤0                                   ├
     │  Initialize(0,0.70711,-0.70711j,0) │
q_1: ┤1                                   ├
     └────────────────────────────────────┘

iswap

iswap(qubit1, qubit2)

GitHub

iSwapGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le premier qubit auquel appliquer la porte.
qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le deuxième qubit auquel appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

mcp

mcp(lam, control_qubits, target_qubit, ctrl_state=None)

GitHub

MCPhaseGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

lam (ParameterExpression |float) – L'angle de rotation.
control_qubits (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]]) – Les qubits utilisés comme témoins.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

mcrx

mcrx(theta, q_controls, q_target, use_basis_gates=False)

GitHub

Appliquer la porte de rotation X à contrôle multiple

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
q_controls (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]]) – Les qubits utilisés comme témoins.
q_target (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le qubit visé par la porte.
use_basis_gates (bool) – utiliser les portes de base p, u, cx.

mcry

mcry(theta, q_controls, q_target, q_ancillae=None, mode=None, use_basis_gates=False)

GitHub

Appliquer la porte de rotation Y à contrôle multiple

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
q_controls (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]]) – Les qubits utilisés comme témoins.
q_target (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le qubit visé par la porte.
q_ancillae (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int] | Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]] | None) – La liste des qubits auxiliaires.
mode (str | None) – Le mode de mise en œuvre à utiliser.
use_basis_gates (bool) – utiliser les portes de base p, u, cx

mcrz

mcrz(lam, q_controls, q_target, use_basis_gates=False)

GitHub

Appliquer la porte de rotation Z à contrôle multiple

Paramètres

lam (ParameterExpression |float) – L'angle de rotation.
q_controls (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]]) – Les qubits utilisés comme témoins.
q_target (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le qubit visé par la porte.
use_basis_gates (bool) – utiliser les portes de base p, u, cx.

mcx

mcx(control_qubits, target_qubit, ancilla_qubits=None, mode=None, ctrl_state=None)

GitHub

MCXGatePostuler.

La porte multi-cX peut être mise en œuvre à l'aide de différentes techniques, qui utilisent des nombres différents de qubits ancillaires et ont une profondeur de circuit variable. Ces modes sont les suivants :

'noancilla': Nécessite 0 qubits ancillaires.
'recursion': Nécessite 1 qubit ancilla si plus de 4 contrôles sont utilisés, sinon 0.
'v-chain': Nécessite 2 ancillas de moins que le nombre de qubits de contrôle.
'v-chain-dirty': Même chose que pour les ancillas propres (mais le circuit sera plus long).

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Déclassé depuis la version 2.1

qiskit.circuit.quantumcircuit.QuantumCircuit.mcx()l'argument de mode est obsolète depuis Qiskit 2.1. Elle sera retirée au plus tôt trois mois après la date de diffusion. Au lieu de cela, ajoutez un MCXGate générique au circuit et spécifiez la méthode de synthèse via le site hls_config dans la transpilation. Des décompositions spécifiques sont également disponibles à l'adresse suivante https://qisk.it/mcx.

Paramètres

control_qubits (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]]) – Les qubits utilisés comme témoins.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.
ancilla_qubits (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int] | Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]] | None) – Les qubits utilisés comme ancillae, si le mode l'exige.
mode (str | None) – Le choix du mode, expliqué plus haut.
ctrl_state (str |int | None) – L'état de contrôle en décimal ou sous forme de chaîne de bits (par exemple '1'). Par défaut, le contrôle se fait sur l'état "1".

Retours

Une poignée pour les instructions créées.

Augmentations

ValueError - si le mode donné n'est pas connu, ou si trop peu de qubits ancilla sont transmis.
AttributeError - si aucun qubit d'ancilla n'est transmis, mais que certains sont nécessaires.

Type de retour

InstructionSet

measure

measure(qubit, cbit)

GitHub

Mesurer un bit quantique (qubit) dans la base Z en un bit classique (cbit).

Lorsqu'un état quantique est mesuré, un qubit est projeté dans la base de calcul (Pauli Z) vers $\lvert 0 \rangle$ ou $\lvert 1 \rangle$ . Le bit classique cbit indique le résultat de cette projection sous la forme d'un 0 ou d'un 1 respectivement. Cette opération n'est pas réversible.

Paramètres

qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – qubit(s) à mesurer.
cbit (Clbit |ClassicalRegister |int |slice |Sequence[Clbit |int]) – bit(s) classique(s) dans lequel (lesquels) placer le(s) résultat(s) de mesure, ou un expr.Var de types.Uint type indexant le clbit cible.

Retours

aux instructions ajoutées.

Type de retour

qiskit.circuit.InstructionSet

Augmentations

CircuitError - si les arguments ont un mauvais format.

Exemples

Dans cet exemple, un qubit est mesuré et le résultat de cette mesure est stocké dans le bit classique (généralement exprimé dans les diagrammes sous la forme d'une double ligne) :

from qiskit import QuantumCircuit
circuit = QuantumCircuit(1, 1)
circuit.h(0)
circuit.measure(0, 0)
circuit.draw()

     ┌───┐┌─┐
  q: ┤ H ├┤M├
     └───┘└╥┘
c: 1/══════╩═
           0

Il est possible d'appeler measure avec des listes de qubits et cbits comme raccourci pour une mesure univoque. Ces deux formulaires produisent des résultats identiques :

circuit = QuantumCircuit(2, 2)
circuit.measure([0,1], [0,1])

circuit = QuantumCircuit(2, 2)
circuit.measure(0, 0)
circuit.measure(1, 1)

Au lieu de listes, vous pouvez utiliser QuantumRegister et ClassicalRegister selon la même logique.

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qreg = QuantumRegister(2, "qreg")
creg = ClassicalRegister(2, "creg")
circuit = QuantumCircuit(qreg, creg)
circuit.measure(qreg, creg)

Cela équivaut à :

circuit = QuantumCircuit(qreg, creg)
circuit.measure(qreg[0], creg[0])
circuit.measure(qreg[1], creg[1])

ms

ms(theta, qubits)

GitHub

MSGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
qubits (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]]) – Les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

p

p(theta, qubit)

GitHub

PhaseGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

pauli

pauli(pauli_string, qubits)

GitHub

PauliGatePostuler.

Paramètres

pauli_string (str) – Une chaîne représentant l'opérateur de Pauli à appliquer, par exemple "XX".
qubits (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]]) – Les qubits auxquels appliquer cette porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

prepare_state

prepare_state(state, qubits=None, label=None, normalize=False)

GitHub

Préparer les qubits dans un état spécifique.

Cette classe met en œuvre un état préparant l'unité. Contrairement à initialize() il ne réinitialise pas les qubits au préalable.

Paramètres

state (Statevector | Sequence[complex] | str |int) –

L'état à initialiser peut être l'un des suivants.
- Vecteur d'état ou vecteur d'amplitudes complexes à initialiser.
- Étiquettes des états de base des états propres de Pauli Z, X, Y. Voir Statevector.from_label(). Notez que l'ordre des étiquettes est inversé par rapport à l'indice du qubit auquel elles s'appliquent. L'étiquette « 01 » initialise le qubit zéro à $|1\rangle$ et le qubit un à $|0\rangle$ .
- Un entier qui est utilisé comme un bitmap indiquant les qubits à initialiser à $|1\rangle$ . Exemple : en réglant params à 5, le qubit 0 et le qubit 2 seront initialisés à $|1\rangle$ et le qubit 1 à $|0\rangle$ .
qubits (Sequence[QubitSpecifier] | None) – Qubits à initialiser. Si None , l'initialisation est appliquée à tous les qubits du circuit.
label (str | None) – Une étiquette facultative pour la porte
normalize (bool) – Normaliser ou non un tableau d'entrée en un vecteur unitaire.

Retours

Une poignée vers l'instruction qui vient d'être initialisée

Type de retour

InstructionSet

Exemples

Préparer un qubit dans l'état $(|0\rangle - |1\rangle) / \sqrt{2}$ .

import numpy as np
from qiskit import QuantumCircuit

circuit = QuantumCircuit(1)
circuit.prepare_state([1/np.sqrt(2), -1/np.sqrt(2)], 0)
circuit.draw()

Sortie :

     ┌─────────────────────────────────────┐
q_0: ┤ State Preparation(0.70711,-0.70711) ├
     └─────────────────────────────────────┘

Préparez, à partir d'une chaîne, deux qubits dans l'état $|10\rangle$ . L'ordre des étiquettes est inversé par rapport à l'indice des qubits. Vous trouverez plus d'informations sur les étiquettes des états de base dans Statevector.from_label().

import numpy as np
from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.prepare_state('01', circuit.qubits)
circuit.draw()

Sortie :

     ┌─────────────────────────┐
q_0: ┤0                        ├
     │  State Preparation(0,1) │
q_1: ┤1                        ├
     └─────────────────────────┘

Initialiser deux qubits à partir d'un tableau d'amplitudes complexes

import numpy as np
from qiskit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.prepare_state([0, 1/np.sqrt(2), -1.j/np.sqrt(2), 0], circuit.qubits)
circuit.draw()

Sortie :

     ┌───────────────────────────────────────────┐
q_0: ┤0                                          ├
     │  State Preparation(0,0.70711,-0.70711j,0) │
q_1: ┤1                                          ├
     └───────────────────────────────────────────┘

r

r(theta, phi, qubit)

GitHub

RGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
phi (ParameterExpression |float) – L'angle de l'axe de rotation dans le plan x-y.
qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

rcccx

rcccx(control_qubit1, control_qubit2, control_qubit3, target_qubit)

GitHub

RC3XGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme premier contrôle.
control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme deuxième commande.
control_qubit3 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme troisième commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

rccx

rccx(control_qubit1, control_qubit2, target_qubit)

GitHub

RCCXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme premier contrôle.
control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits utilisés comme deuxième commande.
target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits ciblés par la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

reset

reset(qubit)

GitHub

Réinitialiser le(s) bit(s) quantique(s) à leur état par défaut.

Paramètres

Retours

à l'instruction ajoutée.

Type de retour

qiskit.circuit.InstructionSet

rv

rv(vx, vy, vz, qubit)

GitHub

RVGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Rotation autour d'un axe de rotation arbitraire $v$ , où $|v|$ est l'angle de rotation en radians.

Paramètres

vx (ParameterExpression |float) – composante x de l'axe de rotation.
vy (ParameterExpression |float) – composante y de l'axe de rotation.
vz (ParameterExpression |float) – composante z de l'axe de rotation.
qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

rx

rx(theta, qubit, label=None)

GitHub

RXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation de la vanne.
qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

rxx

rxx(theta, qubit1, qubit2)

GitHub

RXXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation.
qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.
qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

ry

ry(theta, qubit, label=None)

GitHub

RYGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation de la vanne.
qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

ryy

ryy(theta, qubit1, qubit2)

GitHub

RYYGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation de la vanne.
qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.
qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

rz

rz(phi, qubit)

GitHub

RZGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

phi (ParameterExpression |float) – L'angle de rotation de la vanne.
qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

rzx

rzx(theta, qubit1, qubit2)

GitHub

RZXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation de la vanne.
qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.
qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

rzz

rzz(theta, qubit1, qubit2)

GitHub

RZZGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation de la vanne.
qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.
qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

s

s(qubit)

GitHub

SGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

sdg

sdg(qubit)

GitHub

SdgGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

store

store(lvalue, rvalue, /)

GitHub

Stocker le résultat de l'expression classique en temps réel rvalue dans l'emplacement mémoire défini par lvalue.

Typiquement, lvalue sera un nœud Var et rvalue sera un nœud Expr pour y écrire, mais tout ce qui expr.lift() peut élever à un Expr est autorisé aux deux endroits, et il sera appelé sur eux.

Paramètres

lvalue (Any) – un spécificateur valide pour un emplacement de mémoire dans le circuit. Il s'agit généralement d'un nœud Var mais vous pouvez également écrire sur Clbit ou ClassicalRegister si votre matériel le permet. L'emplacement mémoire doit déjà être présent dans le circuit.
rvalue (Any) – une expression classique en temps réel dont le résultat doit être écrit dans l'emplacement mémoire donné.

Type de retour

InstructionSet

Voir aussi

Store

La classe sous-jacente Instruction qui représente cette opération.

add_var()

Créer une nouvelle variable dans le circuit qui peut être écrite avec cette méthode.

swap

swap(qubit1, qubit2)

GitHub

SwapGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le premier qubit auquel appliquer la porte.
qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le deuxième qubit auquel appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

sx

sx(qubit)

GitHub

SXGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

sxdg

sxdg(qubit)

GitHub

SXdgGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

t

t(qubit)

GitHub

TGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

tdg

tdg(qubit)

GitHub

TdgGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

u

u(theta, phi, lam, qubit)

GitHub

UGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

theta (ParameterExpression |float) – L'angle de rotation de la vanne, exprimé en $\theta$ .
phi (ParameterExpression |float) – L'angle de rotation de la vanne, exprimé en $\phi$ .
lam (ParameterExpression |float) – L'angle de rotation de la vanne, exprimé en $\lambda$ .
qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

unitary

unitary(obj, qubits, label=None)

GitHub

Appliquer la porte unitaire spécifiée par obj à qubits.

Paramètres

obj (np.ndarray | Gate | BaseOperator) – Opérateur unitaire.
qubits (Sequence[QubitSpecifier]) – Les qubits du circuit auxquels appliquer la transformation.
label (str | None) – Nom unitaire pour le backend [Défaut : Aucun].

Retours

Le circuit quantique.

Type de retour

QuantumCircuit

Exemple

Appliquer une porte spécifiée par une matrice unitaire à un circuit quantique

from qiskit import QuantumCircuit
matrix = [[0, 0, 0, 1],
        [0, 0, 1, 0],
        [1, 0, 0, 0],
        [0, 1, 0, 0]]
circuit = QuantumCircuit(2)
circuit.unitary(matrix, [0, 1])

x

x(qubit, label=None)

GitHub

XGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Le ou les qubits auxquels appliquer la porte.
label (str | None) – L'étiquette de la chaîne de la porte dans le circuit.

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

y

y(qubit)

GitHub

YGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

z

z(qubit)

GitHub

ZGatePostuler.

Pour la forme matricielle complète de cette porte, voir la documentation de la porte sous-jacente.

Paramètres

Retours

Une poignée pour les instructions créées.

Type de retour

InstructionSet

Ajout d'un flux de contrôle aux circuits

Voir aussi

Flux de contrôle dans les circuits

Discussion sur la façon dont les opérations de flux de contrôle sont représentées dans l'ensemble du contexte qiskit.circuit l'ensemble du contexte.

`QuantumCircuit` méthode	Instruction de flux de contrôle
`if_test()`	`IfElseOp` avec seulement un `True` corps
`if_else()`	`IfElseOp` avec les corps et `False` à `True` la fois
`while_loop()`	`WhileLoopOp`
`switch()`	`SwitchCaseOp`
`for_loop()`	`ForLoopOp`
`box()`	`BoxOp`
`break_loop()`	`BreakLoopOp`
`continue_loop()`	`ContinueLoopOp`

QuantumCircuit dispose de méthodes correspondantes pour toutes les opérations de contrôle de flux prises en charge par Qiskit. Il existe deux façons de les appeler. ControlFlowOpLa première est une fonction d'encapsulation très simple qui prend en QuantumCircuit arguments les corps des blocs d'instructions et se contente de construire et d'ajouter le fichier correspondant.

La deuxième forme, que nous vous recommandons vivement d'utiliser pour la mise en place du flux de contrôle, est appelée «* interface de construction* ». Ici, les méthodes ne prennent en paramètre que le discriminant en temps réel de l'opération et renvoient des gestionnaires de contexte que vous définissez à l'aide de with. Vous pouvez ensuite utiliser des méthodes classiques QuantumCircuit au sein de ces blocs pour construire les corps du flux de contrôle, et Qiskit identifiera automatiquement les ressources de données nécessaires aux blocs internes, en construisant le code complet ControlFlowOp au fur et à mesure que vous quittez l'instruction with . Il est bien plus simple et moins sujet aux erreurs de définir le flux de contrôle par programmation de cette manière.

Lors de l'utilisation de l'interface de construction du flux de contrôle, il peut arriver qu'un qubit soit inclus dans un bloc, même s'il n'a pas d'opérations définies. Dans ce cas, vous pouvez utiliser la méthode noop() méthode.

QuantumCircuit.has_control_flow_op()Pour vérifier si un circuit contient un ControlFlowOp , vous pouvez utiliser la méthode d'aide.

box

box(body_or_annotations=Ellipsis, /, qubits=None, clbits=None, *, label=None, duration=None, unit=None, annotations=Ellipsis)

GitHub

Créer un site box d'opérations sur ce circuit qui sont traitées de manière atomique dans un contexte plus large.

Une "boîte" est une construction de flux de contrôle qui est saisie sans condition. Le contenu de la boîte se comporte un peu comme si le début et la fin de la boîte étaient des barrières (voir barrier()), si ce n'est qu'il est permis d'effectuer des opérations "jusqu'au bout" de la boîte. La boîte est également une portée explicite pour les variables, les étirements et les passes du compilateur.

Il existe deux façons d'appeler cette fonction :

Passez un paramètre QuantumCircuit par référence, ainsi que clbits les qubits objets sur lesquels il agit. Dans ce formulaire, un BoxOp est immédiatement créé et ajouté en utilisant le circuit comme corps.
A utiliser dans une déclaration with sans body, qubits ou clbits. Il s'agit du "formulaire de l'interface du constructeur", dans lequel vous utilisez ensuite d'autres méthodes dans le champ d'application pour ajouter des instructions à QuantumCircuit dans le cadre de Python with pour ajouter des instructions à box. C'est la forme préférée et elle est beaucoup moins sujette aux erreurs.

Exemples

Utilisation de l'interface du constructeur pour ajouter deux boîtes l'une après l'autre. Les deux boîtes de ce circuit peuvent s'exécuter simultanément, et la seconde insère explicitement une dépendance de flux de données sur le qubit 8 pour la durée de la boîte, même si le qubit est inactif.

from qiskit.circuit import QuantumCircuit, Annotation

class MyAnnotation(Annotation):
    namespace = "my.namespace"

qc = QuantumCircuit(9)
with qc.box():
    qc.cz(0, 1)
    qc.cz(2, 3)
with qc.box([MyAnnotation()]):
    qc.cz(4, 5)
    qc.cz(6, 7)
    qc.noop(8)

En utilisant la construction explicite de la boîte. Cela crée le même circuit que ci-dessus et devrait indiquer pourquoi la forme précédente est préférable pour une utilisation interactive.

from qiskit.circuit import QuantumCircuit, BoxOp

body_0 = QuantumCircuit(4)
body_0.cz(0, 1)
body_0.cz(2, 3)

# Note that the qubit indices inside a body related only to the body.  The
# association with qubits in the containing circuit is made by the ``qubits``
# argument to `QuantumCircuit.box`.
body_1 = QuantumCircuit(5)
body_1.cz(0, 1)
body_1.cz(2, 3)

qc = QuantumCircuit(9)
qc.box(body_0, [0, 1, 2, 3], [])
qc.box(body_1, [4, 5, 6, 7, 8], [])

Paramètres

body_or_annotations (QuantumCircuit |Iterable[Annotation]) – le premier argument de position n'a pas de nom. Si un QuantumCircuit est transmis par référence, il est immédiatement utilisé comme contenu de la boîte, et qubits et clbits doivent également être spécifiés. Si aucun argument n'est fourni, ou si l'on passe un itérable Annotation d'objets, la version « gestionnaire de contexte » de cette méthode est déclenchée.
qubits (Sequence[QubitSpecifier] | None) – les qubits auxquels appliquer l'opération BoxOp , sous sa forme explicite.
clbits (Sequence[ClbitSpecifier] | None) – les bits de contrôle auxquels appliquer l'opération BoxOp , sous forme explicite.
label (str | None) – une chaîne de caractères facultative pour l'instruction.
duration (None) – une durée explicite facultative pour le BoxOp. Les passes de planification ont pour contrainte de planifier la portée qu'elles contiennent de manière à ce qu'elle corresponde à une durée donnée, en insérant des délais si nécessaire.
unit (Literal['dt', 's', 'ms', 'us', 'ns', 'ps', 'expr'] | None) – l'unité du site duration.
annotations (Iterable[Annotation]) – tous Annotation les objets que la boîte doit contenir. Lorsque cette méthode est utilisée sous la forme d'un gestionnaire de contexte, cet argument peut être transmis en tant que seul argument positionnel.

break_loop

break_loop()

GitHub

BreakLoopOpPostuler.

Avertissement

if_test()Si vous utilisez les formes « builder » du gestionnaire de contexte, for_loop() ou while_loop(), vous ne pouvez appeler cette méthode que si vous vous trouvez dans un contexte de boucle, car sinon, la « largeur de ressource » de l'opération ne peut pas être déterminée. Cela conduirait rapidement à des circuits non valides; par conséquent, si vous essayez de créer un corps de boucle réutilisable (sans gestionnaires de contexte), vous devez également utiliser la forme sans gestionnaire de contexte de if_test() et if_else(). Veillez à ce que BreakLoopOp l'instruction couvre toutes les ressources de la boucle qui la contient, et pas seulement la portée immédiate.

Retours

Une poignée de l'instruction créée.

Augmentations

CircuitError - si cette méthode a été appelée dans un contexte de construction, mais n'est pas contenue dans une boucle.

Type de retour

InstructionSet

continue_loop

continue_loop()

GitHub

ContinueLoopOpPostuler.

Avertissement

if_test()Si vous utilisez les formes « builder » du gestionnaire de contexte, for_loop() ou while_loop(), vous ne pouvez appeler cette méthode que si vous vous trouvez dans un contexte de boucle, car sinon, la « largeur de ressource » de l'opération ne peut pas être déterminée. Cela conduirait rapidement à des circuits non valides; par conséquent, si vous essayez de créer un corps de boucle réutilisable (sans gestionnaires de contexte), vous devez également utiliser la forme sans gestionnaire de contexte de if_test() et if_else(). Veillez à ce que ContinueLoopOp l'instruction couvre toutes les ressources de la boucle qui la contient, et pas seulement la portée immédiate.

Retours

Une poignée de l'instruction créée.

Augmentations

CircuitError - si cette méthode a été appelée dans un contexte de construction, mais n'est pas contenue dans une boucle.

Type de retour

InstructionSet

for_loop

for_loop(indexset: Iterable[int], loop_parameter: Parameter | Var | None, body: None, qubits: None, clbits: None, *, label: str | None) → ForLoopContext

GitHub

Créez une boucle for sur ce circuit.

Il existe deux façons d'appeler cette fonction. bodySi elle est appelée avec tous ses arguments (à l'exception éventuelle de label), elle créera un ForLoopOp avec le donné. Si body (et qubits et clbits) ne sont pas fournis, cette fonction agit alors comme un gestionnaire de contexte qui, une fois activé, fournit une variable de boucle (à moins qu’une variable ne soit déjà fournie, auquel cas celle-ci sera réutilisée) et crée automatiquement un ForLoopOp à la fin de la portée. Sous cette forme, vous n'avez pas besoin de garder la trace des qubits ou des clbits que vous utilisez, car l'environnement de développement s'en charge pour vous.

Par exemple :

from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 1)

with qc.for_loop(range(5)) as i:
    qc.h(0)
    qc.cx(0, 1)
    qc.measure(0, 0)
    with qc.if_test((0, True)):
        qc.break_loop()

Paramètres

indexset (Iterable[int]) – Une collection d'entiers sur lesquels on peut effectuer une boucle. Toujours nécessaire.
loop_parameter (Optional[Parameter|expr.Var]) –

Le paramètre utilisé dans body auquel les valeurs de indexset seront affectées. Dans le formulaire du gestionnaire de contexte, si cet argument n'est pas fourni, un paramètre de boucle sera alloué pour vous et renvoyé comme valeur de l'instruction with . Il ne sera lié au circuit que s'il est utilisé à l'intérieur du corps.

Si cet argument est None dans la forme manuelle de cette méthode, body sera répété une fois pour chacun des éléments de indexset mais leurs valeurs seront ignorées.
body (Optional[QuantumCircuit]) – Le corps de la boucle doit être exécuté de manière répétée. Omettre cette option pour utiliser le mode de gestion du contexte.
qubits (Optional[Sequence[QubitSpecifier]]) – Les qubits du circuit sur lesquels le corps de boucle doit être exécuté. Omettre cette option pour utiliser le mode de gestion du contexte.
clbits (Optional[Sequence[ClbitSpecifier]]) – Les circuits sur lesquels le corps de la boucle doit être exécuté. Omettre cette option pour utiliser le mode de gestion du contexte.
label (Optional[str]) – L'étiquette de la chaîne de l'instruction dans le circuit.

Retours

selon la signature de l'appel, soit un gestionnaire de contexte permettant de créer la boucle « for » (qui sera automatiquement ajoutée au circuit à la fin du bloc), soit un InstructionSet descripteur pointant vers l'opération de boucle ajoutée.

Type de retour

InstructionSet ou ForLoopContext

Augmentations

CircuitError - si une convention d'appel incorrecte est utilisée.

if_else

if_else(condition, true_body, false_body, qubits, clbits, label=None)

GitHub

IfElseOpPostuler.

Remarque

Cette méthode n'a pas de formulaire de gestion de contexte associé, car il est déjà géré par la méthode if_test() méthode. Vous pouvez utiliser la partie else de ce texte avec quelque chose comme :

from qiskit.circuit import QuantumCircuit, Qubit, Clbit
bits = [Qubit(), Qubit(), Clbit()]
qc = QuantumCircuit(bits)
qc.h(0)
qc.cx(0, 1)
qc.measure(0, 0)
with qc.if_test((bits[2], 0)) as else_:
    qc.h(0)
with else_:
    qc.x(0)

Paramètres

condition (tuple[ClassicalRegister, int] | tuple[Clbit, int] | tuple[Clbit, bool]) – Une condition à évaluer en temps réel lors de l'exécution du circuit qui, si elle est vraie, déclenchera l'évaluation de true_body. Peut être spécifié soit sous la forme d'un tuple d'un ClassicalRegister à comparer à un donné pour vérifier ints'ils sont égaux, soit sous la forme d'un tuple d'un Clbit à comparer soit à un bool , soit à un int.
true_body (QuantumCircuit) – Le corps du circuit à exécuter si condition est vrai.
false_body (QuantumCircuit) – Le circuit à exécuter si condition est faux.
qubits (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]]) – Les qubits du circuit sur lesquels la condition if/else doit être appliquée.
clbits (Sequence[Clbit |ClassicalRegister |int |slice |Sequence[Clbit |int]]) – Les bits du circuit sur lesquels l'instruction if/else doit s'appliquer.
label (str | None) – L'étiquette de la chaîne de l'instruction dans le circuit.

Augmentations

CircuitError - Si la condition fournie fait référence à des Clbits en dehors du circuit englobant.

Retours

Une poignée de l'instruction créée.

Type de retour

InstructionSet

if_test

if_test(condition: tuple[ClassicalRegister | Clbit, int]) → IfContext

GitHub

Créez une déclaration if sur ce circuit.

Il existe deux façons d'appeler cette fonction. true_bodySi elle est appelée avec tous ses arguments (à l'exception éventuelle de label), elle créera un IfElseOp avec le donné, et il n'y aura pas de branche pour la false condition (voir également la if_else() méthode ). Toutefois, si true_body (et qubits et clbits) ne sont pas fournis, cela fonctionne alors comme un gestionnaire de contexte, qui peut être utilisé pour construire if des instructions. La valeur de retour de l'instruction with est un gestionnaire de contexte chaînable, qui peut être utilisé pour créer des blocs suivants else . Sous cette forme, vous n'avez pas besoin de garder la trace des qubits ou des clbits que vous utilisez, car l'environnement de développement s'en charge pour vous.

Par exemple :

from qiskit.circuit import QuantumCircuit, Qubit, Clbit
bits = [Qubit(), Qubit(), Qubit(), Clbit(), Clbit()]
qc = QuantumCircuit(bits)

qc.h(0)
qc.cx(0, 1)
qc.measure(0, 0)
qc.h(0)
qc.cx(0, 1)
qc.measure(0, 1)

with qc.if_test((bits[3], 0)) as else_:
    qc.x(2)
with else_:
    qc.h(2)
    qc.z(2)

Paramètres

condition (Tuple[Union[ClassicalRegister, Clbit], int]) – Une condition à évaluer en temps réel pendant l'exécution du circuit, qui, si elle est vraie, déclenchera l'évaluation de true_body. Peut être spécifié comme un tuple de ClassicalRegister à tester pour l'égalité avec un int donné, ou comme un tuple de Clbit à comparer à un bool ou un int.
true_body (Optional[QuantumCircuit]) – Le corps du circuit à exécuter si condition est vrai.
qubits (Optional[Sequence[QubitSpecifier]]) – Les qubits du circuit sur lesquels le if/else doit être exécuté.
clbits (Optional[Sequence[ClbitSpecifier]]) – Les clbits du circuit sur lesquels le if/else doit être exécuté.
label (Optional[str]) – L'étiquette de la chaîne de l'instruction dans le circuit.

Retours

selon la signature de l'appel, soit un gestionnaire de contexte permettant de créer le if bloc (celui-ci sera automatiquement ajouté au circuit à la fin du bloc), soit un InstructionSet descripteur pointant vers l'opération conditionnelle ajoutée.

Type de retour

InstructionSet ou IfContext

Augmentations

CircuitError - Si la condition fournie fait référence à des Clbits en dehors du circuit englobant.
CircuitError - si une convention d'appel incorrecte est utilisée.

Retours

Une poignée de l'instruction créée.

switch

GitHub

Créez une structure switch/case sur ce circuit.

Il existe deux façons d'appeler cette fonction. Si elle est appelée avec tous ses arguments (à l'exception éventuelle de label), elle créera un SwitchCaseOp avec la structure de cas indiquée. Si cases (et qubits et clbits) ne sont pas fournis, cette fonction agit alors comme un gestionnaire de contexte, qui créera automatiquement un SwitchCaseOp à la fin de la portée. Sous cette forme, vous n'avez pas besoin de garder la trace des qubits ou des clbits que vous utilisez, car l'environnement de développement s'en charge pour vous.

Exemple d'utilisation :

from qiskit.circuit import QuantumCircuit, ClassicalRegister, QuantumRegister
qreg = QuantumRegister(3)
creg = ClassicalRegister(3)
qc = QuantumCircuit(qreg, creg)
qc.h([0, 1, 2])
qc.measure([0, 1, 2], [0, 1, 2])

with qc.switch(creg) as case:
    with case(0):
        qc.x(0)
    with case(1, 2):
        qc.z(1)
    with case(case.DEFAULT):
        qc.cx(0, 1)

Paramètres

target (Union[ClassicalRegister, Clbit]) – La valeur classique de l'interrupteur un. Il doit s'agir d'un nombre entier.
cases (Iterable[Tuple[Any, QuantumCircuit]]) – Une séquence de spécificateurs de cas. Chaque tuple définit un corps de cas (le deuxième élément). Le premier élément du tuple peut être soit une valeur entière unique, soit la valeur spéciale CASE_DEFAULTou un tuple de plusieurs valeurs entières. Chacune des valeurs entières sera essayée à tour de rôle; le contrôle passera alors à l'organe correspondant à la première correspondance. CASE_DEFAULT correspond à toutes les valeurs possibles. Omettre dans le formulaire de gestion de contexte.
qubits (Sequence[Qubit]) – Les qubits du circuit sur lesquels tous les corps de cas s'exécutent. Omettre dans le formulaire de gestion de contexte.
clbits (Sequence[Clbit]) – Les circuits sur lesquels s'exécutent tous les organes de l'affaire. Omettre dans le formulaire de gestion de contexte.
label (Optional[str]) – L'étiquette de la chaîne de l'instruction dans le circuit.

Retours

Si elle est utilisée en mode gestionnaire de contexte, elle doit être utilisée comme une ressource with , qui renverra un objet pouvant être saisi à plusieurs reprises afin de produire des cas pour l'instruction switch. Si le formulaire complet est utilisé, il renvoie une poignée vers les instructions créées.

Type de retour

InstructionSet ou SwitchCaseContext

Augmentations

CircuitError - si une convention d'appel incorrecte est utilisée.

while_loop

while_loop(condition: tuple[ClassicalRegister | Clbit, int] | Expr, body: None, qubits: None, clbits: None, *, label: str | None) → WhileLoopContext

GitHub

Créez une boucle while sur ce circuit.

Il existe deux façons d'appeler cette fonction. S'il est appelé avec tous ses arguments (à l'exception possible de label), il créera un WhileLoopOp avec le body donné. Si body (et qubits et clbits) n'est pas passé, alors ceci agit comme un gestionnaire de contexte, qui construira automatiquement un WhileLoopOp quand le scope se terminera. Sous cette forme, vous n'avez pas besoin de connaître les qubits ou les clbits que vous utilisez, car la portée s'en charge pour vous.

Exemple d'utilisation :

from qiskit.circuit import QuantumCircuit, Clbit, Qubit
bits = [Qubit(), Qubit(), Clbit()]
qc = QuantumCircuit(bits)

with qc.while_loop((bits[2], 0)):
    qc.h(0)
    qc.cx(0, 1)
    qc.measure(0, 0)

Paramètres

condition (Tuple[Union[ClassicalRegister, Clbit], int]) – Une condition d'égalité à vérifier avant d'exécuter body. Le côté gauche de la condition doit être un ClassicalRegister ou a Clbitet le côté droit doit être un entier ou un booléen.
body (Optional[QuantumCircuit]) – Le corps de la boucle doit être exécuté de manière répétée. Omettre cette option pour utiliser le mode de gestion du contexte.
qubits (Optional[Sequence[Qubit]]) – Les qubits du circuit sur lesquels le corps de boucle doit être exécuté. Omettre cette option pour utiliser le mode de gestion du contexte.
clbits (Optional[Sequence[Clbit]]) – Les circuits sur lesquels le corps de la boucle doit être exécuté. Omettre cette option pour utiliser le mode de gestion du contexte.
label (Optional[str]) – L'étiquette de la chaîne de l'instruction dans le circuit.

Retours

Si elle est utilisée en mode gestionnaire de contexte, elle doit être utilisée comme une ressource with , qui déduira le contenu du bloc et les opérandes à la sortie. Si le formulaire complet est utilisé, il renvoie une poignée vers les instructions créées.

Type de retour

InstructionSet ou WhileLoopContext

Augmentations

CircuitError - si une convention d'appel incorrecte est utilisée.

noop

noop(*qargs)

GitHub

Marque le(s) qubit(s) donné(s) comme étant utilisé(s) dans le cadre actuel, sans ajouter d'opération.

Ceci n'a aucun effet (autre que de soulever une exception en cas d'entrée invalide) lorsqu'il est appelé dans la portée supérieure d'un fichier QuantumCircuit. Dans un constructeur de flux de contrôle, le qubit est "utilisé" par le bloc de flux de contrôle, s'il ne l'est pas déjà, sans qu'aucune opération supplémentaire ne soit effectuée sur lui.

Par exemple :

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(3)
with qc.box():
    # This control-flow block will only use qubits 0 and 1.
    qc.cx(0, 1)
with qc.box():
    # This control-flow block will contain only the same operation as the previous
    # block, but it will also mark qubit 2 as "used" by the box.
    qc.cx(0, 1)
    qc.noop(2)

Paramètres

*qargs ( Qubit | QuantumRegister | int | slice | Sequence* [ Qubit | int ]* ) – liste variadique de spécificateurs de qubits valides. Tout ce qui peut être transmis sous la forme d'un qubit ou d'un ensemble de qubits est valable pour chaque argument ici.

Augmentations

CircuitError - si un qubit demandé n'est pas valide pour le circuit.

has_control_flow_op

has_control_flow_op()

GitHub

Vérifie si le circuit comporte une instance de ControlFlowOp parmi ses opérations.

Type de retour

booléen

Conversion de circuits en d'autres objets

Comme indiqué dans la section « Méthodes pour ajouter des opérations générales », vous pouvez convertir un circuit en ou en GateInstruction à l'aide de deux méthodes auxiliaires.

to_instruction

to_instruction(parameter_map=None, label=None)

GitHub

Créez un Instruction à partir de ce circuit.

Voir aussi

circuit_to_instruction()

Le moteur sous-jacent de cette méthode.

Paramètres

parameter_map (dict[Parameter, ParameterExpression |float] | None) – Pour les circuits paramétrés, une correspondance entre les paramètres du circuit et les paramètres à utiliser dans l'instruction. Si la valeur est « None », les paramètres du circuit existant serviront également à paramétrer l'instruction.
label (str | None) – Étiquette de porte en option.

Retours

une instruction composite encapsulant ce circuit (peut être

dos décomposé).

Type de retour

qiskit.circuit.Instruction

to_gate

to_gate(parameter_map=None, label=None)

GitHub

Créez un Gate à partir de ce circuit. Le circuit ne doit agir que sur des qubits et ne contenir que des opérations unitaires.

Voir aussi

circuit_to_gate()

Le moteur sous-jacent de cette méthode.

Paramètres

parameter_map (dict[Parameter, ParameterExpression |float] | None) – Pour les circuits paramétrés, une correspondance entre les paramètres du circuit et les paramètres à utiliser dans la porte logique. NoneDans ce cas, les paramètres du circuit existant serviront également à paramétrer la porte.
label (str | None) – Étiquette de porte en option.

Retours

une porte composite encapsulant ce circuit (peut être décomposée).

Type de retour

Porte

De plus, vous pouvez convertir l'ensemble du circuit sous la DAGCircuit forme suivante :

to_dag

to_dag(*, copy_operations=True)

GitHub

Convertissez ce circuit en un DAGCircuit.

Il s'agit d'un simple wrapper autour de circuit_to_dag().

Paramètres

copy_operations (bool) – s'il faut copier en profondeur les instructions individuelles. Si cette option est False activée, l'opération est moins coûteuse, mais les modifications apportées aux instructions dans le DAG affecteront le circuit d'origine.

Retours

un DAG représentant ce même circuit.

Type de retour

qiskit.dagcircuit.DAGCircuit

Méthodes de mutation auxiliaires

Il existe deux méthodes de niveau supérieur sur QuantumCircuit pour ajouter des mesures à la fin d'un circuit. Notez que, par défaut, ces derniers ajoutent également un registre supplémentaire.

measure_active

measure_active(inplace=True)

GitHub

Ajoute une mesure à tous les qubits non inactifs. Crée un nouveau site ClassicalRegister dont la taille est égale au nombre de qubits non inactifs mesurés.

Renvoie un nouveau circuit avec des mesures si inplace=False.

Paramètres

inplace (bool) – Toutes les mesures sont effectuées sur place ou sur un nouveau circuit.

Retours

Renvoie le circuit avec les mesures lorsque inplace = False.

Type de retour

QuantumCircuit

measure_all

measure_all(inplace=True, add_bits=True)

GitHub

Ajoute une mesure à tous les qubits.

Par défaut, il ajoute de nouveaux bits classiques dans un ClassicalRegister pour stocker ces mesures. Si add_bits=False, les résultats des mesures seront stockés dans les bits classiques existants, le qubit n étant mesuré dans le bit classique n.

Renvoie un nouveau circuit avec des mesures si inplace=False.

Paramètres

inplace (bool) – Toutes les mesures sont effectuées sur place ou sur un nouveau circuit.
add_bits (bool) – S'il faut ajouter de nouveaux bits pour stocker les résultats.

Retours

Renvoie le circuit avec les mesures lorsque inplace=False.

Type de retour

QuantumCircuit

Augmentations

CircuitError - si add_bits=False mais qu'il n'y a pas assez de bits classiques.

Il existe également deux méthodes « soustractives » sur QuantumCircuit . RemoveFinalMeasurementsCe n'est pas le cas d'utilisation pour lequel QuantumCircuit il a été conçu; en règle générale, il suffit d'utiliser copy_empty_like() à la place de clear(), et d'exécuter remove_final_measurements() sous sa forme de passage de transpileur.

clear

clear()

GitHub

Effacer toutes les instructions en soi.

L'effacement des circuits permet de conserver les métadonnées.

Voir aussi

copy_empty_like()

Une méthode pour produire un nouveau circuit sans instructions et avec le même suivi des données typées quantiques et classiques, mais sans modifier le circuit d'origine.

Type de retour

Aucun

remove_final_measurements

remove_final_measurements(inplace=True)

GitHub

Supprime les mesures finales et les barrières sur tous les qubits s'ils sont présents. Supprime les registres classiques utilisés pour stocker les valeurs de ces mesures qui deviennent inactives à la suite de cette opération, et supprime les bits classiques qui sont référencés uniquement par les registres supprimés, ou qui ne sont pas référencés du tout mais qui sont devenus inactifs à la suite de cette opération.

Les mesures et les barrières sont considérées comme définitives si elles ne sont suivies d'aucune autre opération (hormis d'autres mesures ou barrières)

Remarque

Cette méthode a un comportement assez complexe, notamment en ce qui concerne la suppression des bits classiques et des registres nouvellement inactifs. Il est beaucoup plus efficace d'éviter d'ajouter des données classiques inutiles dès le départ, plutôt que d'essayer de les supprimer par la suite.

Voir aussi

RemoveFinalMeasurements

Un laissez-passer de transpondeur qui supprime les mesures finales et les barrières. Cela ne supprime pas les données classiques. Si tel est votre objectif, vous pouvez l'appeler avec :

from qiskit.circuit import QuantumCircuit
from qiskit.transpiler.passes import RemoveFinalMeasurements

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.barrier()
qc.measure([0, 1], [0, 1])

pass_ = RemoveFinalMeasurements()
just_bell = pass_(qc)

Paramètres

inplace (bool) – Toutes les mesures sont enlevées sur place ou sur un nouveau circuit.

Retours

Renvoie le circuit résultant si inplace=False, sinon Aucun.

Type de retour

QuantumCircuit

Propriétés du circuit

Mesures simples du circuit

Lors de la construction de circuits quantiques, plusieurs propriétés permettent de quantifier la "taille" des circuits et leur capacité à être exécutés sur un dispositif quantique bruyant. Certains d'entre eux, comme le nombre de qubits, sont faciles à comprendre, tandis que d'autres, comme la profondeur et le nombre de composants du tenseur, nécessitent un peu plus d'explications. Nous expliquerons ici toutes ces propriétés et, pour nous préparer à comprendre comment les circuits changent lorsqu'ils sont exécutés sur des appareils réels, nous mettrons en évidence les conditions dans lesquelles ils changent.

Considérons le circuit suivant :

from qiskit import QuantumCircuit
qc = QuantumCircuit(12)
for idx in range(5):
   qc.h(idx)
   qc.cx(idx, idx+5)

qc.cx(1, 7)
qc.x(8)
qc.cx(1, 9)
qc.x(7)
qc.cx(1, 11)
qc.swap(6, 11)
qc.swap(6, 9)
qc.swap(6, 10)
qc.x(6)
qc.draw('mpl')

Sur le graphique, il est facile de voir que ce circuit comporte 12 qubits et un ensemble de portes Hadamard, CNOT, X et SWAP. Mais comment quantifier cela de manière programmatique? Comme nous pouvons effectuer des portes à qubit unique sur tous les qubits simultanément, le nombre de qubits dans ce circuit est égal au nombre de qubits du circuit width() du circuit :

assert qc.width() == 12

Nous pouvons également obtenir le nombre de qubits directement en utilisant num_qubits:

assert qc.num_qubits == 12

Important

Pour un circuit quantique composé uniquement de qubits, la largeur du circuit est égale au nombre de qubits. C'est la définition utilisée dans l'informatique quantique. Cependant, pour des circuits plus compliqués avec des registres classiques et des portes contrôlées de manière classique, cette équivalence s'effondre. C'est pourquoi, à partir de maintenant, nous ne ferons plus référence au nombre de qubits dans un circuit quantique en tant que largeur.

Il est également facile d'obtenir le nombre et le type de portes dans un circuit en utilisant count_ops():

qc.count_ops()

OrderedDict([('cx', 8), ('h', 5), ('x', 3), ('swap', 3)])

Nous pouvons également obtenir le nombre brut d'opérations en calculant les circuits size():

assert qc.size() == 19

count_ops

count_ops()

GitHub

Comptez chaque type d'opération dans le circuit.

Retours

Une ventilation du nombre d'opérations par type, classées par montant.

Type de retour

OrderedDict [ chaîne, entier ]

depth

depth(filter_function=<function QuantumCircuit.<lambda>>)

GitHub

Profondeur du circuit de retour (c'est-à-dire longueur du chemin critique).

La profondeur d'un circuit quantique est une mesure du nombre de "couches" de portes quantiques, exécutées en parallèle, nécessaires pour effectuer le calcul défini par le circuit. Comme la mise en œuvre des portes quantiques prend du temps, la profondeur d'un circuit correspond approximativement au temps qu'il faut à l'ordinateur quantique pour exécuter le circuit.

Avertissement

Cette opération n'est pas bien définie si le circuit contient des opérations de flux de contrôle.

Paramètres

filter_function (Callable[[CircuitInstruction], bool]) – Une fonction permettant de déterminer quelles instructions sont prises en compte pour augmenter la profondeur. CircuitInstructionDoit accepter en entrée une seule position. Les instructions pour lesquelles la fonction renvoie False une valeur sont ignorées lors du calcul de la profondeur du circuit. Par défaut, il filtre les « directives », telles que Barrier.

Retours

Profondeur du circuit.

Type de retour

int

Exemples

Calcul simple de la profondeur totale du circuit :

from qiskit.circuit import QuantumCircuit
qc = QuantumCircuit(4)
qc.h(0)
qc.cx(0, 1)
qc.h(2)
qc.cx(2, 3)
assert qc.depth() == 2

Modification de l'exemple précédent pour ne calculer que la profondeur des portes multi-qubits :

assert qc.depth(lambda instr: len(instr.qubits) > 1) == 1

get_instructions

get_instructions(name)

GitHub

Obtenir les instructions correspondant au nom.

Paramètres

name (str) – Le nom de la commande à récupérer.

Retours

liste de (instruction, qargs, cargs).

Type de retour

liste (tuple)

num_connected_components

num_connected_components(unitary_only=False)

GitHub

Combien de sous-circuits non enchevêtrés le circuit peut-il être factorisé?

Paramètres

unitary_only (bool) – Calculer uniquement la partie unitaire du graphe.

Retours

Nombre de composants connectés dans le circuit.

Type de retour

int

num_nonlocal_gates

num_nonlocal_gates()

GitHub

Renvoi du nombre de portes non locales (c'est-à-dire impliquant 2+ qubits).

Les portes non locales conditionnelles sont également incluses.

Type de retour

int

num_tensor_factors

num_tensor_factors()

GitHub

Calcule le nombre de facteurs tensoriels dans la partie unitaire (quantique) du circuit uniquement.

Remarques

Il s'agit d'une compatibilité ascendante, qui sera supprimée dans une prochaine version de Qiskit. Vous devriez plutôt appeler num_unitary_factors.

Type de retour

int

num_unitary_factors

num_unitary_factors()

GitHub

Calcule le nombre de facteurs tensoriels dans la partie unitaire (quantique) du circuit uniquement.

Type de retour

int

size

size(filter_function=<function QuantumCircuit.<lambda>>)

GitHub

Renvoie le nombre total d'instructions dans le circuit.

Paramètres

filter_function (callable) – une fonction permettant de filtrer certaines instructions. Doit prendre en entrée un tuple de (Instruction, list(Qubit), list(Clbit)). Par défaut, il filtre les "directives", telles que barrier ou snapshot.

Retours

Nombre total d'opérations sur les portes d'embarquement.

Type de retour

int

width

width()

GitHub

Renvoie le nombre de qubits et de clbits dans le circuit.

Retours

Largeur du circuit.

Type de retour

int

Accès aux informations de planification

Si un QuantumCircuit a été programmé dans le cadre d'un pipeline de transpilation, il est possible d'accéder aux informations temporelles pour les qubits individuels. Les informations sur la synchronisation de l'ensemble du circuit sont disponibles par le biais de la méthode estimate_duration() méthode et op_start_times attribut.

estimate_duration

estimate_duration(target, unit='s')

GitHub

Estimer la durée d'un circuit programmé

Cette méthode calcule l'estimation de la durée du circuit en trouvant le chemin le plus long dans le circuit sur la base des durées fournies par une cible donnée. Cette méthode ne fonctionne que pour les circuits simples qui n'ont pas de flux de contrôle ou d'autres opérations classiques en amont.

Paramètres

target (Target) – Si l'instance Target contenant les durées des instructions ne dispose pas des données de durée pour l'une des instructions du circuit, une exception QiskitError sera levée. Il devrait s'agir du même objet cible que celui utilisé pour la transpilation.
unit (str) – L'unité dans laquelle la durée doit être retournée. La valeur par défaut est "s" pour les secondes, mais il peut s'agir d'un préfixe SI pris en charge pour les retours de secondes. Par exemple, la valeur "n" permet d'obtenir l'unité de mesure "nanosecondes". Les valeurs prises en charge de ce type sont "f", "p", "n", "u", "µ", "m", "k", "M", "G", "T" et "P". En outre, la valeur "dt" est également acceptée pour produire un nombre entier en unités de "dt". Pour que cela fonctionne, "dt" doit être spécifié dans le site target.

Retours

Durée estimée pour l'exécution d'une seule prise de vue du circuit dans l'unité spécifiée.

Augmentations

QiskitError - Si le circuit n'est pas programmé ou contient d'autres détails qui empêchent le calcul d'une durée estimée (comme un délai paramétré).

Type de retour

int | float

qubit_duration

qubit_duration(*qubits)

GitHub

Renvoie la durée entre le début et la fin de la première et de la dernière instruction, sans tenir compte des délais, sur les qubits fournis. Son unité de temps est self.unit.

Paramètres

*qubits (Qubit |int) - Qubits à l'intérieur de self à inclure.

Retours

Renvoie la durée entre le premier temps de départ et le dernier temps d'arrêt des instructions non temporisées

Type de retour

Float

qubit_start_time

qubit_start_time(*qubits)

GitHub

Renvoie l'heure de début de la première instruction, hors délais, sur les qubits fournis. Son unité de temps est self.unit.

Retourne 0 s'il n'y a pas d'instructions sur les qubits

Paramètres

*qubits - Qubits à l'intérieur de self à inclure. Les nombres entiers sont autorisés pour les qubits, ce qui indique
self.qubits. (indices of)

Retours

Renvoie l'heure de début de la première instruction, à l'exclusion des retards, sur les qubits

Augmentations

CircuitError - si self est un circuit non encore programmé.

Type de retour

Float

qubit_stop_time

qubit_stop_time(*qubits)

GitHub

Renvoie l'heure d'arrêt de la dernière instruction, hors délais, sur les qubits fournis. Son unité de temps est self.unit.

Retourne 0 s'il n'y a pas d'instructions sur les qubits

Paramètres

*qubits - Qubits à l'intérieur de self à inclure. Les nombres entiers sont autorisés pour les qubits, ce qui indique
self.qubits. (indices of)

Retours

Renvoie l'heure d'arrêt de la dernière instruction, à l'exclusion des retards, sur les qubits

Augmentations

CircuitError - si self est un circuit non encore programmé.

Type de retour

Float

Circuits abstraits et physiques

Les circuits constituent une abstraction assez basique des algorithmes quantiques. Cependant, même dans ce cadre, il existe des nuances. Les programmeurs quantiques souhaitent souvent utiliser un large éventail de portes et d'instructions, et travailler dans un cadre où tous les qubits interagissent entre eux. Le matériel quantique, cependant, dispose généralement d'un ensemble limité de portes natives, et seules certaines paires de qubits matériels peuvent interagir. Nous appelons respectivement ces deux régimes « circuits abstraits » et « circuits physiques ».

Qiskit a deux façons de distinguer un circuit qui est destiné à être physique. Il s'agit d'une vérification floue, pour des raisons historiques; à l'origine, Qiskit n'a jamais fait la distinction (c'est pourquoi transpile() s'appelle ainsi, et non compile!). Le moyen le plus explicite est l'attribut des circuits layout des circuits; si cet attribut est défini, le circuit est certainement censé être physique. L'ancienne méthode, plus implicite, consiste à utiliser les métadonnées des Qubit objets et QuantumRegister instances du circuit. Un circuit ne peut être considéré (selon plusieurs passages du transpondeur) comme physique que s'il contient exactement un registre quantique, appelé q , qui possède tous les qubits du circuit dans l'ordre de l'index. Toujours pour des raisons historiques, c'est la valeur par défaut de la forme QuantumCircuit(int [, int]) du constructeur par défaut.

Normalement, vous créez un QuantumCircuit et vous le construisez au sens abstrait (sans tenir compte des métadonnées du qubit). Vous appelez ensuite transpile() pour compiler le circuit en un circuit supporté par le matériel. Cependant, dans les cas où vous souhaitez écrire un circuit efficace sur le plan matériel dès le départ, vous pouvez court-circuiter l'infrastructure de compilation complète à l'aide de la méthode ensure_physical() méthode. Cela garantit que, quelle que soit la manière dont vous avez défini les métadonnées initiales des qubits, toutes les conditions pour que le circuit soit considéré comme physique seront remplies, avec les indices de qubits mappés sur les qubits matériels.

Pour un contrôle plus complet du choix du mappage virtuel-physique et du routage, voir les étapes de mise en page et de routage <transpiler-preset-stage-routing> des pipelines de compilation des préréglages.

ensure_physical

ensure_physical(num_qubits=None, *, apply_layout=True)

GitHub

Mettre ce circuit sous forme physique canonique, avec le nombre donné de qubits, s'il ne l'est pas déjà.

Plusieurs passages du transpondeur Qiskit n'ont de sens que lorsqu'ils sont appliqués à des circuits définis en termes de qubits physiques. Si vous avez construit manuellement un circuit dans lequel les indices des qubits correspondent à des qubits physiques, utilisez cette fonction pour vous assurer que les métadonnées du circuit correspondent à la forme physique canonique. Il s'agit de remplacer les données des qubits par un seul registre propriétaire appelé "q", et (éventuellement) de régler le champ layout du circuit pour relier ces qubits physiques aux qubits virtuels d'origine.

Si le circuit n'a pas encore de schéma, cette méthode (avec apply_layout=True) est équivalente à l'application de la méthode de schéma trivial complet du pipeline de compilation prédéfini.

Si le circuit est déjà canoniquement physique, il ne lui arrive rien. Cette méthode ne peut pas modifier le nombre de qubits dans le circuit s'il en possède déjà un layout qubits.

Paramètres

num_qubits (int | None) – si elle est donnée, étendre le circuit avec des ancillas jusqu'à cette taille. Les ancillas seront toujours les indices des qubits les plus élevés du circuit. S'il n'est pas donné (par défaut), le circuit conserve la même largeur. Cette option ne peut pas être activée si le circuit est déjà en tant que layout.
apply_layout (bool) – si true (par défaut), définir l'attribut layout du circuit de manière à ce que le circuit semble avoir été conçu avec la disposition "triviale", y compris l'expansion de l'ancilla, pour un backend d'une largeur de num_qubits. Cela n'a pas d'effet si le circuit avait déjà un layout.

Retours

si le circuit a été modifié pour le rendre physique.

Augmentations

ValueError - si num_qubits est trop petit pour le circuit.
CircuitError - si num_qubits est défini pour tenter d'étendre le circuit, mais que le circuit a déjà une configuration définie.

Type de retour

booléen

estimate_fidelity

estimate_fidelity(target)

GitHub

Évaluer la fidélité d'un circuit physique.

Cette fonction calcule le produit des taux d'erreur de chaque porte du circuit afin d'estimer la fidélité de celui-ci :

..math::

label

fidélité estimée du circuit

prod_ {g in text{gates}} bigl(1 - nom_de_l'opérateur {error} (g)bigr)

où $\operatorname{error}(g)$ correspond au taux d'erreur dans la cible pour l'instruction $g$ provenant du circuit de la cible. Si le circuit n'est pas physique, c'est-à-dire si une instruction du circuit (comme « operation » et « qargs ») n'est pas présente dans la cible, cette fonction renverra None. Cette méthode n'a pas pour but de fournir une simulation réaliste de la fidélité de l'exécution sur du matériel réel. Il est conçu pour fournir une estimation du fonctionnement du transpileur en fonction du niveau de fidélité associé aux différentes heuristiques utilisées lors de son exécution. En général, cela ne sert qu'à comparer entre elles les différentes sorties de compilation afin d'estimer laquelle permettrait d'obtenir une exécution de meilleure qualité sur le matériel.

Paramètres

target (Target) – L'instance sur laquelle le circuit sera exécuté et qui Target servira à déterminer les taux d'erreur des instructions du circuit.

Retours

La précision estimée de l'exécution du circuit sur la cible donnée. Si une instruction du circuit n'est pas présente dans la cible

Augmentations

QiskitError – Si le circuit comporte des opérations de contrôle de flux.

Type de retour

float | Aucun

Méthodes de type instructionnel

QuantumCircuit contient également un petit nombre de méthodes dont les détails sont très Instructionsimilaires. Vous obtiendrez sans doute une Instruction meilleure intégration et une prise en charge plus étendue des API si vous convertissez d'abord votre circuit en (to_instruction()) ou Gate (to_gate()), selon le cas, puis que vous appelez la méthode correspondante.

control

control(num_ctrl_qubits=1, label=None, ctrl_state=None, annotated=None)

GitHub

Renvoyer la version contrôlée de ce circuit.

Le circuit d'origine est transformé en une porte logique, et le circuit obtenu contient la version commandée de cette porte. Cette porte contrôlée est mise en œuvre comme ControlledGate lorsque annotated est False, et comme AnnotatedOperation lorsque annotated est True.

Obsolète depuis la version 2.3

qiskit.circuit.quantumcircuit.QuantumCircuit.control()L'argument annotated est obsolète depuis Qiskit 2.3. Il sera supprimé dans Qiskit 3.0. La méthode QuantumCircuit.control() n'accepte plus annotated=None. La nouvelle valeur par défaut est annotated=True, qui représente la porte contrôlée dans le nouveau circuit quantique comme une porte contrôlée ( AnnotatedOperation ) (à moins qu'une classe de porte contrôlée dédiée n'existe déjà). Vous pouvez explicitement définir annotated=False pour conserver le comportement précédent. Cependant, il est recommandé d'utiliser annotated=True, car cela reporte la construction du circuit contrôlé au transcompilateur et permet en outre des optimisations supplémentaires des portes contrôlées (ce qui conduit généralement à des circuits de meilleure qualité).

Paramètres

num_ctrl_qubits (int) – Nombre de contrôles à ajouter. Prend par défaut la valeur 1.
label (str | None) – Étiquette facultative permettant de donner un nom au port contrôlé à des fins de visualisation. Prend par défaut la valeur None. Ignoré si la porte contrôlée est implémentée en tant qu'opération annotée.
ctrl_state (str |int | None) – État de contrôle de la porte, spécifié soit sous forme d'entier, soit sous forme de chaîne de bits (par exemple "110"). Si None, la valeur par défaut est l'état « 2**num_ctrl_qubits - 1tous à 1 ».
annotated (bool | None) – Indique si la porte contrôlée doit être implémentée en tant que porte contrôlée ou en tant qu'opération annotée.

Retours

La version contrôlée de ce circuit.

Type de retour

QuantumCircuit

Augmentations

CircuitError - Si le circuit contient une opération non unitaire et ne peut être contrôlé.

inverse

inverse(annotated=False)

GitHub

Inverser (prendre l'adjoint de) ce circuit.

Pour ce faire, toutes les portes sont inversées de manière récursive.

Paramètres

annotated (bool) – indique si la porte inverse peut être mise en œuvre comme une porte annotée.

Retours

le circuit inversé

Type de retour

QuantumCircuit

Augmentations

CircuitError - si le circuit ne peut pas être inversé.

Exemples

Entrée :

     ┌───┐
q_0: ┤ H ├─────■──────
     └───┘┌────┴─────┐
q_1: ─────┤ RX(1.57) ├
          └──────────┘

Sortie :

                  ┌───┐
q_0: ──────■──────┤ H ├
     ┌─────┴─────┐└───┘
q_1: ┤ RX(-1.57) ├─────
     └───────────┘

power

power(power, matrix_power=False, annotated=False)

GitHub

Élever ce circuit à la puissance de power.

Si power est un nombre entier positif et que matrix_power et annotated sont tous deux False, cette implémentation appelle par défaut repeat. Sinon, le circuit est converti en porte et un nouveau circuit, contenant cette porte élevée à la puissance donnée, est renvoyé. La porte élevée à la puissance donnée est mise en œuvre soit comme une porte unitaire si annotated est False , soit comme une opération annotée si annotated est True.

Paramètres

power (float) – Le pouvoir d'élever ce circuit à.
matrix_power (bool) – indique si la porte de puissance intérieure peut être mise en œuvre comme une porte unitaire.
annotated (bool) – indique si la porte de puissance intérieure peut être mise en œuvre en tant qu'opération annotée.

Augmentations

CircuitError - Si le circuit doit être converti en une porte unitaire, mais qu'il n'est pas unitaire.

Retours

Un circuit mettant en œuvre ce circuit élevé à la puissance de power.

Type de retour

QuantumCircuit

repeat

repeat(reps, *, insert_barriers=False)

GitHub

Répétez ce circuit reps fois.

Paramètres

reps (int) – Combien de fois ce circuit doit-il être répété?
insert_barriers (bool) – L'inclusion ou non de barrières entre les répétitions du circuit.

Retours

Un circuit contenant reps répétitions de ce circuit.

Type de retour

QuantumCircuit

reverse_ops

reverse_ops()

GitHub

Inverser le circuit en inversant l'ordre des instructions.

Pour ce faire, toutes les instructions sont inversées de manière récursive. Il n'inverse (adjoint) aucune porte.

Retours

le circuit inversé.

Type de retour

QuantumCircuit

Exemples

Entrée :

     ┌───┐
q_0: ┤ H ├─────■──────
     └───┘┌────┴─────┐
q_1: ─────┤ RX(1.57) ├
          └──────────┘

Sortie :

                 ┌───┐
q_0: ─────■──────┤ H ├
     ┌────┴─────┐└───┘
q_1: ┤ RX(1.57) ├─────
     └──────────┘

Visualisation

Qiskit comprend des outils de dessin pour vous donner une idée rapide de l'aspect de votre circuit. Cet outil est principalement destiné à la production d'un dessin à partir d'un texte ou d'une image Matplotlib - ou un dessin textuel. Il existe également un backend LaTeX aux fonctionnalités moindres pour le dessin, mais il ne concerne que les circuits simples et n'est pas aussi activement entretenu.

Voir aussi

qiskit.visualization

La documentation principale pour tous les outils de visualisation de Qiskit.

draw

draw(output=None, scale=None, filename=None, style=None, interactive=False, plot_barriers=True, reverse_bits=None, justify=None, vertical_compression='medium', idle_wires=None, with_layout=True, fold=None, ax=None, initial_state=False, cregbundle=None, wire_order=None, expr_len=30, measure_arrows=None, barrier_label_len=16)

GitHub

Dessinez le circuit quantique. Le paramètre de sortie permet de choisir le format de dessin :

text

Art ASCII TextDrawing pouvant être affiché dans la console.

mpl

Images dont les couleurs ont été générées exclusivement dans Python à l'aide de matplotlib.

latex

Images de haute qualité provenant du site LaTeX.

Avertissement

Par conception, cette fonction appelle une version système installée de pdflatex lorsqu’elle reçoit une entrée utilisateur arbitraire (par exemple pour exécuter du code personnalisé dans Instruction.label), et ne doit donc être utilisée qu’avec des entrées fiables.

latex_source

Sortie brute non compilée d' LaTeX. Voici le code source de ce qui sera affiché par le latex drawer.

Avertissement

La prise en charge des Expr dans les domaines des conditions et de SwitchCaseOp.target est préliminaire et incomplète. Les tiroirs text et mpl s'efforceront de montrer les dépendances des données, mais les tiroirs LaTeX-based les ignoreront complètement.

Paramètres

output (str | None) – Sélectionnez la méthode de sortie à utiliser pour dessiner le circuit. Les choix valables sont text, mpl, latex, latex_source. Par défaut, le tiroir text est utilisé, à moins que le fichier de configuration de l'utilisateur (généralement ~/.qiskit/settings.conf) ne contienne un autre backend défini par défaut. Par exemple, circuit_drawer = latex. Si le kwarg de sortie est défini, ce backend sera toujours utilisé à la place du backend par défaut dans le fichier de configuration de l'utilisateur.
scale (float | None) – Échelle de l'image à dessiner (réduire si < 1.0). Utilisé uniquement par les sorties mpl, latex et latex_source . La valeur par défaut est 1.0.
filename (str | None) – Chemin d'accès au fichier dans lequel l'image doit être enregistrée. La valeur par défaut est None (le résultat n'est pas enregistré dans un fichier).
style (dict |str | None) –

Nom du style, nom du fichier JSON du style ou dictionnaire spécifiant le style.
- Les noms de style pris en charge sont "iqp" (par défaut), "iqp-dark", "clifford", "textbook" et "bw".
- Si l'on reçoit un fichier JSON, par exemple my_style.json ou my_style (l'extension .json peut être omise), cette fonction tente de charger le dictionnaire de style à partir de cet emplacement. Notez que le fichier JSON doit spécifier complètement les spécifications de visualisation. Le fichier est recherché dans qiskit/visualization/circuit/styles, le répertoire de travail actuel et l'emplacement spécifié dans ~/.qiskit/settings.conf.
- S'il s'agit d'un dictionnaire, chaque entrée remplace la configuration par défaut. Si la "name" clé est fournie, la configuration par défaut correspond à ce style. Par exemple, {"name": "textbook", "subfontsize": 5} charge le "textbook" style et définit la taille de police secondaire (par exemple, les angles des portes) sur 5.
- Si None , le style par défaut "iqp" est utilisé ou, s'il est donné, le style par défaut spécifié dans ~/.qiskit/settings.conf.
interactive (bool) – Lorsqu'il est défini sur True, il affiche le circuit dans une nouvelle fenêtre (pour mpl , cela dépend du backend matplotlib utilisé qui le prend en charge). Remarque : lorsqu'elle est utilisée avec le type de sortie texte ou latex_source , cette option n'a aucun effet et sera ignorée silencieusement. La valeur par défaut est False.
reverse_bits (bool | None) – Lorsqu'il est défini sur True, il inverse l'ordre des bits à l'intérieur des registres pour la visualisation de sortie. La valeur par défaut est False , à moins que le fichier de configuration de l'utilisateur (généralement ~/.qiskit/settings.conf) ne contienne une autre valeur. Par exemple, circuit_reverse_bits = True.
plot_barriers (bool) – Activer/désactiver les barrières de dessin dans le circuit de sortie. Prend par défaut la valeur True.
justify (str | None) – Les options sont "left", "right" ou "none" (str). Si d'autres informations sont fournies, la justification à gauche sera utilisée à la place. Il indique où les portes doivent être placées dans le circuit de sortie s'il existe une option. none chaque porte est placée dans sa propre colonne. La valeur par défaut est left.
vertical_compression (str | None) – high, medium ou low. Il fusionne les lignes générées par la sortie du texte afin que le dessin prenne moins de place verticalement. La valeur par défaut est medium. Utilisé uniquement par la sortie text , il sera ignoré silencieusement dans le cas contraire.
idle_wires (bool |str | None) – Inclure (ou non) les fils inactifs (fils sans composants) dans la visualisation des résultats. La chaîne "auto" est également possible; dans ce cas, les fils inutilisés sont affichés, sauf si le circuit est associé à un schéma. La valeur par défaut est, sauf "auto" si le fichier de configuration de l'utilisateur (généralement ~/.qiskit/settings.conf) contient une autre valeur. Par exemple, circuit_idle_wires = False.
with_layout (bool) – Inclure des informations sur la mise en page, avec des étiquettes sur la mise en page physique. La valeur par défaut est True.
fold (int | None) – Définit la pagination. Il peut être désactivé à l'aide de -1. Dans text, définit la longueur des lignes. Cette fonction est utile lorsque le dessin ne tient pas dans la console. Si None (défaut), il essaiera de deviner la largeur de la console en utilisant shutil.get_terminal_size(). Cependant, si vous utilisez jupyter, la longueur de ligne par défaut est fixée à 80 caractères. Dans mpl, il s'agit du nombre de couches (visuelles) avant le pliage. La valeur par défaut est 25.
ax (Any | None) – Utilisé uniquement par le backend mpl. Objet matplotlib.axes.Axes facultatif à utiliser pour la sortie de visualisation. Si aucun n'est spécifié, une nouvelle figure matplotlib sera créée et utilisée. De plus, si spécifié, il n'y aura pas de figure renvoyée, car cela serait redondant.
initial_state (bool) – Ajoute $|0\rangle$ au début des fils de qubit et $0$ aux fils classiques. La valeur par défaut est False.
cregbundle (bool | None) – S'il est défini sur True, les registres classiques des liasses sont enregistrés. La valeur par défaut est True, sauf si output est remplacé par "text".
wire_order (list[int] | None) – Une liste d'entiers utilisés pour réorganiser l'affichage des bits. La liste doit comporter une entrée pour chaque bit, les bits étant compris entre 0 et (num_qubits + num_clbits).
expr_len (int) – Nombre de caractères à afficher si un Expr est utilisé pour la condition dans un ControlFlowOp. Si ce nombre est dépassé, la chaîne sera tronquée à ce nombre et « … » sera ajouté à la fin.
measure_arrows (bool | None) – Si la valeur est « True », tracez une flèche partant de chaque case de mesure et descendant vers le bit ou le registre classique où la valeur de la mesure est stockée. Si la valeur est « False », ne dessiner pas de flèche, mais inscrire plutôt le nom du bit ou du registre dans la case de mesure. La valeur par défaut est, sauf True si le fichier de configuration de l'utilisateur (généralement ~/.qiskit/settings.conf) contient une autre valeur. Par exemple, circuit_measure_arrows = False.
barrier_label_len (int) – Nombre de caractères à afficher pour Barrier les étiquettes dans le circuit de sortie. Si ce nombre est dépassé, la chaîne sera tronquée à ce nombre et « … » sera ajouté à la fin.

Retours

TextDrawing ou matplotlib.figure ou PIL.Image ou str:

TextDrawing (si output='text')

Un dessin qui peut être imprimé en ascii art.
matplotlib.figure.Figure (si output='mpl')

Un objet figure matplotlib pour le schéma de circuit.
PIL.Image (if output='latex')

Une représentation en mémoire de l'image du schéma de circuit.
str (si output='latex_source')

Le code source LaTeX pour visualiser le schéma du circuit.

Augmentations

VisualizationError - lorsqu'une méthode de sortie non valide est sélectionnée
ImportError - lorsque les méthodes de sortie nécessitent des bibliothèques non installées.

Exemple

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
qc = QuantumCircuit(1, 1)
qc.h(0)
qc.measure(0, 0)
qc.draw(output='mpl', style={'backgroundcolor': '#EEEEEE'})

En plus du pilote de base draw() il existe deux méthodes d'aide à la visualisation, qui sont principalement utiles pour déballer rapidement certaines instructions internes ou pour inverser les conventions d'étiquetage des qubits dans le dessin. Pour une mutation plus générale, y compris la réécriture des portes de base, vous devez utiliser le transpileur (qiskit.transpiler).

decompose

decompose(gates_to_decompose=None, reps=1)

GitHub

Appeler une passe de décomposition sur ce circuit, pour décomposer un niveau (shallow decompose).

Paramètres

gates_to_decompose (str |type[Instruction] | Sequence[str |type[Instruction]] | None) – Sous-ensemble facultatif de portes à décomposer. Il peut s'agir d'un type de portail, tel que HGate, d'un nom de portail, tel que « h », d'une étiquette de portail, telle que « My H Gate », ou d'une liste combinant ces éléments à volonté. Si un nom de porte est saisi, toutes les portes portant ce nom seront décomposées, qu'elles soient étiquetées ou non. Par défaut, toutes les portes du circuit sont concernées.
reps (int) – Nombre facultatif de fois où le circuit doit être décomposé. Par exemple, reps=2 équivaut à appeler circuit.decompose().decompose().

Retours

un circuit décomposé à un niveau

Type de retour

QuantumCircuit

reverse_bits

reverse_bits()

GitHub

Retournez un circuit avec l'ordre inverse des fils.

Le circuit est inversé "verticalement". Si un circuit est défini sur plusieurs registres, le circuit résultant aura les mêmes registres mais avec leur ordre inversé.

Cette méthode est utile pour convertir un circuit écrit en convention little-endian en son équivalent big-endian, et vice versa.

Retours

le circuit avec l'ordre des bits inversé.

Type de retour

QuantumCircuit

Exemples

Entrée :

     ┌───┐
a_0: ┤ H ├──■─────────────────
     └───┘┌─┴─┐
a_1: ─────┤ X ├──■────────────
          └───┘┌─┴─┐
a_2: ──────────┤ X ├──■───────
               └───┘┌─┴─┐
b_0: ───────────────┤ X ├──■──
                    └───┘┌─┴─┐
b_1: ────────────────────┤ X ├
                         └───┘

Sortie :

                         ┌───┐
b_0: ────────────────────┤ X ├
                    ┌───┐└─┬─┘
b_1: ───────────────┤ X ├──■──
               ┌───┐└─┬─┘
a_0: ──────────┤ X ├──■───────
          ┌───┐└─┬─┘
a_1: ─────┤ X ├──■────────────
     ┌───┐└─┬─┘
a_2: ┤ H ├──■─────────────────
     └───┘

Paramètres

regs (Register |int | Sequence[Bit])
name (str)
global_phase (ParameterValueType)
metadata (dict | None)
inputs (Iterable[expr.Var])
captures (Iterable[expr.Var |expr.Stretch])
declarations (Mapping[expr.Var, expr.Expr] | Iterable[tuple[expr.Var, expr.Expr]])

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

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

QuantumCircuit classe

Attributs du circuit

data

global_phase

name

metadata

qregs

cregs

qubits

ancillas

clbits

parameters

layout

duration

unit

op_start_times

num_ancillas

num_clbits

num_captured_vars

num_captured_stretches

num_declared_vars

num_declared_stretches

num_input_vars

num_identifiers

num_parameters

num_qubits

num_stretches

num_vars

Création de nouveaux circuits

__init__

copy

copy_empty_like

from_instructions

from_qasm_file

from_qasm_str

Objets de données sur les circuits

Ajout d'objets de données

add_bits

add_register

add_var

add_input

add_stretch

add_uninitialized_var

add_capture

Travailler avec des bits et des registres

find_bit

has_register

Utilisation des paramètres de compilation

assign_parameters

has_parameter

get_parameter

Travailler avec des données classiques saisies en temps réel

get_var

get_stretch

get_identifier

has_var

has_stretch

has_identifier

iter_vars

iter_stretches

iter_input_vars

iter_captured_vars

iter_captured_stretches

iter_declared_vars

iter_declared_stretches

Ajout d'opérations aux circuits

Méthodes pour ajouter des opérations générales

append

_append

compose

tensor

Méthodes pour ajouter des instructions standard

barrier

ccx

ccz

ch

cp

crx

cry

crz

`QuantumCircuit` classe

init