# GenericNonAssociativeAlgebra(R, n, ls, gamma)¶

generic.spad line 1 [edit on github]

AlgebraGenericElementPackage allows you to create generic elements of an algebra, i.e. the scalars are extended to include symbolic coefficients

- 0: %
from AbelianMonoid

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

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

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

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

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

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

- *: (SquareMatrix(n, Fraction Polynomial R), %) -> %
from LeftModule SquareMatrix(n, Fraction Polynomial R)

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

- -: % -> %
from AbelianGroup

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

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

- alternative?: () -> Boolean

- antiCommutator: (%, %) -> %

- apply: (Matrix Fraction Polynomial R, %) -> %

- associative?: () -> Boolean

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

- associatorDependence: () -> List Vector Fraction Polynomial R

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

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: Vector Fraction Polynomial R -> %
`coerce(v)`

assumes that it is called with a vector of length equal to the dimension of the algebra, then a linear combination with the basis element is formed

- commutative?: () -> Boolean

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

- conditionsForIdempotents: () -> List Polynomial R if R has IntegralDomain
`conditionsForIdempotents()`

determines a complete list of polynomial equations for the coefficients of idempotents with respect to the fixed`R`

-module basis- conditionsForIdempotents: Vector % -> List Polynomial Fraction Polynomial R

- conditionsForIdempotents: Vector % -> List Polynomial R if R has IntegralDomain
`conditionsForIdempotents([v1, ..., vn])`

determines a complete list of polynomial equations for the coefficients of idempotents with respect to the`R`

-module basis`v1`

, …,`vn`

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

- convert: % -> Vector Fraction Polynomial R
from FramedModule Fraction Polynomial R

- convert: Vector Fraction Polynomial R -> %
from FramedModule Fraction Polynomial R

- coordinates: % -> Vector Fraction Polynomial R
from FramedModule Fraction Polynomial R

- coordinates: (%, Vector %) -> Vector Fraction Polynomial R
- coordinates: (Vector %, Vector %) -> Matrix Fraction Polynomial R
- coordinates: Vector % -> Matrix Fraction Polynomial R
from FramedModule Fraction Polynomial R

- elt: (%, Integer) -> Fraction Polynomial R

- generic: () -> %
`generic()`

returns a generic element, i.e. the linear combination of the fixed basis with the symbolic coefficients`\%x1, \%x2, ..`

- generic: (Symbol, Vector %) -> %
`generic(s, v)`

returns a generic element, i.e. the linear combination of`v`

with the symbolic coefficients`s1, s2, ..`

- generic: (Vector Symbol, Vector %) -> %
`generic(vs, ve)`

returns a generic element, i.e. the linear combination of`ve`

with the symbolic coefficients`vs`

error, if the vector of symbols is shorter than the vector of elements

- generic: Symbol -> %
`generic(s)`

returns a generic element, i.e. the linear combination of the fixed basis with the symbolic coefficients`s1, s2, ..`

- generic: Vector % -> %
`generic(ve)`

returns a generic element, i.e. the linear combination of`ve`

basis with the symbolic coefficients`\%x1, \%x2, ..`

- generic: Vector Symbol -> %
`generic(vs)`

returns a generic element, i.e. the linear combination of the fixed basis with the symbolic coefficients`vs`

; error, if the vector of symbols is too short

- genericLeftDiscriminant: () -> Fraction Polynomial R if R has IntegralDomain
`genericLeftDiscriminant()`

is the determinant of the generic left trace forms of all products of basis element, if the generic left trace form is associative, an algebra is separable if the generic left discriminant is invertible, if it is non-zero, there is some ring extension which makes the algebra separable

- genericLeftMinimalPolynomial: % -> SparseUnivariatePolynomial Fraction Polynomial R if R has IntegralDomain
`genericLeftMinimalPolynomial(a)`

substitutes the coefficients of {em a} for the generic coefficients in`leftRankPolynomial()`

- genericLeftNorm: % -> Fraction Polynomial R if R has IntegralDomain
`genericLeftNorm(a)`

substitutes the coefficients of`a`

for the generic coefficients into the coefficient of the constant term in leftRankPolynomial and changes the sign if the degree of this polynomial is odd. This is a form of degree`k`

- genericLeftTrace: % -> Fraction Polynomial R if R has IntegralDomain
`genericLeftTrace(a)`

substitutes the coefficients of`a`

for the generic coefficients into the coefficient of the second highest term in leftRankPolynomial and changes the sign. This is a linear form

- genericLeftTraceForm: (%, %) -> Fraction Polynomial R if R has IntegralDomain
`genericLeftTraceForm (a, b)`

is defined to be`genericLeftTrace (a*b)`

, this defines a symmetric bilinear form on the algebra

