Ikhtisar kelas-kelas operator

Versi paket

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

qiskit[all]~=2.3.0

Di Qiskit, operator kuantum direpresentasikan menggunakan kelas-kelas dari modul quantum_info. Kelas operator yang paling penting adalah SparsePauliOp, yang merepresentasikan operator kuantum umum sebagai kombinasi linear dari string Pauli. SparsePauliOp adalah kelas yang paling sering digunakan untuk merepresentasikan observabel kuantum. Bagian selanjutnya di halaman ini menjelaskan cara menggunakan SparsePauliOp dan kelas operator lainnya.

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

import numpy as np
from qiskit.quantum_info.operators import Operator, Pauli, SparsePauliOp

SparsePauliOp

Kelas SparsePauliOp merepresentasikan kombinasi linear dari string Pauli. Ada beberapa cara untuk menginisialisasi SparsePauliOp, tetapi cara yang paling fleksibel adalah menggunakan metode from_sparse_list, seperti yang ditunjukkan pada sel kode berikut. from_sparse_list menerima daftar triplet (pauli_string, qubit_indices, coefficient).

op1 = SparsePauliOp.from_sparse_list(
    [("ZX", [1, 4], 1.0), ("YY", [0, 3], -1 + 1j)], num_qubits=5
)
op1

SparsePauliOp(['XIIZI', 'IYIIY'],
              coeffs=[ 1.+0.j, -1.+1.j])

SparsePauliOp mendukung operasi aritmetika, seperti yang ditunjukkan pada sel kode berikut.

op2 = SparsePauliOp.from_sparse_list(
    [("XXZ", [0, 1, 4], 1 + 2j), ("ZZ", [1, 2], -1 + 1j)], num_qubits=5
)

# Addition
print("op1 + op2:")
print(op1 + op2)
print()
# Multiplication by a scalar
print("2 * op1:")
print(2 * op1)
print()
# Operator multiplication (composition)
print("op1 @ op2:")
print(op1 @ op2)
print()
# Tensor product
print("op1.tensor(op2):")
print(op1.tensor(op2))

op1 + op2:
SparsePauliOp(['XIIZI', 'IYIIY', 'ZIIXX', 'IIZZI'],
              coeffs=[ 1.+0.j, -1.+1.j,  1.+2.j, -1.+1.j])

2 * op1:
SparsePauliOp(['XIIZI', 'IYIIY'],
              coeffs=[ 2.+0.j, -2.+2.j])

op1 @ op2:
SparsePauliOp(['YIIYX', 'XIZII', 'ZYIXZ', 'IYZZY'],
              coeffs=[ 1.+2.j, -1.+1.j, -1.+3.j,  0.-2.j])

op1.tensor(op2):
SparsePauliOp(['XIIZIZIIXX', 'XIIZIIIZZI', 'IYIIYZIIXX', 'IYIIYIIZZI'],
              coeffs=[ 1.+2.j, -1.+1.j, -3.-1.j,  0.-2.j])

Pauli

Kelas Pauli merepresentasikan satu string Pauli dengan koefisien fase opsional dari himpunan $\set{+1, i, -1, -i}$. Pauli dapat diinisialisasi dengan memasukkan string karakter dari himpunan {"I", "X", "Y", "Z"}, yang secara opsional diawali dengan salah satu dari {"", "i", "-", "-i"} untuk merepresentasikan koefisien fase.

op1 = Pauli("iXX")
op1

Pauli('iXX')

Sel kode berikut mendemonstrasikan penggunaan beberapa atribut dan metode.

print(f"Dimension of {op1}: {op1.dim}")
print(f"Phase of {op1}: {op1.phase}")
print(f"Matrix representation of {op1}: \n {op1.to_matrix()}")

Dimension of iXX: (4, 4)
Phase of iXX: 3
Matrix representation of iXX:
 [[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.+1.j 0.+0.j 0.+0.j]
 [0.+1.j 0.+0.j 0.+0.j 0.+0.j]]

