Mga Quantum Bit, Gate, at Circuit

tala

Kifumi Numata (19 Apr 2024)

I-click ang dito para ma-download ang pdf ng orihinal na lektura. Tandaan na maaaring maging deprecated na ang ilang code snippet dahil static na imahe ang mga ito.

Ang tinatayang QPU time para patakbuhin ang eksperimentong ito ay 5 segundo.

1. Panimula

Ang mga bit, gate, at circuit ang pangunahing pundasyon ng quantum computing. Matututunan mo ang quantum computation gamit ang circuit model na gumagamit ng mga quantum bit at gate, at susuriin din natin ang superposition, measurement, at entanglement.

Sa araling ito, matututunan mo ang:

• Mga single-qubit gate
• Bloch sphere
• Superposition
• Measurement
• Mga two-qubit gate at entanglement state

Sa katapusan ng lekturang ito, matututunan mo ang tungkol sa circuit depth, na napakahalaga para sa utility-scale quantum computing.

2. Computation bilang isang diagram

Kapag gumagamit ng mga qubit o bit, kailangan nating manipulahin ang mga ito para ma-convert ang mga input na mayroon tayo sa mga output na kailangan natin. Para sa mga pinakasimpleng programa na may kakaunting bit, kapaki-pakinabang na ipakita ang prosesong ito sa pamamagitan ng isang diagram na tinatawag na circuit diagram.

Ang figure sa ibabang-kaliwa ay isang halimbawa ng classical circuit, at ang figure sa ibabang-kanan ay isang halimbawa ng quantum circuit. Sa parehong kaso, ang mga input ay nasa kaliwa at ang mga output ay nasa kanan, habang ang mga operasyon ay kinakatawan ng mga simbolo. Ang mga simbolong ginagamit para sa mga operasyon ay tinatawag na "mga gate", kadalasan sa makasaysayang dahilan.

3. Single-qubit quantum gate

3.1 Quantum state at Bloch sphere

Ang estado ng isang qubit ay kinakatawan bilang superposition ng $|0\rangle$ at $|1\rangle$. Ang isang arbitrary na quantum state ay kinakatawan bilang

$$|\psi\rangle =\alpha|0\rangle+ \beta|1\rangle$$

kung saan ang $\alpha$ at $\beta$ ay mga complex number na nagsasatisfy ng $|\alpha|^2+|\beta|^2=1$.

Ang $|0\rangle$ at $|1\rangle$ ay mga vector sa two-dimensional complex vector space:

$$|0\rangle = \begin{pmatrix} 1 \\0 \end{pmatrix}, |1\rangle = \begin{pmatrix} 0\\1 \end{pmatrix}$$

Kaya naman, ang isang arbitrary na quantum state ay maaari ring ipahayag bilang

$$|\psi\rangle = \alpha\begin{pmatrix} 1 \\ 0 \end{pmatrix} + \beta\begin{pmatrix}0\\ 1 \end{pmatrix} = \begin{pmatrix} \alpha \\ \beta \end{pmatrix}$$

Mula dito, makikita natin na ang estado ng isang quantum bit ay isang unit vector sa isang two-dimensional complex inner product space na may orthonormal basis na $|0\rangle$ at $|1\rangle$. Naka-normalize ito sa 1.

$$\langle\psi|\psi\rangle = \begin{pmatrix} \alpha^* & \beta^* \end{pmatrix} \begin{pmatrix} \alpha \\ \beta \end{pmatrix} = 1$$

Ang |\psi\rangle =\begin\{pmatrix\} \alpha \\ \beta \end\{pmatrix\} ay tinatawag din na statevector.

Ang isang single-qubit quantum state ay maaari ring ipahayag bilang

$$|\psi\rangle =\cos\frac{\theta}{2}|0\rangle+e^{i\varphi}\sin\frac{\theta}{2}|1\rangle =\left( \begin{pmatrix} \cos\frac{\theta}{2}\\ e^{i\varphi}\sin\frac{\theta}{2} \end{pmatrix}\right)$$

kung saan ang $\theta$ at $\varphi$ ay ang mga anggulo ng Bloch sphere sa sumusunod na figure.

Sa mga susunod na code cell, gagawa tayo ng mga pangunahing kalkulasyon mula sa mga bahagi sa Qiskit. Magtatayo tayo ng walang laman na circuit at pagkatapos ay magdaragdag ng mga quantum operation, tatalakayin ang mga gate at ivi-visualize ang kanilang mga epekto habang tayo'y nagpapatuloy. Maaari mong patakbuhin ang cell sa pamamagitan ng "Shift" + "Enter". I-import muna ang mga library.

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

