참고

This page was generated from tutorials/circuits/01_circuit_basics.ipynb.

Run interactively in the IBM Quantum lab.

Circuit Basics

Here, we provide an overview of working with Qiskit. Qiskit provides the basic building blocks necessary to program quantum computers. The fundamental unit of Qiskit is the quantum circuit. A basic workflow using Qiskit consists of two stages: Build and Run. Build allows you to make different quantum circuits that represent the problem you are solving, and Run that allows you to run them on different backends. After the jobs have been run, the data is collected and postprocessed depending on the desired output.

import numpy as np
from qiskit import QuantumCircuit

%matplotlib inline

Building the circuit

The basic element needed for your first program is the QuantumCircuit. We begin by creating a QuantumCircuit comprised of three qubits.

# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)

After you create the circuit with its registers, you can add gates (“operations”) to manipulate the registers. As you proceed through the tutorials you will find more gates and circuits; below is an example of a quantum circuit that makes a three-qubit GHZ state

\[|\psi\rangle = \left(|000\rangle+|111\rangle\right)/\sqrt{2}.\]

이러한 상태를 만들기 위해서는 우선 세개의 큐비트로 구성된 양자 레지스터를 구성한다. 기본적으로 레지스터의 각 큐비트는 \(|0\rangle\) 로 초기화된다. GHZ 상태를 만들기 위해 다음 게이트를 적용한다: - 큐비트 0을 중첩상태 \(\left(|0\rangle+|1\rangle\right)/\sqrt{2}\) 로 만들어 주는 하다마드 게이트 \(H\) 를 큐비트 0에 적용하고, Controlled Not Gate(\(C_{X}\))를 큐비트 0과 큐비트 1에, 다시 Controlled Not Gate를 큐비트 0과 큐비트 2에 적용한다.

On an ideal quantum computer, the state produced by running this circuit would be the GHZ state above.

In Qiskit, operations can be added to the circuit one by one, as shown below.

