Gumawa ng mga Circuit

Mga bersyon ng package

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

qiskit[all]~=2.3.0

Tinitingnan ng pahinang ito nang mas malalim ang klase na QuantumCircuit sa Qiskit SDK, kasama ang ilang mas advanced na pamamaraan na maaari mong gamitin para gumawa ng mga quantum circuit.

Ano ang quantum circuit?

Ang isang simpleng quantum circuit ay isang koleksyon ng mga qubit at isang listahan ng mga instruksyon na kumikilos sa mga qubit na iyon. Para ipakita, ginagawa ng sumusunod na cell ang isang bagong circuit na may dalawang bagong qubit, pagkatapos ay ipinapakita ang attribute na qubits ng circuit, na isang listahan ng mga Qubit mula sa pinakamaliit na significant bit na $q_0$ hanggang sa pinakamalaking significant bit na $q_n$.

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

from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.qubits

[<Qubit register=(2, "q"), index=0>, <Qubit register=(2, "q"), index=1>]

Maraming QuantumRegister at ClassicalRegister na object ang maaaring pagsamahin para gumawa ng circuit. Ang bawat QuantumRegister at ClassicalRegister ay maaari ring pangalanan.

from qiskit.circuit import QuantumRegister, ClassicalRegister

qr1 = QuantumRegister(2, "qreg1")  # Create a QuantumRegister with 2 qubits
qr2 = QuantumRegister(1, "qreg2")  # Create a QuantumRegister with 1 qubit
cr1 = ClassicalRegister(3, "creg1")  # Create a ClassicalRegister with 3 cbits

combined_circ = QuantumCircuit(
    qr1, qr2, cr1
)  # Create a quantum circuit with 2 QuantumRegisters and 1 ClassicalRegister
combined_circ.qubits

[<Qubit register=(2, "qreg1"), index=0>,
 <Qubit register=(2, "qreg1"), index=1>,
 <Qubit register=(1, "qreg2"), index=0>]

Mahahanap mo ang index at register ng isang qubit sa pamamagitan ng paggamit ng pamamaraang find_bit ng circuit at ng mga attribute nito.

desired_qubit = qr2[0]  # Qubit 0 of register 'qreg2'

print("Index:", combined_circ.find_bit(desired_qubit).index)
print("Register:", combined_circ.find_bit(desired_qubit).registers)

Index: 2
Register: [(QuantumRegister(1, 'qreg2'), 0)]

Ang pagdaragdag ng instruksyon sa circuit ay nagdadagdag ng instruksyon sa attribute na data ng circuit. Ipinapakita ng output ng sumusunod na cell na ang data ay isang listahan ng mga object na CircuitInstruction, na ang bawat isa ay may attribute na operation at attribute na qubits.

qc.x(0)  # Add X-gate to qubit 0
qc.data

[CircuitInstruction(operation=Instruction(name='x', num_qubits=1, num_clbits=0, params=[]), qubits=(<Qubit register=(2, "q"), index=0>,), clbits=())]

Ang pinakamadaling paraan para tingnan ang impormasyong ito ay sa pamamagitan ng pamamaraang draw, na nagbabalik ng visualization ng circuit. Tingnan ang Visualize circuits para sa iba't ibang paraan ng pagpapakita ng mga quantum circuit.

qc.draw("mpl")

Ang mga object na circuit instruction ay maaaring maglaman ng mga "definition" na circuit na naglalarawan ng instruksyon sa pamamagitan ng mas pangunahing mga instruksyon. Halimbawa, ang X-gate ay tinukoy bilang isang partikular na kaso ng U3-gate, isang mas pangkalahatang single-qubit gate.

# Draw definition circuit of 0th instruction in `qc`
qc.data[0].operation.definition.draw("mpl")

Ang mga instruksyon at circuit ay magkatulad dahil parehong naglalarawan ng mga operasyon sa mga bit at qubit, ngunit magkaiba ang kanilang mga layunin:

• Ang mga instruksyon ay itinuturing na naayos, at ang kanilang mga pamamaraan ay karaniwang nagbabalik ng mga bagong instruksyon (nang hindi binabago ang orihinal na object).
• Ang mga circuit ay idinisenyo para itayo sa maraming linya ng code, at ang mga pamamaraan ng QuantumCircuit ay madalas na binabago ang kasalukuyang object.

