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}