Libreria di circuiti

• Versioni del pacchetto

  Il codice di questa pagina è stato sviluppato in base ai seguenti requisiti. Si consiglia di utilizzare queste versioni o versioni più recenti.

  qiskit[all]~=2.5.1
  

L'SDK di Qiskit include una libreria di circuiti popolari da utilizzare come blocchi di costruzione nei vostri programmi. L'uso di circuiti predefiniti consente di risparmiare tempo nella ricerca, nella scrittura del codice e nel debug. La libreria comprende circuiti popolari nell'ambito dell'informatica quantistica, circuiti difficili da simulare in modo classico e circuiti utili per il benchmarking dell'hardware quantistico.

Questa pagina elenca le diverse categorie di circuiti che la biblioteca mette a disposizione. Per un elenco completo dei circuiti, consultare la documentazione API della libreria dei circuiti.

Cancelli standard

La libreria di circuiti comprende anche porte quantistiche standard. Alcune sono porte fondamentali (come la UGate), altre sono porte multi-qubit che di solito devono essere costruite a partire da porte a uno o due qubit. Per aggiungere gate importati al vostro circuito, utilizzate il metodo append ; il primo argomento è il gate e l'argomento successivo è un elenco di qubit a cui applicare il gate.

Ad esempio, la seguente cella di codice crea un circuito con una porta Hadamard e una porta-X multicontrollata.

from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, MCXGate

mcx_gate = MCXGate(3)
hadamard_gate = HGate()

qc = QuantumCircuit(4)
qc.append(hadamard_gate, [0])
qc.append(mcx_gate, [0, 1, 2, 3])
qc.draw("mpl")

Output:

Vedere Porte standard nella documentazione dell'API della libreria dei circuiti.

Circuiti N-locali

Questi circuiti alternano strati di porte di rotazione a singolo qubit con strati di porte di entangling a più qubit.

Questa famiglia di circuiti è popolare negli algoritmi quantistici variazionali perché può produrre un'ampia gamma di stati quantistici. Gli algoritmi variazionali regolano i parametri del gate per trovare stati che abbiano determinate proprietà (come gli stati che rappresentano una buona soluzione a un problema di ottimizzazione). A questo scopo, molti circuiti della libreria sono parametrizzati, il che significa che è possibile definirli senza valori fissi.

La seguente cella di codice importa un circuito n_local , in cui le porte di entangling sono porte a due qubit. Questo circuito intreccia blocchi di porte parametrate a un solo qubit, seguiti da blocchi di porte a due qubit entangling. Il codice seguente crea un circuito a tre qubit, con porte RX a un qubit e porte CZ a due qubit.

from qiskit.circuit.library import n_local

two_local = n_local(3, "rx", "cz")
two_local.draw("mpl")

Output:

È possibile ottenere un oggetto simile a un elenco di parametri del circuito dall'attributo parameters .

two_local.parameters

Output:

ParameterView([ParameterVectorElement(θ[0]), ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]), ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]), ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]), ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]), ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]), ParameterVectorElement(θ[11])])

Si può anche usare per assegnare questi parametri a valori reali, usando un dizionario della forma { Parameter: number }. Per dimostrarlo, la seguente cella di codice assegna ogni parametro del circuito a 0.

bound_circuit = two_local.assign_parameters(
    {p: 0 for p in two_local.parameters}
)
bound_circuit.decompose().draw("mpl")

Output:

Per ulteriori informazioni, consultare le porte N-locali nella documentazione dell'API della libreria dei circuiti o seguire il corso di progettazione di algoritmi variazionali in IBM Quantum Learning.

Circuiti di codifica dati

Questi circuiti parametrizzati codificano i dati su stati quantistici per l'elaborazione da parte di algoritmi di apprendimento automatico quantistico. Alcuni circuiti supportati da Qiskit sono:

• Codifica dell'ampiezza, che codifica ogni numero nell'ampiezza di uno stato base. Questo può memorizzare $2^n$ numeri in un singolo stato, ma può essere costoso da implementare.
• Codifica di base, che codifica un intero $k$ preparando il corrispondente stato di base $|k\rangle$.
• Codifica angolare, che imposta ogni numero dei dati come angolo di rotazione in un circuito parametrizzato.

L'approccio migliore dipende dalle caratteristiche specifiche dell'applicazione. Nei computer quantistici attuali, tuttavia, si utilizzano spesso circuiti di codifica angolare come zz_feature_map.

from qiskit.circuit.library import zz_feature_map

features = [0.2, 0.4, 0.8]
feature_map = zz_feature_map(feature_dimension=len(features))

encoded = feature_map.assign_parameters(features)
encoded.draw("mpl")

Output:

Vedere Circuiti di codifica dei dati nella documentazione dell'API della libreria dei circuiti.

Circuiti a evoluzione temporale

