File: classical.doc

package info (click to toggle)
symmetrica 2.0+ds-6
  • links: PTS, VCS
  • area: main
  • in suites: buster, sid
  • size: 9,456 kB
  • sloc: ansic: 97,289; makefile: 170; sh: 70
file content (513 lines) | stat: -rw-r--r-- 20,730 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
COMMENT:
	The CLASSICAL.C module deals with the calculation of the dimensions,
	standard tableaux and characters of the irreducible representations
	of the classical groups.

	This file first gives a very brief description of the labelling scheme
	for representations of classical groups in terms of partitions.
	It then describes the SYMMETRICA routines which calculate the
	dimensions, standard tableaux and characters of all irreducible
	representations of the classical groups. Finally, it describes
	three example programs which make use of these routines.

	In all cases, the set of irreducible representations of the classical
	groups may be naturally indexed by a subset of the set of partitions,
	half partitions (for the spin representations of O(n)) or signed
	partitions (for some O(n) representations). This labelling scheme
	is described in [BKW83], [Wy92], [We92].

	In [We92] (see chapter 2), the specification of the irreducibles
	is slightly different to the others for certain modules of O(n).
	Namely, in [BKW83] and [Wy92], an asterisk is used to distinguish 
	representations of O(n) which are associate (differ by a factor
	of the determinant of the group element) whereas in [We92], 
	associate representations are labelled by different partitions.
	This latter notation is adhered to in these routines.
	The only case where a partition alone does not serve to uniquely
	identify the representation is for SO(2r) ordinary representations
	where the partition has exactly r non-zero parts, and for all spin
	representations of SO(2r). In such cases, there are two inequivalent
	representations corresponding to the partition in question. These
	two representations are usually distinguished by augmenting the
	partition label with + or -. These two representations have the same
	dimension and so are not distinguished in the dimension calculating
	routines.

	The representation labels are summarised here where the (descending)
	partition p=(p(1),p(2),...,p(s)) has s non-zero parts and its conjugate
	is p'=(p'(1),p'(2),...):

	 Ordinary representations
	 GL(n)    |  p : s<=n
	 Sp(2r)   |  p : s<=r
	 Sp(2r+1) |  p : s<=r+1
	 O(n)     |  p : p'(1)+p'(2)<=n
	 SO(2r+1) |  p : s<=r
	 SO(2r)   |  p : s<r
		  |  p+ : s=r
		  |  p- : s=r

	 Spin representations
	 O(2r+1)  |  p : s<=r
	 O(2r)    |  p : s<=r
	 SO(2r+1) |  p : s<=r 
	 SO(2r)   |  p+ : s<=r
		  |  p- : s<=r

	(Although Sp(2r+1) is not defined, remarkably the formulae for Sp(n)
	work whether n is even or odd!)
	In some labelling schemes, the spin representations are distinguished
	from the ordinary representations either by appending a Delta to the
	partition label, or by increasing each of the first [n/2] parts (zero
	or not) by 1/2.

	Each dimension calculation is based on a hook-length formula. For GL(n),
	this was first described in [Ro58]. For Sp(2r), O(n) and the spin modules
	of O(n), the formulae were first given in [EK79].

	The standard tableaux for GL(n) are the well-known "semi-standard"
	tableaux. For Sp(n), the tableaux were first given in [Ki76].
	For the spin cases of O(n), they were first given in [KE83].
	The easy transition to the spin cases of SO(n) is given in [We92].
	The tableaux for the ordinary cases of O(n) and SO(n) were
	first defined in [We92] and [KW93], but based on some tableaux 
	by Proctor [Pr95]. In each case, the standard tableaux enumerate the
	weights of the representation. Moreover, as then follows, the number
	of standard tableaux is equal to the dimension of the corresponding
	representation.
	(In the case where the empty partition is given as an argument to
	standard tableaux calculating routines, in the non-spin cases, 
	for convenience, a single tableau of shape (1) and entry 0 is
	returned. In the spin cases, each tensor component of the
	tableau is also of this form. This should cause no difficulties.)

	For each representation, the character is calculated by summing,
	over all standard tableaux, a monomial (the weight) formed from each
	tableau. The monomial is formed by multiplying together x_i for each
	i appearing in the tableau. A negative entry contributes (x_i)^(-1).
	An entry in a half box (for the spin representations) contributes
	(x_i)^(1/2) or (x_i)^(-1/2). In the case of the spin representations,
	the result obtained from the character routines has all the
	exponents doubled so that integers suffice.

	That this process of summing over standard tableaux actually gives the 
	character is often clear from the original derivation of the standard
	tableaux. Nonetheless, this and all the above is detailed in [We92].
	(Incidentally, in [We92], the standard tableaux are used to provide a
	very convenient basis for the irreducible modules themselves. By this
	means, explicit matrix representations are readily calculated.)

	Typically, each dimension, tableaux generation or character routine
	requires, as arguments, three allocated SYMMETRICA objects. The first
	is an INTEGER object giving the n in GL(n), Sp(n), O(n) or SO(n).
	The second is a PARTITION object specifying the representation.
	The last is an EMPTY object through which the result is returned.
	(When it is necessary to distinguish between the + or - representation
	in certain cases for SO(2r), an extra INTEGER argument is required.
	Its value should be +1 or -1 to indicate either of the two cases.)
	In the case of the dimension routines, this result becomes an INTEGER
	or a LONGINT object containing the result. In the other routines, it
	becomes a LIST object. For the character routines, each element in
	the list is a POLYNOM object. For the ordinary tableaux generation
	routines, each element in the list is a TABLEAUX. For spin tableaux,
	each element is a MONOM, each component of which is a TABLEAUX,
	thereby distinguishing the half-box and whole-box parts of the spinor
	tableau.


	[BKW83] G.R.E. Black, R.C. King and B.G. Wybourne,
	  Kronecker Products for Compact Semisimple Lie Groups,
	  J. Phys. A: Math. Gen. 16 (1983), 1555--1589.

	[Wy92] B.G. Wybourne,
	  Schur: an interactive programme for calculating properties of Lie groups
	  (programme manual), (1992).

	[We92] T.A. Welsh,
	  PhD thesis, University of Southampton, (1992).

	[Ro58] G. de B. Robinson,
	  A Remark by Philip Hall,
	  Can. Math. Bull. 1 (1958), 21--23.

	[EK79] N. El-Samra and R.C. King,
	  Dimensions of Irreducible Representations of the Classical Lie Groups,
	  J. Phys. A: Math. Gen. 12 (1979), 2317--2328.

	[Ki76] R.C. King, Weight Multiplicities for the Classical Groups, in
	  Lecture notes in Physics 50 (1976), 490--499.

	[KE83] R.C. King and N.G.I. El-Sharkaway,
	  Standard Young Tableaux and Weight Multiplicities of the Classical
	  Lie Groups,
	  J. Phys. A16 (1983), 3153--3177.

	[KW93] R.C. King and T.A. Welsh,
	  Construction of Orthogonal Group Modules Using Tableaux,
	  Lin. and Mult. Alg. 33 (1993), 251--283.

	[Pr95] R.A. Proctor,
	  Young Tableaux, Gelfand Patterns, and Branching Rules for
	  Classical Lie Groups,
	  J.Alg. 164 (1994), 299--360.

	/*************************************************************************
	 Here follow routines to calculate dimensions of classical groups 
	*************************************************************************/


