#20402: Make subword complexes compatible with  real reflection groups
-------------------------------------+-------------------------------------
       Reporter:  stumpc5            |        Owner:
           Type:  enhancement        |       Status:  needs_work
       Priority:  major              |    Milestone:  sage-7.2
      Component:  combinatorics      |   Resolution:
       Keywords:  reflection group,  |    Merged in:
  coxeter group, subword complex,    |    Reviewers:
  days80                             |  Work issues:
        Authors:  Christian Stump    |       Commit:
Report Upstream:  N/A                |  0ee1f3bf9c772352b9a7994afc7f4359e618b309
         Branch:  u/stumpc5/20402    |     Stopgaps:
   Dependencies:  #11187             |
-------------------------------------+-------------------------------------

Comment (by stumpc5):

 Replying to [comment:17 tscrim]:
 > -1 to changing all of the examples to ''only'' using GAP3/reflection
 groups. Moreover, it is good to make sure the functionality works between
 different implementations.

 The header contains tests that the core functionality works for Coxeter
 groups, maybe one could add a more elaborate example there, providing
 examples for more functionality.

 But I clearly wrote the code the way I did in close relationshiop to the
 implementation of reflection groups, and I must confess that I prefer the
 speed (and indeed I need that speed for my research) over the code being
 usable by other implementations. I think, it is okay to have the code sort
 of working for {{{CoxeterGroup}}}, but for example the necessity to
 introduce a method {{{action_on_root_indices}}} for those tells that there
 is actually more work to be done to make the implementation work with both
 without giving up the speed on one, and not introducing unnecessary
 function overhead on the other.

 > Until GAP3 becomes an optional spkg, it means they become completely
 untested.

 This should be done soon in my eyes, but I understand that so far I am the
 only one being desperate to have it.

 > I think there are a few things in here which need to be abstracted up to
 the category, root system code, and/or Coxeter type code. For example,
 `is_crystallographic` should be called on the Coxeter type, of which
 `ReflectionGroup` does not have and should (or perhaps the Coxeter
 matrix).

 A reflection group acting on a real vector space can have the property of
 being crystallographic or not (whether or not it stabilizes a lattice). I
 thus think the group itself should have this property.

 What do you think of (me) adding this method also to Coxeter groups (in
 this ticket or another)?

 > I also do not see the reason why this change is needed:
 > {{{#!diff
 > -                Lambda = {li: coeff[li] * Lambda[li] for li in Lambda}
 > +                Lambda = {li: coeff[li] * Lambda[li] for li in
 Lambda.keys()}
 > }}}
 > as the iteration for a dictionary is over its keys (and the former is
 faster and more memory efficient).

 As we have per default that simple reflections are families rather than
 dicts (so that iterating over them actually iterates over them), the
 reflection group implementation also have simple roots and fundamental
 weights as finite families, so iterating goes over the values. That's what
 the {{{keys}}} is there for.

 > With this change:
 > {{{#!diff
 > -                V_weights.append(pi * fund_weight)
 > +                # TODO: little hack to distinguish the implementations
 > +                #       for ReflectionGroups and CoxeterGroup
 > }}}
 > I think it would be better to have the fundamental weights handle the
 action of the reflection group element.

 If you mean, one might have a method {{{act on weight}}}, one could think
 about it, but the point here is that the action on fundamental weights can
 be quickly understood using the action on roots, while the general action
 on weights is not as simple.

 I can implement a method {{{act_on_fundamental_weight}}} to factor out the
 hack, but is that what we actually want?

--
Ticket URL: <http://trac.sagemath.org/ticket/20402#comment:18>
Sage <http://www.sagemath.org>
Sage: Creating a Viable Open Source Alternative to Magma, Maple, Mathematica, 
and MATLAB

-- 
You received this message because you are subscribed to the Google Groups 
"sage-trac" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To post to this group, send email to [email protected].
Visit this group at https://groups.google.com/group/sage-trac.
For more options, visit https://groups.google.com/d/optout.

Reply via email to