# ParametricLinearEquations(R, Var, Expon, GR)¶

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