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}