# ParametricLinearEquations(R, Var, Expon, GR)ΒΆ

- R: Join(EuclideanDomain, PolynomialFactorizationExplicit, CharacteristicZero)
- Var: Join(OrderedSet, ConvertibleTo Symbol)
- Expon: OrderedAbelianMonoidSup
- GR: PolynomialCategory(R, Expon, Var)

This package completely solves a parametric linear system of equations by decomposing the set of all parametric values for which the linear system is consistent into a union of quasi-algebraic sets (which need not be irredundant, but most of the time is). Each quasi-algebraic set is described by a list of polynomials that vanish on the set, and a list of polynomials that vanish at no point of the set. For each quasi-algebraic set, the solution of the linear system is given, as a particular solution and a basis of the homogeneous system. The parametric linear system should be given in matrix form, with a coefficient matrix and a right hand side vector. The entries of the coefficient matrix and right hand side vector should be polynomials in the parametric variables, over a Euclidean domain of characteristic zero. If the system is homogeneous, the right hand side need not be given. The right hand side can also be replaced by an indeterminate vector, in which case, the conditions required for consistency will also be given.

- B1solve: Record(mat: Matrix Fraction Polynomial R, vec: List Fraction Polynomial R, rank: NonNegativeInteger, rows: List Integer, cols: List Integer) -> Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R)
`B1solve(s)`

solves the system (`s`

.mat)`z`

=`s`

.vec for the variables given by the column indices of`s`

.cols in terms of the other variables and the right hand side`s`

.vec by assuming that the rank is`s`

.rank, that the system is consistent, with the linearly independent equations indexed by the given row indices`s`

.rows; the coefficients in`s`

.mat involving parameters are treated as polynomials. B1solve(`s`

) returns a particular solution to the system and a basis of the homogeneous system (`s`

.mat)`z`

= 0.

- bsolve: (Matrix GR, List Fraction Polynomial R, NonNegativeInteger, String, Integer) -> Record(rgl: List Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R)), rgsz: Integer)
`bsolve(c, w, r, s, m)`

returns a list of regimes and solutions of the system`c`

`z`

=`w`

for ranks at least`r`

; depending on the mode`m`

chosen, it writes the output to a file given by the string`s`

.

- dmp2rfi: GR -> Fraction Polynomial R
`dmp2rfi(p)`

converts`p`

to target domain

- dmp2rfi: List GR -> List Fraction Polynomial R
`dmp2rfi(l)`

converts`l`

to target domain

- dmp2rfi: Matrix GR -> Matrix Fraction Polynomial R
`dmp2rfi(m)`

converts`m`

to target domain

- factorset: GR -> List GR
`factorset(p)`

returns the set of irreducible factors of`p`

.

- hasoln: (List GR, List GR) -> Record(sysok: Boolean, z0: List GR, n0: List GR)
`hasoln(g, l)`

tests whether the quasi-algebraic set defined by`p`

= 0 for`p`

in`g`

and`q`

`~=`

0 for`q`

in`l`

is empty or not and returns a simplified definition of the quasi-algebraic set

- inconsistent?: List GR -> Boolean
`inconsistent?(pl)`

returns`true`

if the system of equations`p`

= 0 for`p`

in`pl`

is inconsistent. It is assumed that`pl`

is a groebner basis.

- inconsistent?: List Polynomial R -> Boolean
`inconsistent?(pl)`

returns`true`

if the system of equations`p`

= 0 for`p`

in`pl`

is inconsistent. It is assumed that`pl`

is a groebner basis.

- maxrank: List Record(rank: NonNegativeInteger, eqns: List Record(det: GR, rows: List Integer, cols: List Integer), fgb: List GR) -> NonNegativeInteger
`maxrank(r)`

returns the maximum rank in the list`r`

of regimes

- minrank: List Record(rank: NonNegativeInteger, eqns: List Record(det: GR, rows: List Integer, cols: List Integer), fgb: List GR) -> NonNegativeInteger
`minrank(r)`

returns the minimum rank in the list`r`

of regimes

- minset: List List GR -> List List GR
`minset(sl)`

returns the sublist of`sl`

consisting of the minimal lists (with respect to inclusion) in the list`sl`

of lists

- nextSublist: (Integer, Integer) -> List List Integer
`nextSublist(n, k)`

returns a list of`k`

-subsets of {1, ...,`n`

}.

- overset?: (List GR, List List GR) -> Boolean
`overset?(s, sl)`

returns`true`

if`s`

properly a sublist of a member of`sl`

; otherwise it returns`false`

- ParCond: (Matrix GR, NonNegativeInteger) -> List Record(det: GR, rows: List Integer, cols: List Integer)
`ParCond(m, k)`

returns the list of all`k`

by`k`

subdeterminants in the matrix`m`

- ParCondList: (Matrix GR, NonNegativeInteger) -> List Record(rank: NonNegativeInteger, eqns: List Record(det: GR, rows: List Integer, cols: List Integer), fgb: List GR)
`ParCondList(c, r)`