NAME:          
	gl_dimension
SYNOPSIS:      
	INT gl_dimension (OP n, OP partition, OP dim)
DESCRIPTION:   
	Calculates the dimension of the representation of GL(n)
	       labelled by the partition. If the number of parts
	       exceeds n, then an ERROR results. 
	       Note that each irreducible representation of GL(n) is
	       associate to one labelled by a partition with not more
	       than n parts (and indeed to one with less than n parts).
RETURN:        
	OK or ERROR.


NAME:          
	sp_dimension
SYNOPSIS:      
	INT sp_dimension (OP n, OP partition, OP dim)
DESCRIPTION:   
	Calculates the dimension of the representation of Sp(n)
	       labelled by the partition. If the number of parts
	       exceeds n/2, then an ERROR results. If n is odd
	       then a warning is given, but the calculation will
	       proceed and return a value. 
	       Each irreducible representation of Sp(2r) is labelled
	       by a partition with not more than r parts.
RETURN:
	        OK or ERROR.


NAME:  
	        or_dimension
SYNOPSIS:
	      INT or_dimension (OP n, OP partition, OP dim)
DESCRIPTION:
	   Calculates the dimension of the representation of O(n)
	       labelled by the partition. If the sum of the first
	       two parts of the conjugate partition exceeds n,
	       then an ERROR results.
	       Each irreducible representation of O(n) is labelled by
	       a partition for which the sum of the first two parts
	       of the conjugate does not exceed n.
