Kelas Operator

Versi pakej

Kod pada halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan menggunakan versi ini atau yang lebih baru.

qiskit[all]~=2.3.0

Halaman ini menunjukkan cara menggunakan kelas Operator. Untuk gambaran keseluruhan peringkat tinggi tentang perwakilan operator dalam Qiskit, termasuk kelas Operator dan lain-lain, lihat Gambaran keseluruhan kelas operator.

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

import numpy as np
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import CXGate, RXGate, XGate
from qiskit.quantum_info import Operator, Pauli, process_fidelity

Tukar kelas kepada Operator

Beberapa kelas lain dalam Qiskit boleh ditukar secara langsung kepada objek Operator menggunakan kaedah permulaan operator. Contohnya:

• Objek Pauli
• Objek Gate dan Instruction
• Objek QuantumCircuit

Ambil perhatian bahawa perkara terakhir bermakna anda boleh menggunakan kelas Operator sebagai simulator kesatuan untuk mengira matriks kesatuan akhir bagi Circuit kuantum, tanpa perlu memanggil Backend simulator. Jika Circuit mengandungi sebarang operasi yang tidak disokong, pengecualian akan dilemparkan. Operasi yang tidak disokong ialah: ukur, tetapkan semula, operasi bersyarat, atau Gate yang tidak mempunyai definisi matriks atau penguraian dari segi Gate dengan definisi matriks.

# Create an Operator from a Pauli object

pauliXX = Pauli("XX")
Operator(pauliXX)

