Mga Fractional Gate

Mga bersyon ng package

Ang code sa pahinang ito ay ginawa gamit ang mga sumusunod na kinakailangan. Inirerekumenda naming gamitin ang mga bersyong ito o mas bago pa.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

Ipinapakilala ng pahinang ito ang dalawang bagong uri ng gate na sinusuportahan sa IBM Quantum® fleet ng mga QPU. Ang mga fractional na gate na ito ay sinusuportahan sa Heron QPUs sa anyo ng:

• $R_{ZZ}(\theta)$ para sa $0 \lt \theta \leq \pi/2$
• $R_X(\theta)$ para sa anumang $\theta$

Tinatalakay ng pahinang ito ang mga sitwasyon kung saan maaaring mapabuti ng mga fractional gate ang kahusayan ng iyong mga workflow, pati na rin kung paano gamitin ang mga gate na ito sa IBM Quantum QPUs.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-runtime

Paano gamitin ang mga fractional gate

Sa loob, ang mga fractional na gate na ito ay gumagana sa pamamagitan ng direktang pagsasagawa ng isang $R_{ZZ}(\theta)$ at $R_X(\theta)$ na rotation para sa isang arbitrary na anggulo. Ang paggamit ng $R_X(\theta)$ gate ay maaaring bawasan ang tagal at error para sa mga single-qubit na rotation ng arbitrary na anggulo ng hanggang dalawang beses. Ang direktang pagsasagawa ng $R_{ZZ}(\theta)$ gate rotation ay umiiwas sa decomposition sa maraming CZGate na object, na katulad na nagpapababa ng tagal at error ng isang circuit. Ito ay lalo na kapaki-pakinabang para sa mga circuit na naglalaman ng maraming single- at two-qubit na rotation, tulad ng kapag sinesimulate ang dynamics ng isang quantum system o kapag gumagamit ng variational ansatz na may maraming parameter.

Bagama't ang mga ganitong uri ng gate ay nasa library ng mga standard gate na maaaring mayroon ang isang QuantumCircuit, magagamit lamang ang mga ito sa mga partikular na IBM Quantum QPU, at dapat i-load ang mga ito na may flag na use_fractional_gates na nakatakda sa True (ipinapakita sa ibaba). Titiyakin ng flag na ito na ang mga fractional gate ay isasama sa Target ng backend para sa transpiler.

service = QiskitRuntimeService()
backend = service.backend('ibm_torino', use_fractional_gates=True)

Ipinapakita ng code example na ito kung paano gamitin ang mga fractional gate sa konteksto ng isang workflow na sinesimulate ang dynamics ng isang Ising chain gamit ang mga fractional gate. Ang tagal ng circuit ay inihambing pagkatapos laban sa isang backend na hindi gumagamit ng mga fractional gate.

Tala tungkol sa mga iniulat na error rate

Ang error value na iniulat sa Target ng isang backend na may mga fractional gate na pinagana ay isang kopya lamang ng katumbas ng hindi fractional na gate (na maaaring hindi pareho). Ito ay dahil hindi pa sinusuportahan ang pag-uulat ng mga error rate sa mga fractional gate.

Gayunpaman, dahil pareho ang gate time ng fractional at hindi fractional na gate, makatwirang ipagpalagay na katulad ang kanilang mga error rate — lalo na kapag ang dominanteng pinagmulan ng error sa isang circuit ay dahil sa relaxation.

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization.timeline import draw as draw_timeline, IQXSimple

from qiskit_ibm_runtime import QiskitRuntimeService

num_qubits = 5
num_time_steps = 3
rx_angle = 0.1
rzz_angle = 0.1

ising_circuit = QuantumCircuit(num_qubits)
for i in range(num_time_steps):
    # rx layer
    for q in range(num_qubits):
        ising_circuit.rx(rx_angle, q)
    for q in range(1, num_qubits - 1, 2):
        ising_circuit.rzz(rzz_angle, q, q + 1)
    # 2nd rzz layer
    for q in range(0, num_qubits - 1, 2):
        ising_circuit.rzz(rzz_angle, q, q + 1)
    ising_circuit.barrier()
ising_circuit.draw("mpl")

Magtukoy ng dalawang backend object: isa na may mga fractional gate na pinagana, at isa pang hindi pinagana, pagkatapos ay i-transpile ang dalawa.

service = QiskitRuntimeService()
backend_fractional = service.backend("ibm_torino", use_fractional_gates=True)
backend_conventional = service.backend(
    "ibm_torino", use_fractional_gates=False
)

pm_fractional = generate_preset_pass_manager(
    optimization_level=3, backend=backend_fractional, scheduling_method="alap"
)
pm_conventional = generate_preset_pass_manager(
    optimization_level=3,
    backend=backend_conventional,
    scheduling_method="alap",
)

ising_circuit_fractional = pm_fractional.run(ising_circuit)
ising_circuit_conventional = pm_conventional.run(ising_circuit)

Ipakita ang timeline ng circuit gamit ang dalawang uri ng gate.

# Draw timeline of circuit with conventional gates
draw_timeline(
    ising_circuit_conventional,
    idle_wires=False,
    target=backend_conventional.target,
    time_range=(0, 500),
    style=IQXSimple(),
)

# Draw timeline of circuit with fractional gates
draw_timeline(
    ising_circuit_fractional,
    idle_wires=False,
    target=backend_fractional.target,
    time_range=(0, 500),
    style=IQXSimple(),
)