Ano ang circuit depth?

Ang depth() ng isang quantum circuit ay isang sukatan ng bilang ng mga "layer" ng mga quantum gate, na isinasagawa nang sabay-sabay, na kailangan para matapos ang pagkalkula na tinukoy ng circuit. Dahil ang mga quantum gate ay nangangailangan ng oras para maipatupad, ang depth ng circuit ay halos katumbas ng dami ng oras na kailangan ng quantum computer para isagawa ang circuit. Kaya, ang depth ng circuit ay isa sa mga mahalagang dami na ginagamit para sukatin kung ang isang quantum circuit ay maaaring patakbuhin sa isang device.

Ipinapakita ng natitirang bahagi ng pahinang ito kung paano manipulahin ang mga quantum circuit.

Gumawa ng mga Circuit

Ang mga pamamaraan tulad ng QuantumCircuit.h at QuantumCircuit.cx ay nagdaragdag ng mga partikular na instruksyon sa mga circuit. Para magdagdag ng mga instruksyon sa circuit nang mas pangkalahatan, gamitin ang pamamaraang append. Tinatanggap nito ang isang instruksyon at isang listahan ng mga qubit na ilalapat ang instruksyon. Tingnan ang Circuit Library API documentation para sa listahan ng mga sinusuportahang instruksyon.

from qiskit.circuit.library import HGate

qc = QuantumCircuit(1)
qc.append(
    HGate(),  # New HGate instruction
    [0],  # Apply to qubit 0
)
qc.draw("mpl")

Para pagsamahin ang dalawang circuit, gamitin ang pamamaraang compose. Tinatanggap nito ang isa pang QuantumCircuit at isang opsyonal na listahan ng mga qubit mapping.

tala

Ang pamamaraang compose ay nagbabalik ng bagong circuit at hindi binabago ang alinmang circuit na pinapatakbo nito. Para baguhin ang circuit kung saan mo tinatawag ang pamamaraang compose, gamitin ang argument na inplace=True.

qc_a = QuantumCircuit(4)
qc_a.x(0)

qc_b = QuantumCircuit(2, name="qc_b")
qc_b.y(0)
qc_b.z(1)

# compose qubits (0, 1) of qc_a to qubits (1, 3) of qc_b respectively
combined = qc_a.compose(qc_b, qubits=[1, 3])
combined.draw("mpl")

Maaari ka ring mag-compile ng mga circuit sa mga instruksyon para mapanatiling maayos ang iyong mga circuit. Maaari mong i-convert ang isang circuit sa isang instruksyon sa pamamagitan ng paggamit ng pamamaraang to_instruction, pagkatapos ay i-append ito sa isa pang circuit tulad ng sa anumang ibang instruksyon. Ang circuit na iginuhit sa sumusunod na cell ay katumbas sa functionality ng circuit na iginuhit sa nakaraang cell.

inst = qc_b.to_instruction()
qc_a.append(inst, [1, 3])
qc_a.draw("mpl")

Kung ang iyong circuit ay unitary, maaari mo itong i-convert sa isang Gate sa pamamagitan ng paggamit ng pamamaraang to_gate. Ang mga object na Gate ay mga partikular na uri ng instruksyon na may ilang karagdagang feature, tulad ng pamamaraang control, na nagdaragdag ng quantum control.

gate = qc_b.to_gate().control()
qc_a.append(gate, [0, 1, 3])
qc_a.draw("mpl")

Para makita kung ano ang nangyayari, maaari mong gamitin ang pamamaraang decompose para palawakin ang bawat instruksyon sa kahulugan nito.

tala

Ang pamamaraang decompose ay nagbabalik ng bagong circuit at hindi binabago ang circuit na pinapatakbo nito.

qc_a.decompose().draw("mpl")

Sukatin ang mga Qubit

Ginagamit ang mga measurement para sampulin ang mga estado ng mga indibidwal na qubit at ilipat ang mga resulta sa isang classical register. Tandaan na kung nagsusumite ka ng mga circuit sa isang primitive na Sampler, kailangan ang mga measurement. Gayunpaman, ang mga circuit na isinumite sa isang primitive na Estimator ay hindi dapat maglaman ng mga measurement.

