Struct QuiverReprsentation 

pub struct QuiverReprsentation<RingOperator>
where
    RingOperator: DivisionRingOperations,
{ /* private fields */ }

A quiver of type An together with a representation

Concretely, the quiver is a directed graph on vertex set 0, .., n have one directed edge of form (i, i+1) or (i+1,i) for all i < n. The representation consists of

• A copy of F^{i_k} to each vertex k, where F is a vector space, i_k is a nonnegative integer
• A matrix to each directed edge, where matrix dimensions match the dimensions of the vector spaces assigned to each of the incident vertices. This means that the matrix M for a directed edge (p,q) should have size i_p x i_q. We think of this matrix as a linear map on row vectors sending r to r * M, not a map of column vectors sending c to M * c. This convention is a bit unusual, but we adopt it because allows us to use some powerful computational tools. In particular, it allows us to use a U-match factorization package which works most efficiently with row-major matrices.

This struct holds three vectors:

• vector_space_dimensions is the dimension of the vector space sitting over vertex i
• arrow_directions[i] equals true iff arrow i <--> i+1 points forward, i.e. from i to i+1
• matrix[i] is the matrix representation of the map between vector spaces i and i+1

It also stores a

• ring_operator, which is an object that can perform the basic algebraic operations of the coefficient field (addition, multiplication, division, etc.)

Implementations

impl<RingOperator> QuiverReprsentation<RingOperator>

where RingOperator: DivisionRingOperations,

pub fn new( arrow_directions: Vec<bool>, matrices: Vec<VecOfVec<usize, RingOperator::Element>>, vector_space_dimensions: Vec<usize>, ring_operator: RingOperator, ) -> Self

Constructs a new QuiverReprsentation.

impl<RingOperator> QuiverReprsentation<RingOperator>

where RingOperator: DivisionRingOperations,

pub fn dissolve( self, ) -> (Vec<bool>, Vec<VecOfVec<usize, RingOperator::Element>>, Vec<usize>, RingOperator)

impl<RingOperator> QuiverReprsentation<RingOperator>

where RingOperator: Clone + DivisionRingOperations,

pub fn number_of_arrows(&self) -> usize

Number of arrows in the quiver

pub fn number_of_vertices(&self) -> usize

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

The list of dimensions of the vector spaces

pub fn arrow_directions(&self) -> &Vec<bool>

Reference to the internally stored vector of arrow directions

If v is this vector then v[p] == true implies that arrow p points right; otherwise arrow p points left.

pub fn arrow_matrices(&self) -> &Vec<VecOfVec<usize, RingOperator::Element>>

Returns a reference to the sequence of matrices corresponding to the arrows in the directed graph

pub fn dimension_of_space_over_vertex(&self, n: usize) -> Option<usize>

Returns the dimension of the nth space in the sequence

pub fn ring_operator(&self) -> RingOperator

Returns the ring operator for the coefficient field.

A “ring operator” is an object that performs the basic algebraic operations of a ring on the elements of the ring. For example, you could use a ring operator to multiply or add two elements. See the OAT documentation for rings for details.

pub fn matrix_packet_for_vertex( &self, vertex: usize, ) -> Option<MatrixAlgebraPacket<&VecOfVec<usize, RingOperator::Element>, RingOperator, OrderOperatorByKey, OrderOperatorAuto, OrderOperatorByKey, OrderOperatorAuto>>

Returns a matrix algebra packet for the given vertex, or None if the vertex is out of bounds

pub fn validate_representation(&self) -> Result<(), HashMap<&str, usize>>

Checks that the user input data is a valid quiver representation

Specifically, it checks that

• n_arrows = n_matrices = n_vertices - 1 if n_vertices > 0
• for each arrow p <--> p + 1, the size of the associated matrix agrees with the reported dimensions for p and p+1

If these tests pass then the function returns Ok(()). Otherwise it returns Err(hash), where hash is a dictionary containing information about the error.

pub fn diagonalize( &self, ) -> Result<Diagonalization<RingOperator::Element>, HashMap<&str, usize>>

Decompose the quiver representation as a direct sum of interval modules

pub fn validate_diagonalization( &self, diagonalization: &Diagonalization<RingOperator::Element>, ) -> Result<(), HashMap<&str, usize>>

where RingOperator::Element: PartialEq,

Verify a diagonalization

This will check that

• every basis vector in the diagonalization maps either to zero or to another basis vector
• no two basis vectors map to the same basis vector
• the information recorded for each bar in the barcode accurately tracks the chain of associated bases vectors in the representation

Trait Implementations

impl<RingOperator> Clone for QuiverReprsentation<RingOperator>

where RingOperator: DivisionRingOperations + Clone, RingOperator::Element: Clone,

fn clone(&self) -> QuiverReprsentation<RingOperator>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<RingOperator> Debug for QuiverReprsentation<RingOperator>

where RingOperator: DivisionRingOperations + Debug, RingOperator::Element: Debug,

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

Formats the value using the given formatter.

impl<RingOperator> Eq for QuiverReprsentation<RingOperator>

where RingOperator: DivisionRingOperations + Eq, RingOperator::Element: Eq,

impl<RingOperator> PartialEq for QuiverReprsentation<RingOperator>

where RingOperator: DivisionRingOperations + PartialEq, RingOperator::Element: PartialEq,

fn eq(&self, other: &QuiverReprsentation<RingOperator>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<RingOperator> StructuralPartialEq for QuiverReprsentation<RingOperator>

where RingOperator: DivisionRingOperations + PartialEq, RingOperator::Element: PartialEq,