Branching Rules for Exceptional Groups

[dwbump]

Branching rules for Lie groups are mostly already implemented in weyl_characters. That is, if G is a Lie group and H a subgroup (maximal without loss of generality) we can compute the branching rule from G => H in most cases, always if G is of classical type, and sometimes if G is an exceptional group.

Before the patch, the following rules are not implemented.

E6 => C4 , A2 , G2 , A2xG2
E7 => A2 , A1 , A1 , A1xF4 , G2xC3 , A1xG2 , A1xA1
E8 => G2xF4 , C2 , A1xA2 , A1 , A1 , A1
F4 => A1 , A1xG2
G2 => A1

With the patch, ALL of these are now implemented in Sage. After the patch, every
branching rule in the tables of McKay and Patera (Tables of dimensions, indices and branching rules for representations of simple Lie algebras) is available in Sage!

Here is a file that constructs the branching rule for every maximal subgroup of every simple Lie group of rank less than or equal to 8. This includes every case considered by McKay and Patera, and every exceptional group.

http://sporadic.stanford.edu/bump/branch-table.sage

The embeddings are described in the thematic tutorial. I've posted a copy of the patched tutorial and reference manual on sporadic.stanford.edu. The relevant sections are here:

http://sporadic.stanford.edu/thematic_tutorials/lie/branching_rules.html

http://sporadic.stanford.edu/reference/combinat/sage/combinat/root_system/weyl_characters.html

http://sporadic.stanford.edu/reference/combinat/sage/combinat/root_system/branching_rules.html

The patch makes a class BranchingRule for branching rules. Notable methods are a multiplication corresponding to composition, and a describe() method for branching rules which shows how simple roots and the affine root restrict. The multiplication gives a better method of concatenating branching rules. A projection method for composite types is given. The goals set out in Comment 6 are all achieved. The thematic tutorial is revised.

Since weyl_characters.py was getting huge, I split it, moving the branching rule material into a new file, branching_rules.py.

CC: @dwbump @sagetrac-sage-combinat @vbraun

Component: combinatorics

Author: Daniel Bump

Branch/Commit: public/combinat/15361-branching-rules @ d3e1db5

Reviewer: Volker Braun

Issue created by migration from https://trac.sagemath.org/ticket/15361

[dwbump]

Branch: public/combinat/15361-branching-rules

[dwbump]

Commit: 5feebdb

[dwbump]

comment:6

The principal changes for this ticket are listed above. This comment contains a list of other less important changes.

In both the thematic tutorial and the docstring, hand written rules are discussed. It is omitted to say that the rule should map the positive Weyl chamber into the positive Weyl chamber. The doc should be revised on this point. (It is not necessary for the rule to map dominant weights into the positive Weyl chamber but it is desirable.)

In thematic tutorial and docstring, we should explain how to branch B_r => D_r and D_r => B_{r-1}. This should
go in the section orthogonal-and-symplectic-subgroups-of-orthogonal-and-symplectic-groups of the thematic tutorial.
The r=4 case should be used as an example.

Some doctests in weyl_characters are marked "long time" with obsolete timing information. For example the doctest [F4(fw).branch(B3,rule="levi") for fw in F4.fundamental_weights()] is given with the timing information 36s. This takes less than a second on my laptop. These misleading timings should be removed.

Branching (rule="levi") from E6 to A5 currently returns an error message, but this branching rule should be implemented.

Branching from composite type needs work: for example, branching from AxB to A or B should be implemented.

[sagetrac-git]

Changed commit from 5feebdb to 35f73af

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

