# FreeDivisionAlgebra(VAR, F)¶

The elements of the Free Field are represented by Admissible Linear Systems (ALS) in standard form …

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

*: (%, F) -> %

from RightModule F

*: (%, Fraction Integer) -> %
*: (%, Matrix F) -> %

f * U column transformation

*: (F, %) -> %

from LeftModule F

*: (Fraction Integer, %) -> %
*: (Integer, %) -> %

from AbelianGroup

*: (Matrix F, %) -> %

T * f row transformation

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

+: (%, F) -> %

f + alpha adds the scalar alpha to f.

+: (F, %) -> %

alpha + f adds the scalar alpha to f.

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

-: (%, F) -> %

f - alpha subtracts the scalar alpha from f.

-: (F, %) -> %

alpha - f adds the scalar alpha to -f.

/: (%, %) -> %

f / g computes f * g^-1 for nonzero element g.

/: (%, F) -> %

f / alpha computes f / alpha for nonzero alpha.

/: (F, %) -> %

alpha / f computes alpha / f for nonzero f.

=: (%, %) -> Boolean

from BasicType

^: (%, Integer) -> %

f^n returns f^n.

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

f^n returns f^n.

~=: (%, %) -> Boolean

from BasicType

addALS(f,g) computes f+g in terms of the admissible linear systems for f and g (without minimization).

addColumns!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %

addColumns!(f, i, j, alpha) adds alpha*column(i) to column(j) in A and subtracts row(j) from row(i) in s (in the ALS of f), i.e. (A*U)(U^-1*s) = v.

addColumnsRows!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %

addColumnsRows!(f, i, j, alpha) adds alpha*column(i) to column(j) and subtracts alpha*row(j) from row(i) in the ALS of f.

addRows!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %

addRows!(f, i, j, alpha) adds alpha*row(i) to row(j) in the ALS of f.

addRowsColumns!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %

addRowsColumns!(f, i, j, alpha) adds alpha*row(i) to row(j) and subtracts alpha*column(j) from column(i) in the ALS of f.

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %
appendSupport!: (%, List FreeMonoid VAR) -> %

appendSupport! (f, lst) appends variables not in the support.

associates?: (%, %) -> Boolean

from EntireRing

associator: (%, %, %) -> %
blockElimination: (%, List NonNegativeInteger, List NonNegativeInteger, Boolean, List NonNegativeInteger, List NonNegativeInteger, Boolean) -> List Matrix F

blockElimination(f, rsrc, rdst, flg_u, csrc, cdst, flg_v) returns transformation matrices if it is possible to eliminate all entries in rdst x cdst (including columns in u if flg_u = true, including rows in v if flg_v = true) by using rows in rsrc and columns in csrc. Otherwise an empty list.

blockElimination: (%, List NonNegativeInteger, List NonNegativeInteger, List NonNegativeInteger, List NonNegativeInteger) -> List Matrix F

blockElimination(f, rsrc, rdst, csrc, cdst) flg_u = true, flg_v = true

blockStructure: % -> Matrix NonNegativeInteger

blockStructure(f) analyzes the structure of the ALS of f and detects blocks with respect to an upper triangular structure. Entry (i,1) contains the first row, (i,2) the last row, (i,3) the size and (i,4) if block i is refined.

characteristic: () -> NonNegativeInteger
coerce: % -> OutputForm

coerce(f) prints the ALS of f if the debug flag is set and a rational expression if the alternative output flag is set.

coerce: % -> XDistributedPolynomial(VAR, F)

coerce(f) converts the element to XDPOLY (if possible).

coerce: F -> %

coerce(c) converts the constant c into an element of the free field represented by an ALS in minimal refined form.

coerce: Fraction Integer -> %
coerce: FreeMonoid VAR -> %

coerce(m) converts the monoid m into an element of the free field represented by an ALS in minimal refined form.

coerce: Integer -> %
coerce: XDistributedPolynomial(VAR, F) -> %

coerce(p) converts the polynomial p to an element in the free field represented by an minimal admissible linear system.

