Skip to main content
IBM Quantum Platform

양자 알고리즘: 위상 추정

Note

우에다 켄토 (2024년 5월 15일)

이 노트북은 양자 푸리에 변환(QFT)과 양자 위상 추정(QPE)의 기본 개념과 구현을 제공합니다.

원본 강의의 PDF를 다운로드하세요. 일부 코드 스니펫은 정적 이미지이므로 더 이상 사용되지 않을 수 있습니다.

이 실험을 실행하는 데 걸리는 대략적인 QPU 시간은 7초입니다.

1. 소개

양자 푸리에 변환(QFT)

양자 푸리에 변환은 고전적인 이산 푸리에 변환에 대응하는 양자 변환입니다. 이는 양자 상태에 적용되는 선형 변환으로, 계산 기저를 푸리에 기저 표현에 매핑합니다. QFT는 많은 양자 알고리즘에서 핵심적인 역할을 하며, 양자 상태에서 주기성 정보를 추출하는 효율적인 방법을 제공합니다. QFT는 하다마드 게이트 및 제어 위상 게이트( NN 큐비트용)와 같은 양자 게이트로 O(N2)O(N^2) 연산을 구현하여 기존 푸리에 변환보다 기하급수적으로 빠른 속도를 구현할 수 있습니다.

  • 응용 분야 : 큰 정수를 인수분해하는 쇼의 알고리즘과 이산 로그와 같은 양자 알고리즘의 기초가 되는 부분입니다.

양자 위상 추정(QPE)

양자 위상 추정은 단일 연산자의 고유 벡터와 관련된 위상을 추정하는 데 사용되는 양자 알고리즘입니다. 이 알고리즘은 양자 상태의 추상적인 수학적 특성과 계산 응용 프로그램 사이의 가교 역할을 합니다.

  • 응용 분야 : 일차 행렬의 고유값 찾기, 양자 시스템 시뮬레이션과 같은 문제를 해결할 수 있습니다.

QFT와 QPE는 함께 기존 컴퓨터로는 해결할 수 없는 문제를 해결하는 많은 양자 알고리즘의 필수적인 근간을 형성합니다. 이 노트가 끝나면 이러한 기술이 어떻게 구현되는지 이해하게 될 것입니다.

2. 양자 푸리에 변환(QFT)의 기초

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit.quantum_info import Statevector
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Sampler

from numpy import pi

이산 푸리에 변환과 유사하게, QFT는 NN 큐비트에 대해 양자 상태 ∣X⟩=∑j=0N−1xj∣j⟩\vert X\rangle = \sum_{j=0}^{N-1} x_j \vert j \rangle 에 작용하여 이를 양자 상태 ∣Y⟩=∑k=0N−1yk∣k⟩\vert Y\rangle = \sum_{k=0}^{N-1} y_k \vert k \rangle 에 매핑합니다.

QFTN:∣j⟩↦1N∑k=0N−1ωNjk∣k⟩QFT_{N}: \vert j \rangle \mapsto \frac{1}{\sqrt{N}}\sum_{k=0}^{N-1}\omega_N^{jk} \vert k \rangle

여기서 ωNjk=e2πijkN\omega_N^{jk} = e^{2\pi i \frac{jk}{N}}.

또는 단일 행렬 표현:

UQFT=1N∑j=0N−1∑k=0N−1ωNjk∣k⟩⟨j∣U_{QFT} = \frac{1}{\sqrt{N}} \sum_{j=0}^{N-1} \sum_{k=0}^{N-1} \omega_N^{jk} \vert k \rangle \langle j \vert

2.1. 직관

양자 푸리에 변환(QFT)은 계산 기저와 푸리에 기저라는 두 기저 사이에서 변환합니다. 그렇다면 이 맥락에서 푸리에 기초는 무엇을 의미할까요? 함수 f(x)f(x) 의 푸리에 변환 F(ω)F(\omega) 은 f(x)f(x) 을 주파수 ω\omega 의 사인 곡선 함수로 컨볼루션하는 것을 설명한다는 것을 기억하실 것입니다. 쉽게 설명하자면, 푸리에 변환은 사인 함수(또는 코사인 함수)에서 f(x)f(x) 함수를 만들기 위해 필요한 각 주파수 ω\omega 의 양을 설명하는 함수입니다. 이 맥락에서 QFT가 무엇을 의미하는지 더 잘 이해하려면 네 개의 큐비트를 사용하여 2진수로 인코딩된 숫자를 보여주는 아래의 단계별 이미지를 고려해 보세요:

