001/*
002 * $Id$
003 */
004
005package edu.jas.gbufd;
006
007
008import java.io.Serializable;
009import java.util.List;
010
011import edu.jas.poly.GenSolvablePolynomial;
012import edu.jas.poly.ModuleList;
013import edu.jas.poly.PolynomialList;
014import edu.jas.structure.RingElem;
015
016
017/**
018 * Syzygy interface for solvable polynomials. Defines syzygy computations and
019 * tests.
020 * @param <C> coefficient type
021 * @author Heinz Kredel
022 */
023
024public interface SolvableSyzygy<C extends RingElem<C>> extends Serializable {
025
026
027    /**
028     * Left syzygy for left Groebner base.
029     * @param F a Groebner base.
030     * @return leftSyz(F), a basis for the left module of syzygies for F.
031     */
032    public List<List<GenSolvablePolynomial<C>>> leftZeroRelations(List<GenSolvablePolynomial<C>> F);
033
034
035    /**
036     * Left syzygy for left Groebner base.
037     * @param modv number of module variables.
038     * @param F a Groebner base.
039     * @return leftSyz(F), a basis for the left module of syzygies for F.
040     */
041    public List<List<GenSolvablePolynomial<C>>> leftZeroRelations(int modv, List<GenSolvablePolynomial<C>> F);
042
043
044    /**
045     * Left syzygy for left module Groebner base.
046     * @param M a Groebner base.
047     * @return leftSyz(M), a basis for the left module of syzygies for M.
048     */
049    public ModuleList<C> leftZeroRelations(ModuleList<C> M);
050
051
052    /**
053     * Test if left syzygy.
054     * @param Z list of sysygies.
055     * @param F a polynomial list.
056     * @return true, if Z is a list of left syzygies for F, else false.
057     */
058    public boolean isLeftZeroRelation(List<List<GenSolvablePolynomial<C>>> Z,
059                    List<GenSolvablePolynomial<C>> F);
060
061
062    /**
063     * Test if right syzygy.
064     * @param Z list of sysygies.
065     * @param F a polynomial list.
066     * @return true, if Z is a list of right syzygies for F, else false.
067     */
068    public boolean isRightZeroRelation(List<List<GenSolvablePolynomial<C>>> Z,
069                    List<GenSolvablePolynomial<C>> F);
070
071
072    /**
073     * Test if left sysygy of modules
074     * @param Z list of sysygies.
075     * @param F a module list.
076     * @return true, if Z is a list of left syzygies for F, else false.
077     */
078    public boolean isLeftZeroRelation(ModuleList<C> Z, ModuleList<C> F);
079
080
081    /**
082     * Test if right sysygy of modules
083     * @param Z list of sysygies.
084     * @param F a module list.
085     * @return true, if Z is a list of right syzygies for F, else false.
086     */
087    public boolean isRightZeroRelation(ModuleList<C> Z, ModuleList<C> F);
088
089
090    /**
091     * Resolution of a module. Only with direct GBs.
092     * @param M a module list of a Groebner basis.
093     * @return a resolution of M.
094     */
095    public List<SolvResPart<C>> resolution(ModuleList<C> M);
096
097
098    /**
099     * Resolution of a polynomial list. Only with direct GBs.
100     * @param F a polynomial list of a Groebner basis.
101     * @return a resolution of F.
102     */
103    public List/*<SolvResPart<C>|SolvResPolPart<C>>*/ resolution(PolynomialList<C> F);
104
105
106    /**
107     * Resolution of a module.
108     * @param M a module list of an arbitrary basis.
109     * @return a resolution of M.
110     */
111    public List<SolvResPart<C>> resolutionArbitrary(ModuleList<C> M);
112
113
114    /**
115     * Resolution of a polynomial list.
116     * @param F a polynomial list of an arbitrary basis.
117     * @return a resolution of F.
118     */
119    public List/*<SolvResPart<C>|SolvResPolPart<C>>*/ resolutionArbitrary(PolynomialList<C> F);
120
121
122    /**
123     * Left syzygy module from arbitrary base.
124     * @param F a solvable polynomial list.
125     * @return syz(F), a basis for the module of left syzygies for F.
126     */
127    public List<List<GenSolvablePolynomial<C>>> leftZeroRelationsArbitrary(List<GenSolvablePolynomial<C>> F);
128
129
130    /**
131     * Left syzygy module from arbitrary base.
132     * @param modv number of module variables.
133     * @param F a solvable polynomial list.
134     * @return syz(F), a basis for the module of left syzygies for F.
135     */
136    public List<List<GenSolvablePolynomial<C>>> leftZeroRelationsArbitrary(int modv,
137                    List<GenSolvablePolynomial<C>> F);
138
139
140    /**
141     * Left syzygy for arbitrary left module base.
142     * @param M an arbitrary base.
143     * @return leftSyz(M), a basis for the left module of syzygies for M.
144     */
145    public ModuleList<C> leftZeroRelationsArbitrary(ModuleList<C> M);
146
147
148    /**
149     * Right syzygy module from arbitrary base.
150     * @param F a solvable polynomial list.
151     * @return syz(F), a basis for the module of right syzygies for F.
152     */
153    public List<List<GenSolvablePolynomial<C>>> rightZeroRelationsArbitrary(List<GenSolvablePolynomial<C>> F);
154
155
156    /**
157     * Right syzygy module from arbitrary base.
158     * @param modv number of module variables.
159     * @param F a solvable polynomial list.
160     * @return syz(F), a basis for the module of right syzygies for F.
161     */
162    public List<List<GenSolvablePolynomial<C>>> rightZeroRelationsArbitrary(int modv,
163                    List<GenSolvablePolynomial<C>> F);
164
165
166    /**
167     * Test left Ore condition.
168     * @param a solvable polynomial
169     * @param b solvable polynomial
170     * @param oc = [p,q] two solvable polynomials
171     * @return true if p*a = q*b, else false
172     */
173    public boolean isLeftOreCond(GenSolvablePolynomial<C> a, GenSolvablePolynomial<C> b,
174                    GenSolvablePolynomial<C>[] oc);
175
176
177    /**
178     * Test right Ore condition.
179     * @param a solvable polynomial
180     * @param b solvable polynomial
181     * @param oc = [p,q] two solvable polynomials
182     * @return true if a*p = b*q, else false
183     */
184    public boolean isRightOreCond(GenSolvablePolynomial<C> a, GenSolvablePolynomial<C> b,
185                    GenSolvablePolynomial<C>[] oc);
186
187
188    /**
189     * Left Ore condition. Generators for the left Ore condition of two solvable
190     * polynomials.
191     * @param a solvable polynomial
192     * @param b solvable polynomial
193     * @return [p,q] with p*a = q*b
194     */
195    public GenSolvablePolynomial<C>[] leftOreCond(GenSolvablePolynomial<C> a, GenSolvablePolynomial<C> b);
196
197
198    /**
199     * Right Ore condition. Generators for the right Ore condition of two
200     * solvable polynomials.
201     * @param a solvable polynomial
202     * @param b solvable polynomial
203     * @return [p,q] with a*p = b*q
204     */
205    public GenSolvablePolynomial<C>[] rightOreCond(GenSolvablePolynomial<C> a, GenSolvablePolynomial<C> b);
206
207}