Operator([[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
          [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
          [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
          [1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

# Create an Operator for a Gate object
Operator(CXGate())

Operator([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
          [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
          [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

# Create an operator from a parameterized Gate object
Operator(RXGate(np.pi / 2))

Operator([[0.70710678+0.j        , 0.        -0.70710678j],
          [0.        -0.70710678j, 0.70710678+0.j        ]],
         input_dims=(2,), output_dims=(2,))

# Create an operator from a QuantumCircuit object
circ = QuantumCircuit(10)
circ.h(0)
for j in range(1, 10):
    circ.cx(j - 1, j)

# Convert circuit to an operator by implicit unitary simulation
Operator(circ)

Operator([[ 0.70710678+0.j,  0.70710678+0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.        +0.j,  0.        +0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          ...,
          [ 0.        +0.j,  0.        +0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.70710678+0.j, -0.70710678+0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j]],
         input_dims=(2, 2, 2, 2, 2, 2, 2, 2, 2, 2), output_dims=(2, 2, 2, 2, 2, 2, 2, 2, 2, 2))

Gunakan Operator dalam Circuit

Operator kesatuan boleh dimasukkan secara langsung ke dalam QuantumCircuit menggunakan kaedah QuantumCircuit.append. Ini menukar Operator kepada objek UnitaryGate, yang ditambahkan ke Circuit.

Jika operator bukan kesatuan, pengecualian akan dilemparkan. Ini boleh diperiksa menggunakan fungsi Operator.is_unitary(), yang mengembalikan True jika operator adalah kesatuan dan False sebaliknya.

# Create an operator
XX = Operator(Pauli("XX"))

# Add to a circuit
circ = QuantumCircuit(2, 2)
circ.append(XX, [0, 1])
circ.measure([0, 1], [0, 1])
circ.draw("mpl")

Ambil perhatian bahawa dalam contoh di atas operator dimulakan dari objek Pauli. Walau bagaimanapun, objek Pauli juga boleh dimasukkan secara langsung ke dalam Circuit itu sendiri dan akan ditukar kepada urutan Gate Pauli satu Qubit:

# Add to a circuit
circ2 = QuantumCircuit(2, 2)
circ2.append(Pauli("XX"), [0, 1])
circ2.measure([0, 1], [0, 1])
circ2.draw()

┌────────────┐┌─┐
q_0: ┤0           ├┤M├───
     │  Pauli(XX) │└╥┘┌─┐
q_1: ┤1           ├─╫─┤M├
     └────────────┘ ║ └╥┘
c: 2/═══════════════╩══╩═
                    0  1

Gabungkan Operator

Operator boleh digabungkan menggunakan beberapa kaedah.

Hasil darab tensor

Dua operator $A$ dan $B$ boleh digabungkan menjadi operator hasil darab tensor $A\otimes B$ menggunakan fungsi Operator.tensor. Ambil perhatian bahawa jika kedua-dua $A$ dan $B$ adalah operator satu Qubit, maka A.tensor(B) = $A\otimes B$ akan mempunyai subsistem yang diindeks sebagai matriks $B$ pada subsistem 0, dan matriks $A$ pada subsistem 1.

A = Operator(Pauli("X"))
B = Operator(Pauli("Z"))
A.tensor(B)

Operator([[ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
          [ 0.+0.j, -0.+0.j,  0.+0.j, -1.+0.j],
          [ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
          [ 0.+0.j, -1.+0.j,  0.+0.j, -0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

Pengembangan tensor

Operasi yang berkaitan rapat ialah Operator.expand, yang bertindak seperti hasil darab tensor tetapi dalam urutan terbalik. Oleh itu, untuk dua operator $A$ dan $B$ anda mempunyai A.expand(B) = $B\otimes A$ di mana subsistem diindeks sebagai matriks $A$ pada subsistem 0, dan matriks $B$ pada subsistem 1.

A = Operator(Pauli("X"))
B = Operator(Pauli("Z"))
A.expand(B)

Operator([[ 0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j],
          [ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
          [ 0.+0.j,  0.+0.j, -0.+0.j, -1.+0.j],
          [ 0.+0.j,  0.+0.j, -1.+0.j, -0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

Komposisi

Anda juga boleh mengarang dua operator $A$ dan $B$ untuk melaksanakan pendaraban matriks menggunakan kaedah Operator.compose. A.compose(B) mengembalikan operator dengan matriks $B.A$:

A = Operator(Pauli("X"))
B = Operator(Pauli("Z"))
A.compose(B)

Operator([[ 0.+0.j,  1.+0.j],
          [-1.+0.j,  0.+0.j]],
         input_dims=(2,), output_dims=(2,))

Anda juga boleh mengarang dalam urutan terbalik dengan menerapkan $B$ di hadapan $A$ menggunakan argumen front dari compose: A.compose(B, front=True) = $A.B$:

A = Operator(Pauli("X"))
B = Operator(Pauli("Z"))
A.compose(B, front=True)

Operator([[ 0.+0.j, -1.+0.j],
          [ 1.+0.j,  0.+0.j]],
         input_dims=(2,), output_dims=(2,))

Komposisi subsistem

Ambil perhatian bahawa komposisi sebelumnya memerlukan dimensi output keseluruhan operator pertama $A$ adalah sama dengan dimensi input keseluruhan operator yang dikarang $B$ (dan begitu juga, dimensi output $B$ mesti sama dengan dimensi input $A$ apabila mengarang dengan front=True).

Anda juga boleh mengarang operator yang lebih kecil dengan pilihan subsistem pada operator yang lebih besar menggunakan argumen qargs dari compose, sama ada dengan atau tanpa front=True. Dalam kes ini, dimensi input dan output yang relevan bagi subsistem yang dikarang mesti sepadan. Ambil perhatian bahawa operator yang lebih kecil mesti sentiasa menjadi argumen kaedah compose.

Sebagai contoh, untuk mengarang Gate dua Qubit dengan operator tiga Qubit:

# Compose XZ with a 3-qubit identity operator
op = Operator(np.eye(2**3))
XZ = Operator(Pauli("XZ"))
op.compose(XZ, qargs=[0, 2])

Operator([[ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
           -1.+0.j],
          [ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j, -1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j],
          [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j]],
         input_dims=(2, 2, 2), output_dims=(2, 2, 2))

# Compose YX in front of the previous operator
op = Operator(np.eye(2**3))
YX = Operator(Pauli("YX"))
op.compose(YX, qargs=[0, 2], front=True)

Operator([[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j, 0.+0.j],
          [0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+1.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]],
         input_dims=(2, 2, 2), output_dims=(2, 2, 2))

Gabungan linear

Operator juga boleh digabungkan menggunakan operator linear standard untuk penambahan, penolakan, dan pendaraban skalar dengan nombor kompleks.

XX = Operator(Pauli("XX"))
YY = Operator(Pauli("YY"))
ZZ = Operator(Pauli("ZZ"))

op = 0.5 * (XX + YY - 3 * ZZ)
op

Operator([[-1.5+0.j,  0. +0.j,  0. +0.j,  0. +0.j],
          [ 0. +0.j,  1.5+0.j,  1. +0.j,  0. +0.j],
          [ 0. +0.j,  1. +0.j,  1.5+0.j,  0. +0.j],
          [ 0. +0.j,  0. +0.j,  0. +0.j, -1.5+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

Perkara penting ialah walaupun tensor, expand, dan compose memelihara kesatuan operator kesatuan, gabungan linear tidak; oleh itu, menambah dua operator kesatuan akan, secara umum, menghasilkan operator bukan kesatuan:

op.is_unitary()

False

Penukaran tersirat kepada Operator

Ambil perhatian bahawa untuk semua kaedah berikut, jika objek kedua belum pun merupakan objek Operator, ia akan ditukar secara tersirat kepada satu oleh kaedah itu. Ini bermakna matriks boleh dihantar secara langsung tanpa ditukar secara eksplisit kepada Operator terlebih dahulu. Jika penukaran tidak mungkin, pengecualian akan dilemparkan.

# Compose with a matrix passed as a list
Operator(np.eye(2)).compose([[0, 1], [1, 0]])

Operator([[0.+0.j, 1.+0.j],
          [1.+0.j, 0.+0.j]],
         input_dims=(2,), output_dims=(2,))

Bandingkan Operator

Operator melaksanakan kaedah kesamaan yang boleh digunakan untuk memeriksa sama ada dua operator adalah lebih kurang sama.

Operator(Pauli("X")) == Operator(XGate())

True

Ambil perhatian bahawa ini memeriksa bahawa setiap elemen matriks operator adalah lebih kurang sama; dua kesatuan yang berbeza dengan fasa global tidak dianggap sama:

Operator(XGate()) == np.exp(1j * 0.5) * Operator(XGate())

False

Kesetiaan proses

Anda juga boleh membandingkan operator menggunakan fungsi process_fidelity dari modul Maklumat Kuantum. Ini adalah kuantiti teori maklumat untuk seberapa dekat dua saluran kuantum antara satu sama lain, dan dalam kes operator kesatuan ia tidak bergantung pada fasa global.

# Two operators which differ only by phase
op_a = Operator(XGate())
op_b = np.exp(1j * 0.5) * Operator(XGate())

# Compute process fidelity
F = process_fidelity(op_a, op_b)
print("Process fidelity =", F)

Process fidelity = 1.0

Ambil perhatian bahawa kesetiaan proses umumnya hanya merupakan ukuran kedekatan yang sah jika operator input adalah kesatuan (atau CP dalam kes saluran kuantum), dan pengecualian dilemparkan jika input bukan CP.

Langkah seterusnya

Cadangan

• Terokai rujukan API Operator.