Struct MixedProductWrapper

pub struct MixedProductWrapper {
    pub internal: MixedProduct,
}

A mixed product of pauli products and boson products.

A PauliProduct <struqture_py.spins.PauliProduct> is a representation of products of pauli matrices acting on qubits. It is used in order to build the corresponding spin terms of a hamiltonian.

A BosonProduct <struqture_py.bosons.BosonProduct> is a product of bosonic creation and annihilation operators. It is used as an index for non-hermitian, normal ordered bosonic operators.

A FermionProduct <struqture_py.fermions.FermionProduct> is a product of bosonic creation and annihilation operators. It is used as an index for non-hermitian, normal ordered bosonic operators.

Note: For a physical system, the bosons (BosonProduct) are usually considered in presence of a system-spin part (PauliProduct) and a bath-spin part (PauliProduct), as shown in the example below.

Args: spins (ListPauliProduct): Products of pauli operators acting on qubits. bosons (ListBosonProduct): Products of bosonic creation and annihilation operators. fermions (ListFermionProduct): Products of fermionic creation and annihilation operators.

Returns: MixedProduct: a new MixedProduct with the input of spins, bosons and fermions.

Raises: ValueError: MixedProduct can not be constructed from the input.

Examples

.. code-block:: python

from struqture_py.mixed_systems import MixedProduct
from struqture_py.spins import PauliProduct
from struqture_py.bosons import BosonProduct
 
mp_spins_system = PauliProduct().x(0).x(2)
mp_spins_bath = PauliProduct().x(1).x(2)

mp_bosons = BosonProduct([1], [1])
 
mp = MixedProduct([mp_spins_system, mp_spins_bath], [mp_bosons], [])
npt.assert_equal(mp.spins(), [mp_spins_system, mp_spins_bath])
npt.assert_equal(mp.bosons(), [mp_bosons])

Fields

internal: MixedProduct

Implementations

impl MixedProductWrapper

