1 | ////////////////////////////////////////////////////////////////////////////// |
---|
2 | version="version orbitparam.lib 4.0.0.0 Jun_2013 "; // $Id$ |
---|
3 | category="Algebraic Geometry"; |
---|
4 | info=" |
---|
5 | LIBRARY: orbitparam.lib Parametrizing unipotent orbits |
---|
6 | |
---|
7 | AUTHORS: J. Boehm, boehm at mathematik.uni-kl.de @* |
---|
8 | S. Papadakis, papadak at math.ist.utl.pt @* |
---|
9 | |
---|
10 | OVERVIEW: |
---|
11 | |
---|
12 | This library implements the theorem of Chevalley-Rosenlicht as stated in Theorem 3.1.4 of [Corwin, Greenleaf]. |
---|
13 | Given a set of strictly upper triangular n x n matrices L_1,...,L_c which generate |
---|
14 | a Lie algebra as a vector space, and a vector v of size n, the |
---|
15 | function @code{parametrizeOrbit} constructs a parametrization of the orbit of v under |
---|
16 | the action of exp(<L_1,...,L_c>). |
---|
17 | |
---|
18 | To compute exp of the Lie algebra elements corresponding |
---|
19 | to the parameters we require that the characteristic of the base field is zero or larger than n. |
---|
20 | |
---|
21 | By determining the parameters from bottom to top |
---|
22 | this allows you to find an element in the orbit with (at least) as many zeros as the dimension of the |
---|
23 | orbit. |
---|
24 | |
---|
25 | Note: Theorem 3.1.4 of [Corwin, Greenleaf] uses strictly lower triangular matrices. |
---|
26 | |
---|
27 | REFERENCES: |
---|
28 | |
---|
29 | Laurence 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 | |
---|
31 | PROCEDURES: |
---|
32 | |
---|
33 | tangentGens(list,matrix); Returns elements in the Lie algebra, which form a basis of the tangent space of the parametrization. |
---|
34 | matrixExp(matrix); Matrix exp for nilpotent matrices. |
---|
35 | matrixLog(matrix); Matrix log for unipotent matrices. |
---|
36 | parametrizeOrbit(list,matrix); Returns parametrization of the orbit. |
---|
37 | maxZeros(list,matrix); Determine an element in the orbit with the maximum number of zeroes. |
---|
38 | |
---|
39 | KEYWORDS: nilpotent Lie algebras; unipotent groups; orbit; parametrization; Chevalley-Rosenlicht theorem |
---|
40 | "; |
---|
41 | |
---|
42 | LIB "general.lib"; |
---|
43 | LIB "matrix.lib"; |
---|
44 | |
---|
45 | |
---|
46 | |
---|
47 | /////////////////////////////////////////////////////////////////////////////// |
---|
48 | |
---|
49 | /////////////////////////////////////////////////////////////////////////////// |
---|
50 | proc tangentGens(list L, matrix v) |
---|
51 | "USAGE: tangentGens(L,v); L list, v matrix. |
---|
52 | ASSUME: 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 | |
---|
58 | RETURN: 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 | |
---|
67 | THEORY: We apply the theorem of Chevalley-Rosenlicht. |
---|
68 | |
---|
69 | KEYWORDS: Lie algebra; orbit; Chevalley-Rosenlicht theorem |
---|
70 | |
---|
71 | EXAMPLE: example tangentGens; shows an example |
---|
72 | |
---|
73 | " |
---|
74 | { |
---|
75 | list T; |
---|
76 | list M; |
---|
77 | int i; |
---|
78 | int s; |
---|
79 | int t; |
---|
80 | list Z; |
---|
81 | int d=size(L); |
---|
82 | int 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 | } |
---|
112 | return(list(s,M,T,Z)); |
---|
113 | } |
---|
114 | |
---|
115 | example |
---|
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 | |
---|
127 | proc matrixExp(matrix A) |
---|
128 | "USAGE: matrixExp(A); A matrix. |
---|
129 | ASSUME: 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 | |
---|
133 | RETURN: matrix, exp(A) |
---|
134 | |
---|
135 | THEORY: We compute the power series, which terminates since A is nilpotent. |
---|
136 | |
---|
137 | KEYWORDS: Exp for matrices |
---|
138 | |
---|
139 | EXAMPLE: example matrixExp; shows an example |
---|
140 | |
---|
141 | " |
---|
142 | { |
---|
143 | int i; |
---|
144 | int n = nrows(A); |
---|
145 | if (n<>ncols(A)){ |
---|
146 | ERROR("expected square matrix"); |
---|
147 | } |
---|
148 | matrix Z[n][n]; |
---|
149 | matrix B[n][n]; |
---|
150 | B=B+1; |
---|
151 | matrix D[n][n]; |
---|
152 | D=D+1; |
---|
153 | number j=1; |
---|
154 | for (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 | } |
---|
161 | return(B);} |
---|
162 | example |
---|
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 | |
---|
170 | proc matrixLog(matrix A) |
---|
171 | "USAGE: matrixLog(A); A matrix. |
---|
172 | ASSUME: 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 | |
---|
176 | RETURN: matrix, log(A) |
---|
177 | |
---|
178 | THEORY: We compute the power series, which terminates since A-E is nilpotent. |
---|
179 | |
---|
180 | KEYWORDS: Log for matrices |
---|
181 | |
---|
182 | EXAMPLE: example matrixLog; shows an example |
---|
183 | |
---|
184 | " |
---|
185 | { |
---|
186 | int i; |
---|
187 | int n = nrows(A); |
---|
188 | if (n<>ncols(A)){ |
---|
189 | ERROR("expected square matrix"); |
---|
190 | } |
---|
191 | matrix Z[n][n]; |
---|
192 | matrix B[n][n]; |
---|
193 | matrix D[n][n]; |
---|
194 | matrix N[n][n]= A-1; |
---|
195 | D=D+1; |
---|
196 | number j; |
---|
197 | for (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 | } |
---|
204 | return(B);} |
---|
205 | example |
---|
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 | |
---|
214 | proc parametrizeOrbit(list L, matrix v) |
---|
215 | "USAGE: parametrizeOrbit(L,v); L list, v matrix. |
---|
216 | ASSUME: 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 | |
---|
223 | RETURN: 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 | |
---|
229 | THEORY: 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 | |
---|
233 | KEYWORDS: Lie group; orbit; parametrization |
---|
234 | |
---|
235 | EXAMPLE: example parametrizeOrbit; shows an example |
---|
236 | " |
---|
237 | { |
---|
238 | list T = tangentGens(L,v); |
---|
239 | list T2 = T[2]; |
---|
240 | int i; |
---|
241 | int d=size(L); |
---|
242 | list vL; |
---|
243 | if (nvars(basering)<d) |
---|
244 | { |
---|
245 | ERROR("expected basering with at least generators many variables"); |
---|
246 | } |
---|
247 | for (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 | } |
---|
252 | return(list(T[1],v,T[4],vL)); |
---|
253 | } |
---|
254 | |
---|
255 | example |
---|
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 | |
---|
274 | proc maxZeros(list L, matrix v) |
---|
275 | "USAGE: maxZeros(L,v); L list, v matrix. |
---|
276 | ASSUME: 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 | |
---|
285 | RETURN: 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 | |
---|
289 | THEORY: 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 | |
---|
294 | KEYWORDS: Lie group; orbit; maximum number of zeroes |
---|
295 | |
---|
296 | EXAMPLE: 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 | |
---|
333 | example |
---|
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 | |
---|