# Import the qiskit library
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
from qiskit_ibm_runtime import Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.visualization import plot_histogram

Ihanda ang quantum circuit

Gagawa tayo at iguguhit ang isang single-qubit circuit.

# Create the single-qubit quantum circuit
qc = QuantumCircuit(1)

# Draw the circuit
qc.draw("mpl")

X gate

Ang X gate ay isang $\pi$ na pag-ikot sa paligid ng $x$ axis ng Bloch sphere. Ang pag-apply ng X gate sa $|0\rangle$ ay nagbibigay ng $|1\rangle$, at ang pag-apply ng X gate sa $|1\rangle$ ay nagbibigay ng $|0\rangle$, kaya katulad ito ng klasikal na NOT gate at kilala rin bilang bit flip. Ang matrix representation ng X gate ay nasa ibaba.

$$X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \\ \end{pmatrix}$$

qc = QuantumCircuit(1)  # Prepare the single-qubit quantum circuit

# Apply a X gate to qubit 0
qc.x(0)

# Draw the circuit
qc.draw("mpl")

Sa IBM Quantum®, ang initial state ay nakatakda sa $|0\rangle$, kaya ang quantum circuit sa itaas sa matrix representation ay

$$X|0\rangle= \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \end{pmatrix} =\begin{pmatrix} 0 \\ 1 \end{pmatrix} = |1\rangle$$

Susunod, patakbuhin natin ang circuit na ito gamit ang isang statevector simulator.

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([0.+0.j, 1.+0.j],
            dims=(2,))

Ang vertical na vector ay ipinapakita bilang row vector, na may mga complex number (ang imaginary part ay iniindeks ng $j$).

H gate

Ang Hadamard gate ay isang $\pi$ na pag-ikot sa paligid ng isang axis na nasa gitna ng $x$ at $z$ axes sa Bloch sphere. Ang pag-apply ng H gate sa $|0\rangle$ ay lumilikha ng superposition state tulad ng $\frac{|0\rangle + |1\rangle}{\sqrt{2}}$. Ang matrix representation ng H gate ay nasa ibaba.

$$H = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \\ \end{pmatrix}$$

qc = QuantumCircuit(1)  # Create the single-qubit quantum circuit

# Apply an Hadamard gate to qubit 0
qc.h(0)

# Draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([0.70710678+0.j, 0.70710678+0.j],
            dims=(2,))

Ito ay

$$H|0\rangle= \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} \begin{pmatrix} 1 \\0 \end{pmatrix} =\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix} =\begin{pmatrix} 0.707 \\ 0.707 \end{pmatrix} =\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$$

Ang superposition state na ito ay napakakaraniwan at mahalaga, kaya binibigyan ito ng sariling simbolo:

$$|+\rangle \equiv \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle).$$

Sa pag-apply ng $H$ gate sa $|0\rangle$, nakagawa tayo ng superposition ng $|0\rangle$ at $|1\rangle$ kung saan ang pagsukat sa computational basis (kasama ang z sa larawan ng Bloch sphere) ay magbibigay ng bawat estado na may pantay na probabilidad.

Estado na $|-\rangle$

Maaari mong mahulaan na mayroon ding kaugnay na estado na $|-\rangle$:

$$|-\rangle \equiv \frac{|0\rangle -|1\rangle}{\sqrt{2}}.$$

Para makuha ang estadong ito, una ay mag-apply ng X gate para makuha ang $|1\rangle$, pagkatapos ay mag-apply ng H gate.

qc = QuantumCircuit(1)  # Create the single-qubit quantum circuit

# Apply a X gate to qubit 0
qc.x(0)

# Apply an Hadamard gate to qubit 0
qc.h(0)

# draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([ 0.70710678+0.j, -0.70710678+0.j],
            dims=(2,))

Ito ay

$$H|1\rangle= \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\\ 1 & -1 \end{pmatrix} \begin{pmatrix} 0 \\\ 1 \end{pmatrix} =\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\\ -1 \end{pmatrix} =\begin{pmatrix} 0.707 \\\ -0.707 \end{pmatrix} =\frac{1}{\sqrt{2}}(|0\rangle-|1\rangle) = |-\rangle$$