computes a list of subdeterminants of each rank`>=`

`r`

of the matrix`c`

and returns a groebner basis for the ideal they generate

- pr2dmp: Polynomial R -> GR
`pr2dmp(p)`

converts`p`

to target domain

- psolve: (Matrix GR, List GR) -> List Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R))
`psolve(c, w)`

solves`c`

`z`

=`w`

for all possible ranks of the matrix`c`

and given right hand side vector`w`

- psolve: (Matrix GR, List GR, PositiveInteger) -> List Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R))
`psolve(c, w, k)`

solves`c`

`z`

=`w`

for all possible ranks`>=`

`k`

of the matrix`c`

and given right hand side vector`w`

- psolve: (Matrix GR, List GR, PositiveInteger, String) -> Integer
`psolve(c, w, k, s)`

solves`c`

`z`

=`w`

for all possible ranks`>=`

`k`

of the matrix`c`

and given right hand side`w`

, writes the results to a file named`s`

, and returns the number of regimes

- psolve: (Matrix GR, List GR, String) -> Integer
`psolve(c, w, s)`

solves`c`

`z`

=`w`

for all possible ranks of the matrix`c`

and given right hand side vector`w`

, writes the results to a file named`s`

, and returns the number of regimes

- psolve: (Matrix GR, List Symbol) -> List Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R))
`psolve(c, w)`

solves`c`

`z`

=`w`

for all possible ranks of the matrix`c`

and indeterminate right hand side`w`

- psolve: (Matrix GR, List Symbol, PositiveInteger) -> List Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R))
`psolve(c, w, k)`

solves`c`

`z`

=`w`

for all possible ranks`>=`

`k`

of the matrix`c`

and indeterminate right hand side`w`

- psolve: (Matrix GR, List Symbol, PositiveInteger, String) -> Integer
`psolve(c, w, k, s)`

solves`c`

`z`

=`w`

for all possible ranks`>=`

`k`

of the matrix`c`

and indeterminate right hand side`w`

, writes the results to a file named`s`

, and returns the number of regimes

- psolve: (Matrix GR, List Symbol, String) -> Integer
`psolve(c, w, s)`

solves`c`

`z`

=`w`

for all possible ranks of the matrix`c`

and indeterminate right hand side`w`

, writes the results to a file named`s`

, and returns the number of regimes

- psolve: (Matrix GR, PositiveInteger) -> List Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R))
`psolve(c)`

solves the homogeneous linear system`c`

`z`

= 0 for all possible ranks`>=`

`k`

of the matrix`c`

- psolve: (Matrix GR, PositiveInteger, String) -> Integer
`psolve(c, k, s)`

solves`c`

`z`

= 0 for all possible ranks`>=`

`k`

of the matrix`c`

, writes the results to a file named`s`

, and returns the number of regimes

- psolve: (Matrix GR, String) -> Integer
`psolve(c, s)`

solves`c`

`z`

= 0 for all possible ranks of the matrix`c`

and given right hand side vector`w`

, writes the results to a file named`s`

, and returns the number of regimes

- psolve: Matrix GR -> List Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R))
`psolve(c)`

solves the homogeneous linear system`c`

`z`

= 0 for all possible ranks of the matrix`c`

- rdregime: String -> List Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R))
`rdregime(s)`

reads in a list from a file with name`s`

- redmat: (Matrix GR, List GR) -> Matrix GR
`redmat(m, g)`

returns a matrix whose entries are those of`m`

modulo the ideal generated by the groebner basis`g`

- redpps: (Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R), List GR) -> Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R)
`redpps(s, g)`

returns the simplified form of`s`

after reducing modulo a groebner basis`g`

- regime: (Record(det: GR, rows: List Integer, cols: List Integer), Matrix GR, List Fraction Polynomial R, List List GR, NonNegativeInteger, NonNegativeInteger, Integer) -> Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R))
`regime(y, c, w, p, r, rm, m)`

returns a regime, a list of polynomials specifying the consistency conditions, a particular solution and basis representing the general solution of the parametric linear system`c`

`z`

=`w`

on that regime. The regime returned depends on the subdeterminant`y`

.det and the row and column indices. The solutions are simplified using the assumption that the system has rank`r`

and maximum rank`rm`

. The list`p`

represents a list of list of factors of polynomials in a groebner basis of the ideal generated by higher order subdeterminants, and ius used for the simplification. The mode`m`

distinguishes the cases when the system is homogeneous, or the right hand side is arbitrary, or when there is no new right hand side variables.

- se2rfi: List Symbol -> List Fraction Polynomial R
`se2rfi(l)`

converts`l`

to target domain

- sqfree: GR -> GR
`sqfree(p)`

returns the product of square free factors of`p`

- wrregime: (List Record(eqzro: List GR, neqzro: List GR, wcond: List Polynomial R, bsoln: Record(partsol: Vector Fraction Polynomial R, basis: List Vector Fraction Polynomial R)), String) -> Integer
`wrregime(l, s)`

writes a list of regimes to a file named`s`

and returns the number of regimes written