Kelas Operator

Versi paket

Kode di halaman ini dikembangkan menggunakan persyaratan berikut. Kami sarankan menggunakan versi ini atau yang lebih baru.

qiskit[all]~=2.3.0

Halaman ini menunjukkan cara menggunakan kelas Operator. Untuk gambaran umum tentang representasi operator di Qiskit, termasuk kelas Operator dan lainnya, lihat Gambaran umum 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

Mengonversi kelas ke Operator

Beberapa kelas lain di Qiskit bisa langsung dikonversi menjadi objek Operator menggunakan metode inisialisasi operator. Misalnya:

• Objek Pauli
• Objek Gate dan Instruction
• Objek QuantumCircuit

Perlu dicatat bahwa poin terakhir berarti kamu bisa menggunakan kelas Operator sebagai simulator uniter untuk menghitung matriks uniter akhir dari sebuah Circuit kuantum, tanpa perlu memanggil simulator Backend. Jika Circuit mengandung operasi yang tidak didukung, sebuah pengecualian akan dimunculkan. Operasi yang tidak didukung adalah: measure, reset, operasi kondisional, atau Gate yang tidak memiliki definisi matriks atau dekomposisi dalam bentuk 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))

Menggunakan Operator di dalam Circuit

Operator uniter bisa langsung dimasukkan ke dalam QuantumCircuit menggunakan metode QuantumCircuit.append. Ini mengonversi Operator menjadi objek UnitaryGate, yang kemudian ditambahkan ke Circuit.

Jika operatornya tidak uniter, sebuah pengecualian akan dimunculkan. Hal ini bisa diperiksa menggunakan fungsi Operator.is_unitary(), yang mengembalikan True jika operator bersifat uniter dan False jika tidak.

# 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")

Perlu diperhatikan bahwa pada contoh di atas, operator diinisialisasi dari objek Pauli. Namun, objek Pauli juga bisa langsung dimasukkan ke dalam Circuit itu sendiri dan akan dikonversi menjadi rangkaian Gate Pauli single-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

Menggabungkan Operator

Operator bisa digabungkan menggunakan beberapa metode.

Tensor product

Dua operator $A$ dan $B$ bisa digabungkan menjadi operator tensor product $A\otimes B$ menggunakan fungsi Operator.tensor. Perlu diperhatikan bahwa jika $A$ dan $B$ keduanya adalah operator single-Qubit, maka A.tensor(B) = $A\otimes B$ akan memiliki 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))

Tensor expansion

Operasi yang berkaitan erat adalah Operator.expand, yang bekerja seperti tensor product tetapi dalam urutan terbalik. Sehingga, untuk dua operator $A$ dan $B$ kamu mendapatkan 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

Kamu juga bisa mengomposisikan dua operator $A$ dan $B$ untuk melakukan perkalian matriks menggunakan metode 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,))

Kamu juga bisa mengomposisikan dalam urutan terbalik dengan menerapkan $B$ di depan $A$ menggunakan kwarg 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

Perlu diperhatikan bahwa komposisi sebelumnya mengharuskan total dimensi output dari operator pertama $A$ sama dengan total dimensi input dari operator yang dikomposisikan $B$ (dan begitu juga sebaliknya, dimensi output dari $B$ harus sama dengan dimensi input dari $A$ saat mengomposisikan dengan front=True).

Kamu juga bisa mengomposisikan operator yang lebih kecil dengan pilihan subsistem pada operator yang lebih besar menggunakan kwarg qargs dari compose, baik dengan atau tanpa front=True. Dalam hal ini, dimensi input dan output yang relevan dari subsistem yang dikomposisikan harus cocok. Perhatikan bahwa operator yang lebih kecil harus selalu menjadi argumen dari metode compose.

Misalnya, untuk mengomposisikan 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))

Kombinasi linear

Operator juga bisa digabungkan menggunakan operator linear standar untuk penjumlahan, pengurangan, dan perkalian skalar dengan bilangan 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))

Poin penting adalah bahwa sementara tensor, expand, dan compose mempertahankan keunitaran operator uniter, kombinasi linear tidak; sehingga, menambahkan dua operator uniter pada umumnya akan menghasilkan operator yang tidak uniter:

op.is_unitary()

False

Konversi implisit ke Operator

Perlu dicatat bahwa untuk semua metode berikut, jika objek kedua belum berupa objek Operator, ia akan secara implisit dikonversi menjadi satu oleh metode tersebut. Ini berarti matriks bisa langsung dimasukkan tanpa harus dikonversi secara eksplisit menjadi Operator terlebih dahulu. Jika konversi tidak memungkinkan, sebuah pengecualian akan dimunculkan.

# 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,))

Membandingkan Operator

Operator mengimplementasikan metode kesetaraan yang bisa digunakan untuk memeriksa apakah dua operator kira-kira sama.

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

True

Perlu diperhatikan bahwa ini memeriksa apakah setiap elemen matriks dari operator kira-kira sama; dua uniter yang berbeda hanya berdasarkan fase global tidak dianggap sama:

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

False

Fidelitas proses

Kamu juga bisa membandingkan operator menggunakan fungsi process_fidelity dari modul Quantum Information. Ini adalah besaran teoritis-informasi untuk seberapa dekat dua kanal kuantum satu sama lain, dan dalam kasus operator uniter hal ini tidak bergantung pada fase 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

Perlu diperhatikan bahwa fidelitas proses pada umumnya hanya merupakan ukuran kedekatan yang valid jika operator input bersifat uniter (atau CP dalam kasus kanal kuantum), dan sebuah pengecualian akan dimunculkan jika input tidak CP.

Langkah selanjutnya

Rekomendasi

• Jelajahi referensi Operator API.