Pag-synthesize ng mga unitary na operasyon

Mga bersyon ng package

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

qiskit[all]~=2.3.0

Ang isang unitary na operasyon ay naglalarawan ng isang pagbabago sa quantum system na nagpapanatili ng norm. Para sa $n$ na mga qubit, ang pagbabagong ito ay inilalarawan ng isang $2^n \times 2^n$ na dimensyon, kumplikadong matrix $U$ na ang adjoint ay katumbas ng inverse, iyon ay $U^\dagger U = \mathbb{1}$.

Ang pag-synthesize ng mga tiyak na unitary na operasyon sa isang hanay ng mga quantum gate ay isang pangunahing gawain na ginagamit, halimbawa, sa disenyo at aplikasyon ng mga quantum algorithm o sa pag-compile ng mga quantum circuit.

Bagama't posible ang mahusay na synthesis para sa ilang uri ng mga unitary — tulad ng mga binubuo ng mga Clifford gate o may tensor product na istraktura — karamihan sa mga unitary ay hindi napapabilang sa mga kategoryang ito. Para sa mga pangkalahatang unitary matrix, ang synthesis ay isang kumplikadong gawain na ang computational cost ay tumataas nang exponential habang dumadami ang bilang ng mga qubit. Kaya naman, kung alam mo ang isang mahusay na decomposition para sa unitary na gusto mong ipatupad, malamang na mas maganda pa ito kaysa sa isang pangkalahatang synthesis.

tala

Kung walang available na decomposition, nagbibigay ang Qiskit SDK ng mga tool para mahanap ito. Gayunpaman, tandaan na sa pangkalahatan ay gumagawa ito ng malalim na mga circuit na maaaring hindi angkop para patakbuhin sa mga maingay na quantum computer.

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

import numpy as np
from qiskit import QuantumCircuit

U = 0.5 * np.array(
    [[1, 1, 1, 1], [-1, 1, -1, 1], [-1, -1, 1, 1], [-1, 1, 1, -1]]
)

circuit = QuantumCircuit(2)
circuit.unitary(U, circuit.qubits)

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

Re-synthesis para sa pag-optimize ng circuit

Minsan ay kapaki-pakinabang ang muling pag-synthesize ng mahabang serye ng mga single- at two-qubit gate, kung mababawasan ang haba. Halimbawa, ang sumusunod na circuit ay gumagamit ng tatlong two-qubit gate.

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

qreg_q = QuantumRegister(2, "q")
creg_c = ClassicalRegister(4, "c")
circuit = QuantumCircuit(qreg_q, creg_c)

circuit.h(qreg_q[0])
circuit.cx(qreg_q[0], qreg_q[1])
circuit.sx(qreg_q[1])
circuit.cz(qreg_q[0], qreg_q[1])
circuit.x(qreg_q[1])
circuit.x(qreg_q[0])
circuit.cx(qreg_q[0], qreg_q[1])
circuit.h(qreg_q[0])
circuit.draw("mpl")

Gayunpaman, pagkatapos ng muling pag-synthesize gamit ang sumusunod na code, isang CX gate na lang ang kailangan nito. (Dito ay ginagamit namin ang QuantumCircuit.decompose() na paraan para mas mavisuwalisaw ang mga gate na ginamit sa muling pag-synthesize ng unitary.)

from qiskit.quantum_info import Operator

# compute unitary matrix of circuit
U = Operator(circuit)

# re-synthesize
better_circuit = QuantumCircuit(2)
better_circuit.unitary(U, range(2))
better_circuit.decompose().draw()

global phase: 6.2071
      ┌───────────────┐         ┌────────────────┐
q_0: ─┤ U(π/2,π/2,-π) ├────■────┤ U(π/2,-π,-π/2) ├─
     ┌┴───────────────┴─┐┌─┴─┐┌─┴────────────────┴┐
q_1: ┤ U(1.7229,π/2,-π) ├┤ X ├┤ U(π/2,0.15207,-π) ├
     └──────────────────┘└───┘└───────────────────┘

Ang transpile na function ng Qiskit ay awtomatikong nagsasagawa ng muling pag-synthesize na ito para sa sapat na mataas na antas ng optimization.

Mga susunod na hakbang

Mga Rekomendasyon

• Tingnan ang isang halimbawa ng circuit decomposition sa tutorial na Grover's Algorithm.
• Para sa karagdagang impormasyon tungkol sa Qiskit transpiler, bisitahin ang seksyon ng Transpile.