Mga limitasyon sa anggulo

Para sa two-qubit na $R_{ZZ}(\theta)$ gate, ang mga anggulo lamang na nasa pagitan ng $0$ at $\pi/2$ ang maaaring isagawa sa IBM Quantum hardware. Kung ang isang circuit ay naglalaman ng anumang $R_{ZZ}(\theta)$ gate na may anggulo sa labas ng saklaw na ito, ang karaniwang transpilation pipeline ay karaniwang magtatama nito gamit ang naaangkop na circuit transformation (sa pamamagitan ng FoldRzzAngle pass). Gayunpaman, para sa anumang $R_{ZZ}(\theta)$ gate na naglalaman ng isa o higit pang Parameter, ipagpapalagay ng transpiler na ang mga parameter na ito ay bibigyan ng mga anggulo sa loob ng saklaw na ito sa runtime. Mabibigo ang job kung ang alinman sa mga halaga ng parameter na tinukoy sa PUB na isinumite sa Qiskit Runtime ay nasa labas ng saklaw na ito.

Saan gagamitin ang mga fractional gate

Sa kasaysayan, ang mga basis gate na available sa IBM Quantum QPUs ay CZ, X, RZ, SX, at ID, na hindi mahusay na nakakatawan ng mga circuit na may single- at two-qubit na rotation na hindi multiply ng $\pi / 2$. Halimbawa, ang isang $R_X(\theta)$ gate, kapag na-transpile, ay kailangang ma-decompose sa isang serye ng mga $RZ$ at $\sqrt{X}$ gate, na lumilikha ng circuit na may dalawang gate ng may takdang tagal sa halip na isa.

Katulad nito, kapag ang mga two-qubit na rotation tulad ng isang $R_{ZZ}(\theta)$ gate ay na-transpile, ang decomposition ay nangangailangan ng dalawang CZ gate at ilang single-qubit gate, na nagpapataas ng lalim ng circuit. Ang mga decomposition na ito ay ipinapakita sa sumusunod na code.

qc = QuantumCircuit(1)
param = Parameter("θ")
qc.rx(param, 0)
qc.draw("mpl")

# Decomposition of an RX(θ) gate using the IBM Quantum QPU basis
service = QiskitRuntimeService()
backend = service.backend("ibm_torino")
optimization_level = 3
pm = generate_preset_pass_manager(optimization_level, backend=backend)
transpiled_circuit = pm.run(qc)
transpiled_circuit.draw("mpl", idle_wires=False)

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpiler import generate_preset_pass_manager

from qiskit_ibm_runtime import QiskitRuntimeService

qc = QuantumCircuit(2)
param = Parameter("θ")
qc.rzz(param, 0, 1)
qc.draw("mpl")

# Decomposition of an RZZ(θ) gate using the IBM Quantum QPU basis
service = QiskitRuntimeService()
backend = service.backend("ibm_torino")
optimization_level = 3
pm = generate_preset_pass_manager(optimization_level, backend=backend)
transpiled_circuit = pm.run(qc)
transpiled_circuit.draw("mpl", idle_wires=False)

Para sa mga workflow na nangangailangan ng maraming single-qubit na $R_X(\theta)$ o two-qubit na rotation (tulad ng sa isang variational ansatz o kapag sinesimulate ang time evolution ng mga quantum system), ang limitasyong ito ay nagdudulot ng mabilis na paglago ng lalim ng circuit. Gayunpaman, inaaalis ng mga fractional gate ang kinakailangang ito, dahil ang mga single- at two-qubit na rotation ay direktang isinasagawa, na lumilikha ng mas mahusay (at samakatuwid ay mas kaunting error) na quantum circuit.

Kailan hindi dapat gamitin ang mga fractional gate

Mahalagang tandaan na ang mga fractional gate ay isang experimental na feature at ang gawi ng use_fractional_gates flag ay maaaring magbago sa hinaharap. Tingnan ang mga release note para sa mga bagong bersyon ng Qiskit Runtime para sa karagdagang impormasyon. Tingnan din ang API reference documentation para sa QiskitRuntimeService.backend, na naglalarawan ng use_fractional_gates.

Bukod pa rito, ang Qiskit transpiler ay may limitadong kakayahan na gamitin ang $R_{ZZ}(\theta)$ sa mga optimization pass nito. Kailangan mong maging mas maingat sa paggawa at pag-optimize ng mga circuit na naglalaman ng mga instruksyong ito.

Panghuli, hindi sinusuportahan ang paggamit ng mga fractional gate para sa:

• Mga dynamic circuit
• Pauli twirling — gayunpaman, ang measurement twirling gamit ang TREX ay sinusuportahan.
• Probabilistic error cancellation
• Zero-noise extrapolation (gamit ang probabilistic error amplification)

Basahin ang gabay sa mga primitive option para matuto pa tungkol sa pag-customize ng mga error mitigation at suppression technique para sa isang partikular na quantum workload.

Mga susunod na hakbang

Mga Rekomendasyon

• Para matuto pa tungkol sa transpilation, tingnan ang pahinang panimula sa transpilation.
• Basahin ang tungkol sa pagsulat ng custom na transpiler pass.
• Alamin kung paano i-configure ang error mitigation para sa Qiskit Runtime.