A module defining the type and operations of free k-vector spaces over a basis b (for a field k)

- newtype Vect k b = V [(b, k)]
- zerov :: Vect k b
- add :: (Ord b, Num k) => Vect k b -> Vect k b -> Vect k b
- (<+>) :: (Ord b, Num k) => Vect k b -> Vect k b -> Vect k b
- sumv :: (Ord b, Num k) => [Vect k b] -> Vect k b
- neg :: Num k => Vect k b -> Vect k b
- (<->) :: (Ord b, Num k) => Vect k b -> Vect k b -> Vect k b
- smultL :: Num k => k -> Vect k b -> Vect k b
- (*>) :: Num k => k -> Vect k b -> Vect k b
- smultR :: Num k => Vect k b -> k -> Vect k b
- (<*) :: Num k => Vect k b -> k -> Vect k b
- nf :: (Ord b, Num k) => Vect k b -> Vect k b
- linear :: (Ord b, Num k) => (a -> Vect k b) -> Vect k a -> Vect k b
- newtype EBasis = E Int
- type Trivial k = Vect k ()
- wrap :: Num k => k -> Vect k ()
- unwrap :: Num k => Vect k () -> k
- newtype Dual b = Dual b
- dual :: Vect k b -> Vect k (Dual b)

# Documentation

Given a field type k (ie a Fractional instance), Vect k b is the type of the free k-vector space over the basis type b. Elements of Vect k b consist of k-linear combinations of elements of b.

V [(b, k)] |

Fractional k => Fractional (LaurentPoly k) | |

Num k => Monad (Vect k) | |

Functor (Vect k) | |

HopfAlgebra (LaurentPoly Q) (SL2q String) | |

Bialgebra (LaurentPoly Q) (SL2q String) | |

Bialgebra (LaurentPoly Q) (M2q String) | |

Coalgebra (LaurentPoly Q) (SL2q String) | |

Coalgebra (LaurentPoly Q) (M2q String) | |

Algebra (LaurentPoly Q) (SL2q String) | |

Algebra (LaurentPoly Q) (M2q String) | |

Algebra (LaurentPoly Q) (Aq02 String) | |

Algebra (LaurentPoly Q) (Aq20 String) | |

Comodule (LaurentPoly Q) (M2q String) (Aq20 String) | |

(Eq k, Eq b) => Eq (Vect k b) | |

(Fractional k, Monomial m, Ord m, Algebra k m) => Fractional (Vect k m) | As a convenience, a partial instance of Fractional is defined for polynomials.
The instance is well-defined only for scalars, and gives an error if used on other values.
The purpose of this is to allow entry of fractional scalars, in expressions such as |

(Num k, Eq b, Ord b, Show b, Algebra k b) => Num (Vect k b) | |

(Ord k, Ord b) => Ord (Vect k b) | |

(Num k, Show b) => Show (Vect k b) |

(*>) :: Num k => k -> Vect k b -> Vect k bSource

Same as smultL. Mnemonic is "multiply through (from the left)"

(<*) :: Num k => Vect k b -> k -> Vect k bSource

Same as smultR. Mnemonic is "multiply through (from the right)"

nf :: (Ord b, Num k) => Vect k b -> Vect k bSource

Convert an element of Vect k b into normal form. Normal form consists in having the basis elements in ascending order, with no duplicates, and all coefficients non-zero

linear :: (Ord b, Num k) => (a -> Vect k b) -> Vect k a -> Vect k bSource

A linear map between vector spaces A and B can be defined by giving its action on the basis elements of A. The action on all elements of A then follows by linearity.

If we have A = Vect k a, B = Vect k b, and f :: a -> Vect k b is a function from the basis elements of A into B,
then `linear f`

is the linear map that this defines by linearity.

type Trivial k = Vect k ()Source

Trivial k is the field k considered as a k-vector space. In maths, we would not normally make a distinction here, but in the code, we need this if we want to be able to put k as one side of a tensor product.

Given a finite vector space basis b, Dual b represents a basis for the dual vector space. (If b is infinite, then Dual b is only a sub-basis.)

Dual b |