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