ParametricLinearEquations(R, Var, Expon, GR)

pleqn.spad line 1 [edit on github]

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