// 綠框是解題代碼，其餘是 \*.ipynb 內的題目
## 量子計算 101：正式啟航，探索 Qubit 世界
```python
import qiskit
print(qiskit.__version__)
```
1.0.2
```python
import numpy as np
from qiskit import QuantumCircuit, transpile, QuantumRegister, ClassicalRegister
from qiskit_aer import AerSimulator
```
### 題目1：量子邏輯閘
建立 量子邏輯閘 電路，並提供計算結果：
1. 計算 h gate 作用在量子態 |0> 的結果
2. 計算 cx gate 作用在量子態 |01> 的結果
3. 計算 ccx gate 作用在量子態 |011> 的結果
1. 計算 h gate 作用在量子態 |0> 的結果
:::success
```python
# 創建量子電路
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.measure_all()
```
:::
```python
print('量子電路如下: ')
print(circuit.draw())
```
```
量子電路如下:
┌───┐ ░ ┌─┐
q: ┤ H ├─░─┤M├
└───┘ ░ └╥┘
meas: 1/═════════╩═
0
```
```python
simulator = AerSimulator()
circuit = transpile(circuit, simulator)
result = simulator.run(circuit).result()
counts = result.get_counts(circuit)
print("此電路的量測結果: ")
for bitstr, count in counts.items():
print(f"{bitstr}: {count}")
```
此電路的量測結果:
0: 516
1: 508
2. 計算 cx gate 作用在量子態 |01> 的結果
:::success
```python
# 創建量子電路
circuit = QuantumCircuit(2)
circuit.x(0)
circuit.cx(0, 1)
circuit.measure_all()
```
:::
```python
print('量子電路如下: ')
print(circuit.draw())
```
```
量子電路如下:
┌───┐ ░ ┌─┐
q_0: ┤ X ├──■───░─┤M├───
└───┘┌─┴─┐ ░ └╥┘┌─┐
q_1: ─────┤ X ├─░──╫─┤M├
└───┘ ░ ║ └╥┘
meas: 2/══════════════╩══╩═
0 1
```
```python
simulator = AerSimulator()
circuit = transpile(circuit, simulator)
result = simulator.run(circuit).result()
counts = result.get_counts(circuit)
print("此電路的量測結果: ")
for bitstr, count in counts.items():
print(f"{bitstr}: {count}")
```
此電路的量測結果:
11: 1024
3. 計算 ccx gate 作用在量子態 |011> 的結果
:::success
```python
# 創建量子電路
circuit = QuantumCircuit(3)
circuit.x(1)
circuit.x(0)
circuit.ccx(0, 1, 2)
circuit.measure_all()
```
:::
```python
print('量子電路如下: ')
print(circuit.draw())
```
```
量子電路如下:
┌───┐ ░ ┌─┐
q_0: ┤ X ├──■───░─┤M├──────
├───┤ │ ░ └╥┘┌─┐
q_1: ┤ X ├──■───░──╫─┤M├───
└───┘┌─┴─┐ ░ ║ └╥┘┌─┐
q_2: ─────┤ X ├─░──╫──╫─┤M├
└───┘ ░ ║ ║ └╥┘
meas: 3/══════════════╩══╩══╩═
0 1 2
```
```python
simulator = AerSimulator()
circuit = transpile(circuit, simulator)
result = simulator.run(circuit).result()
counts = result.get_counts(circuit)
print("此電路的量測結果: ")
for bitstr, count in counts.items():
print(f"{bitstr}: {count}")
```
此電路的量測結果:
111: 1024
###
## 題目2：量子加法器電路
建立 量子加法器 電路，並提供計算結果：
1. 計算 量子加法器 電路同時作用在量子態 |00>, |01>, |10>, |11> 的結果
:::success
```python
circuit = QuantumCircuit(4, 4)
# A = 均勻疊加態
circuit.h(0)
circuit.h(1)
circuit.cx(0, 2)
circuit.cx(1, 2)
circuit.ccx(0, 1, 3)
# 右邊是 q0
circuit.measure(0, 0)
circuit.measure(1, 1)
circuit.measure(2, 2)
circuit.measure(3, 3)
```
:::
```python
print('量子電路如下: ')
print(circuit.draw())
```
```
量子電路如下:
┌───┐ ┌─┐
q_0: ┤ H ├──■─────────■─────┤M├──────
├───┤ │ │ └╥┘┌─┐
q_1: ┤ H ├──┼────■────■──────╫─┤M├───
└───┘┌─┴─┐┌─┴─┐ │ ┌─┐ ║ └╥┘
q_2: ─────┤ X ├┤ X ├──┼──┤M├─╫──╫────
└───┘└───┘┌─┴─┐└╥┘ ║ ║ ┌─┐
q_3: ───────────────┤ X ├─╫──╫──╫─┤M├
└───┘ ║ ║ ║ └╥┘
c: 4/═════════════════════╩══╩══╩══╩═
2 0 1 3
```
```python
simulator = AerSimulator()
circuit = transpile(circuit, simulator)
result = simulator.run(circuit).result()
counts = result.get_counts(circuit)
print("此電路的量測結果: ")
for bitstr, count in counts.items():
print(f"{bitstr}: {count}")
```
此電路的量測結果:
0000: 231
0101: 285
1111: 237
1010: 271
---
### 題目3：Grover’s Algorithm 電路
建立 Grover’s Algorithm 電路，並提供計算結果：
1. 計算目標量子態為的 ｜0100> 的 Grover’s Algorithm 電路
2. 計算目標量子態為的 ｜01100> + ｜10000> 的 Grover’s Algorithm 電路
1. 計算目標量子態為的 ｜0100> 的 Grover’s Algorithm 電路
:::success
```python
# 創建量子電路
from qiskit.circuit.library import ZGate
def oracle(qc, qubits, marked):
for i, bit in enumerate(marked):
if bit == '0':
qc.x(i)
mcz = ZGate().control(num_ctrl_qubits=len(qubits)-1, ctrl_state='1'*(len(qubits)-1))
qc.append(mcz, qubits)
for i, bit in enumerate(marked):
if bit == '0':
qc.x(i)
return qc
def diffuser(qc, qubits):
qc.h(qubits)
qc.x(qubits)
mcz = ZGate().control(num_ctrl_qubits=len(qubits)-1, ctrl_state='1'*(len(qubits)-1))
qc.append(mcz, qubits)
qc.x(qubits)
qc.h(qubits)
return qc
def get_grover_circuit(n_qubits,makred: str, n_repeats=1):
qc = QuantumCircuit(n_qubits)
qubits = qc.qubits
for q in qubits:
qc.h(q)
for _ in range(n_repeats):
qc = oracle(qc, qubits, makred)
qc = diffuser(qc, qubits)
return qc
# 從右讀到左 = |0100>
circuit = get_grover_circuit(4, "0010")
circuit.measure_all()
```
:::
```python
print('量子電路如下: ')
print(circuit.draw())
```
```
量子電路如下:
┌───┐┌───┐ ┌───┐┌───┐┌───┐ ┌───┐┌───┐ ░ ┌─┐
q_0: ┤ H ├┤ X ├─■─┤ X ├┤ H ├┤ X ├─■─┤ X ├┤ H ├─░─┤M├─────────
├───┤├───┤ │ ├───┤├───┤├───┤ │ ├───┤├───┤ ░ └╥┘┌─┐
q_1: ┤ H ├┤ X ├─■─┤ X ├┤ H ├┤ X ├─■─┤ X ├┤ H ├─░──╫─┤M├──────
├───┤└───┘ │ ├───┤├───┤└───┘ │ ├───┤├───┤ ░ ║ └╥┘┌─┐
q_2: ┤ H ├──────■─┤ H ├┤ X ├──────■─┤ X ├┤ H ├─░──╫──╫─┤M├───
├───┤┌───┐ │ ├───┤├───┤┌───┐ │ ├───┤├───┤ ░ ║ ║ └╥┘┌─┐
q_3: ┤ H ├┤ X ├─■─┤ X ├┤ H ├┤ X ├─■─┤ X ├┤ H ├─░──╫──╫──╫─┤M├
└───┘└───┘ └───┘└───┘└───┘ └───┘└───┘ ░ ║ ║ ║ └╥┘
meas: 4/═════════════════════════════════════════════╩══╩══╩══╩═
0 1 2 3
```
```python
simulator = AerSimulator()
circuit = transpile(circuit, simulator)
result = simulator.run(circuit).result()
counts = result.get_counts(circuit)
print("此電路的量測結果: ")
for bitstr, count in counts.items():
print(f"{bitstr}: {count}")
```
此電路的量測結果:
1101: 37
1100: 36
0010: 30
0000: 41
0100: 500
1011: 37
0111: 40
0011: 35
0110: 34
1000: 27
1110: 34
1001: 37
0101: 24
0001: 34
1111: 44
1010: 34
2. 計算目標量子態為的 ｜01100> + ｜10000> 的 Grover’s Algorithm 電路
:::success
```python
# 創建量子電路
def full_adder(qc, a, b, cin, sum_bit, cout):
# sum = a XOR b XOR cin
qc.cx(a, sum_bit)
qc.cx(b, sum_bit)
qc.cx(cin, sum_bit)
# carry = ab + ac + bc
qc.ccx(a, b, cout)
qc.ccx(a, cin, cout)
qc.ccx(b, cin, cout)
def create_nbit_adder(a_bits: str, b_bits: str) -> QuantumCircuit:
assert len(a_bits) == len(b_bits), "a 與 b 長度需相同"
n = len(a_bits)
total_qubits = 4 * n + 1 # a, b, carry (n+1), sum (n)
classical_bits = n + 1 # sum + carry-out
qc = QuantumCircuit(total_qubits, classical_bits)
# Qubit 分配
a_idx = lambda i: i
b_idx = lambda i: n + i
cin_idx = lambda i: 2 * n + i
cout_idx = lambda i: 2 * n + i + 1
sum_idx = lambda i: 3 * n + 1 + i
# 初始化 a, b
for i, bit in enumerate(reversed(a_bits)):
if bit == '1':
qc.x(a_idx(i))
for i, bit in enumerate(reversed(b_bits)):
if bit == '1':
qc.x(b_idx(i))
# Full Adders
for i in range(n):
a = a_idx(i)
b = b_idx(i)
cin = cin_idx(i)
cout = cout_idx(i)
sum_bit = sum_idx(i)
full_adder(qc, a, b, cin, sum_bit, cout)
# 測量 sum
for i in range(n):
qc.measure(sum_idx(i), i)這是一個簡化版的加法器，不含 carry-in（進位輸入）。
# 測量最後的 carry
qc.measure(cout_idx(n - 1), n)
return qc
from qiskit.circuit.library import ZGate
def oracle(qc, qubits, marked):
for i, bit in enumerate(marked):
if bit == '0':
qc.x(i)
mcz = ZGate().control(num_ctrl_qubits=len(qubits)-1, ctrl_state='1'*(len(qubits)-1))
qc.append(mcz, qubits)
for i, bit in enumerate(marked):
if bit == '0':
qc.x(i)
return qc
def diffuser(qc, qubits):
qc.h(qubits)
qc.x(qubits)
mcz = ZGate().control(num_ctrl_qubits=len(qubits)-1, ctrl_state='1'*(len(qubits)-1))
qc.append(mcz, qubits)
qc.x(qubits)
qc.h(qubits)
return qc
def get_grover_circuit(n_qubits,marked: str, n_repeats=1):
qc = QuantumCircuit(n_qubits)
qubits = qc.qubits
for q in qubits:
qc.h(q)
for _ in range(n_repeats):
qc = oracle(qc, qubits, "10000")
qc = oracle(qc, qubits, "01100")
qc = diffuser(qc, qubits)
return qc
circuit = get_grover_circuit(5, "ohno", 1)
circuit.measure_all()
```
:::
```python
print('量子電路如下: ')
print(circuit.draw())
```
```
量子電路如下:
┌───┐ ┌───┐ ┌───┐┌───┐┌───┐ ┌───┐┌───┐ ░ ┌─┐ »
q_0: ┤ H ├──────■─┤ X ├──────■─┤ X ├┤ H ├┤ X ├─■─┤ X ├┤ H ├─░─┤M├─────────»
├───┤┌───┐ │ ├───┤ │ ├───┤├───┤└───┘ │ ├───┤├───┤ ░ └╥┘┌─┐ »
q_1: ┤ H ├┤ X ├─■─┤ X ├──────■─┤ H ├┤ X ├──────■─┤ X ├┤ H ├─░──╫─┤M├──────»
├───┤├───┤ │ ├───┤ │ ├───┤├───┤ │ ├───┤├───┤ ░ ║ └╥┘┌─┐ »
q_2: ┤ H ├┤ X ├─■─┤ X ├──────■─┤ H ├┤ X ├──────■─┤ X ├┤ H ├─░──╫──╫─┤M├───»
├───┤├───┤ │ ├───┤┌───┐ │ ├───┤├───┤┌───┐ │ ├───┤├───┤ ░ ║ ║ └╥┘┌─┐»
q_3: ┤ H ├┤ X ├─■─┤ X ├┤ X ├─■─┤ X ├┤ H ├┤ X ├─■─┤ X ├┤ H ├─░──╫──╫──╫─┤M├»
├───┤├───┤ │ ├───┤├───┤ │ ├───┤├───┤├───┤ │ ├───┤├───┤ ░ ║ ║ ║ └╥┘»
q_4: ┤ H ├┤ X ├─■─┤ X ├┤ X ├─■─┤ X ├┤ H ├┤ X ├─■─┤ X ├┤ H ├─░──╫──╫──╫──╫─»
└───┘└───┘ └───┘└───┘ └───┘└───┘└───┘ └───┘└───┘ ░ ║ ║ ║ ║ »
meas: 5/══════════════════════════════════════════════════════════╩══╩══╩══╩═»
0 1 2 3 »
«
« q_0: ───
«
« q_1: ───
«
« q_2: ───
«
« q_3: ───
« ┌─┐
« q_4: ┤M├
« └╥┘
«meas: 5/═╩═
« 4
```
```python
simulator = AerSimulator()
circuit = transpile(circuit, simulator)
result = simulator.run(circuit).result()
counts = result.get_counts(circuit)
print("此電路的量測結果: ")
for bitstr, count in counts.items():
print(f"{bitstr}: {count}")
```
此電路的量測結果:
01101: 15
11101: 22
01001: 18
11100: 15
10101: 21
10010: 14
11110: 19
11000: 13
10000: 11
11111: 18
11011: 16
00000: 20
11001: 17
01110: 19
10011: 19
01011: 24
00011: 16
00111: 18
00001: 241
00110: 244
10111: 21
10100: 23
00010: 22
00101: 16
11010: 16
10001: 18
01010: 13
01000: 15
01100: 26
10110: 19
00100: 19
01111: 16
---
### 題目4：求解簡單數獨問題
下圖 2x2 方框內的元素 v0～v4 數值只有 0 和 1 兩種可能，並且需滿足 v0 ≠ v1, v2 ≠ v3, v0 ≠ v2, v1 ≠ v3 條件。
請使用 Grover’s Algorithm 電路求解此問題，並回傳以下問題的 計算結果檔 作為評分依據。
:::success
```python
# 創建量子電路
from qiskit.circuit.library import ZGate
def diffuser(qc, qubits):
qc.h(range(qubits))
qc.x(range(qubits))
#mcz = ZGate().control(num_ctrl_qubits=len(qubits)-1, ctrl_state='1'*(len(qubits)-1))
qc.h(qubits - 1)
qc.mcx(list(range(qubits - 1)), qubits - 1)
qc.h(qubits - 1)
qc.x(range(qubits))
qc.h(range(qubits))
return qc
def build_oracle_circuit(qc):
qc.cx(0, 4) # v0 xor v1
qc.cx(1, 4)
qc.cx(2, 5) # v2 xor v3
qc.cx(3, 5)
qc.cx(0, 6) # v0 xor v2
qc.cx(2, 6)
qc.cx(1, 7) # v1 xor v3
qc.cx(3, 7)
# 如果 4567 都是 1, filp 8
qc.mcx([4,5,6,7], 8)
# 恢復 tmp
qc.cx(1, 7)
qc.cx(3, 7)
qc.cx(0, 6)
qc.cx(2, 6)
qc.cx(2, 5)
qc.cx(3, 5)
qc.cx(0, 4)
qc.cx(1, 4)
return qc
# qubit
# 0-3: input
# 4-7 tmp, 8: oracle
# classic
# 0-3: v1-v4
circuit = QuantumCircuit(9, 4)
circuit.h({0,1,2,3})
# 將 oracle qubit 準備成 |-⟩ 狀態
circuit.x(8)
circuit.h(8)
#for _ in range(2):
circuit = build_oracle_circuit(circuit)
circuit = diffuser(circuit, 4)
# 測量前 4 個 qubit
circuit.measure(0, 0) # v1
circuit.measure(1, 1) # v2
circuit.measure(2, 2) # v3
circuit.measure(3, 3) # v4
```
:::
```python
print('量子電路如下: ')
print(circuit.draw())
```
```
量子電路如下:
┌───┐ »
q_0: ┤ H ├──■───────────────────■─────────────────────────────■────────────»
├───┤ │ │ │ »
q_1: ┤ H ├──┼─────────■─────────┼─────────■──────────────■────┼────────────»
├───┤ │ │ │ │ │ │ »
q_2: ┤ H ├──┼────■────┼─────────┼────■────┼──────────────┼────┼─────────■──»
├───┤ │ │ │ │ │ │ │ │ │ »
q_3: ┤ H ├──┼────┼────┼────■────┼────┼────┼────■─────────┼────┼────■────┼──»
└───┘┌─┴─┐ │ ┌─┴─┐ │ │ │ │ │ │ │ │ │ »
q_4: ─────┤ X ├──┼──┤ X ├──┼────┼────┼────┼────┼────■────┼────┼────┼────┼──»
└───┘┌─┴─┐└───┘┌─┴─┐ │ │ │ │ │ │ │ │ │ »
q_5: ──────────┤ X ├─────┤ X ├──┼────┼────┼────┼────■────┼────┼────┼────┼──»
└───┘ └───┘┌─┴─┐┌─┴─┐ │ │ │ │ ┌─┴─┐ │ ┌─┴─┐»
q_6: ─────────────────────────┤ X ├┤ X ├──┼────┼────■────┼──┤ X ├──┼──┤ X ├»
└───┘└───┘┌─┴─┐┌─┴─┐ │ ┌─┴─┐└───┘┌─┴─┐└───┘»
q_7: ───────────────────────────────────┤ X ├┤ X ├──■──┤ X ├─────┤ X ├─────»
┌───┐┌───┐ └───┘└───┘┌─┴─┐└───┘ └───┘ »
q_8: ┤ X ├┤ H ├───────────────────────────────────┤ X ├────────────────────»
└───┘└───┘ └───┘ »
c: 4/══════════════════════════════════════════════════════════════════════»
»
« ┌───┐┌───┐ ┌───┐┌───┐ ┌─┐
«q_0: ──■──┤ H ├┤ X ├──────────────────────■──┤ X ├┤ H ├─────┤M├─────────
« │ └───┘└───┘┌───┐┌───┐ │ ├───┤├───┤ └╥┘┌─┐
«q_1: ──┼─────────■──┤ H ├┤ X ├────────────■──┤ X ├┤ H ├──────╫─┤M├──────
« │ │ ├───┤├───┤ │ ├───┤├───┤ ║ └╥┘┌─┐
«q_2: ──┼────■────┼──┤ H ├┤ X ├────────────■──┤ X ├┤ H ├──────╫──╫─┤M├───
« │ │ │ └───┘├───┤┌───┐┌───┐┌─┴─┐├───┤├───┤┌───┐ ║ ║ └╥┘┌─┐
«q_3: ──┼────┼────┼────■──┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├─╫──╫──╫─┤M├
« ┌─┴─┐ │ ┌─┴─┐ │ └───┘└───┘└───┘└───┘└───┘└───┘└───┘ ║ ║ ║ └╥┘
«q_4: ┤ X ├──┼──┤ X ├──┼──────────────────────────────────────╫──╫──╫──╫─
« └───┘┌─┴─┐└───┘┌─┴─┐ ║ ║ ║ ║
«q_5: ─────┤ X ├─────┤ X ├────────────────────────────────────╫──╫──╫──╫─
« └───┘ └───┘ ║ ║ ║ ║
«q_6: ────────────────────────────────────────────────────────╫──╫──╫──╫─
« ║ ║ ║ ║
«q_7: ────────────────────────────────────────────────────────╫──╫──╫──╫─
« ║ ║ ║ ║
«q_8: ────────────────────────────────────────────────────────╫──╫──╫──╫─
« ║ ║ ║ ║
«c: 4/════════════════════════════════════════════════════════╩══╩══╩══╩═
« 0 1 2 3
```
```python
simulator = AerSimulator()
circuit = transpile(circuit, simulator)
result = simulator.run(circuit).result()
counts = result.get_counts(circuit)
print("此電路的量測結果: ")
for bitstr, count in counts.items():
print(f"{bitstr}: {count}")
```
此電路的量測結果:
1011: 10
1010: 16
1101: 17
0110: 422
1000: 17
1100: 16
0010: 13
0000: 6
0001: 16
1111: 12
1110: 13
1001: 399
0101: 11
0011: 20
0111: 14
0100: 22
### 題目5：求解最大切割問題
下圖為一個三個頂點兩個邊的圖形，每個頂點可以由 0 和 1 兩個區塊做表達，而邊上的兩的頂點相異時，邊可被視為切斷。最大切割問題為在切割圖形時要求一刀能夠切段最多數量的邊。
請使用 Grover’s Algorithm 電路求解此問題，並回傳以下問題的 計算結果檔 作為評分依據。
:::success
```python
# 創建量子電路
# v0 != v1 -> +1
# v1 != v2 -> +1
# 但是兩條件不是 AND，是 OR
def maxcut_oracle(qc):
# 0 XOR 1
qc.cx(0, 3)
qc.cx(1, 3)
# 1 XOR 2
qc.cx(1, 4)
qc.cx(2, 4)
# 5 = oracle
qc.mcx([3, 4], 5)
# uncompute
qc.cx(1, 4)
qc.cx(2, 4)
qc.cx(0, 3)
qc.cx(1, 3)
def diffuser(qc, n):
qc.h(range(n))
qc.x(range(n))
qc.h(n - 1)
qc.mcx(list(range(n - 1)), n - 1)
qc.h(n - 1)
qc.x(range(n))
qc.h(range(n))
return qc
# qubit
# 0-2: v1,v2,v3
# 3-4: tmp, 5: oracle
# classic
# 0-2: v1,v2,v3
circuit = QuantumCircuit(6, 3)
circuit.h([0, 1, 2])
# oracle
circuit.x(5)
circuit.h(5)
maxcut_oracle(circuit)
diffuser(circuit, 3)
circuit.measure([0, 1, 2], [0, 1, 2])
```
:::
```python
print('量子電路如下: ')
print(circuit.draw())
```
```
量子電路如下:
┌───┐ ┌───┐┌───┐ »
q_0: ┤ H ├──■─────────────────────────────■──┤ H ├┤ X ├─────────────────■──»
├───┤ │ │ └───┘└───┘┌───┐┌───┐ │ »
q_1: ┤ H ├──┼────■────■──────────────■────┼─────────■──┤ H ├┤ X ├───────■──»
├───┤ │ │ │ │ │ │ ├───┤├───┤┌───┐┌─┴─┐»
q_2: ┤ H ├──┼────┼────┼────■─────────┼────┼────■────┼──┤ H ├┤ X ├┤ H ├┤ X ├»
└───┘┌─┴─┐┌─┴─┐ │ │ │ ┌─┴─┐ │ ┌─┴─┐└───┘└───┘└───┘└───┘»
q_3: ─────┤ X ├┤ X ├──┼────┼────■────┼──┤ X ├──┼──┤ X ├────────────────────»
└───┘└───┘┌─┴─┐┌─┴─┐ │ ┌─┴─┐└───┘┌─┴─┐└───┘ »
q_4: ───────────────┤ X ├┤ X ├──■──┤ X ├─────┤ X ├─────────────────────────»
┌───┐┌───┐ └───┘└───┘┌─┴─┐└───┘ └───┘ »
q_5: ┤ X ├┤ H ├───────────────┤ X ├────────────────────────────────────────»
└───┘└───┘ └───┘ »
c: 3/══════════════════════════════════════════════════════════════════════»
»
« ┌───┐┌───┐ ┌─┐
«q_0: ┤ X ├┤ H ├─────┤M├──────
« ├───┤├───┤ └╥┘┌─┐
«q_1: ┤ X ├┤ H ├──────╫─┤M├───
« ├───┤├───┤┌───┐ ║ └╥┘┌─┐
«q_2: ┤ H ├┤ X ├┤ H ├─╫──╫─┤M├
« └───┘└───┘└───┘ ║ ║ └╥┘
«q_3: ────────────────╫──╫──╫─
« ║ ║ ║
«q_4: ────────────────╫──╫──╫─
« ║ ║ ║
«q_5: ────────────────╫──╫──╫─
« ║ ║ ║
«c: 3/════════════════╩══╩══╩═
« 0 1 2
```
```python
simulator = AerSimulator()
circuit = transpile(circuit, simulator)
result = simulator.run(circuit).result()
counts = result.get_counts(circuit)
print("此電路的量測結果: ")
for bitstr, count in counts.items():
print(f"{bitstr}: {count}")
```
此電路的量測結果:
101: 539
010: 485
Sign in with Wallet
Connect another wallet