RETURN:
	        OK or ERROR.


NAME:  
	        so_dimension
SYNOPSIS:
	      INT so_dimension (OP n, OP partition, OP dim)
DESCRIPTION:
	   Calculates the dimension of the representation of SO(n)
	       labelled by the partition. If the number of parts
	       exceeds n/2, then an ERROR results.
	       Each irreducible representation of SO(n) is labelled
	       by a partition with not more than [n/2] parts, except
	       that if n is even then two inequivalent irreducible
	       representations correspond to each partition with
	       exactly n/2 parts. (These two representations are
	       usually distinguished by the use of + or - subscript
	       on the partition label.) However, the two irreducible
	       representations labelled by partitions with exactly 
	       n/2 non-zero parts are of the same dimension and so
	       for the current purposes, using the partition label is
	       sufficient.
RETURN:
	        OK or ERROR.


NAME:   
	       pn_dimension
SYNOPSIS:
	      INT pn_dimension (OP n, OP partition, OP dim)
DESCRIPTION:
	   Calculates the dimension of the spin representation of 
	       O(n) (the Pin(n) group) labelled by the partition.
	       An ERROR results if the number of parts exceeds n/2.
	       Each irreducible spin representation of O(n)
	       is labelled by a partition for which the number of parts 
	       does not exceed n. In fact, for n odd, there are
	       further representations of Pin(n): the associates of
	       those for which the number of parts does not exceed n/2.
	       However as two-valued representations of O(n), the
	       distinction is lost.
RETURN:
	        OK or ERROR.


NAME:  
	        sn_dimension
SYNOPSIS:
	      INT sn_dimension (OP n, OP partition, OP dim)
DESCRIPTION:
	   Calculates the dimension of the spin representation of 
	       SO(n) (the Spin(n) group) labelled by the partition.
	       If the number of parts exceeds n/2, then an ERROR results.
	       For n odd, each irreducible spin representation of SO(n)
	       is labelled by a partition with not more than [n/2] parts.
	       For n even, each irreducible spin representation of SO(n)
	       is one of two labelled by a partition with not more than
	       n/2 parts. (These two representations are usually 
	       distinguished by the use of + or - subscript on the
	       partition label.) However, for n even, the two
	       inequivalent irreducible representations labelled
	       by a partition are of the same dimension and so for the
	       current purposes, using the partition label is sufficient.
RETURN:
	        OK or ERROR.

COMMENT:
	/*************************************************************************
	 Routines to calculate standard tableaux for the classical groups
	*************************************************************************/


NAME:   
       gl_tableaux 
SYNOPSIS:
      INT gl_tableaux (OP n, OP partition, OP list)
DESCRIPTION:
   Calculates the set of standard tableaux ("semi-standard")
	       for GL(n), returning a LIST of TABLEAUX in list.
	       ERROR returned if partition has tooo many parts.
RETURN:
        ERROR or number of standard tableaux.

NAME: 
         sp_tableaux 
SYNOPSIS:
      INT sp_tableaux (OP n, OP partition, OP list)
