Panduan Cepat

---

title: Quickstart description: Panduan quickstart untuk paket Qiskit addons pauli-prop

Di panduan ini kita pakai paket pauli-prop untuk mensimulasikan secara klasik dinamika waktu model Ising yang di-kick 10-qubit pada rantai spin 1D.

Siapkan input untuk Pauli propagation

Hamiltonian yang dipakai adalah:

$H = -J\sum\limits_{\langle i,j \rangle} Z_iZ_j + h\sum\limits_iX_i$

dengan $J>0$ menggambarkan kopling antar spin tetangga terdekat, $i<j$, dan $h$ adalah medan transversal global. Dekomposisi Trotter orde pertama dari operator yang berevolusi waktu akan diimplementasikan sebagai circuit kuantum, $U$, selama $20$ langkah Trotter. Konstanta kopling, $J$, akan dibuat tetap di $J=-\frac{\pi}{2}$, dan $h$ dibuat tetap di $\frac{\pi}{6}$. Interaksi $ZZ$ akan diimplementasikan memakai gate Clifford ($CX$, $Sdg$, $\sqrt{Y}$).

Kita implementasikan evolusi waktu Trotter sebagai circuit kuantum dan memakai $\frac{\pi}{6}$ untuk rotasi non-Clifford terhadap sumbu x. Makin jauh sudut-sudut ini dari sudut Clifford (misalnya $\theta=n\frac{\pi}{2}, n \in \mathbb{Z}$), makin sulit sistemnya disimulasikan dengan metode Pauli propagation.

Untuk pilihan observable, kita pakai magnetisasi rata-rata per situs, $\frac{1}{N} \sum_{i=1}^{N} \langle z_i \rangle$, dengan $N$ adalah jumlah spin.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"matplotlib": "matplotlib", "numpy": "numpy", "pauli_prop": "pauli-prop", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import CouplingMap

num_qubits = 10
coupling_map = CouplingMap.from_line(num_qubits, bidirectional=False)

# Num Trotter steps
num_steps = 20
theta_rx = np.pi / 6

# Average single-site magnetization
observable = (
    SparsePauliOp(
        [
            "I" * iq + "Z" + "I" * (num_qubits - iq - 1)
            for iq in range(num_qubits)
        ]
    )
    / num_qubits
)

# Create the Trotter circuit
num_qubits = 10
num_steps = 20
theta_rx = np.pi / 6
circuit = QuantumCircuit(num_qubits)
edges = CouplingMap.from_line(num_qubits, bidirectional=False).get_edges()
for _ in range(num_steps):
    circuit.rx(theta_rx, [i for i in range(num_qubits)])
    for edge in edges:
        circuit.sdg(edge)
        circuit.ry(np.pi / 2, edge[1])
        circuit.cx(edge[0], edge[1])
        circuit.ry(-np.pi / 2, edge[1])
circuit.draw("mpl", fold=-1)

Simulasikan evolusi waktu sistem dengan Pauli propagation

Setelah punya circuit, $U$, dan observable, $O$, kita bisa dengan mudah mensimulasikan sistemnya dalam beberapa langkah:

• Pisahkan $U$ menjadi bagian Clifford, $C$, dan non-Clifford, $P$, sehingga $U=PC$ memakai evolve_through_cliffords

• Propagasikan $O$ melalui $P$, menghasilkan operator baru, $O^\prime$, memakai pauli_prop.propagate_through_circuit

• Evolusikan $O^\prime$ melalui bagian Clifford dari circuit memakai dukungan evolusi Clifford yang sudah ada di Qiskit

• Aproksimasi nilai ekspektasi sebagai $\langle0|O^\prime|0\rangle \approx \langle0|U^\dagger OU|0\rangle$ dengan menjumlahkan koefisien di $O^\prime$ yang terkait suku Pauli yang sepenuhnya diagonal (suku Pauli yang berisi I atau Z pada semua qubit). Ingat, ini adalah aproksimasi karena kita memotong beberapa suku dari $O^\prime$ saat mempropagasikannya melalui bagian non-Clifford dari circuit.

import time

from pauli_prop import evolve_through_cliffords, propagate_through_circuit

cliff, non_cliff = evolve_through_cliffords(circuit)

max_terms_list = [10**i for i in range(8)]
approx_evs = []
durations = []
for max_terms in max_terms_list:
    st = time.perf_counter()
    evolved_obs = propagate_through_circuit(
        observable, non_cliff, max_terms=max_terms, atol=1e-12, frame="h"
    )[0]
    evolved_obs.paulis = evolved_obs.paulis.evolve(cliff, frame="h")
    durations.append(time.perf_counter() - st)
    approx_evs.append(
        float(evolved_obs.coeffs[~evolved_obs.paulis.x.any(axis=1)].sum())
    )

Makin besar perhitungan yang kita jalankan, makin akurat aproksimasi nilai ekspektasinya. Di contoh ini, kita menjenuhkan seluruh ruang Pauli di sekitar $4^{10}\approx10^6$, yang terlihat dari kurva yang mendatar di antara dua titik terakhir.

Meski plot di bawah menunjukkan konvergensi monoton, simulasi Pauli propagation umumnya tidak konvergen secara monoton. Wajar kalau kita melihat perilaku "bergelombang" di plot jenis ini.

import matplotlib.pyplot as plt
from qiskit_aer import AerSimulator

sim_circ = circuit.copy()
sim_circ.save_statevector()
backend = AerSimulator(method="statevector")
psi = backend.run(sim_circ).result().data()["statevector"]
exact_ev = psi.expectation_value(observable)

ax1 = plt.gca()
ax1.plot(max_terms_list, approx_evs, marker="o", label="Approximate")
ax1.axhline(exact_ev, linestyle="--", color="green", label="Exact")
ax1.set_xscale("log")
ax1.set_xlabel("# terms kept")
ax1.set_ylabel(r"$\frac{1}{N} \sum_{i=1}^{N} \langle z_i \rangle$")

ax2 = ax1.twinx()
ax2.plot(
    max_terms_list, durations, marker=".", label="Runtime", color="orange"
)
ax2.set_ylabel("Runtime (s)", color="orange")
ax2.set_yscale("log")

handles1, labels1 = ax1.get_legend_handles_labels()
handles2, labels2 = ax2.get_legend_handles_labels()
ax1.legend(handles1 + handles2, labels1 + labels2, loc="lower right")

plt.title(f"Simulating {num_steps}-step 1D Ising Model")

Text(0.5, 1.0, 'Simulating 20-step 1D Ising Model')