QuantumCircuit classe

I dati del circuito (istruzioni e contesto).

Esempio

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

Risultati

Un oggetto simile a una lista contenente le CircuitInstruction istanze presenti nel circuito.

La fase globale dell'ambito del circuito corrente in radianti.

Esempio

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

Tipo: str

Un nome leggibile per il circuito.

Esempio

from qiskit import QuantumCircuit

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

my_circuit

Dizionario arbitrario di metadati definiti dall'utente per il circuito.

Qiskit non esaminerà il contenuto di questa mappatura, ma la passerà attraverso il transpiler e la riattaccherà all'output, in modo da poter tenere traccia dei propri metadati.

Esempio

from qiskit import QuantumCircuit

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

print(qc.metadata)

{'experiment_type': 'Bell state experiment'}

Un elenco di Qubitnell'ordine in cui sono stati aggiunti. Non si deve mutare questo aspetto.

Un elenco di Clbitnell'ordine in cui sono stati aggiunti. Non si deve mutare questo aspetto.

Un elenco di Qubitnell'ordine in cui sono stati aggiunti. Non si deve mutare questo aspetto.

Un elenco di AncillaQubitnell'ordine in cui sono stati aggiunti. Non si deve mutare questo aspetto.

Un elenco di Clbitnell'ordine in cui sono stati aggiunti. Non si deve mutare questo aspetto.

Esempio

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

I parametri definiti nel circuito.

Questo attributo restituisce gli Parameter oggetti presenti nel circuito ordinati in ordine alfabetico. Si noti che i parametri istanziati con un ParameterVector vengono comunque ordinati numericamente.

Esempi

Lo snippet seguente mostra che l'ordine di inserimento dei parametri non ha importanza.

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

Tenete presente che l'ordinamento alfabetico potrebbe essere poco intuitivo quando si tratta di numeri. Il letterale "10" viene prima del "2" in un rigoroso ordinamento alfabetico.

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

Per rispettare l'ordinamento numerico, è possibile utilizzare 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])
])

Risultati

Gli oggetti ordinati Parameter nel circuito.

Restituisce tutte le informazioni di layout associate al circuito.

Questo attributo contiene un oggetto facoltativo TranspileLayout . Di norma, questa opzione viene impostata sull'uscita di transpile() o PassManager.run() per conservare le informazioni relative alle permutazioni causate dal circuito di ingresso dalla transpilazione.

Esistono due tipi di permutazioni causate dalla transpile() funzione: una configurazione iniziale che permuta i qubit in base ai qubit fisici selezionati sulla Target, e una configurazione finale, che è una permutazione in uscita causata dagli SwapGates inseriti durante l'instradamento.

Esempio

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]

La durata totale del circuito, impostata da un passaggio del transpiler di schedulazione. La sua unità è specificata da unit.

L'unità che duration è specificata in.

Restituisce un elenco di orari di inizio delle operazioni.

Questo attributo è abilitato quando uno dei passaggi di analisi di schedulazione viene eseguito sul circuito quantistico.

Esempio

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

Risultati

Elenco di numeri interi che rappresentano gli orari di inizio stimati delle istruzioni. L'indice corrisponde all'indice dell'istruzione in QuantumCircuit.data.

Aumenti

AttributeError - Quando il circuito non è programmato.

Restituisce il numero di qubit ancilla.

Esempio

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

Restituisce il numero di bit classici.

Esempio

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

Il numero di variabili classiche in tempo reale del circuito contrassegnate come catturate da un ambito di riferimento.

Questa è la lunghezza dell'elemento iter_captured_vars() iterabile. Se questo valore è diverso da zero, num_input_vars deve essere zero.

Il numero di tratti del circuito contrassegnati come acquisiti da un campo d'applicazione.

Questa è la lunghezza dell'elemento iter_captured_stretches() iterabile. Se questo valore è diverso da zero, num_input_vars deve essere zero.

Il numero di variabili classiche in tempo reale del circuito che sono dichiarate da questo ambito del circuito, esclusi gli ingressi o le catture.

Questa è la lunghezza dell'elemento iter_declared_vars() iterabile.

Il numero di tratti del circuito dichiarati da questo ambito del circuito, escluse le catture.

Questa è la lunghezza dell'elemento iter_declared_stretches() iterabile.

Il numero di variabili classiche in tempo reale del circuito contrassegnate come ingressi del circuito.

Questa è la lunghezza dell'elemento iter_input_vars() iterabile. Se questo valore è diverso da zero, num_captured_vars deve essere zero.

Il numero di variabili classiche in tempo reale e di tratti nel circuito.

Questo è pari a num_vars() + num_stretches().

Il numero di oggetti parametro nel circuito.

Restituisce il numero di qubit.

Il numero di tratti del circuito.