Ang pag-apply ng $H$ gate sa $|1\rangle$ ay nagbubunga ng pantay na superposition ng $|0\rangle$ at $|1\rangle$, ngunit negatibo ang sign ng $|1\rangle$.

3.2 Single-qubit quantum state at unitary evolution

Ang mga aksyon ng lahat ng gate na nakita natin hanggang ngayon ay unitary, na ibig sabihin ay maaari silang katawanin ng isang unitary operator. Sa ibang salita, ang output state ay maaaring makuha sa pamamagitan ng pag-act ng unitary matrix sa initial state:

$$|\psi^{'}\rangle = U|\psi\rangle$$

Ang isang unitary matrix ay isang matrix na nagsasatisfy ng

$$U^{\dagger}U =U U^{\dagger} = I.$$

Sa mga termino ng quantum computer operation, masasabi nating ang pag-apply ng quantum gate sa qubit ay nagbabago (nag-e-evolve) ng quantum state. Kasama sa mga karaniwang single-qubit gate ang mga sumusunod.

Mga Pauli gate:

$$X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \\ \end{pmatrix} = |0\rangle \langle 1|+|1\rangle \langle 0|$$ $$Y = \begin{pmatrix} 0 & -i \\ i & 0 \\ \end{pmatrix} = -i|0\rangle \langle 1|+i|1\rangle \langle 0|$$ $$Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \\ \end{pmatrix} = |0\rangle \langle 0|-|1\rangle \langle 1|$$

kung saan ang outer product ay kinukuwenta tulad ng sumusunod:

$$|0\rangle \langle 0|= \begin{bmatrix} 1 \\ 0 \end{bmatrix} \begin{bmatrix} 1 & 0 \end{bmatrix} =\begin{bmatrix} 1 & 0 \\ 0 & 0 \\ \end{bmatrix}, \quad |1\rangle \langle 0|= \begin{bmatrix} 0 \\ 1 \end{bmatrix} \begin{bmatrix} 1 & 0 \end{bmatrix} =\begin{bmatrix} 0 & 0 \\ 1 & 0 \\ \end{bmatrix}, \quad$$ $$|0\rangle \langle 1|= \begin{bmatrix} 1 \\ 0 \end{bmatrix} \begin{bmatrix} 0 & 1 \end{bmatrix} =\begin{bmatrix} 0 & 1 \\ 0 & 0 \\ \end{bmatrix}, \quad |1\rangle \langle 1|= \begin{bmatrix} 0 \\ 1 \end{bmatrix} \begin{bmatrix} 0 & 1 \end{bmatrix} =\begin{bmatrix} 0 & 0 \\ 0 & 1 \\ \end{bmatrix}, \quad$$

Iba pang karaniwang single-qubit gate:

$$H= \frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 \\ 1 & -1 \\ \end{bmatrix},\quad S = \begin{bmatrix} 1 & 0 \\ 0 & i \\ \end{bmatrix}, \quad T = \begin{bmatrix} 1 & 0 \\ 0 & exp(i\pi/4) \\ \end{bmatrix}$$ $$R_x(\theta) = e^{-i\theta X/2} = cos\frac{\theta}{2}I - i sin \frac{\theta}{2}X = \begin{bmatrix} cos\frac{\theta}{2} & -i sin \frac{\theta}{2} \\ -i sin \frac{\theta}{2} & cos\frac{\theta}{2} \\ \end{bmatrix}$$ $$R_y(\theta) = e^{-i\theta Y/2} = cos\frac{\theta}{2}I - i sin \frac{\theta}{2}Y = \begin{bmatrix} cos\frac{\theta}{2} & - sin \frac{\theta}{2} \\ sin \frac{\theta}{2} & cos\frac{\theta}{2} \\ \end{bmatrix}$$ $$R_z(\theta) = e^{-i\theta Z/2} = cos\frac{\theta}{2}I - i sin \frac{\theta}{2}Z = \begin{bmatrix} e^{-i\theta /2} & 0 \\ 0 & e^{i\theta /2} \\ \end{bmatrix}$$

Ang kahulugan at paggamit ng mga ito ay inilarawan nang mas detalyado sa kursong Basics of Quantum Information.

Ehersisyo 1

Gamitin ang Qiskit para gumawa ng mga quantum circuit na naghahanda ng mga estado na inilarawan sa ibaba. Pagkatapos, patakbuhin ang bawat circuit gamit ang statevector simulator at ipakita ang resultang estado sa Bloch sphere. Bilang bonus, subukan mong hulaan kung ano ang magiging final state batay sa iyong intuisyon tungkol sa mga gate at rotasyon sa Bloch sphere.

(1) $XX|0\rangle$

(2) $HH|0\rangle$

(3) $HZH|0\rangle$

Tips: Ang Z gate ay maaaring gamitin sa pamamagitan ng

qc.z(0)

Solusyon:

### (1) XX|0> ###

# Create the single-qubit quantum circuit
qc = QuantumCircuit(1)  ##your code goes here##

# Add a X gate to qubit 0
qc.x(0)  ##your code goes here##

# Add a X gate to qubit 0
qc.x(0)  ##your code goes here##

# Draw a circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([1.+0.j, 0.+0.j],
            dims=(2,))

