# FramedAlgebra(R, UP)¶

algcat.spad line 149 [edit on github]

A FramedAlgebra is a FiniteRankAlgebra together with a fixed `R`

-module basis.

- 0: %
from AbelianMonoid

- 1: %
from MagmaWithUnit

- *: (%, %) -> %
from Magma

- *: (%, R) -> %
from RightModule R

- *: (Integer, %) -> %
from AbelianGroup

- *: (NonNegativeInteger, %) -> %
from AbelianMonoid

- *: (PositiveInteger, %) -> %
from AbelianSemiGroup

- *: (R, %) -> %
from LeftModule R

- +: (%, %) -> %
from AbelianSemiGroup

- -: % -> %
from AbelianGroup

- -: (%, %) -> %
from AbelianGroup

- ^: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- ^: (%, PositiveInteger) -> %
from Magma

- annihilate?: (%, %) -> Boolean
from Rng

- antiCommutator: (%, %) -> %

- associator: (%, %, %) -> %
from NonAssociativeRng

- basis: () -> Vector %
from FramedModule R

- characteristic: () -> NonNegativeInteger
from NonAssociativeRing

- characteristicPolynomial: % -> UP
from FiniteRankAlgebra(R, UP)

- charthRoot: % -> Union(%, failed) if R has CharacteristicNonZero

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: Integer -> %
from NonAssociativeRing

- coerce: R -> %
from Algebra R

- commutator: (%, %) -> %
from NonAssociativeRng

- convert: % -> InputForm if R has Finite
from ConvertibleTo InputForm

- convert: % -> Vector R
from FramedModule R

- convert: Vector R -> %
from FramedModule R

- coordinates: % -> Vector R
from FramedModule R

- coordinates: (%, Vector %) -> Vector R
from FiniteRankAlgebra(R, UP)

- coordinates: (Vector %, Vector %) -> Matrix R
from FiniteRankAlgebra(R, UP)

- coordinates: Vector % -> Matrix R
from FramedModule R

- discriminant: () -> R
`discriminant()`

= determinant(traceMatrix()).- discriminant: Vector % -> R
from FiniteRankAlgebra(R, UP)

- hash: % -> SingleInteger if R has Hashable
from Hashable

- hashUpdate!: (HashState, %) -> HashState if R has Hashable
from Hashable

- index: PositiveInteger -> % if R has Finite
from Finite

- latex: % -> String
from SetCategory

- leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- leftPower: (%, PositiveInteger) -> %
from Magma

- leftRecip: % -> Union(%, failed)
from MagmaWithUnit

- lookup: % -> PositiveInteger if R has Finite
from Finite

- minimalPolynomial: % -> UP if R has Field
from FiniteRankAlgebra(R, UP)

- norm: % -> R
from FiniteRankAlgebra(R, UP)

- one?: % -> Boolean
from MagmaWithUnit

- opposite?: (%, %) -> Boolean
from AbelianMonoid

- plenaryPower: (%, PositiveInteger) -> %
from NonAssociativeAlgebra R

- rank: () -> PositiveInteger
from FiniteRankAlgebra(R, UP)

- recip: % -> Union(%, failed)
from MagmaWithUnit

- regularRepresentation: % -> Matrix R
`regularRepresentation(a)`

returns the matrix`m`

of the linear map defined by left multiplication by`a`

with respect to the fixed basis. That is for all`x`

we have`coordinates(a*x) = m*coordinates(x)`

.- regularRepresentation: (%, Vector %) -> Matrix R
from FiniteRankAlgebra(R, UP)

- represents: (Vector R, Vector %) -> %
from FiniteRankAlgebra(R, UP)

- represents: Vector R -> %
from FramedModule R

- rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- rightPower: (%, PositiveInteger) -> %
from Magma

- rightRecip: % -> Union(%, failed)
from MagmaWithUnit

- sample: %
from AbelianMonoid

- size: () -> NonNegativeInteger if R has Finite
from Finite

- smaller?: (%, %) -> Boolean if R has Finite
from Comparable

- subtractIfCan: (%, %) -> Union(%, failed)

- trace: % -> R
from FiniteRankAlgebra(R, UP)

- traceMatrix: () -> Matrix R
`traceMatrix()`

is the`n`

-by-`n`

matrix (`Tr(vi * vj)`

), where`v1`

, …,`vn`

are the elements of the fixed basis.- traceMatrix: Vector % -> Matrix R
from FiniteRankAlgebra(R, UP)

- zero?: % -> Boolean
from AbelianMonoid

Algebra R

BiModule(%, %)

BiModule(R, R)

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

Comparable if R has Finite

ConvertibleTo InputForm if R has Finite

FiniteRankAlgebra(R, UP)

Module R