Questa è la lunghezza dell'elemento iter_stretches() iterabile.

Il numero di variabili classiche in tempo reale nel circuito.

Questa è la lunghezza dell'elemento iter_vars() iterabile.

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

Costruttore predefinito di QuantumCircuit.

Parametri

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

  I registri da includere nel circuito.

  • Se un elenco di Register rappresenta gli oggetti QuantumRegister e/o ClassicalRegister da includere nel circuito.

    Ad esempio:

    • QuantumCircuit(QuantumRegister(4))
    • QuantumCircuit(QuantumRegister(4), ClassicalRegister(3))
    • QuantumCircuit(QuantumRegister(4, 'qr0'), QuantumRegister(2, 'qr1'))

  • Se un elenco di int, la quantità di qubit e/o bit classici da includere nel circuito. Può essere un singolo int per il solo numero di bit quantistici, oppure 2 int per il numero di bit quantistici e classici, rispettivamente.

    Ad esempio:

    • QuantumCircuit(4) # A QuantumCircuit with 4 qubits
    • QuantumCircuit(4, 3) # A QuantumCircuit with 4 qubits and 3 classical bits

  • Se un elenco di liste python contiene Bit oggetti, un insieme di oggetti Bit da aggiungere al circuito.

• name (str | None) – il nome del circuito quantistico. Se non viene impostata, verrà assegnata una stringa generata automaticamente.

• global_phase (ParameterExpression |float) – La fase globale del circuito espressa in radianti.

• metadata (dict | None) – Metadati di valore chiave arbitrari da associare al circuito. Questo viene memorizzato come dato libero in un dict nell'attributo metadata nell'attributo. Non verrà utilizzato direttamente nel circuito.

• inputs (Iterable[Var]) – variabili da dichiarare come variabili input di runtime per questo circuito. Questi dovrebbero essere nodi già expr.Var esistenti che hai creato altrove; se devi creare anche gli input, usa QuantumCircuit.add_input(). Le variabili specificate in questo argomento verranno passate direttamente a add_input(). Un circuito non può avere sia inputs che captures.

• captures (Iterable[Var |Stretch]) – qualsiasi variabile che l'ambito di questo circuito debba ereditare dall'ambito che lo contiene. Le variabili qui indicate verranno passate direttamente a add_capture(). Un circuito non può avere sia inputs che captures.

• declarations (Mapping[Var, Expr] | Iterable[tuple[Var, Expr]]) –

  qualsiasi variabile che questo circuito deve dichiarare e inizializzare immediatamente. È possibile ordinare questo input in modo che le dichiarazioni successive dipendano da quelle precedenti (compresi gli input o le catture). Se è necessario dipendere da valori che verranno calcolati in seguito in fase di esecuzione, utilizzare il metodo add_var() in un punto appropriato dell'esecuzione del circuito.

  Questo argomento serve per una comoda inizializzazione del circuito quando si dispone già di un insieme di variabili create. Le variabili utilizzate qui saranno passate direttamente a add_var()che si può usare direttamente se è la prima volta che si crea la variabile.

Aumenti

• CircuitError - se il nome del circuito, se fornito, non è valido.
• CircuitError - se vengono forniti sia inputs che captures .

copy(name=None)

Copiare il circuito.

Parametri

name (str) – nome da assegnare al circuito copiato. Se nessuno, il nome rimane invariato.

Risultati

una copia profonda del circuito corrente, con il nome specificato

Tipo di restituzione

QuantumCircuit

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

Restituisce una copia di self con la stessa struttura, ma vuota.

Tale struttura comprende:

• nome e altri metadati
• fase globale
• tutti i qubit e i clbit, compresi i registri
• le variabili in tempo reale definite nel circuito, gestite in base all'argomento della parola chiave vars .

Parametri

• name (str | None) – Nome del circuito copiato. Se nessuno, il nome rimane invariato.

• vars_mode (Literal['alike', 'captures', 'drop']) –

  La modalità di gestione delle variabili in tempo reale.

  simile

  Le variabili del circuito di uscita avranno la stessa semantica di dichiarazione del circuito originale. Ad esempio, le variabili di input nella sorgente saranno variabili di input nel circuito di uscita. Si noti che in questo modo le variabili locali non vengono inizializzate, perché i depositi non vengono copiati. Questo può lasciare il circuito in uno stato potenzialmente pericoloso per gli utenti, se non aggiungono nuovamente gli inizializzatori.

  catture

  Tutte le variabili saranno convertite in variabili catturate. Questo è utile quando si sta costruendo un nuovo livello per un circuito esistente che si vuole compose() sulla base, poiché compose() può inserire le catture nel circuito di base (ma non altre variabili).

  rimuovere

  Il circuito di uscita non avrà variabili definite.

Risultati

