Přehled tříd operátorů

Verze balíčků

Kód na této stránce byl vyvinut s použitím následujících požadavků. Doporučujeme používat tyto verze nebo novější.

qiskit[all]~=2.3.0

V Qiskitu jsou kvantové operátory reprezentovány pomocí tříd z modulu quantum_info. Nejdůležitější třídou operátoru je SparsePauliOp, která představuje obecný kvantový operátor jako lineární kombinaci Pauliho řetězců. SparsePauliOp je třída nejčastěji používaná k reprezentaci kvantových pozorovatelných veličin. Zbývající část této stránky vysvětluje, jak používat SparsePauliOp a další třídy operátorů.

# 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

Třída SparsePauliOp reprezentuje lineární kombinaci Pauliho řetězců. Existuje několik způsobů, jak inicializovat SparsePauliOp, ale nejflexibilnějším způsobem je použití metody from_sparse_list, jak je ukázáno v následující buňce kódu. Metoda from_sparse_list přijímá seznam trojic (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 podporuje aritmetické operace, jak je ukázáno v následující buňce kódu.

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

Třída Pauli reprezentuje jeden Pauliho řetězec s volitelným fázovým koeficientem z množiny $\set{+1, i, -1, -i}$. Pauli lze inicializovat předáním řetězce znaků z množiny {"I", "X", "Y", "Z"}, volitelně s předponou z {"", "i", "-", "-i"} pro reprezentaci fázového koeficientu.

op1 = Pauli("iXX")
op1

Pauli('iXX')

Následující buňka kódu ukazuje použití některých atributů a metod.

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

Objekty Pauli disponují řadou dalších metod pro manipulaci s operátory, jako je určení jejich adjungovaného operátoru, zjištění, zda (anti)komutuje s jiným Pauli, a výpočet skalárního součinu s jiným Pauli. Více informací najdeš v dokumentaci API.

Operator

Třída Operator reprezentuje obecný lineární operátor. Na rozdíl od SparsePauliOp ukládá Operator lineární operátor jako hustou matici. Protože paměť potřebná k uložení husté matice roste exponenciálně s počtem Qubitů, je třída Operator vhodná pouze pro použití s malým počtem Qubitů.

Operator lze inicializovat přímým předáním pole Numpy obsahujícího matici operátoru. Například následující buňka kódu vytváří dvouQubitový Pauliho operátor 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))

Objekt operátoru ukládá podkladovou matici a vstupní a výstupní rozměry podsystémů.

• data: Pro přístup k podkladovému poli Numpy můžeš použít vlastnost Operator.data.
• dims: Pro vrácení celkového vstupního a výstupního rozměru operátoru můžeš použít vlastnost Operator.dim. Poznámka: výstup je vrácen jako n-tice (input_dim, output_dim), což je opačné pořadí oproti tvaru podkladové matice.

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)

Třída operátoru také sleduje rozměry podsystémů, které lze použít pro skládání operátorů dohromady. K těmto informacím lze přistupovat pomocí funkcí input_dims a output_dims.

Pro operátory $2^N$ krát $2^M$ jsou vstupní a výstupní rozměry automaticky předpokládány jako M-Qubitové a N-Qubitové:

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

Pokud vstupní matice není dělitelná do Qubitových podsystémů, bude uložena jako jednodimenzionální operátor. Například pro matici $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,)

Vstupní a výstupní rozměr lze také zadat ručně při inicializaci nového operátoru:

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

Pomocí funkcí input_dims a output_dims můžeš také extrahovat pouze vstupní nebo výstupní rozměry podmnožiny podsystémů:

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

Další kroky

Doporučení

• Nauč se, jak specifikovat pozorovatelné veličiny v Pauliho bázi.
• Podívej se na příklad použití operátorů v tutoriálu Kombinace možností zmírnění chyb s primitivem Estimator.
• Přečti si podrobnější popis třídy Operator.
• Prozkoumej referenci Operator API.