Questi circuiti simulano uno stato quantistico che si evolve nel tempo. Utilizzare circuiti ad evoluzione temporale per studiare effetti fisici come il trasferimento di calore o le transizioni di fase in un sistema. I circuiti di evoluzione temporale sono anche un elemento fondamentale delle funzioni d'onda della chimica (come gli stati di prova unitari accoppiati a cluster) e dell'algoritmo QAOA che utilizziamo per i problemi di ottimizzazione.

from qiskit.circuit.library import PauliEvolutionGate
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp


# Prepare an initial state with a Hadamard on the middle qubit
state = QuantumCircuit(3)
state.h(1)

hamiltonian = SparsePauliOp(["ZZI", "IZZ"])
evolution = PauliEvolutionGate(hamiltonian, time=1)

# Evolve state by appending the evolution gate
state.compose(evolution, inplace=True)

state.draw("mpl")

Output:

Leggi il PauliEvolutionGate Documentazione API.

Circuiti di benchmarking e teoria della complessità

I circuiti di benchmarking ci danno un'idea di quanto funzioni effettivamente il nostro hardware, mentre i circuiti della teoria della complessità ci aiutano a capire quanto siano difficili i problemi che vogliamo risolvere.

Ad esempio, il benchmark "quantum volume" misura la precisione con cui un computer quantistico esegue un tipo di circuito quantistico casuale. Il punteggio del computer quantistico aumenta con la dimensione del circuito che può eseguire in modo affidabile. Ciò tiene conto di tutti gli aspetti del computer, compresi il numero di qubit, la fedeltà delle istruzioni, la connettività dei qubit e lo stack software che trasporta e postelabora i risultati. Per saperne di più sul volume quantistico, leggi l' articolo originale sul volume quantistico.

Il codice seguente mostra un esempio di circuito a volume quantistico costruito in Qiskit che funziona su quattro qubit (i blocchi unitary sono porte randomizzate a due qubit).

from qiskit.circuit.library import quantum_volume

quantum_volume(4).draw("mpl")

Output:

La libreria di circuiti comprende anche circuiti ritenuti difficili da simulare in modo classico, come i circuiti polinomiali quantistici istantanei (iqp). Questi circuiti inseriscono alcune porte diagonali (nella base computazionale) tra blocchi di porte Hadamard.

Altri circuiti includono grover_operator per l'utilizzo dell'algoritmo di Grover e il circuito fourier_checking per il problema della verifica di Fourier. Vedere questi circuiti in Circuiti quantistici particolari nella documentazione dell'API della libreria dei circuiti.

Circuiti aritmetici

Le operazioni aritmetiche sono funzioni classiche, come l'addizione di numeri interi e le operazioni bit-wise. Questi possono essere utili in algoritmi come la stima dell'ampiezza per applicazioni finanziarie e in algoritmi come l'algoritmo HHL, che risolve sistemi di equazioni lineari.

A titolo di esempio, proviamo a sommare due numeri a tre bit utilizzando un circuito "ripple-carry" per eseguire l'addizione in-place (FullAdderGate). Questo adder somma due numeri (che chiameremo "A" e "B") e scrive il risultato nel registro che conteneva B. Nell'esempio seguente, A=2 e B=3.

from qiskit.circuit.library import FullAdderGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

adder = FullAdderGate(3)  # Adder of 3-bit numbers

# Create the number A=2
reg_a = QuantumRegister(3, "a")
number_a = QuantumCircuit(reg_a)
number_a.initialize(2)  # Number 2; |010>

# Create the number B=3
reg_b = QuantumRegister(3, "b")
number_b = QuantumCircuit(reg_b)
number_b.initialize(3)  # Number 3; |011>

# Create a circuit to hold everything, including a classical register for
# the result
qregs = [
    QuantumRegister(1, "cin"),
    QuantumRegister(3, "a"),
    QuantumRegister(3, "b"),
    QuantumRegister(1, "cout"),
]
reg_result = ClassicalRegister(3)
circuit = QuantumCircuit(*qregs, reg_result)

# Compose number initializers with the adder. Adder stores the result to
# register B, so we'll measure those qubits.
circuit = (
    circuit.compose(number_a, qubits=reg_a)
    .compose(number_b, qubits=reg_b)
    .compose(adder)
)
circuit.measure(reg_b, reg_result)
circuit.draw("mpl")

Output:

La simulazione del circuito mostra che esso emette 5 per tutti gli scatti di 1024 (cioè è misurato con probabilità 1.0).

from qiskit.primitives import StatevectorSampler

result = StatevectorSampler().run([circuit]).result()

print(f"Count data:\n {result[0].data.c0.get_int_counts()}")

Output:

Count data:
 {5: 1024}

Vedere Aritmetica nella documentazione dell'API della libreria dei circuiti.

Passi successivi