Una copia vuota di sé.

Tipo di restituzione

QuantumCircuit

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

Costruisci un circuito a partire da un iterabile di CircuitInstructions.

Parametri

• instructions (Iterable[CircuitInstruction |tuple[qiskit.circuit.Instruction] | tuple[qiskit.circuit.Instruction, Iterable[Qubit]] | tuple[qiskit.circuit.Instruction, Iterable[Qubit], Iterable[Clbit]]]) – Le istruzioni da aggiungere al circuito.
• qubits (Iterable[Qubit]) – Qualsiasi qubit da aggiungere al circuito. Questo argomento può essere utilizzato, ad esempio, per imporre un particolare ordinamento dei qubit.
• clbits (Iterable[Clbit]) – Qualsiasi bit classico da aggiungere al circuito. Questo argomento può essere usato, ad esempio, per imporre un particolare ordine dei bit classici.
• name (str | None) – Il nome del circuito.
• global_phase (ParameterValueType) – La fase globale del circuito in radianti.
• metadata (dict | None) – Metadati di valore chiave arbitrari da associare al circuito.

Risultati

Il circuito quantistico.

Tipo di restituzione

QuantumCircuit

static from_qasm_file(path)

Leggere un programma di OpenQASM 2.0 da un file e convertirlo in un'istanza di QuantumCircuit.

Parametri

path (str |PathLike) – Percorso del file per un programma di " OpenQASM e 2"

Risultati

L'oggetto QuantumCircuit per l'input OpenQASM 2.

Tipo di restituzione

QuantumCircuit

static from_qasm_str(qasm_str)

Converte una stringa contenente un programma di OpenQASM 2.0 in un file di tipo QuantumCircuit.

Parametri

qasm_str (str) – Una stringa contenente un programma OpenQASM 2.0.

Risultati

L'oggetto QuantumCircuit per l'ingresso OpenQASM 2

Tipo di restituzione

QuantumCircuit

add_bits(bits)

Aggiungere bit al circuito.

Parametri

bits (Iterable[Bit])

Tipo di restituzione

Nessuna

add_register(*regs)

Aggiungere registri.

Parametri

regs (Register |int |Sequence[Bit])

Tipo di restituzione

Nessuna

add_var(name_or_var, /, initial)

Aggiungete a questo circuito una variabile classica con memorizzazione e portata automatica.

La variabile è considerata "dichiarata" all'inizio del circuito, ma viene inizializzata solo nel momento in cui si chiama questo metodo, quindi può dipendere da variabili definite prima di essa.

Parametri

• name_or_var (str |Var) – una stringa del nome della variabile o un'istanza esistente di Var da riutilizzare. Le variabili non possono oscurare nomi già in uso all'interno del circuito.

• initial (Any) –

  il valore con cui inizializzare questa variabile. Se il primo argomento è stato dato come nome di stringa, il tipo della variabile risultante viene dedotto dall'espressione iniziale; per controllare questo aspetto in modo più manuale, si può usare il comando Var.new() per costruire manualmente una nuova variabile con il tipo desiderato, oppure usare expr.cast() per lanciare l'inizializzatore al tipo desiderato.

  Deve essere un nodo Expr o un valore che può essere portato a uno di essi usando expr.lift.

Risultati

La variabile creata. Se è stata fornita un'istanza Var è stata data un'istanza, verrà restituito lo stesso identico oggetto.

Aumenti

CircuitError - se la variabile non può essere creata a causa dell'ombra di un identificatore esistente.

Tipo di restituzione

Var

Esempi

Definire una nuova variabile con un nome e un'espressione di inizializzazione:

from qiskit.circuit import QuantumCircuit

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

Riutilizzare una variabile che può essere stata presa da un circuito correlato, o altrimenti costruita manualmente, e inizializzarla a un'espressione più complessa:

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(name_or_var: str, type_: Type, /) → Var

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

Registrare una variabile come ingresso al circuito.

Parametri

• name_or_var (str |Var) – un nome di stringa oppure un nodo Var esistente da utilizzare come variabile di input.
• tipo - se il nome è dato come stringa, questo deve essere un tipo di stringa Type da utilizzare per la variabile. Se la variabile è data come un oggetto esistente Varnon deve essere indicata e verrà letta dall'oggetto stesso.
• type_ (Type | None)

Risultati

la variabile creata o la stessa variabile passata.

Aumenti

CircuitError - se la variabile non può essere creata a causa dell'ombra di una variabile esistente.

Tipo di restituzione

Var

add_stretch(name_or_stretch)

Dichiara un nuovo tratto con lo scope di questo circuito.

Parametri

name_or_stretch (str |Stretch) – una stringa del nome dell'estensione o un'istanza esistente di Stretch da riutilizzare. Gli stretch non possono ombreggiare nomi già in uso all'interno del circuito.

