Circuit library

Mga bersyon ng package

Ang code sa pahinang ito ay ginawa gamit ang mga sumusunod na requirements. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago.

qiskit[all]~=2.3.0

Kasama sa Qiskit SDK ang isang library ng mga sikat na circuit na magagamit bilang mga building block sa iyong sariling mga programa. Nakakatipid ng oras ang paggamit ng mga pre-defined na circuit sa pananaliksik, pagsusulat ng code, at pag-debug. Kasama sa library ang mga sikat na circuit sa quantum computing, mga circuit na mahirap i-simulate nang klasikal, at mga circuit na kapaki-pakinabang sa benchmarking ng quantum hardware.

Inililista ng pahinang ito ang iba't ibang kategorya ng circuit na ibinibigay ng library. Para sa kumpletong listahan ng mga circuit, tingnan ang circuit library API documentation.

Standard gates

Kasama rin sa circuit library ang mga standard na quantum gate. Ang ilan ay mga mas pangunahing gate (tulad ng UGate), at ang iba ay mga multi-qubit gate na karaniwang kailangang buuin mula sa single- at two-qubit gate. Para magdagdag ng mga imported na gate sa iyong circuit, gamitin ang append method; ang unang argumento ay ang gate, at ang susunod na argumento ay isang listahan ng mga qubit na paglalagyan ng gate.

Halimbawa, ang sumusunod na code cell ay gumagawa ng circuit na may Hadamard gate at isang multi-controlled-X gate.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit

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

Tingnan ang Standard gates sa circuit library API documentation.

Hindi sigurado sa pangalan ng iyong gate? Subukang tanungin ang Qiskit Code Assistant.

N-local circuits

Ang mga circuit na ito ay nagpapalit-palit ng mga layer ng single-qubit rotation gate at mga layer ng multi-qubit entangling gate.

Ang pamilyang ito ng mga circuit ay sikat sa variational quantum algorithms dahil kaya nitong gumawa ng malawak na hanay ng mga quantum state. Inaayos ng variational algorithms ang mga parameter ng gate para mahanap ang mga state na may ilang partikular na katangian (tulad ng mga state na kumakatawan sa magandang solusyon sa optimization problem). Para sa layuning ito, maraming circuit sa library ay parameterized, ibig sabihin ay maaari itong i-define nang walang nakatakdang halaga.

Ang sumusunod na code cell ay nag-i-import ng n_local circuit, kung saan ang mga entangling gate ay two-qubit gate. Ang circuit na ito ay nagpapalit-palit ng mga bloke ng parameterized single-qubit gate, na sinusundan ng mga entangling block ng two-qubit gate. Ang sumusunod na code ay gumagawa ng three-qubit circuit, na may single-qubit RX-gate at two-qubit CZ-gate.

from qiskit.circuit.library import n_local

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

Makakakuha ng list-like na object ng mga parameter ng circuit mula sa parameters attribute.

two_local.parameters

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

Maaari mo rin itong gamitin para mag-assign ng mga tunay na halaga sa mga parameter na ito gamit ang isang dictionary na may format na { Parameter: number }. Bilang demonstrasyon, inaasign ng sumusunod na code cell ang bawat parameter sa circuit sa 0.

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

Para sa karagdagang impormasyon, tingnan ang N-local gates sa circuit library API documentation o kumuha ng Variational algorithm design course sa IBM Quantum Learning.

Data-encoding circuits

Ang mga parameterized na circuit na ito ay nag-e-encode ng data sa mga quantum state para maproseso ng mga quantum machine learning algorithm. Ilan sa mga circuit na sinusuportahan ng Qiskit ay:

• Amplitude encoding, na nag-e-encode ng bawat numero sa amplitude ng isang basis state. Kaya nitong mag-store ng $2^n$ na numero sa isang state, ngunit maaaring mahal ang pagpapatupad nito.
• Basis encoding, na nag-e-encode ng integer na $k$ sa pamamagitan ng paghahanda ng kaukulang basis state na $|k\rangle$.
• Angle encoding, na nagtatakda ng bawat numero sa data bilang rotation angle sa isang parameterized circuit.

