---
# System prepended metadata

title: lab1
tags: [hipac4]

---

// 綠框是解題代碼，其餘是 \*.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 電路求解此問題，並回傳以下問題的 計算結果檔 作為評分依據。

![image](https://hackmd.io/_uploads/HJHc9PQ_gl.png)

:::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 電路求解此問題，並回傳以下問題的 計算結果檔 作為評分依據。

![image](https://hackmd.io/_uploads/HkElcwQ_le.png)
:::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