source: git/Singular/LIB/ncdecomp.lib @ 341696

spielwiese
Last change on this file since 341696 was 341696, checked in by Hans Schönemann <hannes@…>, 14 years ago
Adding Id property to all files git-svn-id: file:///usr/local/Singular/svn/trunk@12231 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 10.9 KB
Line 
1///////////////////////////////////////////////////////////////////////////////
2version="$Id$";
3category="Noncommutative";
4info="
5LIBRARY:  ncdecomp.lib     Decomposition of a module into its central characters
6AUTHORS:  Viktor Levandovskyy,     levandov@mathematik.uni-kl.de.
7
8OVERVIEW:
9@* This library presents algorithms for the central character decomposition of a module,
10@* i.e. a decomposition into generalized weight modules with respect to the center.
11@* Based on ideas of O. Khomenko and V. Levandovskyy (see the article [L2] in the
12@* References for details).
13
14PROCEDURES:
15CentralQuot(M,G);       central quotient M:G,
16CentralSaturation(M,T); central saturation ((M:T):...):T) ( = M:T^{\infty}),
17CenCharDec(I,C);        decomposition of I into central characters w.r.t. C
18IntersectWithSub(M,Z);  intersection of M with the subalgebra, generated by pairwise commutative elements of Z.
19";
20
21  LIB "ncalg.lib";
22  LIB "primdec.lib";
23  LIB "central.lib";
24
25///////////////////////////////////////////////////////////////////////////////
26
27proc testncdecomplib()
28{
29  example CentralQuot;
30  example CentralSaturation;
31  example CenCharDec;
32  example IntersectWithSub;
33}
34
35static proc CharKernel(list L, int i)
36{
37// compute \cup L[j], j!=i
38  int sL = size(L);
39  if ( (i<=0) || (i>sL))  { return(0); }
40  int j;
41  list Li;
42  if (i ==1 )
43  {
44    Li = L[2..sL];
45  }
46  if (i ==sL )
47  {
48    Li = L[1..sL-1];
49  }
50  if ( (i>1) && (i < sL))
51  {
52    Li = L[1..i-1];
53    for (j=i+1; j<=sL; j++)
54    {
55      Li[j-1] = L[j];
56    }
57  }
58//  print("intersecting kernels...");
59  module Cres = intersect(Li[1..size(Li)]);
60  return(Cres);
61}
62///////////////////////////////////////////////////////////////////////////////
63static proc CentralQuotPoly(module M, poly g)
64{
65// here an elimination of components should be used !
66  int N=nrows(M); // M = A^N /I_M
67  module @M;
68  int i,j;
69  for(i=1; i<=N; i++)
70  {
71   @M=@M,g*gen(i);
72  }
73  @M = simplify(@M,2);
74  @M = @M,M;
75  module S = syz(@M);
76  matrix s = S;
77  module T;
78  vector t;
79  for(i=1; i<=ncols(s); i++)
80  {
81    t = 0*gen(N);
82    for(j=1; j<=N; j++)
83    {
84      t = t + s[j,i]*gen(j);
85    }
86    T[i] = t;
87  }
88  T = simplify(T,2);
89  return(T);
90}
91///////////////////////////////////////////////////////////////////////////////
92static proc MyIsEqual(module A, module B)
93{
94// both A and B are submodules of free module
95  option(redSB);
96  option(redTail);
97  if (attrib(A,"isSB")!=1)
98  {
99    A = std(A);
100  }
101  if (attrib(B,"isSB")!=1)
102  {
103    B = std(B);
104  }
105  int ANSWER = 1;
106  if ( ( ncols(A) == ncols(B) ) && ( nrows(A) == nrows(B) ) )
107  {
108    module @AB = A-B;
109    @AB = simplify(@AB,2);
110    if (@AB[1]!=0) { ANSWER = 0; }
111  }
112  else { ANSWER = 0; }
113  return(ANSWER);
114}
115///////////////////////////////////////////////////////////////////////////////
116proc CentralQuot(module I, ideal G)
117"USAGE:  CentralQuot(M, G), M a module, G an ideal
118ASSUME: G is an ideal in the center of the base ring
119RETURN:  module
120PURPOSE: compute the central quotient M:G
121THEORY:  for an ideal G of the center of an algebra and a submodule M of A^n,
122@* the central quotient of M by G is defined to be
123@* M:G  :=  { v in A^n | z*v in M, for all z in G }.
124NOTE:    the output module is not necessarily given in a Groebner basis
125SEE ALSO: CentralSaturation, CenCharDec
126EXAMPLE: example CentralQuot; shows examples
127"{
128/* check assupmtion. Elt's of G must be central */
129  if (! inCenter(G) )
130  {
131    ERROR("ideal in the 2nd argument is not in the center of the base ring!");
132  }
133  int i;
134  list @L;
135  for(i=1; i<=size(G); i++)
136  {
137    @L[i] = CentralQuotPoly(I,G[i]);
138  }
139  module @I = intersect(@L[1..size(G)]);
140  if (nrows(@I)==1)
141  {
142    @I = ideal(@I);
143  }
144  return(@I);
145}
146example
147{ "EXAMPLE:"; echo = 2;
148   option(returnSB);
149   def a = makeUsl2();
150   setring a;
151   ideal I = e3,f3,h3-4*h;
152   I = std(I);
153   poly C=4*e*f+h^2-2*h;  // C in Z(U(sl2)), the central element
154   ideal G = (C-8)*(C-24);  // G normal factor in Z(U(sl2)), subideal in the center
155   ideal R = CentralQuot(I,G);  // same as I:G
156   R;
157}
158///////////////////////////////////////////////////////////////////////////////
159proc CentralSaturation(module M, ideal T)
160"USAGE:  CentralSaturation(M, T), for a module M and an ideal T
161ASSUME: T is an ideal in the center of the base ring
162RETURN:  module
163PURPOSE: compute the central saturation of M by T, that is M:T^{\infty}, by repititive application of @code{CentralQuot}
164NOTE:    the output module is not necessarily a Groebner basis
165SEE ALSO: CentralQuot, CenCharDec
166EXAMPLE: example CentralSaturation; shows examples
167"{
168/* check assupmtion. Elt's of T must be central */
169  if (! inCenter(T) )
170  {
171    ERROR("ideal in the 2nd argument is not in the center of the base ring!");
172  }
173  option(redSB);
174  option(redTail);
175  option(returnSB);
176  module Q=0;
177  module S=M;
178  while ( !MyIsEqual(Q,S) )
179  {
180    Q = CentralQuot(S, T);
181    S = CentralQuot(Q, T);
182  }
183  if (nrows(Q)==1)
184  {
185    Q = ideal(Q);
186  }
187//  Q = std(Q);
188  return(Q);
189}
190example
191{ "EXAMPLE:"; echo = 2;
192   option(returnSB);
193   def a = makeUsl2();
194   setring a;
195   ideal I = e3,f3,h3-4*h;
196   I = std(I);
197   poly C=4*e*f+h^2-2*h;
198   ideal G = C*(C-8);
199   ideal R = CentralSaturation(I,G);
200   R=std(R);
201   vdim(R);
202   R;
203}
204///////////////////////////////////////////////////////////////////////////////
205proc CenCharDec(module I, def #)
206"USAGE:  CenCharDec(I, C);  I a module, C an ideal
207ASSUME: C consists of generators of the center of the base ring
208RETURN:  a list L, where each entry consists of three records (if a finite decomposition exists)
209@*       L[*][1] ('ideal' type), the central character as a maximal ideal in the center,
210@*       L[*][2] ('module' type), the Groebner basis of the weight module, corresponding to the character in  L[*][1],
211@*       L[*][3] ('int' type) is the vector space dimension of the weight module (-1 in case of infinite dimension);
212PURPOSE: compute a finite decomposition of C into central characters or determine that there is no finite decomposition
213NOTE:     actual decomposition is the sum of L[i][2] above;
214@*        some modules have no finite decomposition (in such case one gets warning message)
215@*        The function @code{central} in @code{central.lib} may be used to obtain C, when needed.
216SEE ALSO: CentralQuot, CentralSaturation
217EXAMPLE: example CenCharDec; shows examples
218"
219{
220  list Center;
221  if (typeof(#) == "ideal")
222  {
223    int cc;
224    ideal tmp = ideal(#);
225    for (cc=1; cc<=size(tmp); cc++)
226    {
227      Center[cc] = tmp[cc];
228    }
229    kill tmp;
230  }
231  if (typeof(#) == "list")
232  {
233    Center = #;
234  }
235
236/* check assupmtion. Elt's of G must be central */
237  if (! inCenter(Center) )
238  {
239    ERROR("ideal in the 2nd argument is not in the center of the base ring!");
240  }
241
242// M = A/I
243//1. Find the Zariski closure of Supp_Z M
244// J = Ann_M 1 == I
245// J \cap Z:
246  option(redSB);
247  option(redTail);
248  option(returnSB);
249  def @A = basering;
250  setring @A;
251  int sZ=size(Center);
252  int i,j;
253  poly t=1;
254  for(i=1; i<=nvars(@A); i++)
255  {
256    t=t*var(i);
257  }
258  ring @Z=0,(@z(1..sZ)),dp;
259//  @Z;
260  def @ZplusA = @A+@Z;
261  setring @ZplusA;
262//  @ZplusA;
263  ideal I     = imap(@A,I);
264  list Center = imap(@A,Center);
265  poly t      = imap(@A,t);
266  ideal @Ker;
267  for(i=1; i<=sZ; i++)
268  {
269    @Ker[i]=@z(i) - Center[i];
270  }
271  @Ker = @Ker,I;
272  ideal @JcapZ = eliminate(@Ker,t);
273// do not forget parameters of a basering!
274  string strZ="ring @@Z=("+charstr(@A)+"),(@z(1.."+string(sZ)+")),dp;";
275//  print(strZ);
276  execute(strZ);
277  setring @@Z;
278  ideal @JcapZ = imap(@ZplusA,@JcapZ);
279  @JcapZ = std(@JcapZ);
280//  @JcapZ;
281  int sJ = vdim(@JcapZ);
282  if (sJ==-1)
283  {
284    "There is no finite decomposition";
285    return(0);
286  }
287//  print(@JcapZ);
288// 2. compute the min.ass.primes of the ideal in the center
289  list @L = minAssGTZ(@JcapZ);
290  int sL = size(@L);
291//  print("etL:");
292//  @L;
293// exception: is sL==1, the whole ideal has unique cen.char
294  if (sL ==1)
295  {
296    setring @A;
297    map @M = @@Z,Center[1..size(Center)];
298    list L = @M(@L);
299    list @R;
300    @R[1] = L[1];
301    if (nrows(@R[1])==1)
302    {
303      @R[1] = ideal(@R[1]);
304    }
305    @R[2] = I;
306    if (nrows(@R[2])==1)
307    {
308      @R[2] = ideal(@R[2]);
309    }
310    @R[2] = std(@R[2]);
311    @R[3] = vdim(@R[2]);
312    return(@R);
313  }
314  list @CharKer;
315  for(i=1; i<=sL; i++)
316  {
317    @L[i] = std(@L[i]);
318  }
319// 3. compute the intersections of characters
320  for(i=1; i<=sL; i++)
321  {
322    @CharKer[i] = CharKernel(@L,i);
323  }
324//  print("Charker:");
325//  @CharKer;
326// 4. Go back to the algebra and compute central saturations
327  setring @A;
328  map @M = @@Z,Center[1..size(Center)];
329  list L = @M(@CharKer);
330  list R,@R;
331  for(i=1; i<=sL; i++)
332  {
333    @R[1] = L[i];
334    if (nrows(@R[1])==1)
335    {
336      @R[1] = ideal(@R[1]);
337    }
338    @R[2] = CentralSaturation(I,L[i]);
339    if (nrows(@R[2])==1)
340    {
341      @R[2] = ideal(@R[2]);
342    }
343    @R[2] = std(@R[2]);
344    @R[3] = vdim(@R[2]);
345     R[i] = @R;
346  }
347  return(R);
348}
349example
350{ "EXAMPLE:"; echo = 2;
351   option(returnSB);
352   def a = makeUsl2(); // U(sl_2) in characteristic 0
353   setring a;
354   ideal I = e3,f3,h3-4*h;
355   I = twostd(I);           // two-sided ideal generated by I
356   vdim(I);                 // it is finite-dimensional
357   ideal Cn = 4*e*f+h^2-2*h; // the only central element
358   list T = CenCharDec(I,Cn);
359   T;
360   // consider another example
361   ideal J = e*f*h;
362   CenCharDec(J,Cn);
363}
364///////////////////////////////////////////////////////////////////////////////
365proc IntersectWithSub (ideal M, def #)
366"USAGE:  IntersectWithSub(M,Z),  M an ideal, Z an ideal
367ASSUME: Z consists of pairwise commutative elements
368RETURN:  ideal of two-sided generators, not a Groebner basis
369PURPOSE: computes the intersection of M with the subalgebra, generated by Z
370NOTE:    usually Z consists of generators of the center
371@* The function @code{central} from @code{central.lib} may be used to obtain the center Z, if needed.
372EXAMPLE: example IntersectWithSub; shows an example
373"
374{
375  ideal Z;
376  if (typeof(#) == "list")
377  {
378    int cc;
379    list tmp = #;
380    for (cc=1; cc<=size(tmp); cc++)
381    {
382      Z[cc] = tmp[cc];
383    }
384    kill tmp;
385  }
386  if (typeof(#) == "ideal")
387  {
388    Z = #;
389  }
390  // returns a submodule of M, equal to M \cap Z
391  // assume/correctness: Z should consists of pairwise
392  // commutative elements
393  int nz = size(Z);
394  int i,j;
395  poly p;
396  for (i=1; i<nz; i++)
397  {
398    for (j=i+1; j<=nz; j++)
399    {
400      p = bracket(Z[i],Z[j]);
401      if (p!=0)
402      {
403        "Error: generators of the subalgebra do not commute.";
404        return(ideal(0));
405      }
406    }
407  }
408  // main action
409  def B = basering;
410  setring B;
411  string s1,s2;
412  s1 = "ring @Z = (";
413  s2 = s1 + charstr(basering) + "),(z(1.." + string(nz)+")),Dp";
414  //  s2;
415  execute(s2);
416  setring B;
417  map F = @Z,Z;
418  setring @Z;
419  ideal PreM = preimage(B,F,M);
420  PreM = std(PreM);
421  setring B;
422  ideal T = F(PreM);
423  return(T);
424}
425example
426{
427  "EXAMPLE:"; echo = 2;
428  ring R=(0,a),(e,f,h),Dp;
429  matrix @d[3][3];
430  @d[1,2]=-h;
431  @d[1,3]=2e;
432  @d[2,3]=-2f;
433  def r = nc_algebra(1,@d); setring r; // parametric U(sl_2)
434  ideal I = e,h-a;
435  ideal C;
436  C[1] = h^2-2*h+4*e*f; // the center of U(sl_2)
437  ideal X = IntersectWithSub(I,C);
438  X;
439  ideal G = e*f, h; // the biggest comm. subalgebra of U(sl_2)
440  ideal Y = IntersectWithSub(I,G);
441  Y;
442}
Note: See TracBrowser for help on using the repository browser.