# source:git/Singular/LIB/orbitparam.lib@13710c

spielwiese
Last change on this file since 13710c was 13710c, checked in by Janko Boehm <boehm@…>, 9 years ago
Ultra minor changes to doc
• Property mode set to `100644`
File size: 9.7 KB
Line
1//////////////////////////////////////////////////////////////////////////////
2version="version orbitparam.lib 4.0.0.0 Jun_2013 "; // \$Id\$
3category="Algebraic Geometry";
4info="
5LIBRARY:  orbitparam.lib   Parametrizing orbits of unipotent actions
6
7AUTHORS:  J. Boehm, boehm at mathematik.uni-kl.de @*
9
10OVERVIEW:
11
12This library implements the theorem of Chevalley-Rosenlicht as stated in Theorem 3.1.4 of [Corwin, Greenleaf].
13Given a set of strictly upper triangular n x n matrices L_1,...,L_c which generate
14a Lie algebra as a vector space, and a vector v of size n, the
15function @code{parametrizeOrbit} constructs a parametrization of the orbit of v under
16the action of exp(<L_1,...,L_c>).
17
18To compute exp of the Lie algebra elements corresponding
19to the parameters we require that the characteristic of the base field is zero or larger than n.
20
21By determining the parameters from bottom to top
22this allows you to find an element in the orbit with (at least) as many zeros as the dimension of the
23orbit.
24
25Note: Theorem 3.1.4 of [Corwin, Greenleaf] uses strictly lower triangular matrices.
26
27REFERENCES:
28
29Laurence Corwin, Frederick P. Greenleaf: Representations of Nilpotent Lie Groups and their Applications: Volume 1, Part 1, Basic Theory and Examples, Cambridge University Press (2004).
30
31PROCEDURES:
32
33tangentGens(list,matrix);         Returns elements in the Lie algebra, which form a basis of the tangent space of the parametrization.
34matrixExp(matrix);                Matrix exp for nilpotent matrices.
35matrixLog(matrix);                Matrix log for unipotent matrices.
36parametrizeOrbit(list,matrix);    Returns parametrization of the orbit.
37maxZeros(list,matrix);            Determine an element in the orbit with the maximum number of zeroes.
38
39KEYWORDS: nilpotent Lie algebras; unipotent groups; orbit; parametrization; Chevalley-Rosenlicht theorem
40";
41
42LIB "general.lib";
43LIB "matrix.lib";
44
45
46
47///////////////////////////////////////////////////////////////////////////////
48
49///////////////////////////////////////////////////////////////////////////////
50proc tangentGens(list L, matrix v)
51"USAGE:  tangentGens(L,v); L list, v matrix.
52ASSUME:  L is a list of strictly upper triangular n x n matrices of same size.
53         The vector space <L> genererated by the elements of L should be closed
54         under the Lie bracket.
55
56         v is matrix of constants of size n x 1.
57
58RETURN:  list, with four entries
59@*       - first entry is the dimension of the orbit of under the action of exp(<L>)
60@*       - second entry is a list generators of the tangent space of the orbit of v at v
61           under the action of exp(<L>). If the characteristic p of the ground field is positive, then n has to be smaller than p. The generators are elements of <L>.
62@*       - third entry is the list of matrices with the coefficient to obtain the generators
63           as a linear combination of the elements of L
64@*       - fourth entry is list of integers with entries in v which can be made zero by the
65           action of exp(<L>)
66
67THEORY:  We apply the theorem of Chevalley-Rosenlicht.
68
69KEYWORDS: Lie algebra; orbit; Chevalley-Rosenlicht theorem
70
71EXAMPLE: example tangentGens; shows an example
72
73"
74{
75list T;
76list M;
77int i;
78int s;
79int t;
80list Z;
81int d=size(L);
82int n=nrows(v);
83  if (d<1){ERROR("expected nonempty list of generators");}
84  if (n<>nrows(L[1])){ERROR("vector should be same dimension as size of matrix");}
85  matrix A= L[1]*v;
86  for ( i=2; i <= d; i++ )
87  {
88    A=concat(A,L[i]*v);
89  }
90  matrix B;
91  for ( i=n-1; i >=1; i=i-1 )
92  {
93    B=submat(A,i..n,1..d);
94    matrix E[n-i+1][1];
95    E[1,1]=1;
96    list LU=ludecomp(B);
97    list Q=lusolve(LU[1],LU[2],LU[3],E);
98    if (Q[1]<>0){
99       s++;
100       T[s]=Q[2];
101       matrix C = Q[2][1,1]*L[1];
102       for ( t=2; t <= d; t++ )
103       {
104          C=C+Q[2][t,1]*L[t];
105       }
106       M[s]=C;
107       Z[s]=i;
108       kill C;
109    }
110    kill E,LU,Q;
111  }
112return(list(s,M,T,Z));
113}
114
115example
116{ "EXAMPLE:";
117  ring R = 0,(x),dp;
118  matrix L1[3][3] = 0,1,0, 0,0,0, 0,0,0;
119  matrix L2[3][3] = 0,0,1, 0,0,0, 0,0,0;
120  matrix L3[3][3] = 0,1,1, 0,0,1, 0,0,0;
121  list L = L1,L2,L3;
122  matrix v[3][1] = 1,2,3;
123  tangentGens(L,v);
124}
125
126
127proc matrixExp(matrix A)
128"USAGE:  matrixExp(A); A matrix.
129ASSUME:  A is a nilpotent n x n matrix.
130         If the characteristic p of the ground field is positive, then n has to be
131         smaller than p.
132
133RETURN:  matrix, exp(A)
134
135THEORY:  We compute the power series, which terminates since A is nilpotent.
136
137KEYWORDS: Exp for matrices
138
139EXAMPLE: example matrixExp; shows an example
140
141"
142{
143int i;
144int n = nrows(A);
145if (n<>ncols(A)){
146   ERROR("expected square matrix");
147}
148matrix Z[n][n];
149matrix B[n][n];
150B=B+1;
151matrix D[n][n];
152D=D+1;
153number j=1;
154for (i=1; i <= n; i++ )
155  {
156      j=j*i;
157      D=D*A;
158      if (D==Z){break;}
159      B=B+(1/j)*D;
160  }
161return(B);}
162example
163{ "EXAMPLE:";
164  ring R = 0,(x),dp;
165  matrix A[4][4] = 0,0,1,0, 0,0,1,0, 0,0,0,0;
166  matrixExp(A);
167}
168
169
170proc matrixLog(matrix A)
171"USAGE:  matrixLog(A); A matrix.
172ASSUME:  A-E is a nilpotent n x n matrix.
173         If the characteristic p of the ground field is positive, then n has to be
174         smaller than p.
175
176RETURN:  matrix, log(A)
177
178THEORY:  We compute the power series, which terminates since A-E is nilpotent.
179
180KEYWORDS: Log for matrices
181
182EXAMPLE: example matrixLog; shows an example
183
184"
185{
186int i;
187int n = nrows(A);
188if (n<>ncols(A)){
189   ERROR("expected square matrix");
190}
191matrix Z[n][n];
192matrix B[n][n];
193matrix D[n][n];
194matrix N[n][n]= A-1;
195D=D+1;
196number j;
197for (i=1; i <= n; i++ )
198  {
199      j=j+1;
200      D=D*N;
201      if (D==Z){break;}
202      B=B+(1/j)*(-1)^(i+1)*D;
203  }
204return(B);}
205example
206{ "EXAMPLE:";
207  ring R = 0,(s,t),dp;
208  matrix A[3][3] = 1,s,st/2, 0,1,t, 0,0,1;
209  matrixLog(A);
210}
211
212
213
214proc parametrizeOrbit(list L, matrix v)
215"USAGE:  parametrizeOrbit(L,v); L list, v matrix.
216ASSUME:  L is a list of strictly upper triangular n x n matrices of same size.
217         The vector space <L> genererated by the elements of L should be closed
218         under the Lie bracket.
219@*       v is matrix of constants of size n x 1.
220@*       The basering has at least size(L) variables. However we will only use
221         tangentGens(L,v)[1] many of them.
222
223RETURN:  list, with four entries
224@*       - int, dimension of the orbit
225@*       - matrix A over the basering giving a parametrization of the orbit of v under the action of exp(<L>).
226@*       - list of integers, with the (row)-indices of entries which can be deleted by the action
227@*       - the variables of the parametrization to solve for
228
229THEORY:  We apply the theorem of Chevalley-Rosenlicht. First we determine tangent space generators,
230         then apply @code{matrixExp} to the generators, and finally take the product
231         to obtain the parametrization.
232
233KEYWORDS: Lie group; orbit; parametrization
234
235EXAMPLE: example parametrizeOrbit; shows an example
236"
237{
238list T = tangentGens(L,v);
239list T2 = T[2];
240int i;
241int d=size(L);
242list vL;
243if (nvars(basering)<d)
244{
245   ERROR("expected basering with at least generators many variables");
246}
247for (i=1; i <= size(T2); i++ )
248  {
249    v = matrixExp(T2[size(T2)-i+1]*var(size(T2)-i+1))*v;
250    vL[i]=var(i);
251  }
252return(list(T[1],v,T[4],vL));
253}
254
255example
256{ "EXAMPLE:";
257  ring R = 0,(t(1..3)),dp;
258  matrix L1[3][3] = 0,1,0, 0,0,0, 0,0,0;
259  matrix L2[3][3] = 0,0,1, 0,0,0, 0,0,0;
260  matrix L3[3][3] = 0,1,1, 0,0,1, 0,0,0;
261  list L = L1,L2,L3;
262  matrix v[3][1] = 1,2,3;
263  parametrizeOrbit(L,v);
264
265  ring R1 = 0,(t(1..2)),dp;
266  matrix L1[4][4] = 0,1,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0;
267  matrix L2[4][4] = 0,0,1,0, 0,0,0,1, 0,0,0,0, 0,0,0,0;
268  list L = L1,L2;
269  matrix v[4][1] = 1,2,3,4;
270  parametrizeOrbit(L,v);
271}
272
273
274proc maxZeros(list L, matrix v)
275"USAGE:  maxZeros(L,v); L list, v matrix.
276ASSUME:  L is a list of strictly upper triangular n x n matrices of same size.
277         The vector space <L> genererated by the elements of L should be closed
278         under the Lie bracket.
279
280         v is matrix of constants of size n x 1.
281
282         The basering has at least size(L) variables. However we will only use
283         tangentGens(L,v)[1] many of them.
284
285RETURN:  matrix of constants over the basering giving an element in the orbit of v
286         under the action of exp(<L>)  with (at least) as many zeros as the dimension of the
287         orbit.
288
289THEORY:  We apply @code{parametrizeOrbit} to obtain a parametrization of the orbit
290         according to the theorem of Chevalley-Rosenlicht. By determining the parameters from bottom to top
291         we find an element in the orbit with (at least) as many zeros as the dimension of the
292         orbit.
293
294KEYWORDS: Lie group; orbit; maximum number of zeroes
295
296EXAMPLE: example parametrizeOrbit; shows an example
297"
298{
299  int d = size(L);
300  def Roriginal = basering;
301  list rl = ringlist(Roriginal);
302  int k;
303  for(k = 1; k <= d; k++)
304     {
305        rl[2][k] = "x("+string(k)+")";
306     }
307  rl[3]= list(list("dp",1:(d)),list("C",0));
308  def R = ring(rl);
309  setring R;
310  list L = fetch(Roriginal,L);
311  matrix v = fetch(Roriginal,v);
312  list P = parametrizeOrbit(L,v);
313  matrix p = P[2];
314  int n = P[1];
315  list idx = P[3];
316  list va = P[4];
317  poly equ,rhs;
318  number de;
319  list parval;
320  for(k = 1; k <= n; k++)
321     {
322        equ = p[idx[k],1];
323        rhs=-number(subst(equ,va[k],0));
324        de = number(diff (equ, va[k]));
325        parval[k] = rhs/de;
326        p = subst(p,va[k],rhs/de);
327     }
328  setring(Roriginal);
329  matrix p=fetch(R,p);
330  return(p);
331}
332
333example
334{ "EXAMPLE:";
335  ring R = 0,(x),dp;
336  matrix L1[3][3] = 0,1,0, 0,0,0, 0,0,0;
337  matrix L2[3][3] = 0,0,1, 0,0,0, 0,0,0;
338  matrix L3[3][3] = 0,1,1, 0,0,1, 0,0,0;
339  list L = L1,L2,L3;
340  matrix v[3][1] = 1,2,3;
341  maxZeros(L,v);
342
343  ring R1 = 0,(x),dp;
344  matrix L1[4][4] = 0,1,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0;
345  matrix L2[4][4] = 0,0,1,0, 0,0,0,1, 0,0,0,0, 0,0,0,0;
346  list L = L1,L2;
347  matrix v[4][1] = 1,2,3,4;
348  maxZeros(L,v);
349}
350
351
Note: See TracBrowser for help on using the repository browser.