pub fn from_pyany(input: &Bound<'_, PyAny>) -> PyResult<MixedProduct>

Fallible conversion of generic python object..

impl MixedProductWrapper

pub fn new( spins: Vec<Py<PyAny>>, bosons: Vec<Py<PyAny>>, fermions: Vec<Py<PyAny>>, ) -> PyResult<Self>

Create a new MixedProduct.

Args: spins (ListPauliProduct): Products of pauli operators acting on qubits. bosons (ListBosonProduct): Products of bosonic creation and annihilation operators. fermions (ListFermionProduct): Products of fermionic creation and annihilation operators.

Returns: MixedProduct: a new MixedProduct with the input of spins, bosons and fermions.

Raises: ValueError: MixedProduct can not be constructed from the input.

pub fn create_valid_pair( _cls: &Bound<'_, PyType>, spins: Vec<String>, bosons: Vec<String>, fermions: Vec<String>, value: &Bound<'_, PyAny>, ) -> PyResult<(Self, CalculatorComplexWrapper)>

Create a pair (MixedProduct, CalculatorComplex).

The first item is the valid MixedProduct created from the input creators and annihilators. The second term is the input CalculatorComplex transformed according to the valid order of creators and annihilators.

Args: creators: The creator indices to have in the MixedProduct. annihilators: The annihilators indices to have in the MixedProduct. value: The CalculatorComplex to transform.

Returns: Tuple[MixedProduct, CalculatorComplex] - The valid MixedProduct and the corresponding transformed CalculatorComplex.

Raises: ValueError: Valid pair could not be constructed, pauli spins couldn’t be converted from string. ValueError: Valid pair could not be constructed, bosons couldn’t be converted from string. ValueError: Valid pair could not be constructed, fermions couldn’t be converted from string. TypeError: Value cannot be converted to CalculatorComplex. ValueError: Valid pair could not be constructed.

pub fn __mul__(&self, other: Self) -> PyResult<Vec<(Self, Complex64)>>

Implement * for MixedProduct and MixedProduct.

Args: other (MixedProduct): value by which to multiply the self MixedProduct

Returns: MixedProduct: The MixedProduct multiplied by the value.

Raises: ValueError: The rhs of the multiplication not MixedProduct.

pub fn hermitian_conjugate(&self) -> (MixedProductWrapper, f64)

Return the hermitian conjugate of self and its prefactor.

Returns: (self, float): The hermitian conjugate of self and the potential sign it has picked up.

pub fn is_natural_hermitian(&self) -> bool

Return whether self is naturally hermitian.

For spin objects, this is true when applying the hermitian conjugation does not change the sign. For bosonic and fermionic objects, this is true when creators == annihilators. For mixed objects, this is true when all of the spin, bosonic and fermionic parts’ is_naturally_hermitian functions evaluate to true.

Returns: bool: Whether self is naturally hermitian or not.

pub fn spins(&self) -> Vec<PauliProductWrapper>

Get the spin products of self.

Returns: Liststr: The spin products of self.

pub fn bosons(&self) -> Vec<BosonProductWrapper>

Get the boson products of self.

Returns: Liststr: The boson products of self.

pub fn fermions(&self) -> Vec<FermionProductWrapper>

Get the fermion products of self.

Returns: Liststr: The fermion products of self.

pub fn current_number_spins(&self) -> Vec<usize>

Return the current number of spins each subsystem acts upon.

Returns: List[int]: Number of spins in each spin sub-system.

pub fn current_number_bosonic_modes(&self) -> Vec<usize>

Return the current number of bosonic modes each subsystem acts upon.

Returns: List[int]: Number of bosonic modes in each spin sub-system.

pub fn current_number_fermionic_modes(&self) -> Vec<usize>

Return the current number of fermionic modes each subsystem acts upon.

Returns: List[int]: Number of fermionic modes in each spin sub-system.

pub fn __copy__(&self) -> MixedProductWrapper

Return a copy of self (copy here produces a deepcopy).

Returns: self: A deep copy of Self.

pub fn __deepcopy__(&self, _memodict: &Bound<'_, PyAny>) -> MixedProductWrapper

Return a deep copy of self.

Returns: self: A deep copy of Self.

pub fn from_bincode(input: &Bound<'_, PyAny>) -> PyResult<MixedProductWrapper>

Convert the bincode representation of the object to an instance using the bincode crate.

Args: input (bytearray): The serialized object (in bincode form).

Returns: The deserialized Spin System.

Raises: TypeError: Input cannot be converted to byte array. ValueError: Input cannot be deserialized.

pub fn to_bincode(&self) -> PyResult<Py<PyByteArray>>

Return the bincode representation of the object using the bincode crate.

Returns: bytearray: The serialized object (in bincode form).

Raises: ValueError: Cannot serialize object to bytes.

pub fn to_json(&self) -> PyResult<String>

Return the json representation of the object.

Returns: str: The serialized form of the object.

Raises: ValueError: Cannot serialize object to json.

pub fn from_json(input: String) -> PyResult<MixedProductWrapper>

Convert the json representation of the object to an instance.

Args: input (str): The serialized object in json form.

Returns: The deserialized object.

Raises: ValueError: Input cannot be deserialized.

pub fn from_string(input: String) -> PyResult<MixedProductWrapper>

Convert a string representation of the object to an instance.

Args: input (str): The serialized index in str representation.

Returns: self: The converted object.

Raises: ValueError: Input cannot be converted from str.

pub fn __str__(&self) -> String

Return a string containing a printable representation of the index.

Returns: str: The printable string representation of the index.

pub fn __repr__(&self) -> String

Return a string containing a printable representation of the index.

Returns: str: The printable string representation of the index.

pub fn __richcmp__( &self, other: &Bound<'_, PyAny>, op: CompareOp, ) -> PyResult<bool>

Return the richcmp magic method to perform rich comparison operations on mixed index.

Args: other: The object to compare self to. op: Whether they should be equal or not.

Returns: Whether the two operations compared evaluated to True or False

Raises: NotImplementedError: Other comparison not implemented.

pub fn __hash__(&self) -> PyResult<isize>

Return the hash magic method.

Returns: integer: Hash

Trait Implementations

impl Clone for MixedProductWrapper

fn clone(&self) -> MixedProductWrapper

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MixedProductWrapper

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

Formats the value using the given formatter.

impl Default for MixedProductWrapper

fn default() -> MixedProductWrapper

Returns the “default value” for a type.

impl<'py> IntoPyObject<'py> for MixedProductWrapper

type Target = MixedProductWrapper

The Python output type

type Output = Bound<'py, <MixedProductWrapper as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl Ord for MixedProductWrapper

fn cmp(&self, other: &MixedProductWrapper) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for MixedProductWrapper

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for MixedProductWrapper

fn partial_cmp(&self, other: &MixedProductWrapper) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PyClass for MixedProductWrapper

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for MixedProductWrapper

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<MixedProductWrapper>

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForMixedProductWrapper

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<MixedProductWrapper> for PyClassImplCollector<MixedProductWrapper>

fn new_text_signature(self) -> Option<&'static str>

impl PyClass__mul__SlotFragment<MixedProductWrapper> for PyClassImplCollector<MixedProductWrapper>

unsafe fn __mul__( self, py: Python<'_>, _raw_slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a MixedProductWrapper

type Holder = Option<PyRef<'py, MixedProductWrapper>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a mut MixedProductWrapper

type Holder = Option<PyRefMut<'py, MixedProductWrapper>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyTypeInfo for MixedProductWrapper

const NAME: &'static str = "MixedProduct"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for MixedProductWrapper

impl Eq for MixedProductWrapper

impl StructuralPartialEq for MixedProductWrapper