Changeset 999b3a in git
 Timestamp:
 May 5, 2006, 4:37:36 PM (18 years ago)
 Branches:
 (u'fiekerDuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b52fc4b2495505785981d640dcf7eb3e456778ef')
 Children:
 8492cb96ea713816ff1376eb6195c8eaa8b76c45
 Parents:
 d5f47f4d77a27dca0d58409071b7d42fa0db141e
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

Singular/LIB/perron.lib
rd5f47f r999b3a 1 1 /////////////////////////////////////////////////////////////////////////////// 2 version="$Id: perron.lib,v 1. 2 20060403 13:14:05motsak Exp $";2 version="$Id: perron.lib,v 1.3 20060505 14:37:36 motsak Exp $"; 3 3 category="Noncommutative"; 4 4 info=" … … 7 7 8 8 PROCEDURES: 9 perron(L[, d]); computes relations between pairwise commuting polynomials of L[, up to a given degree bound D]9 perron(L[, D]); relations between pairwise commuting polynomials 10 10 11 11 KEYWORDS: algebraic dependence; relations … … 16 16 ////////////////////////////////////////////////////////////////////////////// 17 17 proc perron( ideal L, list # ) 18 "USAGE: perron( L [, D] ) 19 RETURN: a commutative ring, containing an exported ideal `Relations` with found polynomial relations. 20 PURPOSE: computes relations between pairwise commuting polynomials of L[, up to a given degree bound D] 21 NOTE: the implementation was partially inspired by the Perron's theorem. 22 EXAMPLE: example perron; shows an example 18 "USAGE: perron( L [, D] ) 19 RETURN: commutative ring with ideal `Relations` 20 PURPOSE: computes polynomial relations ('Relations') between pairwise 21 commuting polynomials of L [, up to a given degree bound D] 22 NOTE: the implementation was partially inspired by the Perron's theorem. 23 EXAMPLE: example perron; shows an example 23 24 " 24 25 { 25 int N, D, i; 26 27 if( nameof( basering ) == "basering" ) 28 { 29 ERROR( "No current ring!" ); 30 } 31 32 33 N = size(L); 34 35 if( N == 0 ) 36 { 37 ERROR( "Zero ideal!" ); 38 } 39 40 intvec W; // weights 41 42 for ( i = N; i > 0; i ) 43 { 44 W[i] = deg(L[i]); 45 } 46 47 //////////////////////////////////////////////////////////////////////// 48 D = 1; 49 50 // Check whether the bound degree D is given: 51 if( size(#)>0 ) 52 { 53 if ( typeof(#[1]) == typeof(D) ) 54 { 55 D = #[1]; 26 int N, D, i; 27 28 N = size(L); 29 30 if( N == 0 ) 31 { 32 ERROR( "Input ideal must be nonzero!" ); 33 } 34 35 intvec W; // weights 36 37 for ( i = N; i > 0; i ) 38 { 39 W[i] = deg(L[i]); 40 } 41 42 //////////////////////////////////////////////////////////////////////// 43 D = 1; 44 45 // Check whether the degree bound 'D' is given: 46 if( size(#)>0 ) 47 { 48 if ( typeof(#[1]) == typeof(D) ) 49 { 50 D = #[1]; 56 51 57 52 if( D <= 0 ) 58 53 { 59 54 ERROR( "An optional parameter D must be positive!" ); 60 55 } 61 56 } 62 57 } 63 58 64 // , otherwise we try to estimate it after PerronTh:65 66 { 67 68 69 70 71 72 73 { 74 59 // , otherwise we try to estimate it according to Perron's Th: 60 if( D < 0 ) 61 { 62 D = 1; 63 int d, min; 64 65 min = 1; 66 67 for ( i = size(L); i > 0 ; i ) 68 { 69 d = W[i]; 75 70 76 77 71 D = D * d; 72 if( min == 1) 78 73 { 79 74 min = d; 80 75 } else 81 76 { 82 77 if( min > d ) 83 78 { 84 79 min = d; 85 86 80 } 81 } 87 82 } 88 83 89 90 { 91 84 if( (D == 0) or (min <= 0) ) 85 { 86 ERROR( "Wrong set of polynomials!" ); 92 87 } 93 88 94 D = D / min; 95 96 kill d; 97 } 98 99 //////////////////////////////////////////////////////////////////////// 100 101 def NCRING = basering; 102 103 def CurrentField = ringlist( NCRING )[1]; 104 105 // We are going to construct a commutative ring in N variables: 106 107 ring TEMPRING = 0, ( F(1..N) ), dp; 108 109 list RingList = ringlist( TEMPRING ); 110 111 RingList[1] = CurrentField; // Take the Field from NC Ring! 112 113 kill CurrentField; // ! 114 115 // New Commutative Ring with correct field! 116 117 def COMMUTATIVERING = ring( RingList ); 118 119 setring COMMUTATIVERING; 120 121 kill TEMPRING; 122 123 //////////////////////////////////////////////////////////////////////// 124 125 // we are in COMMUTATIVERING now: 126 127 ideal PBWBasis = PBW_maxDeg( D ); // All monomials of degree(!) <= D. 128 // TODO: it would be better to compute weighted monomials of weight <= W[1] \cdot ... W[N]. 129 130 // PBWBasis; 131 132 setring NCRING; 133 134 // kill CurrentField; // we cleanup every bit of it. 135 136 map Psi = COMMUTATIVERING, L; // F(i) \mapsto L[i] 137 138 ideal Images = Psi( PBWBasis ); // Corresponding products of polynomials from L 139 140 // Images; 141 142 def T = linearMapKernel( Images ); // Compute relations in NC ring 143 144 // T; 145 146 147 // We check the output: 148 149 if( (typeof(T) != "module") and (typeof(T) != "int" ) ) 150 { 151 ERROR( "Wrong output from the 'linearMapKernel' function!" ); 152 } 153 154 if( typeof(T) == "int" ) 155 { 156 if( T != 0 ) 157 { 158 ERROR( "Wrong output from the 'linearMapKernel' function!" ); 89 D = D / min; 90 91 } 92 93 //////////////////////////////////////////////////////////////////////// 94 95 def NCRING = basering; 96 97 def CurrentField = ringlist( NCRING )[1]; 98 99 // We are going to construct a commutative ring in N variables F(i), 100 // with the field specified by 'CurrentField': 101 102 ring TEMPRING = 0, ( F(1..N) ), dp; 103 104 list RingList = ringlist( TEMPRING ); 105 RingList[1] = CurrentField; 106 107 // New Commutative Ring with correct field! 108 def COMMUTATIVERING = ring( RingList ); 109 110 //////////////////////////////////////////////////////////////////////// 111 112 setring COMMUTATIVERING; // we are in COMMUTATIVERING now 113 114 ideal PBWBasis = PBW_maxDeg( D ); // All monomials of degree(!) <= D. 115 116 // TODO: it would be better to compute weighted monomials of weight 117 // <= W[1] \cdots W[N]. 118 119 setring NCRING; // and back to NCRING 120 121 map Psi = COMMUTATIVERING, L; // F(i) \mapsto L[i] 122 123 ideal Images = Psi( PBWBasis ); // Corresponding products of polynomials 124 // from L 125 126 // ::MAIN STEP:: // Compute relations in NC ring: 127 def T = linearMapKernel( Images ); 128 129 //////////////////////////////////////////////////////////////////////// 130 131 // check the output of 'linearMapKernel': 132 int t = 0; 133 134 if( (typeof(T) != "module") and (typeof(T) != "int" ) ) 135 { 136 ERROR( "Wrong output from function 'linearMapKernel'!" ); 137 } 138 139 if( typeof(T) == "int" ) 140 { 141 t = 1; 142 if( T != 0 ) 143 { 144 ERROR( "Wrong output from function 'linearMapKernel'!" ); 159 145 } 160 146 } 161 162 163 // , and go back to commutative case in both cases: 164 if( typeof(T) == "module" ) 165 { 166 // Back to 167 setring COMMUTATIVERING; 168 module KER = imap( NCRING, T ); 169 170 // some clean up: 171 setring NCRING; 172 kill T; 173 kill Psi; 174 175 setring COMMUTATIVERING; 176 ideal result = linearCombinations( PBWBasis, KER ); 177 178 kill KER; 179 180 147 148 //////////////////////////////////////////////////////////////////////// 149 150 // Go back to commutative case in both cases: 151 setring COMMUTATIVERING; 152 153 ideal Relations; // And generate Relations: 154 155 if( t == 0 ) // T is a module 156 { 157 module KER = imap( NCRING, T ); 158 Relations = linearCombinations( PBWBasis, KER ); 159 181 160 } else 182 { 183 // If all images are zero... 184 kill T; 185 kill Psi; 186 setring COMMUTATIVERING; 187 ideal result = PBWBasis; 188 } 189 190 // now we must be in COMMUTATIVERING and there must be an ideal result. 191 kill PBWBasis; 192 193 // listvar(all); 194 195 //////////////////////////////////////////////////////////////////////// 196 // we compute an std basis of the relations: 197 198 // save options 199 intvec v = option( get ); 200 201 // set right options 202 option( redSB ); 203 option( redTail ); 204 205 // compute everything in a right form 206 ideal Relations = simplify( std( result ), 1 + 2 + 8 ); 207 208 // restore options 209 option( set, v ); 210 211 kill result; 212 213 // Relations; 214 export Relations; 215 216 return( COMMUTATIVERING ); 161 { // T == int(0) => all images are zero => 162 Relations = PBWBasis; 163 } 164 165 166 //////////////////////////////////////////////////////////////////////// 167 168 // we compute an std basis of the relations: 169 170 // save options 171 intvec v = option( get ); 172 173 // set right options 174 option( redSB ); 175 option( redTail ); 176 177 // reduce everything in as far as possible 178 Relations = simplify( std( Relations ), 1 + 2 + 8 ); 179 180 // restore options 181 option( set, v ); 182 183 // Relations; 184 export Relations; 185 186 return( COMMUTATIVERING ); 217 187 } 218 188 example … … 224 194 D[1,2]=z; D[1,3]=2*x; D[2,3]=2*y; 225 195 ncalgebra(1,D); // this algebra is U(sl_2) 226 ideal L= x^p, y^p, z^pz, 4*x*y+z^22*z; // the center227 def R = perron( L, p );228 setring R ;229 R ;196 ideal I = x^p, y^p, z^pz, 4*x*y+z^22*z; // the center 197 def RA = perron( I, p ); 198 setring RA; 199 RA; 230 200 Relations; // it was exported from perron to be in the returned ring. 231 kill R; 201 232 202 // perron can be also used in a commutative case, for example: 233 ring r=0,(x,y,z),dp;203 ring B = 0,(x,y,z),dp; 234 204 ideal J = xy+z2, z2+y2, x2y22xy3+y4; 235 def R = perron(J);236 setring R ;205 def RB = perron(J); 206 setring RB; 237 207 Relations; 238 208 }
Note: See TracChangeset
for help on using the changeset viewer.