Open 6bbcde06-8197-41f1-b9a3-c998bb839000 opened 9 years ago
New commits:
3779d1a | get_branching_rule method |
Branch: public/combinat/branching-15398
Commit: 3779d1a
Branch pushed to git repo; I updated commit sha1. New commits:
186389c | automated branching rules now working |
Branch pushed to git repo; I updated commit sha1. New commits:
1ee0267 | doc revision |
I think it would be better if we implement a method on the various CartanType
classes which does the respective branching rules. In #15463, I go part of the way there by implementing a subtype
method, but I think we should take that idea and expand on it here, and then use subtype
to do the branching rule here. Does this sound like a good approach or do you need something more direct here (FYI - I haven't looked too closely at this patch yet)?
Work Issues: #18767 should be merged first since it is more important
This patch contains a lot of case-by-case encoding of work that can also be done by hand by the user when the user needs the branching rules (explained in the reference manual). It saves the reader having to line up the Dynkin diagrams.
So although it is convenient not to have to do this, the reader who needs a branching rule can do so without this patch. This patch is therefore less important than #18767 which adds real new functionality. After #18767 this patch should be generalized to include the twisted types. So I think it is better if #18767 (which adds real new functionality) is merged first. After that, this patch should be extended to include the twisted cases.
In #15463, I go part of the way there by implementing a subtype method, but I think we should take that idea and expand on it here, and then use subtype to do the branching rule here.
Following a suggestion of Volker Braun, branching rules for finite dimensional Lie algebras were implemented in the categorical framework in the Weyl character ring.
sage: R1=branching_rule("E7","A7","extended")
sage: type(R1)
<class 'sage.combinat.root_system.branching_rules.BranchingRule'>
sage: R2=branching_rule("A7","A3xA3","levi")
sage: R1*R2
composite branching rule E7 => (extended) A7 => (levi) A3xA3
One could try to extend this to the affine case but here we are only dealing with Levi branching rules. (The Levi subalgebras are finite-dimensional.) This is less ambitious but still useful.
We could probably benefit from using the subtype
method in #17798 (and could potentially need improvements) so it requires less hard-coded branching rules.
Dependencies: #18767
Changed work issues from #18767 should be merged first since it is more important to none
multiple doctests fail, cf. patchbot
Currently branching rules for IntegrableRepresentations of untwisted affine Lie algebras are implemented. But the process requires the user to create a dictionary between the nodes of two Dynkin diagrams, a process that can be automated.
Depends on #18767
CC: @sagetrac-sage-combinat
Component: combinatorics
Author: Daniel Bump
Branch/Commit: public/combinat/branching-15398 @
1706a8d
Issue created by migration from https://trac.sagemath.org/ticket/18398