DESCRIPTION:
   Calculates the set of standard tableaux for Sp(n),
	       returning a LIST of TABLEAUX in list.
	       ERROR returned if partition has tooo many parts.
RETURN:
        ERROR or number of standard tableaux.

NAME:
          or_tableaux 
SYNOPSIS:
      INT or_tableaux (OP n, OP partition, OP list)
DESCRIPTION:
   Calculates the set of standard tableaux for O(n),
	       returning a LIST of TABLEAUX in list.
	       ERROR returned if partition is not a valid label. 
RETURN:
        ERROR or number of standard tableaux.

NAME:
	          so_tableaux 
SYNOPSIS:
	      INT so_tableaux (OP n, OP partition, INT flag, OP list)
DESCRIPTION:
   Calculates the set of standard tableaux for SO(n),
	       returning a LIST of TABLEAUX in list. flag is used
	       only if n is even and partition has exactly n/2 parts.
               For flag=+1 or -1, it chooses between the two
	       representations labelled by the partition in this case.
	       ERROR returned if partition has tooo many parts.
RETURN:
        ERROR or number of standard tableaux.

NAME:
          pn_tableaux 
SYNOPSIS:
      INT pn_tableaux (OP n, OP partition, OP list)
DESCRIPTION:
   Calculates the set of standard spinor-tableaux for O(n),
	       returning a LIST of MONOM in list. Each MONOM has
	       a TABLEAUX as each component. The koeff TABLEAUX
	       has one column and contains the entries from the
	       half (spin) boxes, while the self TABLEAUX contains
	       the entries from the whole (tensor) boxes.
	       ERROR returned if partition has tooo many parts.
RETURN:
        ERROR or number of standard tableaux.
 
NAME:
          sn_tableaux 
SYNOPSIS:
      INT sn_tableaux (OP n, OP partition, INT flag, OP list)
DESCRIPTION:
   Calculates the set of standard spinor-tableaux for SO(n),
	       returning a LIST of MONOM in list. Each MONOM has
	       a TABLEAUX as each component. The koeff TABLEAUX
	       has one column and contains the entries from the
	       half (spin) boxes, while the self TABLEAUX contains
	       the entries from the whole (tensor) boxes. flag is
	       used only if n is even. For flag=+1 or -1, it chooses
	       between the two representations labelled by the
	       partition in this case.
	       ERROR returned if partition has tooo many parts.
RETURN:
        ERROR or number of standard tableaux.
 
COMMENT:
	/*************************************************************************
	 Routines to calculate characters for the classical groups
	*************************************************************************/

NAME:
          gl_character
SYNOPSIS:
      INT gl_character (OP n, OP partition, OP character)
DESCRIPTION:
   Calculates the character of the representation of GL(n)
	       labelled by partition. This is the Schur function.
	       It is returned as a POLYNOM object in character.
	       ERROR returned if partition has tooo many parts.
RETURN:
        OK or ERROR.

NAME:
          sp_character
SYNOPSIS:
      INT sp_character (OP n, OP partition, OP character)
DESCRIPTION:
   Calculates the character of the representation of Sp(n)
	       labelled by partition. It is returned as a POLYNOM
	       object in character. ERROR returned if partition has
	       tooo many parts.
RETURN:
        OK or ERROR.

NAME:
          or_character
SYNOPSIS:
      INT or_character (OP n, OP partition, OP character)
DESCRIPTION:
   Calculates the character of the representation of O(n)
	       labelled by partition. It is returned as a POLYNOM
	       object in character. ERROR returned if partition is
	       not a valid representation label. 
RETURN:
        OK or ERROR.

NAME:
          so_character
SYNOPSIS:
      INT so_character (OP n, OP partition, INT flag, OP character)
DESCRIPTION:
   Calculates the character of the representation of SO(n)
	       labelled by partition. It is returned as a POLYNOM
	       object in character. flag is used only if n is even
	       and partition has exactly n/2 parts. For flag=+1 or -1,
	       it chooses between the two representations labelled by
	       the partition in this case. ERROR returned if partition
	       has tooo many parts.