### (2) HH|0> ###
##your code goes here##
qc = QuantumCircuit(1)
qc.h(0)
qc.h(0)
qc.draw("mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([1.+0.j, 0.+0.j],
            dims=(2,))

### (3) HZH|0> ###
##your code goes here##
qc = QuantumCircuit(1)
qc.h(0)
qc.z(0)
qc.h(0)
qc.draw("mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([0.+0.j, 1.+0.j],
            dims=(2,))

3.3 Measurement

Ang measurement ay isang napakakumplikadong paksa sa teorya. Ngunit sa praktikal na paraan, ang pagsasagawa ng measurement kasama ang $z$ (tulad ng ginagawa ng lahat ng IBM® quantum computer) ay simpleng pinipilit ang estado ng qubit na $\alpha|0\rangle+\beta|1\rangle \quad (s.t.|\alpha|^2+|\beta|^2=1)$ na maging alinman sa $|0\rangle$ o $|1\rangle$, at sinisita natin ang resulta.

• Ang $|\alpha|^2$ ang probabilidad na makuha nating $|0\rangle$ kapag nasukat.
• Ang $|\beta|^2$ ang probabilidad na makuha nating $|1\rangle$ kapag nasukat.

Kaya naman, ang $\alpha$ at $\beta$ ay tinatawag na probability amplitude. (tingnan ang "Born rule")

Halimbawa, ang $\frac{\sqrt{2}}{2}|0\rangle+\frac{\sqrt{2}}{2}|1\rangle$ ay may pantay na probabilidad na maging $|0\rangle$ o $|1\rangle$ sa pagsukat. Ang $\frac{\sqrt{3}}{2}|0\rangle-\frac{1}{2}i|1\rangle$ ay may 75% na pagkakataon na maging $|0\rangle$.

Qiskit Aer Simulator

Susunod, susukat tayo ng circuit na naghahanda ng pantay na superposition na nabanggit sa itaas. Kailangan nating magdagdag ng mga measurement gate, dahil ang Qiskit Aer simulator ay nag-si-simulate ng ideal (walang noise) na quantum hardware bilang default. Tandaan: Ang Aer simulator ay maaari ring mag-apply ng noise model batay sa tunay na quantum computer. Babalik tayo sa mga noise model mamaya.

# Create a new circuit with one qubits (first argument) and one classical bits (second argument)
qc = QuantumCircuit(1, 1)
qc.h(0)
qc.measure(0, 0)  # Add the measurement gate

qc.draw(output="mpl")

Handa na tayong patakbuhin ang ating circuit sa Aer simulator. Sa halimbawang ito, gagamitin natin ang default na shots=1024, na ibig sabihin ay susukat tayo ng 1024 beses. Pagkatapos ay i-pplot natin ang mga bilang na iyon sa isang histogram.

# Run the circuit on a simulator to get the results
# Define backend
backend = AerSimulator()

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(mode=backend)
job = sampler.run([isa_qc])
result = job.result()

# Print the results
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram
plot_histogram(counts)

{'0': 521, '1': 503}

Makikita natin na ang 0 at 1 ay nasukat na may probabilidad na halos 50% bawat isa. Kahit na hindi na-simulate ang noise dito, ang mga estado ay probabilistiko pa rin. Kaya habang umaasa tayo ng humigit-kumulang 50-50 na distribusyon, bihirang makita natin ang eksaktong iyon. Tulad ng 100 na pagtapon ng barya na bihirang magbunga ng eksaktong 50 bawat panig.

4. Multi-qubit quantum gate at entanglement

