Prezentare generală a claselor de operatori

Versiuni de pachete

Codul de pe această pagină a fost dezvoltat folosind următoarele cerințe. Recomandăm folosirea acestor versiuni sau a unora mai noi.

qiskit[all]~=2.3.0

În Qiskit, operatorii cuantici sunt reprezentați folosind clase din modulul quantum_info. Cea mai importantă clasă de operatori este SparsePauliOp, care reprezintă un operator cuantic general ca o combinație liniară de șiruri Pauli. SparsePauliOp este clasa folosită cel mai frecvent pentru a reprezenta observabile cuantice. Restul acestei pagini explică cum să folosești SparsePauliOp și alte clase de operatori.

# 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

Clasa SparsePauliOp reprezintă o combinație liniară de șiruri Pauli. Există mai multe moduri de a inițializa un SparsePauliOp, dar cel mai flexibil este să folosești metoda from_sparse_list, după cum se demonstrează în celula de cod următoare. from_sparse_list acceptă o listă de triplete (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 suportă operații aritmetice, după cum se demonstrează în celula de cod următoare.

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

Clasa Pauli reprezintă un singur șir Pauli cu un coeficient de fază opțional din mulțimea $\set{+1, i, -1, -i}$ . Un Pauli poate fi inițializat prin transmiterea unui șir de caractere din mulțimea {"I", "X", "Y", "Z"}, opțional prefixat de unul dintre {"", "i", "-", "-i"} pentru a reprezenta coeficientul de fază.

op1 = Pauli("iXX")
op1

Pauli('iXX')

Celula de cod următoare demonstrează utilizarea unor atribute și 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]]

Obiectele Pauli dispun de o serie de alte metode pentru manipularea operatorilor, cum ar fi determinarea adjunctului său, dacă (anti)comută cu un alt Pauli și calculul produsului punctual cu un alt Pauli. Consultă documentația API pentru mai multe informații.

Operator

Clasa Operator reprezintă un operator liniar general. Spre deosebire de SparsePauliOp, Operator stochează operatorul liniar ca o matrice densă. Deoarece memoria necesară pentru a stoca o matrice densă crește exponențial cu numărul de qubiți, clasa Operator este potrivită doar pentru un număr mic de qubiți.

Poți inițializa un Operator transmițând direct un array Numpy care stochează matricea operatorului. De exemplu, celula de cod următoare creează un operator Pauli XX pe doi qubiți:

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

Obiectul operator stochează matricea de bază, precum și dimensiunile de intrare și ieșire ale subsistemelor.

data: Pentru a accesa array-ul Numpy de bază, poți folosi proprietatea Operator.data.
dims: Pentru a returna dimensiunile totale de intrare și ieșire ale operatorului, poți folosi proprietatea Operator.dim. Notă: ieșirea este returnată ca un tuplu (input_dim, output_dim), care este inversul formei matricei de bază.

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)

Clasa operator urmărește, de asemenea, dimensiunile subsistemelor, care pot fi folosite pentru compunerea operatorilor. Acestea pot fi accesate folosind funcțiile input_dims și output_dims.

Pentru operatori de dimensiune $2^N$ pe $2^M$ , dimensiunile de intrare și ieșire sunt presupuse automat ca fiind M-Qubit și 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,)

Dacă matricea de intrare nu poate fi împărțită în subsisteme de qubiți, atunci va fi stocată ca un operator cu un singur qubit. De exemplu, pentru o matrice de $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,)

Dimensiunile de intrare și ieșire pot fi specificate și manual la inițializarea unui operator nou:

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

Poți extrage, de asemenea, doar dimensiunile de intrare sau ieșire ale unui subset de subsisteme folosind funcțiile input_dims și 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,)

Pași următori

Recomandări

Află cum să specifici observabile în baza Pauli.
Vezi un exemplu de utilizare a operatorilor în tutorialul Combină opțiunile de atenuare a erorilor cu primitiva Estimator.
Citește mai multe informații detaliate despre clasa Operator.
Explorează referința API Operator.

SparsePauliOp​

Pauli​

Operator​

Pași următori​

SparsePauliOp

Pauli

Operator

Pași următori