계산 기반에서는 ∣0⟩|0\rangle 및 ∣1⟩|1\rangle 상태를 사용하여 숫자를 2진수로 저장합니다.

가장 왼쪽 큐비트는 숫자가 1씩 증가할 때마다, 그다음 큐비트는 2씩 증가할 때마다, 세 번째 큐비트는 4씩 증가할 때마다 뒤집히는 식으로 서로 다른 큐비트가 바뀌는 빈도에 주목하세요.

이러한 상태에 양자 푸리에 변환을 적용하면 다음과 같이 매핑됩니다

∣State in Computational Basis⟩→QFT∣State in Fourier Basis⟩|\text{State in Computational Basis}\rangle \quad \xrightarrow[]{\text{QFT}} \quad |\text{State in Fourier Basis}\rangle QFT∣x⟩=∣x~⟩\text{QFT}|x\rangle = |\widetilde{x}\rangle

(물결표(~)를 사용하여 푸리에 단위로 상태를 표시하는 경우가 많습니다).

푸리에 단위에서는 Z축을 중심으로 다양한 회전을 사용하여 숫자를 저장합니다:

IFRAME

저장하려는 숫자는 각 큐비트가 Z축을 중심으로 회전하는 각도를 나타냅니다. 상태 ∣0~⟩|\widetilde{0}\rangle 에서 모든 큐비트는 상태 ∣+⟩|{+}\rangle 에 있습니다. 위의 예에서 볼 수 있듯이, 4개의 큐비트에 상태 ∣5~⟩|\widetilde{5}\rangle 를 인코딩하기 위해 가장 왼쪽 큐비트를 52n=516\tfrac{5}{2^n} = \tfrac{5}{16} 풀턴( 516×2π\tfrac{5}{16}\times 2\pi 라디안)으로 회전시켰습니다. 다음 큐비트는 이 각도의 두 배( 1016×2π\tfrac{10}{16}\times 2\pi 라디안 또는 10/1610/16 풀턴)로 돌리고, 그 다음 큐비트에 대해 이 각도를 두 배로 돌리는 방식으로 진행됩니다.

다시 한 번, 각 큐비트가 변경되는 빈도에 주목하세요. 이 경우 가장 왼쪽 큐비트(qubit 0)의 주파수가 가장 낮고, 가장 오른쪽이 가장 높습니다.

2.2 예시: 1-큐비트 양자장 이론

N=21=2N = 2^1 = 2 의 경우를 고려해 보겠습니다.

단일 행렬을 작성할 수 있습니다:

UQFT=12∑j=01∑k=01ω2jk∣k⟩⟨j∣=12(ω20∣0⟩⟨0∣+ω20∣0⟩⟨1∣+ω20∣1⟩⟨0∣+ω21∣1⟩⟨1∣)=12(∣0⟩⟨0∣+∣0⟩⟨1∣+∣1⟩⟨0∣−∣1⟩⟨1∣)=H\begin{aligned} U_{QFT} & = \frac{1}{\sqrt{2}} \sum_{j=0}^{1} \sum_{k=0}^{1} \omega_2^{jk} \vert k \rangle \langle j \vert \\ & = \frac{1}{\sqrt{2}} (\omega_2^{0} \vert 0 \rangle \langle 0 \vert + \omega_2^{0} \vert 0 \rangle \langle 1 \vert + \omega_2^{0} \vert 1 \rangle \langle 0 \vert + \omega_2^{1} \vert 1 \rangle \langle 1 \vert) \\ & = \frac{1}{\sqrt{2}} (\vert 0 \rangle \langle 0 \vert + \vert 0 \rangle \langle 1 \vert + \vert 1 \rangle \langle 0 \vert - \vert 1 \rangle \langle 1 \vert) \\ & = H \end{aligned}

이 작업은 하다마드 게이트( HH )를 적용한 결과입니다.

2.3 QFT의 제품 표현

상태 ∣x⟩=∣x1…xn⟩\vert x \rangle = \vert x_1\ldots x_n \rangle 에 대해 작동하는 N=2nN = 2^n, QFTNQFT_{N} 에 대한 변환을 일반화해 보겠습니다.