Risultati

Il tratto creato. Se è stata fornita un'istanza Stretch è stata data un'istanza, verrà restituito lo stesso identico oggetto.

Aumenti

CircuitError - se il tratto non può essere creato a causa dell'ombra di un identificatore esistente.

Tipo di restituzione

Allungamento

Esempi

Definire e utilizzare un nuovo tratto con un semplice nome:

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)

add_uninitialized_var(var, /)

Aggiungere una variabile senza inizializzatore.

Nella maggior parte dei casi, si dovrebbe usare add_var() per inizializzare la variabile. Per utilizzare questa funzione, è necessario essere già in possesso di un'istanza di Var poiché l'uso della funzione ha senso solo in contesti di copia.

Parametri

var (Var) – la variabile da aggiungere.

add_capture(var: Var)

add_capture(stretch: Stretch)

Aggiungere un identificatore al circuito che deve catturare da un ambito in cui sarà contenuto.

Questo metodo richiede un Var o Stretch per assicurarsi di avere un handle a un identificatore, perché sarà necessario dichiarare lo stesso identificatore usando lo stesso oggetto nel circuito esterno.

Si tratta di un metodo di basso livello, utile solo se si costruiscono manualmente le operazioni del flusso di controllo. In genere non è necessario chiamare questo metodo, se si utilizza l'interfaccia del costruttore per gli ambiti del flusso di controllo (with dichiarazioni del gestore di contesto per if_test() e gli altri costrutti di scope). L'interfaccia del costruttore creerà automaticamente le chiusure degli ambiti interni per conto dell'utente, catturando tutti gli identificatori utilizzati al loro interno.

Parametri

var (Union[expr.Var, expr.Stretch]) – la variabile o il tratto da catturare da un ambito chiuso.

Aumenti

CircuitError - se l'identificatore non può essere creato a causa dell'ombra di un identificatore esistente.

find_bit(bit)

Individuare le posizioni del circuito che possono essere utilizzate per fare riferimento a una data Bit.

In particolare, questa funzione può trovare l'indice intero di un qubit, che corrisponde al suo indice hardware per un circuito transpilato.

Parametri

bit (Bit) – Il bit da localizzare.

Risultati

Una 2-tupla. Il primo elemento (index) contiene l'indice in cui si trova Bit (sia in qubits, clbits, a seconda del tipo). Il secondo elemento (registers) è un elenco di coppie di (register, index) con una voce per ogni Register nel circuito che contiene l'elemento Bit (e l'indice nel circuito Register in cui può essere trovato).

Tipo di restituzione

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

Aumenti

• CircuitError - Se l'elemento fornito Bit è di tipo sconosciuto.
• CircuitError - Se l'alimentazione Bit non è stato possibile trovare il circuito.

Esempi

Eseguire il loop di un circuito, ottenendo gli indici di qubit e clbit di ogni operazione:

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
]

has_register(register)

Verificare se questo circuito dispone del registro r.

Parametri

register (Register) – un registro quantistico o classico.

Risultati

Vero se il registro è contenuto in questo circuito.

Tipo di restituzione

bool

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

Assegnare i parametri a nuovi parametri o valori.

Se parameters viene passato come dizionario, le chiavi devono essere Parameter istanze nel circuito corrente. I valori del dizionario possono essere sia valori numerici che nuovi oggetti parametro.

Se parameters viene passato come lista o array, gli elementi vengono assegnati ai parametri correnti nell'ordine di parameters , che è ordinato alfabeticamente (rispettando l'ordinamento degli ParameterVector oggetti in ).

I valori possono essere assegnati all'oggetto circuito corrente o a una sua copia.

Parametri

• parameters (Mapping[Parameter, ParameterExpression |float] | Iterable[ParameterExpression |float]) – Un dizionario o un iterabile che specifichi i nuovi valori dei parametri.
• inplace (bool) – Se il valore è False, viene restituita una copia del circuito con i parametri associati. Se il valore è True, viene modificata l'istanza del circuito stessa.
• flat_input (bool) – Se True e parameters è un tipo di mappatura, si presume che sia esattamente una mappatura di {parameter: value}. Per impostazione predefinita (False), la mappatura può contenere ParameterVector anche chiavi che rimandano a una sequenza corrispondente di valori, che verranno sviluppate durante la mappatura, oppure chiavi di tipo stringa, che verranno convertite in Parameter istanze tramite get_parameter().
• strict (bool) – In tal caso False, eventuali parametri specificati nella mappatura che non vengono utilizzati nel circuito verranno ignorati. Se True (impostazione predefinita), verrà generato un errore che segnala un errore logico.

Aumenti

