Gambaran keseluruhan kelas operator

Versi pakej

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

qiskit[all]~=2.3.0

Dalam Qiskit, operator kuantum diwakili menggunakan kelas daripada modul quantum_info. Kelas operator yang paling penting ialah SparsePauliOp, yang mewakili operator kuantum umum sebagai gabungan linear rentetan Pauli. SparsePauliOp adalah kelas yang paling kerap digunakan untuk mewakili observable kuantum. Selebihnya halaman ini menerangkan cara menggunakan SparsePauliOp dan kelas operator lain.

# 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 mewakili gabungan linear rentetan Pauli. Terdapat beberapa cara untuk memulakan SparsePauliOp, tetapi cara yang paling fleksibel ialah menggunakan kaedah from_sparse_list, seperti yang ditunjukkan dalam sel kod berikut. from_sparse_list menerima senarai 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 menyokong operasi aritmetik, seperti yang ditunjukkan dalam sel kod 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 mewakili satu rentetan Pauli dengan pekali fasa pilihan daripada set $\set{+1, i, -1, -i}$. Pauli boleh dimulakan dengan menghantar rentetan aksara daripada set {"I", "X", "Y", "Z"}, secara pilihan diawali oleh salah satu daripada {"", "i", "-", "-i"} untuk mewakili pekali fasa.

op1 = Pauli("iXX")
op1

Pauli('iXX')

Sel kod berikut menunjukkan penggunaan beberapa atribut dan kaedah.

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 mempunyai pelbagai kaedah lain untuk memanipulasi operator, seperti menentukan adjointnya, sama ada ia (anti)komut dengan Pauli lain, dan mengira hasil darab titik dengan Pauli lain. Rujuk dokumentasi API untuk maklumat lanjut.

Operator

Kelas Operator mewakili operator linear umum. Berbeza dengan SparsePauliOp, Operator menyimpan operator linear sebagai matriks padat. Oleh sebab memori yang diperlukan untuk menyimpan matriks padat meningkat secara eksponen mengikut bilangan Qubit, kelas Operator hanya sesuai digunakan dengan bilangan Qubit yang kecil.

Anda boleh memulakan Operator dengan menghantar terus tatasusunan Numpy yang menyimpan matriks operator. Contohnya, sel kod berikut mencipta 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 asas, serta dimensi input dan output subsistem.

• data: Untuk mengakses tatasusunan Numpy asas, anda boleh menggunakan sifat Operator.data.
• dims: Untuk mendapatkan jumlah dimensi input dan output operator, anda boleh menggunakan sifat Operator.dim. Nota: output dikembalikan sebagai tuple (input_dim, output_dim), yang merupakan songsangan bentuk matriks asas.

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 menjejak dimensi subsistem, yang boleh digunakan untuk menggabungkan operator bersama-sama. Ini boleh diakses menggunakan fungsi input_dims dan output_dims.

Untuk operator $2^N$ kali $2^M$, dimensi input dan output secara automatik dianggap 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 boleh dibahagikan kepada subsistem Qubit, ia akan disimpan sebagai operator satu-Qubit. Contohnya, 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 boleh ditentukan secara manual semasa memulakan operator baharu:

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

Anda juga boleh mengekstrak hanya dimensi input atau output 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 seterusnya

Cadangan

• Pelajari cara menentukan observable dalam asas Pauli.
• Lihat contoh penggunaan operator dalam tutorial Gabungkan pilihan mitigasi ralat dengan primitif Estimator.
• Baca liputan mendalam kelas Operator.
• Terokai rujukan API Operator.