columnSpan: % -> Stream Matrix XDistributedPolynomial(VAR, F)

columnSpan(f) computes the column span for a regular element, that is (v', Mv', M^2v’, …) where PAs=Pv=v’ with PA = I-M.

commutator: (%, %) -> %
copy: % -> %

copy(f) gives a copy of the element f.

copy: (%, F) -> %

copy(f, alpha) gives a copy of element f multiplied by alpha.

dimension: % -> NonNegativeInteger

dimension(f) returns the dimension of the ALS.

disableAlternativeOutput: % -> %

disableAlternativeOutput(f) disable output as rational expression.

disableDebugOutput: % -> %

disableDebugOutput(f) disable displaying the ALS.

display: (%, List Symbol) -> OutputForm

display(f,[s]) prints the element f as A*(s_1,s_2,…,s_n)’ = v.

display: (%, OutputForm) -> OutputForm

display(f,sol) prints the element f as A*sol = v.

elt: (%, NonNegativeInteger) -> F

elt(f, i) returns v(i) from the ALS of f.

elt: (%, NonNegativeInteger, NonNegativeInteger) -> XDistributedPolynomial(VAR, F)

elt(f, i, j) returns A(i,j) from the ALS of f.

enableAlternativeOutput: % -> %

enableAlternativeOutput(f) enable output as rational expression.

enableDebugOutput: % -> %

enableDebugOutput(f) enable displaying the ALS.

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

from EntireRing

extendedALS: % -> %

extendedALS(f) returns an extended ALS for f, that is, 1*f (with a scalar first row).

factor: % -> List %

factor(f) factorizes f in f=f_1*f_2*…*f_k with atoms (irreducible elements) f_i. Notice that this factorization is unique only with respect to similiarity.

factorizationEquations: (%, NonNegativeInteger, NonNegativeInteger) -> List Polynomial F

factorizationEquations(f,k_rows,k_cols) for debugging purposes (interface LINPEN)

factorizationGroebner: (%, NonNegativeInteger, NonNegativeInteger) -> List Polynomial F

factorizationGroebner(f,k_rows,k_cols) for debugging purposes (interface LINPEN)

factorizationSolve: (%, NonNegativeInteger, NonNegativeInteger) -> List List Equation Polynomial F

factorizationSolve(f,k_rows,k_cols) returns a (possible empty) list of solutions for an admissible transformation to create an upper right block of zeros of size k_rows times k_cols.

factorizationTransformations: (%, NonNegativeInteger, NonNegativeInteger, List Equation Polynomial F) -> List Matrix F

factorizationTransformations(f,k_rows,k_cols,sol) for debugging purposes (interface LINPEN)

factorize: (%, NonNegativeInteger) -> List %

factorize(f,k) factorizes f in f=g*h with rank(g)=k if possible (if necessary by using non-linear techniques).

factors: % -> List %

factors(f) analysis the block structure of the system matrix of the ALS of f to split f into factors.

insertRowsColumns: (%, List NonNegativeInteger, List NonNegativeInteger) -> %

insertRowsColumns(f, lst_row, lst_col) returns a new system with rows and columns inserted. An index k means a new row/column between k and k+1. The number of rows and columns have to be the same!

interval: (NonNegativeInteger, NonNegativeInteger) -> List NonNegativeInteger

interval(i, j) creates list [i, i+1, …, j]

inv: % -> %

from DivisionRing

inverse: % -> %

inverse(f) f^-1 using invertMIN.

invertALS: % -> %

invertALS(f) computes f^-1 in terms of the ALS for f. There is no check if f is invertible!

invertMIN: % -> %

invertMIN(f) uses invertSTD(f) and minimization to construct a minimal system for f^-1. Linear techniques are used to get a fine pivot block structure.

invertSTD: % -> %

invertSTD(f) computes the standard inverse of f in terems of the admissible linear system There is no check if f is invertible!

latex: % -> String

from SetCategory

leftFactor: (%, NonNegativeInteger) -> %