[35f73af](https://github.com/sagemath/sagetrac-mirror/commit/35f73af)

implemented E6->G2xA2 branching rule and corrected wrong timing info on long tests

[sagetrac-git]

Changed commit from 35f73af to fa2255a

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

[fa2255a](https://github.com/sagemath/sagetrac-mirror/commit/fa2255a)	implemented multiplication of branching rules
[ecadb7a](https://github.com/sagemath/sagetrac-mirror/commit/ecadb7a)	Merge branch 'public/combinat/15361-branching-rules' of trac.sagemath.org:sage into 15361-branching-rules
[dcd5477](https://github.com/sagemath/sagetrac-mirror/commit/dcd5477)	updated timing information and implemented E6->G2xA2 branching rule
[36e6b24](https://github.com/sagemath/sagetrac-mirror/commit/36e6b24)	make CartanType idempotent in get_branching_rule

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

[3372f1e](https://github.com/sagemath/sagetrac-mirror/commit/3372f1e)

revision of branching rules, including composite rules

[sagetrac-git]

Changed commit from fa2255a to 3372f1e

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

[9b2121d](https://github.com/sagemath/sagetrac-mirror/commit/9b2121d)

F4 => G2xA1 branching rule implemented

[sagetrac-git]

Changed commit from 3372f1e to 9b2121d

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

[0bf9e40](https://github.com/sagemath/sagetrac-mirror/commit/0bf9e40)	changed E6=>G2xA2 rule not to use redundant components to weight vector
[14601e0](https://github.com/sagemath/sagetrac-mirror/commit/14601e0)	E6 => G2xA2 branching rule written without x6 and x7

[sagetrac-git]

Changed commit from 9b2121d to 0bf9e40

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

[4a4bac8](https://github.com/sagemath/sagetrac-mirror/commit/4a4bac8)	corrections and revisions to existing branching rules and tests
[37ad3a2](https://github.com/sagemath/sagetrac-mirror/commit/37ad3a2)	Use compact representation for Cartan type in WeylCharacterRing repr method

[sagetrac-git]

Changed commit from 0bf9e40 to 4a4bac8

[sagetrac-git]

Changed commit from 4a4bac8 to e9ccead

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

[e9ccead](https://github.com/sagemath/sagetrac-mirror/commit/e9ccead)

further cleanup and corrections

[sagetrac-git]

Changed commit from e9ccead to efb2a92

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

[efb2a92](https://github.com/sagemath/sagetrac-mirror/commit/efb2a92)

E8->E7,E7->E6 rules gave correct answers but did not map weight lattice into weight lattice, hence were broke for composition. This is fixed.

[sagetrac-git]

Changed commit from efb2a92 to 3ed9056

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

[3ed9056](https://github.com/sagemath/sagetrac-mirror/commit/3ed9056)

projection branching for reducible types

[sagetrac-git]

Changed commit from 3ed9056 to e656f78

[dwbump]

comment:60

There are two suggestions here. I think I agree with the first though there was a rationale for making maximal_subgroups global: this was that as it stands one may call it without creating the WeylCharacterRing. So if you wanted to explore the subgroup lattice by descending through various subgroups this would be an advantage.

Still I agree with the comment.

For the second, if one is making maximal_subgroups a method, one might have two different methods and avoid the question of which is default. The question remains how to name them ...

[vbraun]

comment:61

I see. I don't have a particular suggestion for method names... maximal_subgroups() vs. maximal_subgroups_table()? A third option would be to write a custom container for the subgroups that behaves like a dictionary but prints like the table, though imho that would be overengineered for the problem at hand.

[vbraun]

comment:62

In the "Non-maximal Levi subgroups and Projection from Reducible Types" section you say that 'branching_rule("E6","A5","levi") returns a not-implemented error'. But you did implement it in this patch ;-) Its a good example, maybe just change it to say that it used to be not implemented (although it works now). Is there any Levi branching rule that still needs manual intervention? Maybe that subsection should be changed to just talk about projection to reducible types?

[vbraun]

comment:63

Is there an easy way to apply a BranchingRule to a representation (i.e. a WeylCharacterRing.element_class)? This seems like it would be one of the most common use cases:

sage: rule = branching_rule("A3", "C2", "symmetric")
sage: rep = WeylCharacterRing("A3")(1,0,0,0)
sage: rule.branch(rep)   # does not exist
sage: rep.branch(rule)   # does not work
sage: rule(rep)          # somewhat unexpected result
[0, 0]

The only thing I can come up with is the slightly awkward

sage: rep.branch(WeylCharacterRing(rule.Stype()), rule=rule)
C2(1,0)

The BranchingRule.__call__ could check for the parent of the argument and simply return the branched representation.

[dwbump]

comment:64

Replying to @vbraun:

Hopefully all branching rules to maximal subgroups are either implemented or
constructable as plethysms, but branching to a nonmaximal Levi may or may not
be implemented. For example, one of the G2 Levi's is implemented, the other not.
(Neither Levi is a maximal subgroup.)

I'll have to correct the documentation per your comment.

In the "Non-maximal Levi subgroups and Projection from Reducible Types" section you say that 'branching_rule("E6","A5","levi") returns a not-implemented error'. But you did implement it in this patch ;-) Its a good example, maybe just change it to say that it used to be not implemented (although it works now). Is there any Levi branching rule that still needs manual intervention? Maybe that subsection should be changed to just talk about projection to reducible types?

[dwbump]

comment:65

Replying to @vbraun:

sage: rep.branch(rule) # does not work

You do need to construct the WeylCharacterRing you are branching to. The following works.

sage: br = branching_rule("A3", "C2", "symmetric")
sage: [A3,C2] = [WeylCharacterRing(x,style="coroots") for x in ["A3","C2"]]
sage: rep=A3(1,0,0,0); rep
A3(1,0,0)
sage: rep.branch(C2, rule=br)
C2(1,0)

sage: rule.branch(rep) # does not exist

It does seem like an excellent idea for branch to also be a method of the branching rule and I'll try to implement that.

[sagetrac-git]

Changed commit from faec227 to 4dac78b

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

4dac78b

implemented maximal_subgroup(s) as a WeylCharacterRing method etc.

[dwbump]

New commits:

4dac78b

implemented maximal_subgroup(s) as a WeylCharacterRing method etc.

[dwbump]

Reviewer: Volker Braun

[dwbump]

Work Issues: Thematic tutorial needs further revision

[dwbump]

comment:68

In response to the above discussion, WeylCharacterRing instances now have two (very similarly named) methods, maximal_subgroups and maximal_subgroup. Also, the BranchingRule class has a branch method.

The thematic tutorials still need to be revised so I changed the status to needs_work.

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

d6de77b

removed bogus commits

[sagetrac-git]

Changed commit from 4dac78b to d6de77b

[sagetrac-git]

Changed commit from d6de77b to f688ff3

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

f688ff3

reference: branching_rules: minor fixup

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

7ca100a

revised thematic tutorial regarding maximal_subgroup(s) method

[sagetrac-git]

Changed commit from f688ff3 to 7ca100a

[dwbump]

comment:72

I have pushed revisions to the thematic tutorial. I'm changing the status back to needs_review

[vbraun]

Changed work issues from Thematic tutorial needs further revision to none

[sagetrac-git]

Branch pushed to git repo; I updated commit sha1. New commits:

d3e1db5

note that the E6->A5 rule is now implemented

[sagetrac-git]

Changed commit from 7ca100a to d3e1db5

[vbraun]

Changed author from bump to Daniel Bump

[vbraun]

comment:75

I made a minor edit to the tutorial, rest looks great!