QFTN∣x⟩=1N∑y=0N−1ωNxy∣y⟩=1N∑y=0N−1e2πixy/2n∣y⟩ since ωNxy=e2πixyN and N=2n=1N∑y=0N−1e2πi(∑k=1nyk/2k)x∣y1…yn⟩ rewriting in fractional binary notation y=y1…yn,y/2n=∑k=1nyk/2k=1N∑y=0N−1∏k=1ne2πixyk/2k∣y1…yn⟩ after expanding the exponential of a sum to a product of exponentials,=1N⨂k=1n(∣0⟩+e2πix/2k∣1⟩) after rearranging the sum and products, and expanding∑y=0N−1=∑y1=01∑y2=01…∑yn=01=1N(∣0⟩+e2πi2x∣1⟩)⊗(∣0⟩+e2πi22x∣1⟩)⊗…⊗(∣0⟩+e2πi2n−1x∣1⟩)⊗(∣0⟩+e2πi2nx∣1⟩)\begin{aligned} QFT_N\vert x \rangle & = \frac{1}{\sqrt{N}} \sum_{y=0}^{N-1}\omega_N^{xy} \vert y \rangle \\ & = \frac{1}{\sqrt{N}} \sum_{y=0}^{N-1} e^{2 \pi i xy / 2^n} \vert y \rangle ~\text{since}\: \omega_N^{xy} = e^{2\pi i \frac{xy}{N}} \:\text{and}\: N = 2^n \\ & = \frac{1}{\sqrt{N}} \sum_{y=0}^{N-1} e^{2 \pi i \left(\sum_{k=1}^n y_k/2^k\right) x} \vert y_1 \ldots y_n \rangle \:\text{rewriting in fractional binary notation}\: y = y_1\ldots y_n, y/2^n = \sum_{k=1}^n y_k/2^k \\ & = \frac{1}{\sqrt{N}} \sum_{y=0}^{N-1} \prod_{k=1}^n e^{2 \pi i x y_k/2^k } \vert y_1 \ldots y_n \rangle \:\text{after expanding the exponential of a sum to a product of exponentials,} \\ & = \frac{1}{\sqrt{N}} \bigotimes_{k=1}^n \left(\vert0\rangle + e^{2 \pi i x /2^k } \vert1\rangle \right) \:\text{after rearranging the sum and products, and expanding} \sum_{y=0}^{N-1} = \sum_{y_1=0}^{1}\sum_{y_2=0}^{1}\ldots\sum_{y_n=0}^{1} \\ & = \frac{1}{\sqrt{N}} \left(\vert0\rangle + e^{\frac{2\pi i}{2}x} \vert1\rangle\right) \otimes \left(\vert0\rangle + e^{\frac{2\pi i}{2^2}x} \vert1\rangle\right) \otimes \ldots \otimes \left(\vert0\rangle + e^{\frac{2\pi i}{2^{n-1}}x} \vert1\rangle\right) \otimes \left(\vert0\rangle + e^{\frac{2\pi i}{2^n}x} \vert1\rangle\right) \end{aligned}

2.4 예시: 3 큐비트 양자장 이론(QFT) 회로 구성

위의 설명만으로는 QFT 회로를 구성하는 방법이 명확하지 않을 수 있습니다. 현재로서는 3개의 큐비트가 서로 다른 '속도'로 진화하는 단계를 가질 것으로 예상하고 있습니다. 이것이 어떻게 회로로 변환되는지 정확히 이해하는 것은 독자의 몫으로 남겨져 있습니다. 강의 PDF에는 여러 가지 도표와 예제가 있습니다. 추가 리소스에는 양자 알고리즘의 기초 과정의 이 강의가 포함되어 있습니다.

저희는 시뮬레이터만을 사용하여 QFT를 시연할 것이며, 따라서 양자 위상 추정으로 넘어갈 때까지 키스킷 패턴 프레임워크는 사용하지 않을 것입니다.

# Prepare for 3 qubits circuit
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
qc = QuantumCircuit(qr, cr)
qc.h(2)
qc.cp(pi / 2, 1, 2)  # Controlled-phase gate from qubit 1 to qubit 2
qc.cp(pi / 4, 0, 2)  # Controlled-phase gate from qubit 0 to qubit 2
qc.draw(output="mpl")

Output:

Output of the previous code cell 
qc.h(1)
qc.cp(pi / 2, 0, 1)  # Controlled-phase gate from qubit 0 to qubit 1

qc.draw(output="mpl")

Output:

Output of the previous code cell 
qc.h(0)

qc.draw(output="mpl")

Output:

Output of the previous code cell 
qc.swap(0, 2)

qc.draw(output="mpl")

Output:

Output of the previous code cell

예를 들어 ∣5⟩|5\rangle 에 QFT를 적용해 보겠습니다.

먼저 정수 5의 이진 표기법을 확인하고 상태 5를 인코딩하는 회로를 생성합니다:

bin(5)

Output:

'0b101'

qc = QuantumCircuit(3)

qc.x(0)
qc.x(2)
qc.draw(output="mpl")

Output:

Output of the previous code cell

Aer 시뮬레이터를 사용하여 양자 상태를 확인합니다:

statevector = Statevector(qc)
plot_bloch_multivector(statevector)

Output:

Output of the previous code cell

마지막으로 QFT를 추가하고 큐비트의 최종 상태를 확인합니다:

qc.h(2)
qc.cp(pi / 2, 1, 2)
qc.cp(pi / 4, 0, 2)

qc.h(1)
qc.cp(pi / 2, 0, 1)

qc.h(0)

qc.swap(0, 2)

qc.draw(output="mpl")

Output:

Output of the previous code cell 
statevector = Statevector(qc)
plot_bloch_multivector(statevector)

Output:

Output of the previous code cell

QFT 기능이 올바르게 작동하는 것을 확인할 수 있습니다. 큐비트 0은 58\tfrac{5}{8} 풀턴, 큐비트 1은 108\tfrac{10}{8} 풀턴(풀턴의 14\tfrac{1}{4} 에 해당), 큐비트 2는 208\tfrac{20}{8} 풀턴(풀턴의 12\tfrac{1}{2} 에 해당)으로 회전했습니다.

2.5 연습: QFT

(1) 4 큐비트의 QFT를 구현합니다.

##your code goes here##

(2) ∣14⟩|14\rangle 에 QFT를 적용하고 블로흐 구를 사용하여 상태벡터를 시뮬레이션하고 플롯합니다.

##your code goes here##

연습문제 해답: 양자장론

(1)

qr = QuantumRegister(4)
cr = ClassicalRegister(4)
qc = QuantumCircuit(qr, cr)

qc.h(3)
qc.cp(pi / 2, 2, 3)
qc.cp(pi / 4, 1, 3)
qc.cp(pi / 8, 0, 3)

qc.h(2)
qc.cp(pi / 2, 1, 2)
qc.cp(pi / 4, 0, 2)

qc.h(1)
qc.cp(pi / 2, 0, 1)

qc.h(0)

qc.swap(0, 3)
qc.swap(1, 2)

qc.draw(output="mpl")

Output:

Output of the previous code cell

(2)

bin(14)

Output:

'0b1110'

qc = QuantumCircuit(4)

qc.x(1)
qc.x(2)
qc.x(3)
qc.draw("mpl")

Output:

Output of the previous code cell 
qc.h(3)
qc.cp(pi / 2, 2, 3)
qc.cp(pi / 4, 1, 3)
qc.cp(pi / 8, 0, 3)

qc.h(2)
qc.cp(pi / 2, 1, 2)
qc.cp(pi / 4, 0, 2)

qc.h(1)
qc.cp(pi / 2, 0, 1)
qc.h(0)

qc.swap(0, 3)
qc.swap(1, 2)

qc.draw(output="mpl")

Output:

Output of the previous code cell 
statevector = Statevector(qc)
plot_bloch_multivector(statevector)

Output:

Output of the previous code cell

3. 양자 위상 추정(QPE)의 기초

단일 연산 UU 이 주어지면 QPE는 UU 이 단일 연산이므로 U∣ψ⟩=e2πiθ∣ψ⟩U\vert\psi \rangle =e^{\boldsymbol{2\pi i} \theta }|\psi \rangle 에서 θ\theta 을 추정하며, 모든 고유값은 1의 규범을 갖습니다.

3.1 절차

1. 설정

∣ψ⟩\vert\psi\rangle 는 하나의 큐비트 레지스터 세트에 있습니다. nn 큐비트 추가 세트는 값 2nθ2^n\theta 을 저장할 카운팅 레지스터를 형성합니다:

∣ψ0⟩=∣0⟩⊗n∣ψ⟩|\psi_0\rangle = \lvert 0 \rangle^{\otimes n} \lvert \psi \rangle

2. 중첩

계수 레지스터에 nn -비트 하다마드 게이트 연산 H⊗nH^{\otimes n} 을 적용합니다:

∣ψ1⟩=12n2(∣0⟩+∣1⟩)⊗n∣ψ⟩|\psi_1\rangle = {\frac {1}{2^{\frac {n}{2}}}}\left(|0\rangle +|1\rangle \right)^{\otimes n} \lvert \psi \rangle

3. 통제된 단일 작업

해당 제어 비트가 ∣1⟩|1\rangle 인 경우에만 대상 레지스터에 단항 연산자 UU 를 적용하는 제어 단항 CUCU 을 도입해야 합니다. UU 은 고유 벡터 ∣ψ⟩|\psi\rangle 를 갖는 단일 연산자이므로 U∣ψ⟩=e2πiθ∣ψ⟩U|\psi \rangle =e^{\boldsymbol{2\pi i} \theta }|\psi \rangle 이 됩니다:

U2j∣ψ⟩=U2j−1U∣ψ⟩=U2j−1e2πiθ∣ψ⟩=⋯=e2πi2jθ∣ψ⟩U^{2^{j}}|\psi \rangle =U^{2^{j}-1}U|\psi \rangle =U^{2^{j}-1}e^{2\pi i\theta }|\psi \rangle =\cdots =e^{2\pi i2^{j}\theta }|\psi \rangle

3.2 예시: T-게이트 QPE

TT 게이트를 QPE의 예로 사용하여 θ\theta 의 위상을 추정해 보겠습니다.

T∣1⟩=(100eiπ4)(01)=eiπ4∣1⟩T|1\rangle = \begin{pmatrix} 1 & 0\\ 0 & e^\frac{i\pi}{4}\\ \end{pmatrix} \begin{pmatrix} 0\\ 1\\ \end{pmatrix} = e^\frac{i\pi}{4}|1\rangle

찾을 수 있을 것으로 기대합니다:

θ=18\theta = \frac{1}{8}

여기서,

T∣1⟩=e2iπθ∣1⟩T|1\rangle = e^{2i\pi\theta}|1\rangle

TT 게이트의 고유 벡터를 XX 게이트를 적용하여 ∣ψ⟩=∣1⟩\vert\psi\rangle = \vert1\rangle 를 초기화합니다:

qpe = QuantumCircuit(4, 3)
qpe.x(3)
qpe.draw(output="mpl")

Output:

Output of the previous code cell

다음으로 하다마드 게이트를 카운팅 큐비트에 적용합니다:

for qubit in range(3):
    qpe.h(qubit)
qpe.draw(output="mpl")

Output:

Output of the previous code cell

당사는 통제된 단일 작업을 수행합니다:

repetitions = 1
for counting_qubit in range(3):
    for i in range(repetitions):
        qpe.cp(pi / 4, counting_qubit, 3)  # This is C-U
    repetitions *= 2
qpe.draw(output="mpl")

Output:

Output of the previous code cell

역 양자 푸리에 변환을 적용하여 계수 레지스터의 상태를 변환한 다음 계수 레지스터를 측정합니다:

from qiskit.circuit.library import QFT
# Apply inverse QFT
qpe.append(QFT(3, inverse=True), [0, 1, 2])
qpe.draw(output="mpl")

Output:

Output of the previous code cell 
for n in range(3):
    qpe.measure(n, n)
qpe.draw(output="mpl")

Output:

Output of the previous code cell

Aer 시뮬레이터를 사용하여 시뮬레이션할 수 있습니다:

aer_sim = AerSimulator()
shots = 2048

pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
t_qpe = pm.run(qpe)

sampler = Sampler(mode=aer_sim)
job = sampler.run([t_qpe], shots=shots)
result = job.result()
answer = result[0].data.c.get_counts()

plot_histogram(answer)

Output:

Output of the previous code cell

우리는 확실하게 하나의 결과(001)를 얻을 수 있으며, 이는 소수로 변환됩니다: 1. 이제 결과(1)를 2n2^n 으로 나누어 θ\theta 을 구해야 합니다:

θ=123=18\theta = \frac{1}{2^3} = \frac{1}{8}

Shor의 알고리즘을 사용하면 θ\theta 미지수로 회로를 만들고 θ\theta 을 구하여 숫자를 인수분해할 수 있습니다.

3.3 운동

계산에 큐비트 3개, 고유 벡터에 큐비트 1개를 사용하여 θ=1/3\theta = 1/3 을 추정합니다.

P∣1⟩=eiλ∣1⟩P|1\rangle = e^{i\lambda}|1\rangle. U∣1⟩=e2πi13∣1⟩U|1\rangle = e^{2\pi i \tfrac{1}{3}}|1\rangle 을 구현하고 싶으므로 λ=2π3\lambda = \tfrac{2 \pi}{3} 을 설정해야 합니다.

##your code goes here##

연습 문제 해설: θ=1/3\theta = 1/3

# Create and set up circuit
qpe = QuantumCircuit(4, 3)

# Apply H-Gates to counting qubits:
for qubit in range(3):
    qpe.h(qubit)

# Prepare our eigenstate |psi>:
qpe.x(3)

# Do the controlled-U operations:
angle = 2 * pi / 3
repetitions = 1
for counting_qubit in range(3):
    for i in range(repetitions):
        qpe.cp(angle, counting_qubit, 3)
    repetitions *= 2

# Do the inverse QFT:
qpe.append(QFT(3, inverse=True), [0, 1, 2])

for n in range(3):
    qpe.measure(n, n)

qpe.draw(output="mpl")

Output:

Output of the previous code cell 
aer_sim = AerSimulator()
shots = 4096

pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
t_qpe = pm.run(qpe)

sampler = Sampler(mode=aer_sim)
job = sampler.run([t_qpe], shots=shots)
result = job.result()
answer = result[0].data.c.get_counts()

plot_histogram(answer)

Output:

Output of the previous code cell

4. ‘ IBM Quantum ’ 샘플러 프리미티브를 사용한 실행

실제 양자 장치를 사용하여 QPE를 수행하고 4단계의 키스킷 패턴을 따릅니다.

  1. 문제를 퀀텀 네이티브 형식으로 매핑하기
  2. 회로 최적화
  3. 대상 회로 실행
  4. 결과 후처리
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import Sampler
# Loading your IBM Quantum® account(s)

service = QiskitRuntimeService()

4.1 1단계: 문제를 양자 회로 및 연산자로 매핑하기

qpe = QuantumCircuit(4, 3)
qpe.x(3)
for qubit in range(3):
    qpe.h(qubit)
repetitions = 1
for counting_qubit in range(3):
    for i in range(repetitions):
        qpe.cp(pi / 4, counting_qubit, 3)  # This is C-U
    repetitions *= 2
qpe.append(QFT(3, inverse=True), [0, 1, 2])
for n in range(3):
    qpe.measure(n, n)
qpe.draw(output="mpl")

Output:

Output of the previous code cell 
backend = service.least_busy(simulator=False, operational=True, min_num_qubits=4)

print(backend)

Output:

<IBMBackend('ibm_strasbourg')>

4.2 2단계: 대상 하드웨어에 최적화하기

# Transpile the circuit into basis gates executable on the hardware
pm = generate_preset_pass_manager(backend=backend, optimization_level=2)
qc_compiled = pm.run(qpe)

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

Output:

Output of the previous code cell

4.3 3단계: 대상 하드웨어에서 실행

real_sampler = Sampler(mode=backend)
job = real_sampler.run([qc_compiled], shots=1024)
job_id = job.job_id()
print("job id:", job_id)

Output:

job id: d13p4zb5z6q00087ag00

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

Output:

'DONE'

result_real = job.result()
print(result_real)

Output:

PrimitiveResult([SamplerPubResult(data=DataBin(c=BitArray(<shape=(), num_shots=1024, num_bits=3>)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan(<start='2025-06-09 22:39:00', stop='2025-06-09 22:39:00', size=1024>)])}, 'version': 2})

4.4 4단계: 결과 후처리

from qiskit.visualization import plot_histogram

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

Output:

Output of the previous code cell 
# See the version of Qiskit
import qiskit

qiskit.__version__

Output:

'2.0.2'
이 페이지가 도움이 되었습니까?
GitHub에서 버그, 오타를 보고하거나 컨텐츠를 요청하십시오.