leftFactor(f,k) returns the left factor of rank k of a polynomial f or 1 if it's not possible by linear techniques.

leftFamily: % -> List OutputForm

leftFamily(f) prints the left family s=A^-1*v.

leftMinimization: (%, NonNegativeInteger, NonNegativeInteger) -> %

leftMinimization(f, i_min, i_max) tries to apply a left minimization step with respect to the pivot block with the rows/columns (i_min, …, i_max).

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

linearization: % -> Matrix %

linearization(f) returns the element f as linearization with entries represented by admissible linear systems in minimal refined form.

linearization: % -> Matrix XDistributedPolynomial(VAR, F)

linearization(f) returns the element f as linearization.

matrix: % -> Matrix XDistributedPolynomial(VAR, F)

matrix(f) returns the matrix of the ALS of f.

matrix: (%, FreeMonoid VAR) -> Matrix F

matrix(f,m) returns the coefficient matrix for the monomial m of the ALS of f.

minimal?: % -> Boolean

minimal?(f) is f represented by a minimal ALS?

minimize: % -> %

minimize(f) minimizes the unterlying ALS by applying left and right block minimization steps. Minimality is only guaranteed if the remaining blocks are refined.

multiplyALS: (%, %) -> %

multiplyALS(f,g) computes f*g in terms of the admissible linear systems for f and g (without minimization).

multiplyColumn!: (%, NonNegativeInteger, F) -> %

multiplyColumn!(f, i, alpha) multiplies column(i) by alpha in the ALS of f.

multiplyMIN: (%, %) -> %

multiplyMIN(f,g) uses multiplyALS(f,g) with minimization.

multiplyRow!: (%, NonNegativeInteger, F) -> %

multiplyRow!(f, i, alpha) multiplies row(i) by alpha in the ALS of f.

mutable?: % -> Boolean

mutable?(f) is the underlying ALS of f mutable?

new: (FreeMonoid VAR, F) -> %

new(m,c) creates a monomial element with coefficient c.

new: (LinearMultivariateMatrixPencil F, List FreeMonoid VAR) -> %

new(lp, lst) creates an element by the linear multivariate matrix pencil lp and the list of monomials lst.

new: F -> %

new(c) creates a constant element.

normalALS: % -> %

normalALS(f) removes a scalar first row of an (extended) ALS.

normalize!: % -> %

normalize!(f) rescales the rows such that the first nonzero entry of the coefficient matrix in the diagonal is one. The right hand side is normalized by normalizeRHS! and the non-zero entry is in the last row of the corresponding block.

normalizeDIAG!: % -> %

normalizeDIAG!(f) rescales the rows such that the first nonzero entry of the coefficient matrix in the diagonal is one.

normalizePLS!: % -> %

normalizePLS!(f) scales and rearranges rows and columns of the system matrix such that the constant part of the system matrix is the identity matrix (possibly of smaller size).

normalizeRHS!: % -> %

normalizeRHS!(f) eliminates non-zero entries in the right hand side of ALS with respect of the non-zero entry with the highest index.

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

pencil: % -> LinearMultivariateMatrixPencil F

pencil(f) returns a pointer to the underlying pencil.

plenaryPower: (%, PositiveInteger) -> %
polynomial?: % -> Boolean

polynomial?(f) is the ALS in polynomial form?

polynomial: % -> XDistributedPolynomial(VAR, F)

polynomial(f) returns f as XDPOLY (if possible)

qaddColumns!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %

addColumns!(f, i, j, alpha) adds alpha*column(i) to column(j) in A and subtracts row(j) from row(i) in s (in the ALS of f), i.e. (A*U)(U^-1*s) = v.

qaddRows!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %

addRows!(f, i, j, alpha) adds alpha*row(i) to row(j) in the ALS of f.

qelt: (%, NonNegativeInteger, NonNegativeInteger) -> XDistributedPolynomial(VAR, F)

qelt(f, i, j) returns A(i,j) from the ALS of f.