• CircuitError - Se parametri è una dict e contiene parametri non presenti nel circuito.
• ValueError - Se i parametri sono un elenco/array e la loro lunghezza non corrisponde al numero di parametri liberi del circuito.

Risultati

Una copia del circuito con parametri vincolati se inplace è False, altrimenti None.

Tipo di restituzione

QuantumCircuit | Nessuno

Esempi

Creare un circuito parametrizzato e assegnare i parametri in loco.

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

Legare i valori fuori posto per elenco e ottenere una copia del circuito originale.

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

has_parameter(name_or_param, /)

Controlla se esiste un oggetto parametro in questo circuito.

Parametri

name_or_param (str |Parameter) – il parametro, ovvero il nome di un parametro da verificare. TrueSe si tratta di un Parameter nodo, il parametro deve essere esattamente quello specificato affinché questa funzione restituisca il risultato.

Risultati

se un parametro di corrispondenza è assegnabile in questo circuito.

Tipo di restituzione

bool

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

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

Recupera un parametro in tempo di compilazione accessibile per nome in questo ambito del circuito.

Parametri

• name (str) – il nome del parametro da recuperare.
• default (Any) – Se specificato, questo valore verrà restituito nel caso in cui il parametro non sia presente. Se non viene specificato, viene KeyError generato un.

Risultati

Il parametro corrispondente.

Aumenti

KeyError - se non viene dato alcun valore predefinito, ma il parametro non esiste nel circuito.

Tipo di restituzione

Parametro

Esempi

Recupera un parametro per nome da un circuito:

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

Ottiene una variabile da un circuito in base al nome, restituendo un valore predefinito se non è presente:

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

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

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

Recupera una variabile accessibile per nome in questo ambito del circuito.

Parametri

• name (str) – il nome della variabile da recuperare.
• default (Any) – Se specificato, questo valore verrà restituito nel caso in cui la variabile non sia presente. Se non viene specificato, viene KeyError generato un.

Risultati

La variabile corrispondente.

Aumenti

KeyError - se non viene dato alcun valore predefinito, ma la variabile non esiste.

Esempi

Recupera una variabile per nome da un circuito:

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

Ottiene una variabile da un circuito in base al nome, restituendo un valore predefinito se non è presente:

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

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

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

Recupera un tratto accessibile in questo ambito del circuito in base al nome.

Parametri

• name (str) – il nome del tratto da recuperare.
• default (Any) – Se specificato, questo valore verrà restituito nel caso in cui la variabile non sia presente. Se non viene specificato, viene KeyError generato un.

Risultati

Il tratto corrispondente.

Aumenti

KeyError - se non viene dato alcun valore predefinito, ma la variabile non esiste.

Esempi

Recupera un tratto per nome da un circuito:

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

Ottiene una variabile da un circuito in base al nome, restituendo un valore predefinito se non è presente:

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

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

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

Recupera un identificatore accessibile in questo ambito del circuito in base al nome.

Attualmente questo include sia le variabili classiche in tempo reale che i tratti.

Parametri

• name (str) – il nome dell'identificatore da recuperare.
• default (Any) – Se specificato, questo valore verrà restituito nel caso in cui la variabile non sia presente. Se non viene specificato, viene KeyError generato un.

Risultati

La variabile corrispondente.

Aumenti

KeyError - se non viene dato alcun valore predefinito, ma l'identificatore non esiste.

has_var(name_or_var, /)

Controlla se una variabile è accessibile in questo ambito.

Parametri

name_or_var (str |Var) – la variabile o il nome di una variabile da controllare. Se si tratta di un expr.Var nodo, la variabile deve essere esattamente quella specificata affinché questa funzione restituisca True.

Risultati

se una variabile corrispondente è accessibile.

Tipo di restituzione

bool

has_stretch(name_or_stretch, /)

Verificare se un tratto è accessibile in questo ambito.

Parametri

name_or_stretch (str |Stretch) – il tratto o il nome di un tratto da controllare. Se si tratta di un expr.Stretch nodo, l'allungamento deve essere esattamente quello specificato affinché questa funzione restituisca True.

Risultati

se un tratto corrispondente è accessibile.

Tipo di restituzione

bool

has_identifier(name_or_ident, /)

Verifica se un identificatore è accessibile in questo ambito.

Parametri

name_or_ident (str |Var |Stretch) – l'istanza o il nome dell'identificatore da controllare. Se si tratta di un nodo expr.Varexpr.Stretch o, l'istanza corrispondente deve essere esattamente quella specificata affinché questa funzione restituisca True.

Risultati

se un identificatore corrispondente è accessibile.

Tipo di restituzione

bool

iter_vars()

Ottiene un iterabile su tutte le variabili classiche in tempo reale in ambito di questo circuito.

