Struct pauli::PauliOperator

source · [−]

pub struct PauliOperator { /* private fields */ }

Expand description

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

source

impl PauliOperator

source

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.

source

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

source

pub fn empty() -> Self

Creates a Pauli operator of zero length.

source

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

source

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

source

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

source

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

source

pub fn len(&self) -> usize

Returns the length of the operator.

source

pub fn weight(&self) -> usize

Returns the number of non identity elements.

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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