qnew: (NonNegativeInteger, List FreeMonoid VAR) -> %

qnew(n, lst) creates an empty ALS of dimension n.

qnew: NonNegativeInteger -> %

qnew(n) creates an empty ALS of dimension n.

qregular?: (%, NonNegativeInteger, NonNegativeInteger) -> Boolean

qregular?(f, i_min, i_max) does the specified diagonal block define a regular element?

qswapColumns!: (%, NonNegativeInteger, NonNegativeInteger) -> %

swapColumns!(f, i, j) exchanges columns i and j in the ALS of f.

qswapRows!: (%, NonNegativeInteger, NonNegativeInteger) -> %

swapRows!(f, i, j) exchanges rows i and j in the ALS of f.

qzero?: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger) -> Boolean

qzero?(f, i_min, i_max, j_min, j_max) is the spezified block zero (in the system matrix)?

qzero?: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, FreeMonoid VAR) -> Boolean

qzero?(f, i_min, i_max, j_min, j_max, m) is the spezified block zero in the (system) matrix corresponding to the monomial m?

qzero?: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger) -> Boolean

qzero?(f, i_min, i_max, j_min, j_max, l) is the spezified block zero in matrix l?

rank: % -> NonNegativeInteger

rank(f) returns the rank of the element f, that is, the dimension of a minimal admissible linear system (for f).

ratexpr: % -> OutputForm

ratexpr(f) analysis the block structure of the admissible linear system to write f as rational expression.

ratexprInverse: (%, Boolean) -> OutputForm

ratexprInverse(f, flg) returns f in output form if it is a polynomial, (f)^-1 if f^-1 is a polynomial, “r<rank>” if the system is minimal and “d<dim>” in general.

recip: % -> Union(%, failed)

from MagmaWithUnit

refine!: % -> %

refine!(f) refines f using non-linear techniques.

refine!: (%, Boolean) -> %

refine!(f, flg) refines the underlying admissible admissible linear system using simple and linear techniques and if flg=true also non-linear techniques (Groebner basis).

refined?: % -> Boolean

refined?(f) is f represented by a refined ALS?

refinementEquations: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, Boolean, Boolean) -> List Polynomial F

refinementEquations(f,i_min,i_max,k_rows,flg_u,flg_r) for debugging purposes (interface LINPEN)

refinementGroebner: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, Boolean, Boolean) -> List Polynomial F

refinementGroebner(f,i_min,i_max,k_rows,flg_u,flg_r) computes a Groebner basis for the ideal generated by the equations for creating a zero block with k rows within the pivot block i_min..i_max and conditions to guarantee invertible transformations.

refinementSolve: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, Boolean, Boolean) -> List List Equation Polynomial F

refinementSolve(f,i_min,i_max,k_rows,flg_u,flg_r) Computes a list of solutions (for the entries in transformation matrices) to create a lower left block of zeros with k rows in the pivot block i_min..i_max.

refinementTransformations: (%, NonNegativeInteger, NonNegativeInteger, List Equation Polynomial F) -> List Matrix F

refinementTransformations(f,i_min,i_max,sol) for debugging purposes (interface LINPEN)

refineUR!: % -> %

refineUR!(f) uses linear techniques to create upper right blocks of zeros in staircase form (as far as possible).

refineUR!: (%, NonNegativeInteger) -> %

refineUR!(f,k) uses linear techniques to create an upper right block of zeros with k rows (if possible).

regular?: % -> Boolean

regular?(f) is f a regular element?

removeRowsColumns: (%, List NonNegativeInteger, List NonNegativeInteger) -> %

removeRowsColumns(f, lst_row, lst_col) returns a new system with the specified rows and columns removed. The number of rows and columns have to be the same!

representation: % -> List Matrix XDistributedPolynomial(VAR, F)

representation(f) returns the element f as linear representation (u,A,v).

rightFactor: (%, NonNegativeInteger) -> %

rightFactor(f,k) returns the right factor of rank k of a polynomial f or 1 if it's not possible by linear techniques.