Questo metodo esegue un'iterazione su tutte le variabili in ambito. Per gli iteratori a grana più fine, vedere iter_declared_vars(), iter_input_vars() e iter_captured_vars().

Tipo di restituzione

Iterabile[* Var* ]

iter_stretches()

Ottenere un iterabile su tutti i tratti in ambito all'interno di questo circuito.

Questo metodo itera su tutte le tratte in ambito. Per gli iteratori a grana più fine, si veda iter_declared_stretches() e iter_captured_stretches().

Tipo di restituzione

Iterabile[* Stretch* ]

iter_input_vars()

Ottiene un iterabile su tutte le variabili classiche in tempo reale dichiarate come ingressi di questo ambito circuitale. Sono escluse le variabili dichiarate localmente (vedi iter_declared_vars()) e le variabili catturate (vedere iter_captured_vars()).

Tipo di restituzione

Iterabile[* Var* ]

iter_captured_vars()

Ottiene un iterabile su tutte le variabili classiche in tempo reale catturate da questo ambito del circuito da un ambito contenente. Sono escluse le variabili di input (vedere iter_input_vars()) e le variabili dichiarate localmente (vedere iter_declared_vars()).

Tipo di restituzione

Iterabile[* Var* ]

iter_captured_stretches()

Ottiene un iterabile sui tratti catturati da questo ambito di circuito da un ambito contenente. Sono esclusi i tratti dichiarati localmente (vedere iter_declared_stretches()).

Tipo di restituzione

Iterabile[* Stretch* ]

iter_declared_vars()

Ottiene un iterabile su tutte le variabili classiche in tempo reale dichiarate con durata di memorizzazione automatica in questo ambito. Sono escluse le variabili di input (vedere iter_input_vars()) e le variabili catturate (vedere iter_captured_vars()).

Tipo di restituzione

Iterabile[* Var* ]

iter_declared_stretches()

Ottiene un iterabile su tutti i tratti dichiarati in questo ambito. Sono esclusi i tratti catturati (vedi iter_captured_stretches()).

Tipo di restituzione

Iterabile[* Stretch* ]

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

Aggiungere una o più istruzioni alla fine del circuito, modificando il circuito stesso.

Il qargs e cargs il verranno espansi e trasmessi secondo le regole del dato Instruction, e qualsiasi specificatore nonBit (come gli indici interi) verrà risolto nelle istanze pertinenti.

Se viene fornito un CircuitInstruction , questo verrà "sconfezionato", verificato nel contesto di questo circuito e un nuovo oggetto verrà aggiunto al circuito. In questo caso, non è possibile passare qargs o cargs separatamente.

Parametri

• instruction (Operation |CircuitInstruction) –Instruction un'istanza da aggiungere, oppure un CircuitInstruction con tutto il suo contesto. Sono supportati anche gli oggetti che implementano to_instruction , ma in genere è preferibile passare direttamente un Instruction , poiché ciò evita il costo delle conversioni ripetute.
• qargs (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]] | None) – elementi a cui Qubit associare l'istruzione
• cargs (Sequence[Clbit |ClassicalRegister |int |slice |Sequence[Clbit |int]] | None) – elementi a cui Clbit associare l'istruzione
• copy (bool) – se True (l'impostazione predefinita), l'istruzione instruction in arrivo viene copiata prima di essere aggiunta al circuito se contiene parametri simbolici, in modo che possa essere mutata in modo sicuro senza influenzare altri circuiti in cui potrebbe trovarsi la stessa istruzione. Se si è certi che questa istruzione non verrà utilizzata in altri circuiti, è possibile impostare questo False per ottenere un piccolo aumento di velocità.

Risultati

CircuitInstructionun riferimento agli elementi che sono stati effettivamente aggiunti al circuito.

Tipo di restituzione

qiskit.circuit.InstructionSet

Aumenti

CircuitError – se l'operazione passata non è un'istanza di Instruction, oppure non può essere convertita in tale istanza richiamando to_instruction su di essa.

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

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

Aggiungere un'istruzione alla fine del circuito, modificando il circuito stesso.

Parametri

• istruzione -

  Una descrizione completa e ben strutturata CircuitInstruction dell'operazione e del contesto in cui va inserita.

  Nella forma di compatibilità con le versioni precedenti, può trattarsi di un semplice Operation, nel qual caso qargs e cargs devono essere specificati esplicitamente.

• qargs – Argomento legacy per i qubit a cui collegare il bare Operation . Viene ignorato se il primo argomento è nella forma preferenziale CircuitInstruction .

• cargs – Argomento legacy per clbits a cui associare il bare Operation . Viene ignorato se il primo argomento è nella forma preferenziale CircuitInstruction .

• _standard_gate (bool)

Risultati

un handle all'istruzione appena aggiunta.

Tipo di restituzione

CircuitInstruction

compose(other: QuantumCircuit | Instruction, qubits: Qubit | QuantumRegister | int | slice | Sequence[Qubit | int] | Sequence[Qubit | QuantumRegister | int | slice | Sequence[Qubit | int]] | None = None, clbits: Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int] | Sequence[Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int]] | None = None, front: bool = False, inplace: Literal[True] = True, wrap: bool = False, *, copy: bool = True, var_remap: Mapping[str | Var | Stretch, str | Var | Stretch] | None = None, inline_captures: bool = False) → None

