Trait qsym2::analysis::RepAnalysis
source · pub trait RepAnalysis<G, I, T, D>: Orbit<G, I>where
T: ComplexFloat + Lapack + Debug,
<T as ComplexFloat>::Real: ToPrimitive,
G: GroupProperties + ClassProperties + CharacterProperties,
G::GroupElement: Display,
G::CharTab: SubspaceDecomposable<T>,
D: Dimension,
I: Overlap<T, D> + Clone,
Self::OrbitIter: Iterator<Item = Result<I, Error>>,{
Show 14 methods
// Required methods
fn set_smat(&mut self, smat: Array2<T>);
fn smat(&self) -> Option<&Array2<T>>;
fn xmat(&self) -> &Array2<T>;
fn norm_preserving_scalar_map(
&self,
i: usize,
) -> Result<fn(_: T) -> T, Error>;
fn integrality_threshold(&self) -> <T as ComplexFloat>::Real;
fn eigenvalue_comparison_mode(&self) -> &EigenvalueComparisonMode;
// Provided methods
fn calc_smat(
&mut self,
metric: Option<&Array<T, D>>,
metric_h: Option<&Array<T, D>>,
use_cayley_table: bool,
) -> Result<&mut Self, Error> { ... }
fn normalise_smat(&mut self) -> Result<&mut Self, Error> { ... }
fn calc_tmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error> { ... }
fn calc_dmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error> { ... }
fn calc_character(&self, op: &G::GroupElement) -> Result<T, Error> { ... }
fn calc_characters(
&self,
) -> Result<Vec<(<G as ClassProperties>::ClassSymbol, T)>, Error> { ... }
fn analyse_rep(
&self,
) -> Result<<<G as CharacterProperties>::CharTab as SubspaceDecomposable<T>>::Decomposition, DecompositionError> { ... }
fn characters_to_string(
&self,
chis: &[(<G as ClassProperties>::ClassSymbol, T)],
integrality_threshold: <T as ComplexFloat>::Real,
) -> String
where T: ComplexFloat + Lapack + Debug,
<T as ComplexFloat>::Real: ToPrimitive { ... }
}Expand description
Trait for representation or corepresentation analysis on an orbit of items spanning a linear space.
Required Methods§
sourcefn set_smat(&mut self, smat: Array2<T>)
fn set_smat(&mut self, smat: Array2<T>)
Sets the overlap matrix between the items in the orbit.
§Arguments
smat- The overlap matrix between the items in the orbit.
sourcefn smat(&self) -> Option<&Array2<T>>
fn smat(&self) -> Option<&Array2<T>>
Returns the overlap matrix between the items in the orbit.
sourcefn xmat(&self) -> &Array2<T>
fn xmat(&self) -> &Array2<T>
Returns the transformation matrix $\mathbf{X}$ for the overlap matrix $\mathbf{S}$
between the items in the orbit.
The matrix $\mathbf{X}$ serves to bring $\mathbf{S}$ to full rank, i.e., the matrix
$\tilde{\mathbf{S}}$ defined by
\tilde{\mathbf{S}} = \mathbf{X}^{\dagger\lozenge} \mathbf{S} \mathbf{X}
is a full-rank matrix.
If the overlap between items is complex-symmetric (see Overlap::complex_symmetric), then
$\lozenge = *$ is the complex-conjugation operation, otherwise, $\lozenge$ is the
identity.
Depending on how $\mathbf{X}$ has been computed, $\tilde{\mathbf{S}}$ might also be
orthogonal. Either way, $\tilde{\mathbf{S}}$ is always guaranteed to be of full-rank.
sourcefn norm_preserving_scalar_map(&self, i: usize) -> Result<fn(_: T) -> T, Error>
fn norm_preserving_scalar_map(&self, i: usize) -> Result<fn(_: T) -> T, Error>
Returns the norm-preserving scalar map $f$ for every element of the generating group
defined by
\langle \hat{\iota} \mathbf{v}_w, \hat{g}_i \mathbf{v}_x \rangle
= f \left( \langle \hat{\iota} \hat{g}_i^{-1} \mathbf{v}_w, \mathbf{v}_x \rangle \right).
Typically, if $\hat{g}_i$ is unitary, then $f$ is the identity, and if $\hat{g}_i$ is
antiunitary, then $f$ is the complex-conjugation operation. Either way, the norm of the
inner product is preserved.
If the overlap between items is complex-symmetric (see Overlap::complex_symmetric), then
this map is currently unsupported because it is currently unclear if the unitary and
antiunitary symmetry operators in QSym² are .
sourcefn integrality_threshold(&self) -> <T as ComplexFloat>::Real
fn integrality_threshold(&self) -> <T as ComplexFloat>::Real
Returns the threshold for integrality checks of irreducible representation or corepresentation multiplicities.
sourcefn eigenvalue_comparison_mode(&self) -> &EigenvalueComparisonMode
fn eigenvalue_comparison_mode(&self) -> &EigenvalueComparisonMode
Returns the enumerated type specifying the comparison mode for filtering out orbit overlap eigenvalues.
Provided Methods§
sourcefn calc_smat(
&mut self,
metric: Option<&Array<T, D>>,
metric_h: Option<&Array<T, D>>,
use_cayley_table: bool,
) -> Result<&mut Self, Error>
fn calc_smat( &mut self, metric: Option<&Array<T, D>>, metric_h: Option<&Array<T, D>>, use_cayley_table: bool, ) -> Result<&mut Self, Error>
Calculates and stores the overlap matrix between items in the orbit, with respect to a metric of the basis in which these items are expressed.
§Arguments
metric- The metric of the basis in which the orbit items are expressed.metric_h- The complex-symmetric metric of the basis in which the orbit items are expressed. This is required if antiunitary operations are involved.use_cayley_table- A boolean indicating if the Cayley table of the group should be used to speed up the computation of the overlap matrix.
sourcefn normalise_smat(&mut self) -> Result<&mut Self, Error>
fn normalise_smat(&mut self) -> Result<&mut Self, Error>
Normalises overlap matrix between items in the orbit such that its diagonal entries are unity.
§Errors
Errors if no orbit overlap matrix can be found, of if linear-algebraic errors are encountered.
sourcefn calc_tmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error>
fn calc_tmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error>
Computes the $\mathbf{T}(g)$ matrix for a particular element $g$ of the generating
group.
The elements of this matrix are given by
T_{wx}(g)
= \langle \hat{\iota} \hat{g}_w \mathbf{v}_0, \hat{g} \hat{g}_x \mathbf{v}_0 \rangle.
This means that $\mathbf{T}(g)$ is just the orbit overlap matrix $\mathbf{S}$ with its
columns permuted according to the way $g$ composites on the elements in the group from
the left.
§Arguments
op- The element $g$ in the generating group.
§Returns
The matrix $\mathbf{T}(g)$.
sourcefn calc_dmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error>
fn calc_dmat(&self, op: &G::GroupElement) -> Result<Array2<T>, Error>
Computes the representation or corepresentation matrix $\mathbf{D}(g)$ for a particular
element $g$ in the generating group in the basis of the orbit.
The matrix $\mathbf{D}(g)$ is defined by
\hat{g} \mathcal{G} \cdot \mathbf{v}_0 = \mathcal{G} \cdot \mathbf{v}_0 \mathbf{D}(g),
where $\mathcal{G} \cdot \mathbf{v}_0$ is the orbit generated by the action of the group
$\mathcal{G}$ on the origin $\mathbf{v}_0$.
§Arguments
op- The element $g$ of the generating group.
§Returns
The matrix $\mathbf{D}(g)$.
sourcefn calc_character(&self, op: &G::GroupElement) -> Result<T, Error>
fn calc_character(&self, op: &G::GroupElement) -> Result<T, Error>
Computes the character of a particular element $g$ in the generating group in the basis
of the orbit.
See Self::calc_dmat for more information.
§Arguments
op- The element $g$ of the generating group.
§Returns
The character $\chi(g)$.
sourcefn calc_characters(
&self,
) -> Result<Vec<(<G as ClassProperties>::ClassSymbol, T)>, Error>
fn calc_characters( &self, ) -> Result<Vec<(<G as ClassProperties>::ClassSymbol, T)>, Error>
Computes the characters of the elements in a conjugacy-class transversal of the generating group in the basis of the orbit.
See Self::calc_dmat and Self::calc_character for more information.
§Returns
The conjugacy class symbols and the corresponding characters.
sourcefn analyse_rep(
&self,
) -> Result<<<G as CharacterProperties>::CharTab as SubspaceDecomposable<T>>::Decomposition, DecompositionError>
fn analyse_rep( &self, ) -> Result<<<G as CharacterProperties>::CharTab as SubspaceDecomposable<T>>::Decomposition, DecompositionError>
Reduces the representation or corepresentation spanned by the items in the orbit to a direct sum of the irreducible representations or corepresentations of the generating group.
§Returns
The decomposed result.
§Errors
Errors if the decomposition fails, e.g. because one or more calculated multiplicities are non-integral.