4.1 Multi-qubit quantum circuit

Maaari tayong gumawa ng two-qubit quantum circuit gamit ang sumusunod na code. Mag-a-apply tayo ng H gate sa bawat qubit.

# Create the two qubits quantum circuit
qc = QuantumCircuit(2)

# Apply an H gate to qubit 0
qc.h(0)

# Apply an H gate to qubit 1
qc.h(1)

# Draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

Statevector([0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j],
            dims=(2, 2))

Tandaan: Pagkakasunod ng bits sa Qiskit

Gumagamit ang Qiskit ng Little Endian na notasyon sa pag-aayos ng mga qubit at bit, ibig sabihin ang qubit 0 ay ang pinakakanang bit sa mga bitstring. Halimbawa: ang $|01\rangle$ ay nangangahulugang ang q0 ay $|1\rangle$ at ang q1 ay $|0\rangle$. Mag-ingat dahil ang ilang literatura sa quantum computing ay gumagamit ng Big Endian na notasyon (ang qubit 0 ay ang pinakakaliwang bit), at ganoon din ang maraming literatura sa quantum mechanics.

Isa pang bagay na dapat mapansin — kapag kinakatawan ang isang quantum circuit, ang $|q_0\rangle$ ay laging nasa itaas ng circuit. Dahil dito, ang quantum state ng circuit sa itaas ay maisusulat bilang tensor product ng mga single-qubit quantum state.

$|q1\rangle \otimes|q0\rangle = (a|0\rangle+b|1\rangle) \otimes (c|0\rangle+d|1\rangle)$

$= ac|0\rangle|0\rangle+ad|0\rangle|1\rangle+bc|1\rangle|0\rangle+bd|1\rangle|1\rangle$

$= ac|00\rangle+ad|01\rangle+bc|10\rangle+bd|11\rangle$

( $|ac|^2+ |ad|^2+ |bc|^2+ |bd|^2=1$ )

Ang initial state ng Qiskit ay $|0\rangle|0\rangle=|00\rangle$, kaya sa pag-apply ng $H$ sa bawat qubit, nagbabago ito sa isang estado ng pantay na superposition.

$H|0\rangle \otimes H|0\rangle=\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle) \otimes \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle) = \frac{1}{2}(|00\rangle+|01\rangle+|10\rangle+|11\rangle)$

$$=\frac{1}{2}\left( \begin{pmatrix} 1 \\ 1 \end{pmatrix} \otimes \begin{pmatrix} 1 \\ 1 \end{pmatrix}\right) = \frac{1}{2}\begin{pmatrix} 1 \\ 1 \\ 1 \\ 1 \end{pmatrix}=\frac{1}{2}\left(\begin{pmatrix} 1 \\ 0 \\ 0 \\ 0 \end{pmatrix}+\begin{pmatrix} 0 \\ 1 \\ 0 \\ 0 \end{pmatrix}+\begin{pmatrix} 0 \\ 0 \\ 1 \\ 0 \end{pmatrix}+\begin{pmatrix} 0 \\ 0 \\ 0 \\ 1 \end{pmatrix}\right)$$

Ang panuntuan sa pagsukat ay katulad din ng sa single qubit — ang posibilidad na masukat ang $|00\rangle$ ay $|ac|^2$.

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Susunod, sukatin natin ang circuit na ito.

# Create a new circuit with two qubits (first argument) and two classical bits (second argument)
qc = QuantumCircuit(2, 2)

# Apply the gates
qc.h(0)
qc.h(1)

# Add the measurement gates
qc.measure(0, 0)  # Measure qubit 0 and save the result in bit 0
qc.measure(1, 1)  # Measure qubit 1 and save the result in bit 1

# Draw the circuit
qc.draw(output="mpl")

Gagamitin natin muli ang Aer simulator para eksperimentong mapatunayan na ang relatibong posibilidad ng lahat ng posibleng output state ay halos pantay-pantay.

# Run the circuit on a simulator to get the results
# Define backend
backend = AerSimulator()

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(mode=backend)
job = sampler.run([isa_qc])
result = job.result()

# Print the results
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram
plot_histogram(counts)

{'10': 262, '01': 246, '00': 265, '11': 251}

Gaya ng inaasahan, ang mga estado na $|00\rangle$, $|01\rangle$, $|10\rangle$, $|11\rangle$ ay nasukat na halos 25% bawat isa.