compose(other: QuantumCircuit | Instruction, qubits: Qubit | QuantumRegister | int | slice | Sequence[Qubit | int] | Sequence[Qubit | QuantumRegister | int | slice | Sequence[Qubit | int]] | None = None, clbits: Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int] | Sequence[Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int]] | None = None, front: bool = False, inplace: Literal[False] = False, wrap: bool = False, *, copy: bool = True, var_remap: Mapping[str | Var | Stretch, str | Var | Stretch] | None = None, inline_captures: bool = False) → QuantumCircuit

Applicare le istruzioni di un circuito ai qubit e/o ai clbit specificati di un altro circuito.

Quando si ha a che fare con variabili in tempo reale (expr.Var e expr.Stretch ci sono due strategie principali per l'utilizzo di compose():

1. Il circuito other è trattato come interamente additivo, comprese le sue variabili. Le variabili in other devono essere completamente distinte da quelle in self (per questo si può usare var_remap ) e tutte le variabili in other saranno dichiarate nuovamente nell'output con uno scoping input/capture/local corrispondente a quello di other. In genere, è quello che si desidera se si devono unire due circuiti non correlati.
2. Il circuito other è stato creato come un'estensione esatta di self per essere inline su di esso, agendo anche sulle variabili esistenti nei loro stati alla fine di self. In questo caso, si dovrebbe creare other con tutte le variabili da inserire dichiarate come "catture" e poi si può usare inline_captures=True in questo metodo per collegarle. Questo è generalmente ciò che si desidera se si sta costruendo un circuito definendo i livelli al volo o ricostruendo un circuito usando livelli presi da se stesso. L'argomento vars_mode="captures" di copy_empty_like() per creare la base di ogni livello, in questo caso.

Parametri

• other (qiskit.circuit.Instruction orQuantumCircuit) – (sotto)circuito o istruzione da applicare a se stesso. Se non è un QuantumCircuit, può essere qualsiasi cosa che append accetti.

• qubits (list[Qubit|int]) – qubit di sé da comporre.

• clbits (list[Clbit|int]) – pezzi di sé da comporre.

• front (bool) – Se True, verrà eseguita la composizione frontale. Questo non è possibile all'interno dei gestori di contesto dei costruttori di flussi di controllo.

• inplace (bool) – Se True, modificare l'oggetto. Altrimenti, restituire il circuito composto.

• copy (bool) – Se True (l'impostazione predefinita), l'input viene trattato come condiviso e tutte le istruzioni contenute verranno copiate, se dovessero essere mutate in futuro. Si può impostare False se l'ingresso deve essere considerato di proprietà del circuito di base, per evitare copie inutili; in questo caso, non è valido l'uso successivo di other e alcune istruzioni potrebbero essere state mutate sul posto.

• var_remap (Mapping) –

  mappatura da utilizzare per riscrivere expr.Var e expr.Stretch in other mentre vengono inseriti in self. Questo può essere usato per evitare conflitti di denominazione.

  Sia le chiavi che i valori possono essere forniti come stringhe o istanze di identificatori diretti. Se una chiave è una stringa, corrisponde a qualsiasi elemento Var o Stretch con lo stesso nome. Se un valore è una stringa, ogni volta che una nuova chiave corrisponde ad essa, un nuovo elemento Var o Stretch viene creato con il tipo corretto. Se un valore è una variabile Varil suo type deve corrispondere esattamente a quello della variabile che sostituisce.

• inline_captures (bool) –

  se True, allora tutti i nodi di identificatori "catturati" in other QuantumCircuit si presume si riferiscano a identificatori già dichiarati in self (come qualsiasi tipo di ingresso/cattura/locale) e gli usi in other si applicheranno agli identificatori esistenti. Se si vuole costruire un livello per un circuito esistente da usare con compose()si potrebbe trovare utile l'argomento vars_mode="captures" di copy_empty_like() utile. Qualsiasi rimappatura in vars_remap avviene prima della valutazione di questa variabile inlining.

  Se questo è False (l'impostazione predefinita), tutti gli identificatori in other dovranno essere distinti da quelli in self e verranno fatte nuove dichiarazioni per loro.

• wrap (bool) – Se è vero, avvolge l'altro circuito in un gate (o in un'istruzione, a seconda che contenga solo istruzioni unitarie) prima di comporlo in sé. Piuttosto che usare questa opzione, è quasi sempre meglio controllare manualmente questo aspetto, usando i tasti to_instruction() o to_gate()e poi chiamare append().

Risultati

il circuito composto (restituisce None se inplace==True).

Tipo di restituzione

QuantumCircuit

Aumenti

• CircuitError - se non è possibile effettuare una mappatura corretta dei fili tra i due circuiti, ad esempio se other è più largo di self.
• CircuitError - se si cerca di emettere un nuovo circuito mentre self ha un contesto di flusso di controllo parzialmente costruito attivo, come le forme di context-manager di if_test(), for_loop() e while_loop().
• CircuitError - se si cerca di comporre la parte anteriore di un circuito quando è attivo un blocco costruttore di flussi di controllo; non c'è un significato chiaro per questa azione.

Esempi

>>> 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 ═══════════════════════

tensor(other, inplace=False)

Tensore self con other.

Ricordate che nella convenzione little-endian l'operazione più a sinistra si trova in fondo al circuito. Per ulteriori informazioni, consultare la documentazione.

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

Parametri

• other (QuantumCircuit) – L'altro circuito con cui tensurare questo circuito.
• inplace (bool) – Se True, modificare l'oggetto. Altrimenti restituire il circuito composto.

Tipo di restituzione

QuantumCircuit | Nessuno

Esempi

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

Risultati

Il circuito tensored (restituisce None se inplace=True).

Tipo di restituzione

QuantumCircuit

Parametri

• other (QuantumCircuit)
• inplace (bool)

barrier(*qargs, label=None)

Applicare Barrier. Se qargs è vuoto, si applica a tutti i qubit del circuito.

Parametri

• qargs (QubitSpecifier) – Specifica per uno o più argomenti di qubit.
• label (str) – L'etichetta stringa della barriera.

Risultati

maniglia alle istruzioni aggiunte.

Tipo di restituzione

qiskit.circuit.InstructionSet

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

CCXGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come primo controllo.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come secondo controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CCZGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come primo controllo.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come secondo controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '10'). Per impostazione predefinita, controlla lo stato '11'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CHGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CPhaseGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• theta (ParameterExpression |float) – L'angolo di rotazione.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CRXGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• theta (ParameterExpression |float) – L'angolo di rotazione.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CRYGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• theta (ParameterExpression |float) – L'angolo di rotazione.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CRZGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• theta (ParameterExpression |float) – L'angolo di rotazione.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CSGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CSdgGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CSwapGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• target_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). L'impostazione predefinita è il controllo dello stato '1' .

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CSXGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CUGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• theta (ParameterExpression |float) – L' $\theta$ e angolo di rotazione del gate.
• phi (ParameterExpression |float) – L' $\phi$ e angolo di rotazione del gate.
• lam (ParameterExpression |float) – L' $\lambda$ e angolo di rotazione del gate.
• gamma (ParameterExpression |float) – La fase globale applicata al gate U, se presente.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CXGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CYGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

CZGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit utilizzato/i come controllo.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il o i qubit su cui agisce il gate.
• label (str | None) – L'etichetta della stringa del gate nel circuito.
• ctrl_state (str |int | None) – Lo stato di controllo in decimale o come stringa di bit (ad es. '1'). Per impostazione predefinita, controlla lo stato '1'.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

dcx(qubit1, qubit2)

DCXGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit a cui applicare il gate.
• qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il/i qubit a cui applicare il gate.

Risultati

Un handle alle istruzioni create.

Tipo di restituzione

InstructionSet

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

Applicare Delay. Se qarg è None, si applica a tutti i qubit. Quando si applica a più qubit, verranno creati ritardi con la stessa durata.

Parametri

• duration (Object) – durata del ritardo. Se si tratta di un elemento Exprdeve essere un'espressione costante di tipo Duration.
• qarg (Object) – per applicare questo ritardo.
• unit (str | None) – dell'unità di misura della durata, a meno che duration non sia un Expr nel qual caso non deve essere specificato. Unità supportate: 's', 'ms', 'us', 'ns', 'ps', e 'dt'. L'impostazione predefinita è 'dt', ovvero un'unità di tempo intera che dipende dal backend di destinazione.

Risultati

maniglia alle istruzioni aggiunte.

Tipo di restituzione

qiskit.circuit.InstructionSet

Aumenti

CircuitError - se gli argomenti hanno un formato sbagliato.

ecr(qubit1, qubit2)

ECRGateInvia la candidatura.

Per la forma matriciale completa di questo gate, vedere la documentazione del gate sottostante.

Parametri

• qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il primo qubit a cui applicare il gate.
• qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – Il secondo qubit a cui applicare il gate.

Risultati