Ang pinakamainam na approach ay nakasalalay sa mga detalye ng iyong application. Sa mga kasalukuyang quantum computer, gayunpaman, madalas na gumagamit tayo ng angle-encoding circuit tulad ng 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")

Tingnan ang Data encoding circuits sa circuit library API documentation.

Time-evolution circuits

Ang mga circuit na ito ay nagsi-simulate ng quantum state na nagbabago sa paglipas ng panahon. Gamitin ang mga time-evolution circuit para imbestigahan ang mga pisikal na epekto tulad ng paglipat ng init o phase transitions sa isang sistema. Ang mga time-evolution circuit ay pangunahing building block din ng chemistry wave functions (tulad ng unitary coupled-cluster trial states) at ng QAOA algorithm na ginagamit natin para sa mga optimization problem.

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

Basahin ang PauliEvolutionGate API documentation.

Benchmarking at complexity-theory circuits

Ang mga benchmarking circuit ay nagbibigay sa atin ng ideya kung gaano kahusay ang aktwal na pagganap ng ating hardware, at ang mga complexity-theory circuit ay tumutulong sa atin na maunawaan kung gaano kahirap ang mga problemang nais nating lutasin.

Halimbawa, ang "quantum volume" benchmark ay sumusukat kung gaano katumpak na nagpapatupad ang isang quantum computer ng isang uri ng random quantum circuit. Tumataas ang score ng quantum computer habang lumalaki ang circuit na maaaring patakbuhin nito nang maaasahan. Isinasaalang-alang nito ang lahat ng aspeto ng computer, kasama na ang bilang ng qubit, fidelity ng instruksyon, koneksyon ng qubit, at ang software stack na nagta-transpile at nagpo-post-process ng mga resulta. Basahin ang higit pa tungkol sa quantum volume sa orihinal na quantum volume paper.

Ang sumusunod na code ay nagpapakita ng halimbawa ng quantum volume circuit na ginawa sa Qiskit na tumatakbo sa apat na qubit (ang mga unitary block ay randomized na two-qubit gate).

from qiskit.circuit.library import quantum_volume

quantum_volume(4).draw("mpl")

Kasama rin sa circuit library ang mga circuit na pinaniniwalaang mahirap i-simulate nang klasikal, tulad ng instantaneous quantum polynomial (iqp) circuits. Ang mga circuit na ito ay naglalagay ng ilang diagonal gate (sa computational basis) sa pagitan ng mga bloke ng Hadamard gate.

Kasama rin sa ibang circuit ang grover_operator para gamitin sa Grover's algorithm, at ang fourier_checking circuit para sa Fourier checking problem. Tingnan ang mga circuit na ito sa Particular quantum circuits sa circuit library API documentation.

Arithmetic circuits

Ang mga arithmetic operation ay mga klasikal na function, tulad ng pagdaragdag ng mga integer at mga bit-wise na operasyon. Ang mga ito ay maaaring maging kapaki-pakinabang sa mga algorithm tulad ng amplitude estimation para sa mga aplikasyon sa finance, at sa mga algorithm tulad ng HHL algorithm, na naglulutas ng mga linear system ng equations.

Bilang halimbawa, subukan nating magdagdag ng dalawang three-bit na numero gamit ang "ripple-carry" circuit para magsagawa ng in-place addition (FullAdderGate). Ang adder na ito ay nagdadagdag ng dalawang numero (tatawagan natin silang "A" at "B") at isinusulat ang resulta sa register na naghahawak ng B. Sa sumusunod na halimbawa, A=2 at 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")

Ang pag-simulate ng circuit ay nagpapakita na nagla-labas ito ng 5 para sa lahat ng 1024 shots (ibig sabihin, nasusukat na may probabilidad na 1.0).

from qiskit.primitives import StatevectorSampler

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

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

Count data:
 {5: 1024}

Tingnan ang Arithmetic sa circuit library API documentation.

Susunod na hakbang

Mga Rekomendasyon

• Alamin ang mga advanced na paraan ng paggawa ng circuit sa paksa ng Construct circuits.
• Tingnan ang halimbawa ng paggamit ng mga circuit sa tutorial na Grover's Algorithm.
• Suriin ang circuit library API reference.