Lumaktaw sa pangunahing nilalaman

Pangkalahatang-tanaw ng mga klase ng operator

Mga bersyon ng package

Ang code sa page na ito ay ginawa gamit ang mga sumusunod na kinakailangan. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago pa.

qiskit[all]~=2.3.0

Sa Qiskit, ang mga quantum operator ay kinakatawan gamit ang mga klase mula sa quantum_info module. Ang pinakamahalagang klase ng operator ay SparsePauliOp, na kumakatawan sa isang pangkalahatang quantum operator bilang linear na kombinasyon ng mga Pauli string. Ang SparsePauliOp ang klase na pinakakaraniwang ginagamit para kumatawan sa mga quantum observable. Ipinaliwanag sa natitirang bahagi ng page na ito kung paano gamitin ang SparsePauliOp at iba pang mga klase ng operator.

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

Ang SparsePauliOp na klase ay kumakatawan sa isang linear na kombinasyon ng mga Pauli string. Maraming paraan para ma-initialize ang isang SparsePauliOp, ngunit ang pinaka-flexible na paraan ay ang paggamit ng from_sparse_list na method, tulad ng ipinapakita sa sumusunod na code cell. Ang from_sparse_list ay tumatanggap ng listahan ng mga (pauli_string, qubit_indices, coefficient) na triplets.

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

Sinusuportahan ng SparsePauliOp ang mga aritmetikong operasyon, tulad ng ipinapakita sa sumusunod na code cell.

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​

Ang Pauli na klase ay kumakatawan sa isang Pauli string na may opsyonal na phase coefficient mula sa set na { +1,i,−1,−i }\set{+1, i, -1, -i}. Maaaring ma-initialize ang isang Pauli sa pamamagitan ng pagpasa ng string ng mga karakter mula sa set na {"I", "X", "Y", "Z"}, na opsyonal na may prefix na isa sa {"", "i", "-", "-i"} para kumatawan sa phase coefficient.

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

Ipinapakita ng sumusunod na code cell ang paggamit ng ilang mga katangian at method.

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

Ang mga Pauli object ay may maraming iba pang method para manipulahin ang mga operator tulad ng pagkuha ng adjoint, pagtukoy kung ito ay (anti)commutes sa isa pang Pauli, at pagkalkula ng dot product sa isa pang Pauli. Tingnan ang API documentation para sa karagdagang impormasyon.

Operator​

Ang Operator na klase ay kumakatawan sa isang pangkalahatang linear operator. Hindi tulad ng SparsePauliOp, ang Operator ay nag-iimbak ng linear operator bilang isang dense matrix. Dahil ang memoryang kinakailangan para mag-imbak ng dense matrix ay lumalaki nang exponential habang tumataas ang bilang ng qubit, ang Operator na klase ay angkop lamang para sa maliit na bilang ng qubit.

Maaari kang mag-initialize ng Operator sa pamamagitan ng direktang pagpasa ng Numpy array na nag-iimbak ng matrix ng operator. Halimbawa, ang sumusunod na code cell ay gumagawa ng two-qubit Pauli XX operator:

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

Nag-iimbak ang operator object ng pinagbabatayan na matrix, at ang input at output na dimensyon ng mga subsystem.

  • data: Para ma-access ang pinagbabatayan na Numpy array, maaari mong gamitin ang Operator.data property.
  • dims: Para maibalik ang kabuuang input at output na dimensyon ng operator, maaari mong gamitin ang Operator.dim property. Tandaan: ang output ay ibinalik bilang tuple (input_dim, output_dim), na kabaligtaran ng hugis ng pinagbabatayan na matrix.
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)

Sinusubaybayan din ng klase ng operator ang mga dimensyon ng subsystem, na maaaring gamitin para pagsamahin ang mga operator. Maa-access ang mga ito gamit ang mga function na input_dims at output_dims.

Para sa mga operator na 2N2^N by 2M2^M, ang input at output na dimensyon ay awtomatikong ipinapalagay na M-qubit at 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,)

Kung ang input matrix ay hindi mahahati sa mga qubit subsystem, ito ay itatabi bilang isang single-qubit operator. Halimbawa, para sa isang 6×66\times6 na matrix:

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

Maaari ring manu-manong tukuyin ang input at output na dimensyon kapag nagsi-initialize ng bagong operator:

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

Maaari ka ring mag-extract lamang ng input o output na dimensyon ng isang subset ng mga subsystem gamit ang mga function na input_dims at 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,)

Mga susunod na hakbang​

Mga rekomendasyon