RETURN:
        OK or ERROR.

NAME:
          pn_character
SYNOPSIS:
      INT pn_character (OP n, OP partition, OP character)
DESCRIPTION:
   Calculates the spin character of the representation of
	       O(n) labelled by partition. It is returned as a
	       POLYNOM object in character, where each exponent is
	       double the actual exponent which is an half odd-integer.
	       ERROR returned if partition has tooo many parts.
RETURN:
        OK or ERROR.

NAME:
          sn_character
SYNOPSIS:
      INT sn_character (OP n, OP partition, INT flag, OP character)
DESCRIPTION:
   Calculates the spin character of the representation of
	       SO(n) labelled by partition. It is returned as a
	       POLYNOM object in character, where each exponent is
	       double the actual exponent which is an half odd-integer.
	       flag is used only if partition has exactly n/2 parts.
	       For flag=+1 or -1, it chooses between the two
	       representations labelled by the partition in this case.
	       ERROR returned if partition has tooo many parts.
RETURN:
        OK or ERROR.
COMMENT:

	/*************************************************************************
	 Here follows a list of prototypes for the routines described above.
	*************************************************************************/

	/*************************************************************************
	 Routines to calculate dimensions of the classical groups
	*************************************************************************/

	INT gl_dimension (OP n, OP partition, OP dim);
	INT sp_dimension (OP n, OP partition, OP dim);
	INT or_dimension (OP n, OP partition, OP dim);
	INT so_dimension (OP n, OP partition, OP dim);
	INT pn_dimension (OP n, OP partition, OP dim);
	INT sn_dimension (OP n, OP partition, OP dim);

	/*************************************************************************
	 Routines to calculate standard tableaux for the classical groups
	*************************************************************************/

	INT gl_tableaux (OP n, OP partition, OP list);
	INT sp_tableaux (OP n, OP partition, OP list);
	INT or_tableaux (OP n, OP partition, OP list);
	INT so_tableaux (OP n, OP partition, INT flag, OP list);
	INT pn_tableaux (OP n, OP partition, OP list);
	INT sn_tableaux (OP n, OP partition, INT flag, OP list);

	/*************************************************************************
	 Routines to calculate characters for the classical groups
	*************************************************************************/

	INT gl_character (OP n, OP partition, OP character);
	INT sp_character (OP n, OP partition, OP character);
	INT or_character (OP n, OP partition, OP character);
	INT so_character (OP n, OP partition, INT flag, OP character);
	INT pn_character (OP n, OP partition, OP character);
	INT sn_character (OP n, OP partition, INT flag, OP character);


	/*************************************************************************
	 Here follow brief descriptions of the example programs.
	*************************************************************************/


	The following program is written in the C language, using the
	SYMMETRICA object oriented approach.

	CLS_EX1.C
	  This program first requests the user for a value of n and then for
	a partition. These values are sent in turn to each of the dimension
	calculating routines above (for some they may be invalid) to calculate
	the dimension of the irreducible representation labelled by the
	partition, for each case: GL(n), Sp(n), O(n), SO(n), spin O(n),
	spin SO(n).  After each call, the result is displayed.

	CLS_EX2.C
	  This program first requests the user for a value of n and then for
	a partition. The user is then asked for which classical group,
	GL(n), Sp(n), O(n), SO(n), spin O(n), or spin SO(n), she wishes
	to calculate the set of standard tableaux. If necessary the
	+/- specification is also requested. The standard tableaux are
	displayed together with their number.

	CLS_EX3.C
	  This program first requests the user for a value of n and then for
	a partition. The user is then asked for which classical group,
	GL(n), Sp(n), O(n), SO(n), spin O(n), or spin SO(n), she wishes to 
	calculate the character. If necessary, the +/- specification is also
	requested. The character is then displayed. 

	/*************************************************************************
				      Trevor Welsh, Bayreuth, April 1996.
	*************************************************************************/