Перейти до основного вмісту

Огляд класів операторів

Версії пакетів

Код на цій сторінці розроблено з використанням наведених нижче залежностей. Рекомендуємо використовувати ці версії або новіші.

qiskit[all]~=2.3.0

У Qiskit квантові оператори представлені класами з модуля quantum_info. Найважливішим класом операторів є SparsePauliOp, який представляє загальний квантовий оператор як лінійну комбінацію рядків Паулі. SparsePauliOp — це клас, що найчастіше використовується для представлення квантових спостережуваних. Решта цієї сторінки пояснює, як використовувати SparsePauliOp та інші класи операторів.

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

Клас SparsePauliOp представляє лінійну комбінацію рядків Паулі. Існує кілька способів ініціалізації SparsePauliOp, але найгнучкішим є метод from_sparse_list, продемонстрований у наступному блоці коду. Метод from_sparse_list приймає список трійок (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 підтримує арифметичні операції, що продемонстровано в наступному блоці коду.

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​

Клас Pauli представляє одиночний рядок Паулі з необов'язковим фазовим коефіцієнтом із множини { +1,i,−1,−i }\set{+1, i, -1, -i}. Pauli можна ініціалізувати, передавши рядок символів із множини {"I", "X", "Y", "Z"}, необов'язково з префіксом із {"", "i", "-", "-i"} для позначення фазового коефіцієнта.

op1 = Pauli("iXX")
op1
Pauli('iXX')

Наступний блок коду демонструє використання деяких атрибутів і методів.

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

Об'єкти Pauli мають низку інших методів для маніпуляцій з операторами, зокрема визначення спряженого оператора, перевірки (анти)комутативності з іншим Pauli та обчислення скалярного добутку з іншим Pauli. Докладніше дивись у документації API.

Operator​

Клас Operator представляє загальний лінійний оператор. На відміну від SparsePauliOp, клас Operator зберігає лінійний оператор у вигляді щільної матриці. Оскільки пам'ять, необхідна для зберігання щільної матриці, зростає експоненційно зі збільшенням кількості кубітів, клас Operator підходить лише для роботи з невеликою кількістю кубітів.

Ти можеш ініціалізувати Operator, безпосередньо передавши масив Numpy, що зберігає матрицю оператора. Наприклад, наступний блок коду створює двокубітний оператор Паулі XX:

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

Об'єкт оператора зберігає базову матрицю, а також вхідні та вихідні розмірності підсистем.

  • data: Щоб отримати доступ до базового масиву Numpy, використовуй властивість Operator.data.
  • dims: Щоб повернути загальні вхідну та вихідну розмірності оператора, використовуй властивість Operator.dim. Примітка: результат повертається як кортеж (input_dim, output_dim), що є зворотним порядком відносно форми базової матриці.
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)

Клас оператора також відстежує розмірності підсистем, які можна використовувати для компонування операторів. До них можна звернутися за допомогою функцій input_dims і output_dims.

Для операторів розміру 2N2^N на 2M2^M вхідні та вихідні розмірності автоматично вважаються M-кубітними та N-кубітними відповідно:

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

Якщо вхідна матриця не ділиться на кубітні підсистеми, вона буде збережена як однокубітний оператор. Наприклад, для матриці 6×66\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,)

Вхідну та вихідну розмірності також можна вказати вручну під час ініціалізації нового оператора:

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

Ти також можеш отримати лише вхідні або вихідні розмірності підмножини підсистем за допомогою функцій input_dims і 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,)

Наступні кроки​

Рекомендації