Objek Pauli memiliki sejumlah metode lain untuk memanipulasi operator, seperti menentukan adjoint-nya, apakah operator itu (anti)komut dengan Pauli lain, dan menghitung hasil kali titik dengan Pauli lain. Lihat dokumentasi API untuk info lebih lanjut.

Operator

Kelas Operator merepresentasikan operator linear umum. Tidak seperti SparsePauliOp, Operator menyimpan operator linear sebagai matriks padat. Karena memori yang dibutuhkan untuk menyimpan matriks padat tumbuh secara eksponensial seiring bertambahnya jumlah Qubit, kelas Operator hanya cocok digunakan dengan jumlah Qubit yang kecil.

Kamu bisa menginisialisasi Operator dengan langsung memasukkan array Numpy yang menyimpan matriks operator. Misalnya, sel kode berikut membuat operator Pauli XX dua Qubit:

XX = Operator(
    np.array(
        [
            [0, 0, 0, 1],
            [0, 0, 1, 0],
            [0, 1, 0, 0],
            [1, 0, 0, 0],
        ]
    )
)
XX

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

Objek operator menyimpan matriks yang mendasarinya, serta dimensi input dan output dari subsistem.

• data: Untuk mengakses array Numpy yang mendasarinya, kamu bisa menggunakan properti Operator.data.
• dims: Untuk mengembalikan total dimensi input dan output operator, kamu bisa menggunakan properti Operator.dim. Catatan: output dikembalikan sebagai tuple (input_dim, output_dim), yang merupakan kebalikan dari bentuk matriks yang mendasarinya.

XX.data

array([[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_dim, output_dim = XX.dim
input_dim, output_dim

(4, 4)

Kelas operator juga melacak dimensi subsistem, yang bisa digunakan untuk mengomposisi operator bersama-sama. Ini bisa diakses menggunakan fungsi input_dims dan output_dims.

Untuk operator berukuran $2^N$ kali $2^M$, dimensi input dan output secara otomatis diasumsikan sebagai M-Qubit dan N-Qubit:

op = Operator(np.random.rand(2**1, 2**2))
print("Input dimensions:", op.input_dims())
print("Output dimensions:", op.output_dims())

Input dimensions: (2, 2)
Output dimensions: (2,)

Jika matriks input tidak dapat dibagi menjadi subsistem Qubit, maka akan disimpan sebagai operator single-qubit. Misalnya, untuk matriks $6\times6$:

op = Operator(np.random.rand(6, 6))
print("Input dimensions:", op.input_dims())
print("Output dimensions:", op.output_dims())

Input dimensions: (6,)
Output dimensions: (6,)

Dimensi input dan output juga bisa ditentukan secara manual saat menginisialisasi operator baru:

# Force input dimension to be (4,) rather than (2, 2)
op = Operator(np.random.rand(2**1, 2**2), input_dims=[4])
print("Input dimensions:", op.input_dims())
print("Output dimensions:", op.output_dims())

Input dimensions: (4,)
Output dimensions: (2,)

# Specify system is a qubit and qutrit
op = Operator(np.random.rand(6, 6), input_dims=[2, 3], output_dims=[2, 3])
print("Input dimensions:", op.input_dims())
print("Output dimensions:", op.output_dims())

Input dimensions: (2, 3)
Output dimensions: (2, 3)

Kamu juga bisa mengekstrak hanya dimensi input atau output dari subset subsistem menggunakan fungsi input_dims dan output_dims:

print("Dimension of input system 0:", op.input_dims([0]))
print("Dimension of input system 1:", op.input_dims([1]))

Dimension of input system 0: (2,)
Dimension of input system 1: (3,)

Langkah berikutnya

Rekomendasi

• Pelajari cara menentukan observabel dalam basis Pauli.
• Lihat contoh penggunaan operator dalam tutorial Combine error mitigation options with the Estimator primitive.
• Baca lebih lanjut pembahasan mendalam tentang kelas Operator.
• Jelajahi referensi Operator API.