[380a17b] | 1 | ////////////////////////////////////////////////////////////////////////////// |
---|
[3686937] | 2 | version="version orbitparam.lib 4.0.0.0 Jun_2013 "; // $Id$ |
---|
[1e1ec4] | 3 | category="Algebraic Geometry"; |
---|
| 4 | info=" |
---|
[13710c] | 5 | LIBRARY: orbitparam.lib Parametrizing orbits of unipotent actions |
---|
[1e1ec4] | 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 | |
---|