001/*
002 * $Id: SolvableSyzygy.java 5267 2015-07-27 17:57:50Z kredel $
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, List<GenSolvablePolynomial<C>> F);
059
060
061    /**
062     * Test if right syzygy.
063     * @param Z list of sysygies.
064     * @param F a polynomial list.
065     * @return true, if Z is a list of right syzygies for F, else false.
066     */
067    public boolean isRightZeroRelation(List<List<GenSolvablePolynomial<C>>> Z,
068                    List<GenSolvablePolynomial<C>> F);
069
070
071    /**
072     * Test if left sysygy of modules
073     * @param Z list of sysygies.
074     * @param F a module list.
075     * @return true, if Z is a list of left syzygies for F, else false.
076     */
077    public boolean isLeftZeroRelation(ModuleList<C> Z, ModuleList<C> F);
078
079
080    /**
081     * Test if right sysygy of modules
082     * @param Z list of sysygies.
083     * @param F a module list.
084     * @return true, if Z is a list of right syzygies for F, else false.
085     */
086    public boolean isRightZeroRelation(ModuleList<C> Z, ModuleList<C> F);
087
088
089    /**
090     * Resolution of a module. Only with direct GBs.
091     * @param M a module list of a Groebner basis.
092     * @return a resolution of M.
093     */
094    public List<SolvResPart<C>> resolution(ModuleList<C> M);
095
096
097    /**
098     * Resolution of a polynomial list. Only with direct GBs.
099     * @param F a polynomial list of a Groebner basis.
100     * @return a resolution of F.
101     */
102    public List/*<SolvResPart<C>|SolvResPolPart<C>>*/resolution(PolynomialList<C> F);
103
104
105    /**
106     * Resolution of a module.
107     * @param M a module list of an arbitrary basis.
108     * @return a resolution of M.
109     */
110    public List<SolvResPart<C>> resolutionArbitrary(ModuleList<C> M);
111
112
113    /**
114     * Resolution of a polynomial list.
115     * @param F a polynomial list of an arbitrary basis.
116     * @return a resolution of F.
117     */
118    public List/*<SolvResPart<C>|SolvResPolPart<C>>*/resolutionArbitrary(PolynomialList<C> F);
119
120
121    /**
122     * Left syzygy module from arbitrary base.
123     * @param F a solvable polynomial list.
124     * @return syz(F), a basis for the module of left syzygies for F.
125     */
126    public List<List<GenSolvablePolynomial<C>>> leftZeroRelationsArbitrary(List<GenSolvablePolynomial<C>> F);
127
128
129    /**
130     * Left syzygy module from arbitrary base.
131     * @param modv number of module variables.
132     * @param F a solvable polynomial list.
133     * @return syz(F), a basis for the module of left syzygies for F.
134     */
135    public List<List<GenSolvablePolynomial<C>>> leftZeroRelationsArbitrary(int modv,
136                    List<GenSolvablePolynomial<C>> F);
137
138
139    /**
140     * Left syzygy for arbitrary left module base.
141     * @param M an arbitrary base.
142     * @return leftSyz(M), a basis for the left module of syzygies for M.
143     */
144    public ModuleList<C> leftZeroRelationsArbitrary(ModuleList<C> M);
145
146
147    /**
148     * Right syzygy module from arbitrary base.
149     * @param F a solvable polynomial list.
150     * @return syz(F), a basis for the module of right syzygies for F.
151     */
152    public List<List<GenSolvablePolynomial<C>>> rightZeroRelationsArbitrary(List<GenSolvablePolynomial<C>> F);
153
154
155    /**
156     * Right syzygy module from arbitrary base.
157     * @param modv number of module variables.
158     * @param F a solvable polynomial list.
159     * @return syz(F), a basis for the module of right syzygies for F.
160     */
161    public List<List<GenSolvablePolynomial<C>>> rightZeroRelationsArbitrary(int modv,
162                    List<GenSolvablePolynomial<C>> F);
163
164
165    /**
166     * Test left Ore condition.
167     * @param a solvable polynomial
168     * @param b solvable polynomial
169     * @param oc = [p,q] two solvable polynomials
170     * @return true if p*a = q*b, else false
171     */
172    public boolean isLeftOreCond(GenSolvablePolynomial<C> a, GenSolvablePolynomial<C> b,
173                    GenSolvablePolynomial<C>[] oc);
174
175
176    /**
177     * Test right Ore condition.
178     * @param a solvable polynomial
179     * @param b solvable polynomial
180     * @param oc = [p,q] two solvable polynomials
181     * @return true if a*p = b*q, else false
182     */
183    public boolean isRightOreCond(GenSolvablePolynomial<C> a, GenSolvablePolynomial<C> b,
184                    GenSolvablePolynomial<C>[] oc);
185
186
187    /**
188     * Left Ore condition. Generators for the left Ore condition of two solvable
189     * polynomials.
190     * @param a solvable polynomial
191     * @param b solvable polynomial
192     * @return [p,q] with p*a = q*b
193     */
194    public GenSolvablePolynomial<C>[] leftOreCond(GenSolvablePolynomial<C> a, GenSolvablePolynomial<C> b);
195
196
197    /**
198     * Right Ore condition. Generators for the right Ore condition of two
199     * solvable polynomials.
200     * @param a solvable polynomial
201     * @param b solvable polynomial
202     * @return [p,q] with a*p = b*q
203     */
204    public GenSolvablePolynomial<C>[] rightOreCond(GenSolvablePolynomial<C> a, GenSolvablePolynomial<C> b);
205
206}