# Add a H gate on qubit 0, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
circ.cx(0, 1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting
# the qubits in a GHZ state.
circ.cx(0, 2)

<qiskit.circuit.instructionset.InstructionSet at 0x7fbfb0bd5400>

Visualize Circuit

You can visualize your circuit using Qiskit QuantumCircuit.draw(), which plots the circuit in the form found in many textbooks.

circ.draw('mpl')

In this circuit, the qubits are put in order, with qubit zero at the top and qubit two at the bottom. The circuit is read left to right (meaning that gates that are applied earlier in the circuit show up further to the left).

When representing the state of a multi-qubit system, the tensor order used in Qiskit is different than that used in most physics textbooks. Suppose there are \(n\) qubits, and qubit \(j\) is labeled as \(Q_{j}\). Qiskit uses an ordering in which the \(n^{\mathrm{th}}\) qubit is on the left side of the tensor product, so that the basis vectors are labeled as \(Q_{n-1}\otimes \cdots \otimes Q_1\otimes Q_0\).

For example, if qubit zero is in state 0, qubit 1 is in state 0, and qubit 2 is in state 1, Qiskit would represent this state as \(|100\rangle\), whereas many physics textbooks would represent it as \(|001\rangle\).

This difference in labeling affects the way multi-qubit operations are represented as matrices. For example, Qiskit represents a controlled-X (\(C_{X}\)) operation with qubit 0 being the control and qubit 1 being the target as

\[\begin{split}C_X = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\\end{pmatrix}.\end{split}\]

Simulating circuits

To simulate a circuit we use the quant-info module in Qiskit. This simulator returns the quantum state, which is a complex vector of dimensions \(2^n\), where \(n\) is the number of qubits (so be careful using this as it will quickly get too large to run on your machine).

시뮬레이터에는 두 가지 단계가 있다. 첫 번째로는 입력 상태를 설정하는 것이고 두 번째는 양자 회로에 의해 상태를 발전시키는 것이다.

from qiskit.quantum_info import Statevector

# Set the intial state of the simulator to the ground state using from_int
state = Statevector.from_int(0, 2**3)

# Evolve the state by the quantum circuit
state = state.evolve(circ)

#draw using latex
state.draw('latex')

$$ \begin{bmatrix} \tfrac{1}{\sqrt{2}} & 0 & 0 & 0 & 0 & 0 & 0 & \tfrac{1}{\sqrt{2}} \\ \end{bmatrix} $$

키스킷은 이러한 결과들을 보여주는 시각화 도구상자를 제공한다.

Below, we use the visualization function to plot the qsphere and a hinton representing the real and imaginary components of the state density matrix \(\rho\).

state.draw('qsphere')

state.draw('hinton')

Unitary representation of a circuit

또한, Qiskit의 quant_info 모듈에는 회로를 위한 단일 연산자를 만들기 위해 사용될 수 있는 오퍼레이터 메서드가 있다. 이는 양자 회로를 나타내는 \(2^n \times 2^n\) 행렬을 계산한다.

from qiskit.quantum_info import Operator

U = Operator(circ)

# Show the results
U.data

array([[ 0.70710678+0.j,  0.70710678+0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.70710678+0.j, -0.70710678+0.j],
       [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j,
         0.70710678+0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.70710678+0.j, -0.70710678+0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.70710678+0.j,  0.70710678+0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j,
        -0.70710678+0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.70710678+0.j,  0.70710678+0.j],
       [ 0.70710678+0.j, -0.70710678+0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j]])

OpenQASM backend

The simulators above are useful because they provide information about the state output by the ideal circuit and the matrix representation of the circuit. However, a real experiment terminates by measuring each qubit (usually in the computational \(|0\rangle, |1\rangle\) basis). Without measurement, we cannot gain information about the state. Measurements cause the quantum system to collapse into classical bits.

예를 들어 3개의 큐빗을 가진 GHZ 상태의 각각의 큐빗을 독립적으로 측정한다고 가정해 보자.

\[|\psi\rangle = (|000\rangle +|111\rangle)/\sqrt{2},\]

and let \(xyz\) denote the bitstring that results. Recall that, under the qubit labeling used by Qiskit, \(x\) would correspond to the outcome on qubit 2, \(y\) to the outcome on qubit 1, and \(z\) to the outcome on qubit 0.

Note: This representation of the bitstring puts the most significant bit (MSB) on the left, and the least significant bit (LSB) on the right. This is the standard ordering of binary bitstrings. We order the qubits in the same way (qubit representing the MSB has index 0), which is why Qiskit uses a non-standard tensor product order.

\(xyz\) 의 결과를 얻는 확률은 다음과 같이 주어진다.

\[\mathrm{Pr}(xyz) = |\langle xyz | \psi \rangle |^{2}\]

and as such for the GHZ state probability of obtaining 000 or 111 are both 1/2.

To simulate a circuit that includes measurement, we need to add measurements to the original circuit above, and use a different Aer backend.

# Create a Quantum Circuit
meas = QuantumCircuit(3, 3)
meas.barrier(range(3))
# map the quantum measurement to the classical bits
meas.measure(range(3), range(3))

# The Qiskit circuit object supports composition.
# Here the meas has to be first and front=True (putting it before)
# as compose must put a smaller circuit into a larger one.
qc = meas.compose(circ, range(3), front=True)

#drawing the circuit
qc.draw('mpl')

This circuit adds a classical register, and three measurements that are used to map the outcome of qubits to the classical bits.

이 회로를 시뮬레이트하기 위해서 키스킷 Aer 에 있는 qasm_simulator``를 사용한다. 이 회로의 각각의 실행은 비트 문자열 000 혹은 111을 생성한다. 비트 문자열 (예를 들어 :math:`\mathrm{Pr}(000)`)의 분포에 대한 통계를 얻기 위해서는 회로를 여러번 실행해야 한다. 회로가 반복되는 횟수를 결정하기 위해서는 ``execute 함수에 있는 shots 키워드를 조정하면 된다.

# Adding the transpiler to reduce the circuit to QASM instructions
# supported by the backend
from qiskit import transpile

# Use Aer's qasm_simulator
from qiskit.providers.aer import QasmSimulator

backend = QasmSimulator()

# First we have to transpile the quantum circuit
# to the low-level QASM instructions used by the
# backend
qc_compiled = transpile(qc, backend)

# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = backend.run(qc_compiled, shots=1024)

# Grab the results from the job.
result_sim = job_sim.result()

결과 객체를 얻은 후에는 이러한 시뮬레이션 횟수를 get_counts(circuit) 함수를 통해 접근할 수 있다. 이를 통해서 지금까지 실행했던 시뮬레이션의 합산된 결과값을 구할 수 있다.

counts = result_sim.get_counts(qc_compiled)
print(counts)

{'000': 505, '111': 519}

대략 50 퍼센트 정도는 결과 비트 문자열이 000인 값을 가진다. 또한 키스킷은 결과를 보여주는 plot_histogram 함수를 제공한다.

from qiskit.visualization import plot_histogram
plot_histogram(counts)

예측값인 확률 \(\mathrm{Pr}(000)\)mathrm{Pr}(111)`는 유효 카운트를 모두 더한 후에 (회로가 몇번 실행되었는지를 가르키는) 시뮬레이션 숫자로 나누어서 계산되어진다. execute 함수에 있는 shots 키워드를 수정해 보면서 예측 확률값이 어떻게 변하는지 살펴보라.

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.25.0
Terra	0.17.0
Aer	0.8.0
Ignis	0.6.0
Aqua	0.9.0
IBM Q Provider	0.12.2
System information
Python	3.8.8 (default, Feb 24 2021, 13:46:16) [Clang 10.0.0 ]
OS	Darwin
CPUs	4
Memory (Gb)	32.0
Tue Apr 06 21:48:52 2021 EDT

This code is a part of Qiskit

© Copyright IBM 2017, 2021.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.