Struct pauli::PauliOperator

pub struct PauliOperator { /* fields omitted */ }

A Pauli operator optimized for sparse operations.

A Pauli operator is a string of Paulis such as IXIX or XIYIZ. However, we usually only care about the non-identity positions and we refer to the previous as operators as X_1 X_3 and X_0 Y_2 Z_4.

Implementations

impl PauliOperator

pub fn new(length: usize, positions: Vec<usize>, paulis: Vec<Pauli>) -> Self

Builds a new Pauli Operator.

To build an operator, we specify the length, the position of non-identity elements and their values.

Exemple

This creates the XIYIZ operator.

let operator = PauliOperator::new(5, vec![0, 2, 4], vec![X, Y, Z]);

Panic

Panics if a position is greater or equal to the length or if the number of positions and Paulis are different.

pub fn try_new(
    length: usize,
    positions: Vec<usize>,
    paulis: Vec<Pauli>
) -> Result<Self, PauliError>

Builds a new Pauli Operator or returns an error if either a position is greater or equal to the length or if the numbers of positions and Paulis are different.

Exemple

This creates the XIYIZ operator.

let operator = PauliOperator::try_new(5, vec![0, 2, 4], vec![X, Y, Z]);
assert!(operator.is_ok());

pub fn empty() -> Self

Creates a Pauli operator of zero length.

pub fn commutes_with(&self, other: &Self) -> bool

Checks if two operators commute.

If an operator is smaller than the other, it is padded with identities.

Example

let op1 = PauliOperator::new(5, vec![1, 2, 3], vec![X, Y, Z]);
let op2 = PauliOperator::new(5, vec![2, 3, 4], vec![X, X, X]);
let op3 = PauliOperator::new(5, vec![0, 1], vec![Z, Z]);

assert!(op1.commutes_with(&op2));
assert!(!op1.commutes_with(&op3));

pub fn anticommutes_with(&self, other: &Self) -> bool

Checks if two operators anticommute.

If an operator is smaller than the other, it is padded with identities.

Example

let op1 = PauliOperator::new(5, vec![1, 2, 3], vec![X, Y, Z]);
let op2 = PauliOperator::new(5, vec![2, 3, 4], vec![X, X, X]);
let op3 = PauliOperator::new(5, vec![0, 1], vec![Z, Z]);

assert!(!op1.anticommutes_with(&op2));
assert!(op1.anticommutes_with(&op3));

pub fn iter(&self) -> VectorIterator<'_, Pauli, usize>

Returns an iterator over pairs of positions and Paulis.

Example

let operator = PauliOperator::new(5, vec![0, 2, 4], vec![X, Y, Z]);
let mut iter = operator.iter();

assert_eq!(iter.next(), Some((0, &X)));
assert_eq!(iter.next(), Some((2, &Y)));
assert_eq!(iter.next(), Some((4, &Z)));
assert_eq!(iter.next(), None);

pub fn get(&self, position: usize) -> Option<Pauli>

Returns the Pauli at the given position or None if the position is out of bound.

Example

let operator = PauliOperator::new(5, vec![0, 2, 4], vec![X, Y, Z]);

assert_eq!(operator.get(0), Some(X));
assert_eq!(operator.get(1), Some(I));
assert_eq!(operator.get(2), Some(Y));
assert_eq!(operator.get(10), None);

pub fn len(&self) -> usize

Returns the length of the operator.

pub fn weight(&self) -> usize

Returns the number of non identity elements.

pub fn non_trivial_positions(&self) -> &[usize]

Returns a slice of the positions where the element is not identity.

Example

let operator = PauliOperator::new(5, vec![0, 2, 4], vec![X, Y, Z]);

assert_eq!(operator.non_trivial_positions(), &[0, 2, 4]);

pub fn partition_x_and_z(&self) -> (Self, Self)

Returns two operators such that there product is the original operator and the first contains only Xs and the second only Zs.

Example

let operator = PauliOperator::new(5, vec![0, 2, 4], vec![X, Y, Z]);
let (x_operator, z_operator) = operator.partition_x_and_z();

assert_eq!(x_operator, PauliOperator::new(5, vec![0, 2], vec![X, X]));
assert_eq!(z_operator, PauliOperator::new(5, vec![2, 4], vec![Z, Z]));

pub fn x_part(&self) -> Self

Returns the X part of the operator.

Example

let operator = PauliOperator::new(5, vec![0, 2, 4], vec![X, Y, Z]);
let x_operator = operator.x_part();

assert_eq!(x_operator, PauliOperator::new(5, vec![0, 2], vec![X, X]));

pub fn z_part(&self) -> Self

Returns the Z part of the operator.

Example

let operator = PauliOperator::new(5, vec![0, 2, 4], vec![X, Y, Z]);
let z_operator = operator.z_part();

assert_eq!(z_operator, PauliOperator::new(5, vec![2, 4], vec![Z, Z]));

pub fn multiply_with(&self, other: &Self) -> Result<Self, PauliError>

Returns the element-wise product of two operators or an Error if they have different lengths.

For a panicking version, use the * operator.

Example

let op1 = PauliOperator::new(5, vec![1, 2, 3], vec![X, Y, Z]);
let op2 = PauliOperator::new(5, vec![2, 3, 4], vec![Y, X, Z]);

let product = PauliOperator::new(5, vec![1, 3, 4], vec![X, Y, Z]);

assert_eq!(op1.multiply_with(&op2), Ok(product))

pub fn into_raw_positions(self) -> Vec<usize>

Converts a PauliOperator to a Vec of its non trivial positions consumming the operator.

Example

let operator = PauliOperator::new(5, vec![1, 2, 3], vec![X, Y, Z]);
let positions = operator.into_raw_positions();
assert_eq!(positions, vec![1, 2, 3]);

pub fn into_raw_paulis(self) -> Vec<Pauli>

Converts a PauliOperator to a Vec of the Paulis consumming the operator.

Example

let operator = PauliOperator::new(5, vec![1, 2, 3], vec![X, Y, Z]);
let paulis = operator.into_raw_paulis();
assert_eq!(paulis, vec![X, Y, Z]);

pub fn into_raw(self) -> (Vec<usize>, Vec<Pauli>)

Converts a PauliOperator to a Vec of the positions and a Vec of Paulis consumming the operator.

Example

let operator = PauliOperator::new(5, vec![1, 2, 3], vec![X, Y, Z]);
let (positions, paulis) = operator.into_raw();
assert_eq!(positions, vec![1, 2, 3]);
assert_eq!(paulis, vec![X, Y, Z]);

Trait Implementations

impl Clone for PauliOperator

fn clone(&self) -> PauliOperator

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PauliOperator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PauliOperator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for PauliOperator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for PauliOperator

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a> Mul<&'a PauliOperator> for &'a PauliOperator

type Output = PauliOperator

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self::Output

Performs the * operation.

impl PartialEq<PauliOperator> for PauliOperator

fn eq(&self, other: &PauliOperator) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &PauliOperator) -> bool

This method tests for !=.

impl Serialize for PauliOperator

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Eq for PauliOperator

impl StructuralEq for PauliOperator

impl StructuralPartialEq for PauliOperator