4.2 Multi-qubit quantum gates

CNOT gate

Ang CNOT ("controlled NOT" o CX) gate ay isang two-qubit gate — ang kilos nito ay kinabibilangan ng dalawang qubit nang sabay-sabay: ang control qubit at ang target qubit. Bina-flip ng CNOT ang target qubit tanging kapag ang control qubit ay nasa $|1\rangle$ na estado.

Input (target, control)	Output (target, control)
00	00
01	11
10	10
11	01

Una, i-simulate natin ang kilos ng two-qubit gate na ito kapag ang q0 at q1 ay parehong nasa $|0\rangle$, at kunin ang output statevector. Ang Qiskit syntax na ginagamit ay qc.cx(control qubit, target qubit).

# Create a circuit with two quantum registers and two classical registers
qc = QuantumCircuit(2, 2)

# Apply the CNOT (cx) gate to a |00> state.
qc.cx(0, 1)  # Here the control is set to q0 and the target is set to q1.

# Draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

Statevector([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
            dims=(2, 2))

Gaya ng inaasahan, ang pag-apply ng CNOT gate sa $|00\rangle$ ay hindi nagbago ng estado, dahil ang control qubit ay nasa $|0\rangle$ na estado. Bumalik tayo sa ating CNOT operation. Sa pagkakataong ito, mag-a-apply tayo ng CNOT gate sa $|01\rangle$ at titingnan kung ano ang mangyayari.

qc = QuantumCircuit(2, 2)

# q0=1, q1=0
qc.x(0)  # Apply a X gate to initialize q0 to 1
qc.cx(0, 1)  # Set the control bit to q0 and the target bit to q1.

# Draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

Statevector([0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
            dims=(2, 2))

Sa pag-apply ng CNOT gate, ang estado na $|01\rangle$ ay naging $|11\rangle$ na.

I-verify natin ang mga resultang ito sa pamamagitan ng pagpapatakbo ng circuit sa isang simulator.

# Add measurements
qc.measure(0, 0)
qc.measure(1, 1)

# Draw the circuit
qc.draw(output="mpl")

# Run the circuit on a simulator to get the results
# Define backend
backend = AerSimulator()

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(backend)
job = sampler.run([isa_qc])
result = job.result()

# Print the results
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram
plot_histogram(counts)

{'11': 1024}

Dapat ipakita ng mga resulta na ang $|11\rangle$ ay nasukat nang may 100% na posibilidad.

4.3 Quantum entanglement at pagpapatakbo sa tunay na quantum device

Magsimula tayo sa pagpapakilala ng isang partikular na entangled state na napakahalagang sa quantum computation, saka natin bibigyang-kahulugan ang terminong "entangled":

$$\frac{1}{\sqrt{2}}|00\rangle + \frac{1}{\sqrt{2}}|11\rangle$$

at ang estadong ito ay tinatawag na Bell state.

Ang entangled state ay isang estado na $|\psi_{AB}\rangle$ na binubuo ng mga quantum state na $|\psi_A\rangle$ at $|\psi_B\rangle$ na hindi maaaring katawanin bilang tensor product ng mga indibidwal na quantum state.

Kung ang $|\psi_{AB}\rangle$ sa ibaba ay may dalawang estado na $|\psi\rangle_A$ at $|\psi\rangle_B$:

$$|\psi_{AB}\rangle = \frac{1}{\sqrt{2}}(|00\rangle +|11\rangle) = \frac{1}{\sqrt{2}}(|0\rangle_A|0\rangle_B +|1\rangle_A|1\rangle_B)$$ $$|\psi\rangle_A = a_0|0\rangle+a_1|1\rangle$$ $$|\psi\rangle_B = b_0|0\rangle+b_1|1\rangle$$

ang tensor product ng dalawang estadong ito ay ang sumusunod

$$|\psi\rangle _A\otimes |\psi\rangle _B = a_0 b_0|00\rangle+a_0 b_1|01\rangle+a_1 b_0|10\rangle+a_1 b_1|11\rangle$$

ngunit walang mga coefficient na $a_0, a_1, b_0,$ at $b_1$ na makakatugon sa dalawang equation na ito. Samakatuwid, ang $|\psi_{AB}\rangle$ ay hindi maaaring katawanin bilang tensor product ng mga indibidwal na quantum state na $|\psi\rangle_A$ at $|\psi\rangle_B$, at nangangahulugan ito na ang $|\psi_{AB}\rangle = \frac{1}{\sqrt{2}}(|00\rangle +|11\rangle)$ ay isang entangled state.

Gawin natin ang Bell state at patakbuhin ito sa isang tunay na quantum computer. Susundin natin ang apat na hakbang sa pagsulat ng quantum program, na tinatawag na Qiskit patterns:

1. I-map ang problema sa mga quantum circuit at operator
2. I-optimize para sa target na hardware
3. Isabuhay sa target na hardware
4. I-post-process ang mga resulta

Hakbang 1. I-map ang problema sa mga quantum circuit at operator

Sa isang quantum program, ang mga quantum circuit ang katutubong format para katawanin ang mga quantum instruction. Kapag gumagawa ng circuit, kadalasan ay gagawa ka ng bagong QuantumCircuit object, tapos magdadagdag ng mga instruction nang sunod-sunod.

Ang sumusunod na code cell ay gumagawa ng circuit na nagpo-produce ng Bell state — ang partikular na two-qubit entangled state mula sa itaas.

qc = QuantumCircuit(2, 2)

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

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

qc.draw("mpl")

Hakbang 2. I-optimize para sa target na hardware

Kino-convert ng Qiskit ang mga abstract circuit sa QISA (Quantum Instruction Set Architecture) circuit na sumusunod sa mga limitasyon ng target na hardware at ino-optimize ang circuit performance. Kaya bago ang optimization, tutukuyin muna natin ang target na hardware. Kung wala kang qiskit-ibm-runtime, kailangan mo itong i-install muna. Para sa karagdagang impormasyon tungkol sa Qiskit Runtime, tingnan ang API reference.

# Install
# !pip install qiskit-ibm-runtime

Tutukuyin natin ang target na hardware.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
service.backends()

# You can specify the device
# backend = service.backend('ibm_kingston')

# You can also identify the least busy device
backend = service.least_busy(operational=True)
print("The least busy device is ", backend)

Ang pag-transpile ng circuit ay isang kumplikadong proseso. Sa madaling salita, sine-rewrite nito ang circuit sa isang logically equivalent na bersyon gamit ang "native gates" (mga gate na kaya ng isang partikular na quantum computer na isagawa) at imi-map ang mga qubit sa iyong circuit sa pinakamainam na tunay na mga qubit sa target na quantum computer. Para sa karagdagang impormasyon tungkol sa transpilation, tingnan ang dokumentasyong ito.

# Transpile the circuit into basis gates executable on the hardware
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
target_circuit = pm.run(qc)

target_circuit.draw("mpl", idle_wires=False)

Makikita mo na sa transpilation ay na-rewrite ang circuit gamit ang mga bagong gate. Para sa karagdagang impormasyon, tingnan ang dokumentasyon ng ECRGate.

Hakbang 3. Isabuhay ang target circuit

Ngayon, patakbuhin natin ang target circuit sa tunay na device.

sampler = Sampler(backend)
job_real = sampler.run([target_circuit])

job_id = job_real.job_id()
print("job id:", job_id)

Ang pagpapatakbo sa tunay na device ay maaaring mangailangan ng paghihintay sa pila, dahil ang mga quantum computer ay mahahalagang mapagkukunan at lubos na hinahangad. Ang job_id ay ginagamit para suriin ang katayuan ng pagpapatakbo at mga resulta ng trabaho sa bandang huli.

# Check the job status (replace the job id below with your own)
job_real.status(job_id)

Maaari ka ring suriin ang katayuan ng trabaho mula sa iyong IBM Quantum dashboard: https://quantum.cloud.ibm.com/workloads

# If the Notebook session got disconnected you can also check your job status by running the following code
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
job_real = service.job(job_id)  # Input your job-id between the quotations
job_real.status()

# Execute after job has successfully run
result_real = job_real.result()
print(result_real[0].data.c.get_counts())

Hakbang 4. I-post-process ang mga resulta

Sa wakas, kailangan nating i-post-process ang ating mga resulta para makagawa ng mga output sa inaasahang format, tulad ng mga value o graph.

plot_histogram(result_real[0].data.c.get_counts())

Makikita mo na ang $|00\rangle$ at $|11\rangle$ ang pinaka-madalas na naobserbahan. May ilang resulta na iba sa inaasahang data, at ito ay dahil sa ingay at qubit decoherence. Matututunan natin ang higit pa tungkol sa mga error at ingay sa mga quantum computer sa mga susunod na aralin ng kursong ito.

4.4 GHZ state

Ang konsepto ng entanglement ay maaaring palawakin sa mga sistema na may higit sa dalawang qubit. Ang GHZ state (Greenberger-Horne-Zeilinger state) ay isang maximally entangled state ng tatlo o higit pang qubit. Ang GHZ state para sa tatlong qubit ay tinukoy bilang

$$\frac{1}{\sqrt 2}(|000\rangle + |111\rangle)$$

Maaari itong gawin gamit ang sumusunod na quantum circuit.

qc = QuantumCircuit(3, 3)

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

qc.measure(0, 0)
qc.measure(1, 1)
qc.measure(2, 2)

qc.draw("mpl")

Ang "depth" ng isang quantum circuit ay isang kapaki-pakinabang at karaniwang sukatan para ilarawan ang mga quantum circuit. Maghanap ng landas sa quantum circuit, gumagalaw mula kaliwa patungo sa kanan, nagpapalit lamang ng qubit kapag sila ay konektado ng isang multi-qubit gate. Bilangin ang bilang ng mga gate sa kahabaan ng landas na iyon. Ang pinakamataas na bilang ng mga gate para sa anumang naturang landas sa isang circuit ang tinatawag na depth. Sa mga modernong maingay na quantum computer, ang mga circuit na may mababang depth ay may mas kaunting error at malamang na magbabalik ng magandang resulta. Ang mga napakalalim na circuit ay hindi.

Gamit ang QuantumCircuit.depth(), masisuri natin ang depth ng ating quantum circuit. Ang depth ng circuit sa itaas ay 4. Ang nangungunang qubit ay may tatlong gate lamang kasama ang pagsukat. Ngunit may landas mula sa nangungunang qubit pababa sa qubit 1 o qubit 2 na kinabibilangan ng isa pang CNOT gate.

qc.depth()

4

Ehersisyo 2

Ang GHZ state ng isang 8-qubit system ay

$$\frac{1}{\sqrt 2}(|00000000\rangle + |11111111\rangle)$$

Sumulat ng code para ihanda ang estadong ito gamit ang pinaka-mababang posibleng circuit. Ang depth ng pinaka-mababang quantum circuit ay 5, kasama ang mga measurement gate.

Solusyon:

# Step 1
qc = QuantumCircuit(8, 8)

##your code goes here##
qc.h(0)
qc.cx(0, 4)
qc.cx(4, 6)
qc.cx(6, 7)

qc.cx(4, 5)

qc.cx(0, 2)
qc.cx(2, 3)

qc.cx(0, 1)
qc.barrier()  # for visual separation

# measure
for i in range(8):
    qc.measure(i, i)

qc.draw("mpl")
# print(qc.depth())

print(qc.depth())

5

from qiskit.visualization import plot_histogram
# Step 2
# For this exercise, the circuit and operators are simple, so no optimizations are needed.

# Step 3
# Run the circuit on a simulator to get the results
backend = AerSimulator()

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

sampler = Sampler(mode=backend)
job = sampler.run([isa_qc], shots=1024)
result = job.result()

counts = result[0].data.c.get_counts()
print(counts)

# Step 4
# Plot the counts in a histogram

plot_histogram(counts)

{'11111111': 535, '00000000': 489}

5. Buod

Natutunan mo ang quantum computation gamit ang circuit model na gumagamit ng mga quantum bit at gate, at nasuri mo ang superposition, pagsukat, at entanglement. Natutunan mo rin ang paraan ng pagpapatakbo ng quantum circuit sa tunay na quantum device.

Sa huling ehersisyo para gumawa ng GHZ circuit, sinubukan mong bawasan ang circuit depth, na isang mahalagang salik para makakuha ng utility scale na solusyon sa isang maingay na quantum computer. Sa mga susunod na aralin ng kursong ito, matututunan mo ang tungkol sa ingay at mga pamamaraan ng error mitigation nang mas detalyado. Sa araling ito, bilang panimula, isinaalang-alang nating bawasan ang circuit depth sa isang ideal na device, ngunit sa katotohanan, kailangan nating isaalang-alang ang mga limitasyon ng tunay na device, tulad ng qubit connectivity. Matututunan mo ang higit pa tungkol dito sa mga susunod na aralin ng kursong ito.

# See the version of Qiskit
import qiskit

qiskit.__version__

'2.0.2'