- genericRightDiscriminant: () -> Fraction Polynomial R if R has IntegralDomain
`genericRightDiscriminant()`

is the determinant of the generic left trace forms of all products of basis element, if the generic left trace form is associative, an algebra is separable if the generic left discriminant is invertible, if it is non-zero, there is some ring extension which makes the algebra separable

- genericRightMinimalPolynomial: % -> SparseUnivariatePolynomial Fraction Polynomial R if R has IntegralDomain
`genericRightMinimalPolynomial(a)`

substitutes the coefficients of`a`

for the generic coefficients in rightRankPolynomial

- genericRightNorm: % -> Fraction Polynomial R if R has IntegralDomain
`genericRightNorm(a)`

substitutes the coefficients of`a`

for the generic coefficients into the coefficient of the constant term in rightRankPolynomial and changes the sign if the degree of this polynomial is odd

- genericRightTrace: % -> Fraction Polynomial R if R has IntegralDomain
`genericRightTrace(a)`

substitutes the coefficients of`a`

for the generic coefficients into the coefficient of the second highest term in rightRankPolynomial and changes the sign

- genericRightTraceForm: (%, %) -> Fraction Polynomial R if R has IntegralDomain
`genericRightTraceForm (a, b)`

is defined to be genericRightTrace (a*b), this defines a symmetric bilinear form on the algebra

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

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

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

- latex: % -> String
from SetCategory

- leftDiscriminant: () -> Fraction Polynomial R
- leftDiscriminant: Vector % -> Fraction Polynomial R

- leftNorm: % -> Fraction Polynomial R

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

- leftRankPolynomial: () -> SparseUnivariatePolynomial Fraction Polynomial R if R has IntegralDomain
`leftRankPolynomial()`

returns the left minimimal polynomial of the generic element- leftRankPolynomial: () -> SparseUnivariatePolynomial Polynomial Fraction Polynomial R

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

- leftRegularRepresentation: % -> Matrix Fraction Polynomial R
- leftRegularRepresentation: (%, Vector %) -> Matrix Fraction Polynomial R

- leftTrace: % -> Fraction Polynomial R

- leftTraceMatrix: () -> Matrix Fraction Polynomial R
- leftTraceMatrix: Vector % -> Matrix Fraction Polynomial R

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

- leftUnits: () -> Union(Record(particular: %, basis: List %), failed)
`leftUnits()`

returns the affine space of all left units of the algebra, or`"failed"`

if there is none

- lieAlgebra?: () -> Boolean

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

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

- plenaryPower: (%, PositiveInteger) -> %

- random: () -> % if Fraction Polynomial R has Finite
from Finite

- rank: () -> PositiveInteger
from FramedModule Fraction Polynomial R

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

- represents: (Vector Fraction Polynomial R, Vector %) -> %
- represents: Vector Fraction Polynomial R -> %
from FramedModule Fraction Polynomial R

- rightDiscriminant: () -> Fraction Polynomial R
- rightDiscriminant: Vector % -> Fraction Polynomial R

- rightNorm: % -> Fraction Polynomial R

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

- rightRankPolynomial: () -> SparseUnivariatePolynomial Fraction Polynomial R if R has IntegralDomain
`rightRankPolynomial()`

returns the right minimimal polynomial of the generic element- rightRankPolynomial: () -> SparseUnivariatePolynomial Polynomial Fraction Polynomial R

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

- rightRegularRepresentation: % -> Matrix Fraction Polynomial R
- rightRegularRepresentation: (%, Vector %) -> Matrix Fraction Polynomial R

- rightTraceMatrix: () -> Matrix Fraction Polynomial R
- rightTraceMatrix: Vector % -> Matrix Fraction Polynomial R

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

- rightUnits: () -> Union(Record(particular: %, basis: List %), failed)
`rightUnits()`

returns the affine space of all right units of the algebra, or`"failed"`

if there is none

- sample: %
from AbelianMonoid

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

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

- structuralConstants: () -> Vector Matrix Fraction Polynomial R
- structuralConstants: Vector % -> Vector Matrix Fraction Polynomial R

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

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

- zero?: % -> Boolean
from AbelianMonoid

BiModule(Fraction Polynomial R, Fraction Polynomial R)

Comparable if Fraction Polynomial R has Finite

ConvertibleTo InputForm if Fraction Polynomial R has Finite

Finite if Fraction Polynomial R has Finite

FiniteRankNonAssociativeAlgebra Fraction Polynomial R

FramedModule Fraction Polynomial R

FramedNonAssociativeAlgebra Fraction Polynomial R

Hashable if Fraction Polynomial R has Hashable

LeftModule Fraction Polynomial R

LeftModule SquareMatrix(n, Fraction Polynomial R)

NonAssociativeAlgebra Fraction Polynomial R