rightFamily: % -> List OutputForm

rightFamily(f) prints the right family t=u*A^-1.

rightMinimization: (%, NonNegativeInteger, NonNegativeInteger) -> %

rightMinimization(f, i_min, i_max) tries to apply a right minimization step with respect to the pivot block with the rows/columns (i_min, …, i_max).

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

rowSpan: % -> Stream Matrix XDistributedPolynomial(VAR, F)

rowSpan(f) computes the row span for a regular element, that is (u; uM; uM^2; …) where PAs=Pv with PA = I-M.

sample: %

from AbelianMonoid

scalar?: % -> Boolean

scalar?(f) is f scalar?

scalar?: (%, NonNegativeInteger, NonNegativeInteger) -> Boolean

scalar?(f, i, j) is A(i,j) scalar?

scaleALS: (%, F) -> %

scaleALS(f, alpha) computes alpha*f by scaling the right hand side of the ALS for f.

setelt!: (%, NonNegativeInteger, F) -> F

setelt!(f, i, alpha) sets v(i) = alpha in the ALS of f.

setelt!: (%, NonNegativeInteger, NonNegativeInteger, XDistributedPolynomial(VAR, F)) -> XDistributedPolynomial(VAR, F)

setelt!(f, i, j, p) sets A(i,j) = p in the ALS of f (where p has degree less equal one) if the system is in polynomial form and j>i.

setRefined!: (%, NonNegativeInteger) -> %

setRefined!(f,max_sze) sets the internal flag if the system is refined (over the ground field) up to the specified block size.

solutionVector: % -> Matrix XDistributedPolynomial(VAR, F)

solutionVector(f) computes the solution vector s of As=v if f is polynomial.

solutionVector: (%, NonNegativeInteger) -> Matrix XDistributedPolynomial(VAR, F)

solutionVector(f, k) computes the approximated solution vector up to powers M^k v' where PAs=Pv=v’ with PA = I-M.

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

summands(f) analysis the block structure of the system matrix of the ALS of f to split f into summands.

swapColumns!: (%, NonNegativeInteger, NonNegativeInteger) -> %

swapColumns!(f, i, j) exchanges columns i and j in the ALS of f.

swapRows!: (%, NonNegativeInteger, NonNegativeInteger) -> %

swapRows!(f, i, j) exchanges rows i and j in the ALS of f.

swapRowsColumns!: (%, NonNegativeInteger, NonNegativeInteger) -> %

swapRowsColumns!(f, i, j) exchanges rows i and j and columns j and i in the ALS of f.

toggleAlternativeOutput: % -> %

toggleAlternativeOutput(f) enable/disable output as rational expression.

toggleDebugOutput: % -> %

toggleDebugOutput(f) enable/disable ALS.

transformationMatrix: % -> Matrix F

transformationMatrix(f) returns the identity matrix to be modified and used within transformRows! or transformColumns!

transformColumns!: (%, Matrix F) -> %

transformColumns!(f, U) transforms the ALS of f from the right.

transformRows!: (%, Matrix F) -> %

transformRows!(f, T) transforms the ALS of f from the left.

unit?: % -> Boolean

from EntireRing

unitCanonical: % -> %

from EntireRing

unitNormal: % -> Record(unit: %, canonical: %, associate: %)

from EntireRing

variables: % -> List FreeMonoid VAR

variables(f) returns a list of the variables.

vector: % -> Matrix F

vector(f) returns v from the ALS of f.

vector: % -> Matrix XDistributedPolynomial(VAR, F)

vector(f) returns v from the ALS of f.

zero?: % -> Boolean

from AbelianMonoid

zero?: (%, NonNegativeInteger, NonNegativeInteger) -> Boolean

zero?(f, i, j) is A(i,j) zero?

AbelianGroup

AbelianMonoid

AbelianSemiGroup

BasicType

BiModule(%, %)

BiModule(F, F)

CancellationAbelianMonoid

DivisionRing

EntireRing

Magma

MagmaWithUnit

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip

unitsKnown