Maaaring sukatin ang mga qubit gamit ang tatlong pamamaraan: measure, measure_all at measure_active. Para malaman kung paano i-visualize ang mga nasukat na resulta, tingnan ang pahina na Visualize results.

1. QuantumCircuit.measure : sinusukat ang bawat qubit sa unang argument sa classical bit na ibinigay bilang pangalawang argument. Pinapayagan ng pamamaraang ito ang buong kontrol kung saan itatago ang resulta ng measurement.

2. QuantumCircuit.measure_all : walang tinatanggap na argument at maaaring gamitin para sa mga quantum circuit na walang paunang natukoy na mga classical bit. Gumagawa ito ng mga classical wire at iniimbak ang mga resulta ng measurement sa pagkakasunod-sunod. Halimbawa, ang measurement ng qubit na $q_i$ ay iniimbak sa cbit na $meas_i$). Nagdaragdag din ito ng barrier bago ang measurement.

3. QuantumCircuit.measure_active : katulad ng measure_all, ngunit sinusukat lamang ang mga qubit na may mga operasyon.

qc1 = QuantumCircuit(2, 2)
qc1.measure(0, 1)
qc1.draw("mpl", cregbundle=False)

qc2 = QuantumCircuit(2)
qc2.measure_all()
qc2.draw("mpl", cregbundle=False)

qc3 = QuantumCircuit(2)
qc3.x(1)
qc3.measure_active()
qc3.draw("mpl", cregbundle=False)

Mga parameterized na circuit

Maraming near-term quantum algorithm ang nangangailangan ng pagpapatakbo ng maraming variation ng isang quantum circuit. Dahil ang pagbuo at pag-optimize ng malalaking circuit ay maaaring mahal sa computational, sinusuportahan ng Qiskit ang mga parameterized na circuit. Ang mga circuit na ito ay may mga hindi natukoy na parameter, at hindi kailangang tukuyin ang kanilang mga halaga hanggang sa sandali bago isagawa ang circuit. Nagbibigay-daan ito sa iyo na ilipat ang pagbuo at pag-optimize ng circuit labas sa pangunahing program loop. Gumagawa at nagpapakita ang sumusunod na cell ng isang parameterized na circuit.

from qiskit.transpiler import generate_preset_pass_manager
from qiskit.circuit import Parameter

angle = Parameter("angle")  # undefined number

# Create and optimize circuit once
qc = QuantumCircuit(1)
qc.rx(angle, 0)
qc = generate_preset_pass_manager(
    optimization_level=3, basis_gates=["u", "cx"]
).run(qc)

qc.draw("mpl")

Gumagawa ang sumusunod na cell ng maraming variation ng circuit na ito at ipinapakita ang isa sa mga variation.

circuits = []
for value in range(100):
    circuits.append(qc.assign_parameters({angle: value}))

circuits[0].draw("mpl")

Mahahanap mo ang listahan ng mga hindi natukoy na parameter ng isang circuit sa attribute nitong parameters.

qc.parameters

ParameterView([Parameter(angle)])

Palitan ang pangalan ng parameter

Bilang default, ang mga pangalan ng parameter para sa isang parameterized na circuit ay may prefix na x— halimbawa, x[0]. Maaari mong palitan ang mga pangalan pagkatapos nilang matukoy, tulad ng ipinapakita sa sumusunod na halimbawa.

from qiskit.circuit.library import z_feature_map
from qiskit.circuit import ParameterVector

# Define a parameterized circuit with default names
# For example, x[0]
circuit = z_feature_map(2)

# Set new parameter names
# They will now be prefixed by `hi` instead
# For example, hi[0]
training_params = ParameterVector("hi", 2)

# Assign parameter names to the quantum circuit
circuit = circuit.assign_parameters(parameters=training_params)

Nakalimutan ang pangalan ng pamamaraan? Subukang tanungin ang Qiskit Code Assistant.

Mga susunod na hakbang

Mga rekomendasyon

• Para matuto tungkol sa mga near-term quantum algorithm, kunin ang kursong Variational algorithm design.
• Tingnan ang isang halimbawa ng paggamit ng mga circuit sa tutorial na Grover's Algorithm.
• Magtrabaho sa mga simpleng circuit gamit ang IBM Quantum Composer.