001/*
002 * $Id: SolvableGroebnerBase.java 5687 2017-01-03 08:44:03Z kredel $
003 */
004
005package edu.jas.gb;
006
007
008import java.io.Serializable;
009import java.util.List;
010
011import edu.jas.poly.ModuleList;
012import edu.jas.poly.GenSolvablePolynomial;
013import edu.jas.structure.RingElem;
014
015
016/**
017 * Solvable Groebner Bases interface. Defines methods for left, right and
018 * twosided Groebner bases and left, right and twosided GB tests.
019 * @param <C> coefficient type
020 * @author Heinz Kredel
021 */
022
023public interface SolvableGroebnerBase<C extends RingElem<C>> extends Serializable {
024
025
026    /**
027     * Left Groebner base test.
028     * @param F solvable polynomial list.
029     * @return true, if F is a left Groebner base, else false.
030     */
031    public boolean isLeftGB(List<GenSolvablePolynomial<C>> F);
032
033
034    /**
035     * Left Groebner base test.
036     * @param modv number of module variables.
037     * @param F solvable polynomial list.
038     * @return true, if F is a left Groebner base, else false.
039     */
040    public boolean isLeftGB(int modv, List<GenSolvablePolynomial<C>> F);
041
042
043    /**
044     * Twosided Groebner base test.
045     * @param Fp solvable polynomial list.
046     * @return true, if Fp is a two-sided Groebner base, else false.
047     */
048    public boolean isTwosidedGB(List<GenSolvablePolynomial<C>> Fp);
049
050
051    /**
052     * Twosided Groebner base test.
053     * @param modv number of module variables.
054     * @param Fp solvable polynomial list.
055     * @return true, if Fp is a two-sided Groebner base, else false.
056     */
057    public boolean isTwosidedGB(int modv, List<GenSolvablePolynomial<C>> Fp);
058
059
060    /**
061     * Right Groebner base test.
062     * @param F solvable polynomial list.
063     * @return true, if F is a right Groebner base, else false.
064     */
065    public boolean isRightGB(List<GenSolvablePolynomial<C>> F);
066
067
068    /**
069     * Right Groebner base test.
070     * @param modv number of module variables.
071     * @param F solvable polynomial list.
072     * @return true, if F is a right Groebner base, else false.
073     */
074    public boolean isRightGB(int modv, List<GenSolvablePolynomial<C>> F);
075
076
077    /**
078     * Left Groebner base using pairlist class.
079     * @param F solvable polynomial list.
080     * @return leftGB(F) a left Groebner base of F.
081     */
082    public List<GenSolvablePolynomial<C>> leftGB(List<GenSolvablePolynomial<C>> F);
083
084
085    /**
086     * Left Groebner base using pairlist class.
087     * @param modv number of module variables.
088     * @param F solvable polynomial list.
089     * @return leftGB(F) a left Groebner base of F.
090     */
091    public List<GenSolvablePolynomial<C>> leftGB(int modv, List<GenSolvablePolynomial<C>> F);
092
093
094    /**
095     * Solvable Extended Groebner base using critical pair class.
096     * @param F solvable polynomial list.
097     * @return a container for an extended left Groebner base of F.
098     */
099    public SolvableExtendedGB<C> extLeftGB(List<GenSolvablePolynomial<C>> F);
100
101
102    /**
103     * Solvable Extended Groebner base using critical pair class.
104     * @param modv module variable number.
105     * @param F solvable polynomial list.
106     * @return a container for an extended left Groebner base of F.
107     */
108    public SolvableExtendedGB<C> extLeftGB(int modv, List<GenSolvablePolynomial<C>> F);
109
110
111    /**
112     * Left minimal ordered groebner basis.
113     * @param Gp a left Groebner base.
114     * @return leftGBmi(F) a minimal left Groebner base of Gp.
115     */
116    public List<GenSolvablePolynomial<C>> leftMinimalGB(List<GenSolvablePolynomial<C>> Gp);
117
118
119    /**
120     * Twosided Groebner base using pairlist class.
121     * @param Fp solvable polynomial list.
122     * @return tsGB(Fp) a twosided Groebner base of Fp.
123     */
124    public List<GenSolvablePolynomial<C>> twosidedGB(List<GenSolvablePolynomial<C>> Fp);
125
126
127    /**
128     * Twosided Groebner base using pairlist class.
129     * @param modv number of module variables.
130     * @param Fp solvable polynomial list.
131     * @return tsGB(Fp) a twosided Groebner base of Fp.
132     */
133    public List<GenSolvablePolynomial<C>> twosidedGB(int modv, List<GenSolvablePolynomial<C>> Fp);
134
135
136    /**
137     * Right Groebner base using opposite ring left GB.
138     * @param F solvable polynomial list.
139     * @return rightGB(F) a right Groebner base of F.
140     */
141    public List<GenSolvablePolynomial<C>> rightGB(List<GenSolvablePolynomial<C>> F);
142
143
144    /**
145     * Right Groebner base using opposite ring left GB.
146     * @param modv number of module variables.
147     * @param F solvable polynomial list.
148     * @return rightGB(F) a right Groebner base of F.
149     */
150    public List<GenSolvablePolynomial<C>> rightGB(int modv, List<GenSolvablePolynomial<C>> F);
151
152
153    /**
154     * Test if left reduction matrix.
155     * @param exgb an SolvableExtendedGB container.
156     * @return true, if exgb contains a left reduction matrix, else false.
157     */
158    public boolean isLeftReductionMatrix(SolvableExtendedGB<C> exgb);
159
160
161    /**
162     * Test if left reduction matrix.
163     * @param F a solvable polynomial list.
164     * @param G a left Groebner base.
165     * @param Mf a possible left reduction matrix.
166     * @param Mg a possible left reduction matrix.
167     * @return true, if Mg and Mf are left reduction matrices, else false.
168     */
169    public boolean isLeftReductionMatrix(List<GenSolvablePolynomial<C>> F, List<GenSolvablePolynomial<C>> G,
170                    List<List<GenSolvablePolynomial<C>>> Mf, List<List<GenSolvablePolynomial<C>>> Mg);
171
172
173    /**
174     * Module left Groebner base test.
175     * @param M a module basis.
176     * @return true, if M is a left Groebner base, else false.
177     */
178    public boolean isLeftGB(ModuleList<C> M);
179
180
181    /**
182     * Left Groebner base using pairlist class.
183     * @param M a module basis.
184     * @return leftGB(M) a left Groebner base for M.
185     */
186    public ModuleList<C> leftGB(ModuleList<C> M);
187
188
189    /**
190     * Module twosided Groebner base test.
191     * @param M a module basis.
192     * @return true, if M is a twosided Groebner base, else false.
193     */
194    public boolean isTwosidedGB(ModuleList<C> M);
195
196
197    /**
198     * Twosided Groebner base using pairlist class.
199     * @param M a module basis.
200     * @return tsGB(M) a twosided Groebner base for M.
201     */
202    public ModuleList<C> twosidedGB(ModuleList<C> M);
203
204
205    /**
206     * Module right Groebner base test.
207     * @param M a module basis.
208     * @return true, if M is a right Groebner base, else false.
209     */
210    public boolean isRightGB(ModuleList<C> M);
211
212
213    /**
214     * Right Groebner base using pairlist class.
215     * @param M a module basis.
216     * @return rightGB(M) a right Groebner base for M.
217     */
218    public ModuleList<C> rightGB(ModuleList<C> M);
219
220}