This is WeylGroups.info, produced by Macaulay2, version 1.26.06

WeylGroups -- Weyl groups
*************************

Description
===========

This package provides functions to compute in Weyl groups of root systems. In
particular, it can compute intervals for the Bruhat order.

Here is a quick tutorial (see common/share/Macaulay2/WeylGroups/tutorial.html )
on how to use it.

Authors
=======

  * Baptiste Calmès (see http://bcalmes.perso.math.cnrs.fr/ )
  * Viktor Petrov

Version
=======

This documentation describes version 0.5.3 of WeylGroups, released October 15,
2022.

Citation
========

If you have used this package in your research, please cite it as follows:

+----------------------------------------------------------------------------+
|@misc{WeylGroupsSource,                                                     |
|  title = {{WeylGroups: root systems and Weyl groups. Version~0.5.3}},      |
|  author = {Baptiste Calm{\`e}s and Viktor Petrov},                         |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Types
      * DynkinDiagram -- the class of Dynkin diagrams
      * DynkinType -- the class of Dynkin Types
      * HasseDiagram -- the class of Hasse diagrams
      * HasseGraph -- the class of Hasse graphs
      * Parabolic -- the class of parabolic subgroups of Weyl
        groups
      * Root -- the class of roots (or, more generally, elements
        of the root lattice)
      * RootSystem -- the class of all root systems
      * Weight -- the class of weights
      * WeylGroupDoubleCoset -- the class of
        double cosets of Weyl groups by pairs of parabolic subgroups
      * WeylGroupElement -- the class of elements of
        Weyl groups
      * WeylGroupLeftCoset -- the class of left
        cosets of Weyl groups by parabolic subgroup
      * WeylGroupRightCoset -- the class of right
        cosets of Weyl groups by parabolic subgroups
  * Functions and commands
      * aboveBruhat -- obtain Weyl group elements just
        greater than an element for the Bruhat order
      * addRoots -- adding roots
      * cartanMatrix -- the Cartan matrix of a root system
      * connectedComponents -- get the connected
        components
      * coxeterLength -- the length of a reduced
        decomposition of an element of a Weyl group
      * dynkinDiagram -- produce a Dynkin Diagram
      * dynkinExponents -- the exponents associated to
        a type
      * dynkinType -- obtaining a Dynkin type
      * endVertices -- the vertices with at most one edge
      * eval -- evaluate the dual of a root at something
      * halfSumOfRoots -- the half-sum of positive roots
      * hasseDiagramToGraph -- turning a hasse
        diagram into a graph (intended for graphic representation)
      * hasseGraphToPicture -- construct the
        picture of a Hasse Graph
      * intervalBruhat -- obtaining an interval for the
        Bruhat order
      * isLtBruhat -- compare two Weyl group elements in the
        Bruhat order
      * isMinimalRepresentative -- check
        whether an element of a Weyl group is the minimal representative of a
        coset
      * isPositiveRoot -- check whether a weight is a
        positive root
      * isReduced -- check whether a decomposition is of
        minimal length
      * isReflection -- checks whether an element of a
        Weyl group is a reflection
      * isRoot -- check whether a weight is a root or whether a
        root is in a parabolic sub root system
      * listWeylGroupElements -- list all
        elements of a given length in a Weyl group
      * loadHasseGraph -- load a Hasse graph from a file
      * longestWeylGroupElement -- the longest
        element of a Weyl group
      * minimalRepresentative -- the minimal
        representative of a coset
      * neutralWeylGroupElement -- the neutral
        element of a Weyl group
      * numberOfPositiveRoots -- the number of
        positive roots
      * parabolic -- construct a parabolic
      * poincareSeries -- a generating series for number
        of elements in a Weyl group
      * positiveRoots -- the set of all positive roots
      * reduce -- the product of several reflections
      * reducedDecomposition -- the reduced
        decomposition of an element of a Weyl group
      * reflect -- apply the reflection with respect to a root
      * reflection -- the reflection with respect to a root
      * rootCoefficients -- coefficients at the simple
        roots
      * rootSystem -- obtain a root system
      * rootSystemA -- a root system of type A
      * rootSystemB -- a root system of type B
      * rootSystemC -- a root system of type C
      * rootSystemD -- a root system of type D
      * rootSystemE -- a root system of type E
      * scalarProduct -- compute a scalar product
        (invariant by the Weyl group)
      * simpleRoot -- a simple root
      * storeHasseGraph -- store a Hasse graph in a
        file
      * underBruhat -- obtain Weyl group elements less than
        an element for the Bruhat order
      * weight -- construct a weight in the weight lattice of a
        root system
      * whoseReflection -- the positive root whose
        reflection is a given element of a Weyl group
  * Methods
      * - Weight -- the negative of a weight
      * aboveBruhat(BasicList) -- The Weyl
        group elements just under the ones in the list for the Bruhat order
      * aboveBruhat(WeylGroupElement),
        -- Weyl group elements just above a given one for the Bruhat order
      * addRoots(RootSystem,Root,Root)
        -- the sum of two roots
      * cartanMatrix(RootSystem) -- the
        Cartan matrix of a root system
      * connectedComponents(DynkinDiagram)
        -- the connected components of
        a Dynkin diagram
      * coxeterLength(WeylGroupElement)
        -- the length of a reduced
        decomposition of an element of a Weyl group
      * dynkinDiagram(DynkinDiagram,Parabolic)
        -- the Dynkin diagram of
        the Levy subgroup of a parabolic
      * dynkinDiagram(RootSystem) -- the
        Dynkin diagram of a root system
      * dynkinExponents(DynkinType), --
        the exponents of the Dynkin type
      * DynkinType ++ DynkinType -- the
        disjoint union of Dynkin Types
      * DynkinType == DynkinType -- the
        equality of Dynkin Types
      * dynkinType(BasicList) -- constructing
        a Dynkin type
      * dynkinType(DynkinDiagram) -- the
        Dynkin type of a Dynkin diagram
      * dynkinType(RootSystem) -- the Dynkin
        type of a root system
      * endVertices(DynkinDiagram), --
        the vertices of a Dynkin diagram with at most one neighbor
      * eval(RootSystem,Weight,Root)
        -- evaluate the dual of a root at
        a Weight
      * eval(RootSystem,Weight,ZZ),
        -- evaluate the dual of a simple root at a Weight
      * eval(RootSystem,ZZ,Root), --
        evaluate the dual of a root at a fundamental weight
      * eval(RootSystem,ZZ,ZZ), --
        evaluate the dual of a simple root at another one
      * halfSumOfRoots(RootSystem), --
        the half-sum of positive roots
      * hasseDiagramToGraph(HasseDiagram)
        -- turning a hasse diagram into
        a graph (intended for graphic representation)
      * hasseGraphToPicture(HasseGraph)
        -- Obtain a picture from a Hasse
        graph
      * intervalBruhat(WeylGroupElement,WeylGroupElement)
        -- elements
        between two given ones for the Bruhat order on a Weyl group
      * intervalBruhat(WeylGroupLeftCoset,WeylGroupLeftCoset),
        --
        elements between two given ones for the Bruhat order on a quotient of a
        Weyl group
      * intervalBruhat(WeylGroupRightCoset,WeylGroupRightCoset),
        --
        elements between two given ones for the Bruhat order on a quotient of a
        Weyl group
      * inverse(WeylGroupElement) -- the
        inverse to an element of a Weyl group
      * isLtBruhat(WeylGroupElement,WeylGroupElement)
        -- compare two
        Weyl group elements in the Bruhat order
      * isMinimalRepresentative(Parabolic,WeylGroupElement)
        -- check
        whether an element of a Weyl group is the minimal representative of a
        right coset
      * isMinimalRepresentative(Parabolic,WeylGroupElement,Parabolic),
        -- check whether an element of a Weyl group is the minimal
        representative of a double coset
      * isMinimalRepresentative(WeylGroupElement,Parabolic)
        -- check
        whether an element of a Weyl group is the minimal representative of a
        left coset
      * isPositiveRoot(RootSystem,Weight)
        -- check whether a weight is a
        positive root
      * isReduced(BasicList,WeylGroupElement)
        -- whether an Weyl group
        element can be multiplied by some simple reflections with length
        increasing at each step
      * isReduced(RootSystem,BasicList)
        -- whether a decomposition in
        simple reflections is reduced
      * isReflection(WeylGroupElement)
        -- checks whether an element of a
        Weyl group is a reflection
      * isRoot(RootSystem,Parabolic,Root)
        -- check whether a root is
        in the sub root system of the parabolic
      * isRoot(RootSystem,Weight), --
        check whether a weight is a positive root
      * listWeylGroupElements(RootSystem,ZZ)
        -- list all elements of a
        given length in a Weyl group
      * loadHasseGraph(String) -- load a
        Hasse graph from a file
      * longestWeylGroupElement(RootSystem)
        -- the longest element of the
        Weyl group of a root system
      * longestWeylGroupElement(RootSystem,Parabolic)
        -- the longest
        element of a parabolic subgroup of the Weyl group of a root system
      * minimalRepresentative(WeylGroupDoubleCoset)
        -- the minimal
        representative of a coset
      * minimalRepresentative(WeylGroupLeftCoset)
        -- the minimal
        representative of a coset
      * minimalRepresentative(WeylGroupRightCoset)
        -- the minimal
        representative of a coset
      * neutralWeylGroupElement(RootSystem)
        -- the neutral element of the
        Weyl group of a root system
      * norm(RootSystem,Root) -- the
        squared norm of a root
      * numberOfPositiveRoots(DynkinType)
        -- the number of positive roots
      * numberOfPositiveRoots(RootSystem)
        -- the number of positive roots
      * Parabolic % WeylGroupElement, --
        the right coset defined by an element of Weyl group
      * Parabolic % WeylGroupLeftCoset,
        -- the double coset defined by a left coset
      * Parabolic == Parabolic -- equality of
        parabolics
      * parabolic(RootSystem,Set), --
        construct a parabolic from a set of simple roots
      * parabolic(WeylGroupDoubleCoset)
        -- the parabolic associated to a
        double coset
      * poincareSeries(HasseDiagram,RingElement)
        -- the generating
        series of a Hasse diagram
      * poincareSeries(RootSystem,Parabolic,RingElement)
        -- the
        generating series of a quotient of the Weyl group by length
      * poincareSeries(RootSystem,RingElement)
        -- the generating series
        of the Weyl group by length
      * positiveRoots(RootSystem) -- the
        set of all positive roots
      * positiveRoots(RootSystem,Parabolic)
        -- the set of all positive
        roots in a parabolic sugroups
      * rank(DynkinDiagram) -- the rank of a
        Dynkin diagram
      * rank(RootSystem) -- the rank of a root
        system
      * reduce(RootSystem,BasicList),
        -- the product of several reflections with respect to simple roots
      * reducedDecomposition(WeylGroupElement)
        -- the reduced
        decomposition of an element of a Weyl group
      * reflect(RootSystem,BasicList,Root)
        -- apply to a root several
        reflections with respect to simple roots
      * reflect(RootSystem,BasicList,Weight)
        -- apply to a weight
        several reflections with respect to roots
      * reflect(RootSystem,ZZ,Root),
        -- apply to a root the reflection with respect to a simple root
      * reflect(RootSystem,ZZ,Weight)
        -- apply to a weight the
        reflection with respect to a root
      * reflection(RootSystem,Root),
        -- the reflection with respect to a root
      * rootCoefficients(RootSystem,Root)
        -- the coefficients at the
        simple roots
      * rootCoefficients(RootSystem,Weight)
        -- the coefficients at the
        simple roots
      * RootSystem ++ RootSystem -- the direct
        sum of root systems
      * RootSystem == RootSystem -- equality
        of root systems
      * rootSystem(DynkinDiagram) -- the
        root system corresponding to a Dynkin diagram
      * rootSystem(DynkinType) -- the root
        system of a given type
      * rootSystem(RootSystem,Parabolic)
        -- the root system of the Levy
        subgroup of a parabolic
      * scalarProduct(RootSystem,Weight,Weight)
        -- the scalar product
        of two weights
      * scalarProduct(RootSystem,ZZ,Weight)
        -- the scalar product of a
        fundamental weight and a weight
      * scalarProduct(RootSystem,ZZ,ZZ)
        -- the scalar product of two
        fundamental weights
      * simpleRoot(RootSystem,ZZ), --
        the n-th simple root
      * storeHasseGraph(HasseGraph,String)
        -- store a Hasse graph in a
        file
      * underBruhat(BasicList) -- Weyl group
        elements just under the ones in the list for the Bruhat order
      * underBruhat(WeylGroupElement),
        -- Weyl group elements just under a given one for the Bruhat order
      * Weight + Weight -- the sum of two weights
      * Weight - Weight -- the difference of two
        weights
      * weight(RootSystem,BasicList),
        -- construct a weight from a list
      * weight(RootSystem,Vector), --
        construct a weight from a vector
      * WeylGroupDoubleCoset == WeylGroupDoubleCoset
        -- equality of double
        cosets
      * WeylGroupElement % Parabolic, --
        the left coset defined by an element of Weyl group
      * WeylGroupElement * Root -- apply an
        element of a Weyl group to a root
      * WeylGroupElement * Weight -- apply
        an element of a Weyl group to a weight
      * WeylGroupElement * WeylGroupElement
        -- the product of two elements of a Weyl group
      * WeylGroupElement * WeylGroupLeftCoset
        -- apply an element of a Weyl group to a left coset
      * WeylGroupElement == WeylGroupElement
        -- equality of elements of Weyl groups
      * WeylGroupElement ^ ZZ -- the power of an
        element of a Weyl group
      * WeylGroupLeftCoset == WeylGroupLeftCoset
        -- equality of left cosets
      * WeylGroupRightCoset % Parabolic,
        -- the double coset defined by a right coset
      * WeylGroupRightCoset * WeylGroupElement
        -- apply an element of a Weyl group to a left coset
      * WeylGroupRightCoset == WeylGroupRightCoset
        -- equality of right cosets
      * whoseReflection(WeylGroupElement)
        -- the positive root whose
        reflection is a given element of a Weyl group
      * ZZ * Root -- multiplication of a root by an integer
      * ZZ * Weight -- the multiple of a weight
  * Other things
      * rootSystemF4 -- the root system of type F4
      * rootSystemG2 -- the root system of type G2

For the programmer
==================

The object WeylGroups, is a package (Macaulay2Doc),
defined in WeylGroups.m2, with auxiliary files in WeylGroups/.

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1559:0.

RootSystem -- the class of all root systems
*******************************************

Methods that use an object of class RootSystem:
===============================================

  * addRoots(RootSystem,Root,Root)
    -- the sum of two roots
  * cartanMatrix(RootSystem) -- the Cartan
    matrix of a root system
  * dynkinDiagram(RootSystem) -- the
    Dynkin diagram of a root system
  * dynkinType(RootSystem) -- the Dynkin
    type of a root system
  * eval(RootSystem,Weight,Root),
    -- evaluate the dual of a root at a Weight
  * eval(RootSystem,Weight,ZZ), --
    evaluate the dual of a simple root at a Weight
  * eval(RootSystem,ZZ,Root), --
    evaluate the dual of a root at a fundamental weight
  * eval(RootSystem,ZZ,ZZ) -- evaluate
    the dual of a simple root at another one
  * halfSumOfRoots(RootSystem) -- the
    half-sum of positive roots
  * isPositiveRoot(RootSystem,Weight)
    -- check whether a weight is a
    positive root
  * isReduced(RootSystem,BasicList)
    -- whether a decomposition in simple
    reflections is reduced
  * isRoot(RootSystem,Parabolic,Root)
    -- check whether a root is in
    the sub root system of the parabolic
  * isRoot(RootSystem,Weight) -- check
    whether a weight is a positive root
  * listWeylGroupElements(RootSystem,ZZ)
    -- list all elements of a given
    length in a Weyl group
  * longestWeylGroupElement(RootSystem)
    -- the longest element of the Weyl
    group of a root system
  * longestWeylGroupElement(RootSystem,Parabolic)
    -- the longest element
    of a parabolic subgroup of the Weyl group of a root system
  * neutralWeylGroupElement(RootSystem)
    -- the neutral element of the Weyl
    group of a root system
  * norm(RootSystem,Root) -- the squared
    norm of a root
  * numberOfPositiveRoots(RootSystem)
    -- the number of positive roots
  * parabolic(RootSystem,Set), --
    construct a parabolic from a set of simple roots
  * poincareSeries(RootSystem,Parabolic,RingElement)
    -- the generating
    series of a quotient of the Weyl group by length
  * poincareSeries(RootSystem,RingElement)
    -- the generating series of
    the Weyl group by length
  * positiveRoots(RootSystem) -- the set
    of all positive roots
  * positiveRoots(RootSystem,Parabolic)
    -- the set of all positive roots
    in a parabolic sugroups
  * rank(RootSystem) -- the rank of a root system
  * reduce(RootSystem,BasicList), --
    the product of several reflections with respect to simple roots
  * reflect(RootSystem,BasicList,Root)
    -- apply to a root several
    reflections with respect to simple roots
  * reflect(RootSystem,BasicList,Weight)
    -- apply to a weight several
    reflections with respect to roots
  * reflect(RootSystem,ZZ,Root), --
    apply to a root the reflection with respect to a simple root
  * reflect(RootSystem,ZZ,Weight),
    -- apply to a weight the reflection with respect to a root
  * reflection(RootSystem,Root), --
    the reflection with respect to a root
  * rootCoefficients(RootSystem,Root)
    -- the coefficients at the simple
    roots
  * rootCoefficients(RootSystem,Weight)
    -- the coefficients at the
    simple roots
  * RootSystem ++ RootSystem -- the direct sum
    of root systems
  * RootSystem == RootSystem -- equality of
    root systems
  * rootSystem(RootSystem,Parabolic)
    -- the root system of the Levy
    subgroup of a parabolic
  * scalarProduct(RootSystem,Weight,Weight)
    -- the scalar product of
    two weights
  * scalarProduct(RootSystem,ZZ,Weight)
    -- the scalar product of a
    fundamental weight and a weight
  * scalarProduct(RootSystem,ZZ,ZZ)
    -- the scalar product of two
    fundamental weights
  * simpleRoot(RootSystem,ZZ) -- the
    n-th simple root
  * weight(RootSystem,BasicList), --
    construct a weight from a list
  * weight(RootSystem,Vector), --
    construct a weight from a vector

For the programmer
==================

The object RootSystem, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc), <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1578:0.

rootSystem -- obtain a root system
**********************************

Ways to use rootSystem:
=======================

  * rootSystem(DynkinDiagram) -- the root
    system corresponding to a Dynkin diagram
  * rootSystem(DynkinType) -- the root
    system of a given type
  * rootSystem(RootSystem,Parabolic)
    -- the root system of the Levy
    subgroup of a parabolic

For the programmer
==================

The object rootSystem, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1779:0.

cartanMatrix -- the Cartan matrix of a root system
**************************************************

Ways to use cartanMatrix:
=========================

  * cartanMatrix(RootSystem) -- the Cartan
    matrix of a root system

For the programmer
==================

The object cartanMatrix, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1585:0.

rank(RootSystem) -- the rank of a root system
*********************************************

  * Function: rank (Macaulay2Doc),
  * Usage:
        r=rank(R)
  * Inputs:
      * R, an instance of the type RootSystem,
  * Outputs:
      * an integer (Macaulay2Doc), the rank of R

Description
===========

+------------------------+
|i1 : R = rootSystemA(5) |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : rank R             |
|                        |
|o2 = 5                  |
+------------------------+

Ways to use this method:
========================

  * rank(RootSystem) -- the rank of a root system
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1626:0.

rootSystem(DynkinType) -- the root system of a given type
*********************************************************

  * Function: rootSystem,
  * Usage:
        rootSystem(T)
  * Inputs:
      * T, an instance of the type DynkinType,
  * Outputs:
      * an instance of the type RootSystem, the root system
        of the corresponding type

Description
===========

+----------------------------------------------+
|i1 : rootSystem(dynkinType({{"A",2},{"D",4}}))|
|                                              |
|o1 = RootSystem{...8...}                      |
|                                              |
|o1 : RootSystem                               |
+----------------------------------------------+

Ways to use this method:
========================

  * rootSystem(DynkinType) -- the root
    system of a given type
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1824:0.

rootSystemA -- a root system of type A
**************************************

  * Usage:
        rootSystemA(n)
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type RootSystem, a root system of
        type A and of rank n

Description
===========

+------------------------+
|i1 : rootSystemA(5)     |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+

For the programmer
==================

The object rootSystemA, is a function closure (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1689:0.

rootSystemB -- a root system of type B
**************************************

  * Usage:
        rootSystemB(n)
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type RootSystem, a root system of
        type B and of rank n

Description
===========

+------------------------+
|i1 : rootSystemB(5)     |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+

For the programmer
==================

The object rootSystemB, is a function closure (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1706:0.

rootSystemC -- a root system of type C
**************************************

  * Usage:
        rootSystemC(n)
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type RootSystem, a root system of
        type C and of rank n

Description
===========

+------------------------+
|i1 : rootSystemC(5)     |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+

For the programmer
==================

The object rootSystemC, is a function closure (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1723:0.

rootSystemD -- a root system of type D
**************************************

  * Usage:
        rootSystemD(n)
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type RootSystem, a root system of
        type D and of rank n

Description
===========

+------------------------+
|i1 : rootSystemD(5)     |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+

For the programmer
==================

The object rootSystemD, is a function closure (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1740:0.

rootSystemE -- a root system of type E
**************************************

  * Usage:
        rootSystemE(n)
  * Inputs:
      * n, an integer (Macaulay2Doc), from 6 to 8
  * Outputs:
      * an instance of the type RootSystem, a root system of
        type E and of rank n

Description
===========

+------------------------+
|i1 : rootSystemE(6)     |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+

For the programmer
==================

The object rootSystemE, is a function closure (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1758:0.

rootSystem(RootSystem,Parabolic) -- the root system of the Levy subgroup of a parabolic
***************************************************************************************

  * Function: rootSystem,
  * Usage:
        rootSystem(R,P)
  * Inputs:
      * R, an instance of the type RootSystem,
      * P, an instance of the type Parabolic,
  * Outputs:
      * an instance of the type RootSystem, the root system
        of the Levy subgroup of P

Description
===========

+---------------------------------------+
|i1 : R1=rootSystemD(4)                 |
|                                       |
|o1 = RootSystem{...8...}               |
|                                       |
|o1 : RootSystem                        |
+---------------------------------------+
|i2 : P=parabolic(R1,set{1,3,4})        |
|                                       |
|o2 = set {4, 1, 3}                     |
|                                       |
|o2 : Parabolic                         |
+---------------------------------------+
|i3 : R2=rootSystem(R1,P)               |
|                                       |
|o3 = RootSystem{...8...}               |
|                                       |
|o3 : RootSystem                        |
+---------------------------------------+
|i4 : dynkinType(R2)                    |
|                                       |
|o4 = DynkinType{{A, 1}, {A, 1}, {A, 1}}|
|                                       |
|o4 : DynkinType                        |
+---------------------------------------+

Ways to use this method:
========================

  * rootSystem(RootSystem,Parabolic)
    -- the root system of the Levy
    subgroup of a parabolic
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1800:0.

rootSystem(DynkinDiagram) -- the root system corresponding to a Dynkin diagram
******************************************************************************

  * Function: rootSystem,
  * Usage:
        rootSystem(D)
  * Inputs:
      * D, an instance of the type DynkinDiagram,
  * Outputs:
      * an instance of the type RootSystem, the root system
        corresponding to the Dynkin diagram

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R1=rootSystemB(3)++rootSystemD(4)                                       |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : D=dynkinDiagram(R1)                                                     |
|                                                                             |
|o2 = DynkinDiagram{{{2}, {}, {}, {}, {}}, {{1}, {3}, {}, {}, {}}, {{}, {},   |
|                                                                             |
|o2 : DynkinDiagram                                                           |
|-----------------------------------------------------------------------------|
|{2}, {}, {}}, {{5}, {}, {}, {}, {}}, {{4, 6, 7}, {}, {}, {}, {}}, {{5}, {},  |
|-----------------------------------------------------------------------------|
|{}, {}, {}}, {{5}, {}, {}, {}, {}}}                                          |
+-----------------------------------------------------------------------------+
|i3 : R2=rootSystem(D)                                                        |
|                                                                             |
|o3 = RootSystem{...8...}                                                     |
|                                                                             |
|o3 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i4 : R1==R2                                                                  |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * rootSystem(DynkinDiagram) -- the root
    system corresponding to a Dynkin diagram
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1848:0.

Weight -- the class of weights
******************************

Description
===========

a weight is represented by an element of ZZ^n, the basis consisting in the
fundamental weights

Types of Weight:
================

  * Root -- the class of roots (or, more generally, elements of
    the root lattice)

Methods that use an object of class Weight:
===========================================

  * - Weight -- the negative of a weight
  * eval(RootSystem,Weight,Root),
    -- evaluate the dual of a root at a Weight
  * eval(RootSystem,Weight,ZZ), --
    evaluate the dual of a simple root at a Weight
  * isPositiveRoot(RootSystem,Weight)
    -- check whether a weight is a
    positive root
  * isRoot(RootSystem,Weight) -- check
    whether a weight is a positive root
  * reflect(RootSystem,BasicList,Weight)
    -- apply to a weight several
    reflections with respect to roots
  * reflect(RootSystem,ZZ,Weight),
    -- apply to a weight the reflection with respect to a root
  * rootCoefficients(RootSystem,Weight)
    -- the coefficients at the
    simple roots
  * scalarProduct(RootSystem,Weight,Weight)
    -- the scalar product of
    two weights
  * scalarProduct(RootSystem,ZZ,Weight)
    -- the scalar product of a
    fundamental weight and a weight
  * Weight + Weight -- the sum of two weights
  * Weight - Weight -- the difference of two weights
  * WeylGroupElement * Weight -- apply an
    element of a Weyl group to a weight
  * ZZ * Weight -- the multiple of a weight

For the programmer
==================

The object Weight, is a type (Macaulay2Doc), with
ancestor classes Vector (Macaulay2Doc), < BasicList (Macaulay2Doc)
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1871:0.

weight -- construct a weight in the weight lattice of a root system
*******************************************************************

Ways to use weight:
===================

  * weight(RootSystem,BasicList), --
    construct a weight from a list
  * weight(RootSystem,Vector), --
    construct a weight from a vector

For the programmer
==================

The object weight, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1989:0.

weight(RootSystem,BasicList) -- construct a weight from a list
**************************************************************

  * Function: weight,
  * Usage:
        weight(R,L)
  * Inputs:
      * R, an instance of the type RootSystem,
      * L, a basic list (Macaulay2Doc), the coordinates of the
        weight
  * Outputs:
      * an instance of the type Weight, a weight vector in a the
        weight lattice of R

Description
===========

+------------------------+
|i1 : R=rootSystemB(3)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : weight(R,{1,2,1})  |
|                        |
|o2 = | 1 |              |
|     | 2 |              |
|     | 1 |              |
|                        |
|       3                |
|o2 : ZZ                 |
+------------------------+

Ways to use this method:
========================

  * weight(RootSystem,BasicList), --
    construct a weight from a list
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2009:0.

weight(RootSystem,Vector) -- construct a weight from a vector
*************************************************************

  * Function: weight,
  * Usage:
        weight(R,v)
  * Inputs:
      * R, an instance of the type RootSystem,
      * v, a vector (Macaulay2Doc), the coordinates of the weight
  * Outputs:
      * an instance of the type Weight, a weight vector in a the
        weight lattice of R

Description
===========

+-----------------------------+
|i1 : R=rootSystemB(3)        |
|                             |
|o1 = RootSystem{...8...}     |
|                             |
|o1 : RootSystem              |
+-----------------------------+
|i2 : weight(R,vector {1,2,1})|
|                             |
|o2 = | 1 |                   |
|     | 2 |                   |
|     | 1 |                   |
|                             |
|       3                     |
|o2 : ZZ                      |
+-----------------------------+

Ways to use this method:
========================

  * weight(RootSystem,Vector), --
    construct a weight from a vector
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2034:0.

isPositiveRoot -- check whether a weight is a positive root
***********************************************************

Ways to use isPositiveRoot:
===========================

  * isPositiveRoot(RootSystem,Weight)
    -- check whether a weight is a
    positive root

For the programmer
==================

The object isPositiveRoot, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2162:0.

isRoot -- check whether a weight is a root or whether a root is in a parabolic sub root system
**********************************************************************************************

Ways to use isRoot:
===================

  * isRoot(RootSystem,Parabolic,Root)
    -- check whether a root is in
    the sub root system of the parabolic
  * isRoot(RootSystem,Weight) -- check
    whether a weight is a positive root

For the programmer
==================

The object isRoot, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2197:0.

Root -- the class of roots (or, more generally, elements of the root lattice)
*****************************************************************************

Description
===========

a root is represented by the respective weight

Methods that use an object of class Root:
=========================================

  * addRoots(RootSystem,Root,Root)
    -- the sum of two roots
  * eval(RootSystem,Weight,Root),
    -- evaluate the dual of a root at a Weight
  * eval(RootSystem,ZZ,Root), --
    evaluate the dual of a root at a fundamental weight
  * isRoot(RootSystem,Parabolic,Root)
    -- check whether a root is in
    the sub root system of the parabolic
  * norm(RootSystem,Root) -- the squared
    norm of a root
  * reflect(RootSystem,BasicList,Root)
    -- apply to a root several
    reflections with respect to simple roots
  * reflect(RootSystem,ZZ,Root), --
    apply to a root the reflection with respect to a simple root
  * reflection(RootSystem,Root), --
    the reflection with respect to a root
  * rootCoefficients(RootSystem,Root)
    -- the coefficients at the simple
    roots
  * WeylGroupElement * Root -- apply an
    element of a Weyl group to a root
  * ZZ * Root -- multiplication of a root by an integer

For the programmer
==================

The object Root, is a type (Macaulay2Doc), with
ancestor classes Weight, < Vector (Macaulay2Doc) <
BasicList (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2059:0.

addRoots -- adding roots
************************

Ways to use addRoots:
=====================

  * addRoots(RootSystem,Root,Root)
    -- the sum of two roots

For the programmer
==================

The object addRoots, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2066:0.

addRoots(RootSystem,Root,Root) -- the sum of two roots
******************************************************

  * Function: addRoots,
  * Usage:
        r1 + r2
  * Inputs:
      * R, an instance of the type RootSystem,
      * r1, an instance of the type Root,
      * r2, an instance of the type Root,
  * Outputs:
      * an instance of the type Weight, the sum of r1 and r2.
        Actually, it is returned as an object of class Root, if the
        resulting weight is a root.

Description
===========

+------------------------+
|i1 : R=rootSystemA(2)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : r1=simpleRoot(R,1) |
|                        |
|o2 = |  2 |             |
|     | -1 |             |
|                        |
|       2                |
|o2 : ZZ                 |
+------------------------+
|i3 : r2=simpleRoot(R,2) |
|                        |
|o3 = | -1 |             |
|     |  2 |             |
|                        |
|       2                |
|o3 : ZZ                 |
+------------------------+
|i4 : r=addRoots(R,r1,r2)|
|                        |
|o4 = | 1 |              |
|     | 1 |              |
|                        |
|       2                |
|o4 : ZZ                 |
+------------------------+
|i5 : addRoots(R,r1,r)   |
|                        |
|o5 = | 3 |              |
|     | 0 |              |
|                        |
|       2                |
|o5 : ZZ                 |
+------------------------+

Ways to use this method:
========================

  * addRoots(RootSystem,Root,Root)
    -- the sum of two roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2089:0.

ZZ * Root -- multiplication of a root by an integer
***************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        n*r
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * r, an instance of the type Root,
  * Outputs:
      * an instance of the type Weight,

Description
===========

+------------------------+
|i1 : R=rootSystemA(3)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : r=simpleRoot(R,1)  |
|                        |
|o2 = |  2 |             |
|     | -1 |             |
|     |  0 |             |
|                        |
|       3                |
|o2 : ZZ                 |
+------------------------+
|i3 : 2*r                |
|                        |
|o3 = |  4 |             |
|     | -2 |             |
|     |  0 |             |
|                        |
|       3                |
|o3 : ZZ                 |
+------------------------+

Note that if the integer is +1 or -1, we obtain a weight that is a root.

+-----------+
|i4 : -1*r  |
|           |
|o4 = | -2 ||
|     |  1 ||
|     |  0 ||
|           |
|       3   |
|o4 : ZZ    |
+-----------+

Ways to use this method:
========================

  * ZZ * Root -- multiplication of a root by an integer
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2120:0.

halfSumOfRoots -- the half-sum of positive roots
************************************************

Ways to use halfSumOfRoots:
===========================

  * halfSumOfRoots(RootSystem) -- the
    half-sum of positive roots

For the programmer
==================

The object halfSumOfRoots, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2133:0.

simpleRoot -- a simple root
***************************

Ways to use simpleRoot:
=======================

  * simpleRoot(RootSystem,ZZ) -- the
    n-th simple root

For the programmer
==================

The object simpleRoot, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2265:0.

norm(RootSystem,Root) -- the squared norm of a root
***************************************************

  * Function: norm (Macaulay2Doc),
  * Usage:
        norm(R,r)
  * Inputs:
      * R, an instance of the type RootSystem,
      * r, an instance of the type Root,
  * Outputs:
      * an integer (Macaulay2Doc), the squared norm of r, short roots
        being of norm 1

Description
===========

+--------------------------------------------------+
|i1 : norm(rootSystemF4,simpleRoot(rootSystemF4,2))|
|                                                  |
|o1 = 2                                            |
+--------------------------------------------------+

Ways to use this method:
========================

  * norm(RootSystem,Root) -- the squared
    norm of a root
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2301:0.

rootCoefficients -- coefficients at the simple roots
****************************************************

Ways to use rootCoefficients:
=============================

  * rootCoefficients(RootSystem,Root)
    -- the coefficients at the simple
    roots
  * rootCoefficients(RootSystem,Weight)
    -- the coefficients at the
    simple roots

For the programmer
==================

The object rootCoefficients, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2532:0.

positiveRoots -- the set of all positive roots
**********************************************

Ways to use positiveRoots:
==========================

  * positiveRoots(RootSystem) -- the set
    of all positive roots
  * positiveRoots(RootSystem,Parabolic)
    -- the set of all positive roots
    in a parabolic sugroups

For the programmer
==================

The object positiveRoots, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2587:0.

numberOfPositiveRoots -- the number of positive roots
*****************************************************

Ways to use numberOfPositiveRoots:
==================================

  * numberOfPositiveRoots(DynkinType)
    -- the number of positive roots
  * numberOfPositiveRoots(RootSystem)
    -- the number of positive roots

For the programmer
==================

The object numberOfPositiveRoots, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2631:0.

WeylGroupElement -- the class of elements of Weyl groups
********************************************************

Description
===========

w is represented by the list consisting of a root system and w applied to the
half-sum of positive roots

Methods that use an object of class WeylGroupElement:
=====================================================

  * aboveBruhat(WeylGroupElement), --
    Weyl group elements just above a given one for the Bruhat order
  * coxeterLength(WeylGroupElement),
    -- the length of a reduced decomposition of an element of a Weyl group
  * intervalBruhat(WeylGroupElement,WeylGroupElement)
    -- elements
    between two given ones for the Bruhat order on a Weyl group
  * inverse(WeylGroupElement) -- the
    inverse to an element of a Weyl group
  * isLtBruhat(WeylGroupElement,WeylGroupElement)
    -- compare two Weyl
    group elements in the Bruhat order
  * isMinimalRepresentative(Parabolic,WeylGroupElement)
    -- check whether
    an element of a Weyl group is the minimal representative of a right coset
  * isMinimalRepresentative(Parabolic,WeylGroupElement,Parabolic),
    --
    check whether an element of a Weyl group is the minimal representative of a
    double coset
  * isMinimalRepresentative(WeylGroupElement,Parabolic)
    -- check whether
    an element of a Weyl group is the minimal representative of a left coset
  * isReduced(BasicList,WeylGroupElement)
    -- whether an Weyl group
    element can be multiplied by some simple reflections with length increasing
    at each step
  * isReflection(WeylGroupElement),
    -- checks whether an element of a Weyl group is a reflection
  * Parabolic % WeylGroupElement -- the
    right coset defined by an element of Weyl group
  * reducedDecomposition(WeylGroupElement)
    -- the reduced decomposition of
    an element of a Weyl group
  * underBruhat(WeylGroupElement), --
    Weyl group elements just under a given one for the Bruhat order
  * WeylGroupElement % Parabolic -- the
    left coset defined by an element of Weyl group
  * WeylGroupElement * Root -- apply an
    element of a Weyl group to a root
  * WeylGroupElement * Weight -- apply an
    element of a Weyl group to a weight
  * WeylGroupElement * WeylGroupElement
    -- the product of two elements of a Weyl group
  * WeylGroupElement * WeylGroupLeftCoset
    -- apply an element of a Weyl group to a left coset
  * WeylGroupElement == WeylGroupElement
    -- equality of elements of Weyl groups
  * WeylGroupElement ^ ZZ -- the power of an
    element of a Weyl group
  * WeylGroupRightCoset * WeylGroupElement
    -- apply an element of a Weyl group to a left coset
  * whoseReflection(WeylGroupElement)
    -- the positive root whose
    reflection is a given element of a Weyl group

For the programmer
==================

The object WeylGroupElement, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2823:0.

reduce -- the product of several reflections
********************************************

Ways to use reduce:
===================

  * reduce(RootSystem,BasicList), --
    the product of several reflections with respect to simple roots

For the programmer
==================

The object reduce, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3057:0.

reducedDecomposition -- the reduced decomposition of an element of a Weyl group
*******************************************************************************

Ways to use reducedDecomposition:
=================================

  * reducedDecomposition(WeylGroupElement)
    -- the reduced decomposition of
    an element of a Weyl group

For the programmer
==================

The object reducedDecomposition, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3087:0.

isReduced -- check whether a decomposition is of minimal length
***************************************************************

Ways to use isReduced:
======================

  * isReduced(BasicList,WeylGroupElement)
    -- whether an Weyl group
    element can be multiplied by some simple reflections with length increasing
    at each step
  * isReduced(RootSystem,BasicList)
    -- whether a decomposition in simple
    reflections is reduced

For the programmer
==================

The object isReduced, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3115:0.

coxeterLength -- the length of a reduced decomposition of an element of a Weyl group
************************************************************************************

Ways to use coxeterLength:
==========================

  * coxeterLength(WeylGroupElement),
    -- the length of a reduced decomposition of an element of a Weyl group

For the programmer
==================

The object coxeterLength, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3182:0.

longestWeylGroupElement -- the longest element of a Weyl group
**************************************************************

Ways to use longestWeylGroupElement:
====================================

  * longestWeylGroupElement(RootSystem)
    -- the longest element of the Weyl
    group of a root system
  * longestWeylGroupElement(RootSystem,Parabolic)
    -- the longest element
    of a parabolic subgroup of the Weyl group of a root system

For the programmer
==================

The object longestWeylGroupElement, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2977:0.

reflection -- the reflection with respect to a root
***************************************************

Ways to use reflection:
=======================

  * reflection(RootSystem,Root), --
    the reflection with respect to a root

For the programmer
==================

The object reflection, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3210:0.

isReflection -- checks whether an element of a Weyl group is a reflection
*************************************************************************

Ways to use isReflection:
=========================

  * isReflection(WeylGroupElement),
    -- checks whether an element of a Weyl group is a reflection

For the programmer
==================

The object isReflection, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3244:0.

whoseReflection -- the positive root whose reflection is a given element of a Weyl group
****************************************************************************************

Ways to use whoseReflection:
============================

  * whoseReflection(WeylGroupElement)
    -- the positive root whose
    reflection is a given element of a Weyl group

For the programmer
==================

The object whoseReflection, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3274:0.

listWeylGroupElements -- list all elements of a given length in a Weyl group
****************************************************************************

Ways to use listWeylGroupElements:
==================================

  * listWeylGroupElements(RootSystem,ZZ)
    -- list all elements of a given
    length in a Weyl group

For the programmer
==================

The object listWeylGroupElements, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2680:0.

neutralWeylGroupElement -- the neutral element of a Weyl group
**************************************************************

Ways to use neutralWeylGroupElement:
====================================

  * neutralWeylGroupElement(RootSystem)
    -- the neutral element of the Weyl
    group of a root system

For the programmer
==================

The object neutralWeylGroupElement, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3029:0.

underBruhat -- obtain Weyl group elements less than an element for the Bruhat order
***********************************************************************************

Ways to use underBruhat:
========================

  * underBruhat(BasicList) -- Weyl group
    elements just under the ones in the list for the Bruhat order
  * underBruhat(WeylGroupElement), --
    Weyl group elements just under a given one for the Bruhat order

For the programmer
==================

The object underBruhat, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4262:0.

aboveBruhat -- obtain Weyl group elements just greater than an element for the Bruhat order
*******************************************************************************************

Ways to use aboveBruhat:
========================

  * aboveBruhat(BasicList) -- The Weyl group
    elements just under the ones in the list for the Bruhat order
  * aboveBruhat(WeylGroupElement), --
    Weyl group elements just above a given one for the Bruhat order

For the programmer
==================

The object aboveBruhat, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4309:0.

isLtBruhat -- compare two Weyl group elements in the Bruhat order
*****************************************************************

Ways to use isLtBruhat:
=======================

  * isLtBruhat(WeylGroupElement,WeylGroupElement)
    -- compare two Weyl
    group elements in the Bruhat order

For the programmer
==================

The object isLtBruhat, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4225:0.

intervalBruhat -- obtaining an interval for the Bruhat order
************************************************************

Ways to use intervalBruhat:
===========================

  * intervalBruhat(WeylGroupElement,WeylGroupElement)
    -- elements
    between two given ones for the Bruhat order on a Weyl group
  * intervalBruhat(WeylGroupLeftCoset,WeylGroupLeftCoset)
    -- elements
    between two given ones for the Bruhat order on a quotient of a Weyl group
  * intervalBruhat(WeylGroupRightCoset,WeylGroupRightCoset)
    -- elements
    between two given ones for the Bruhat order on a quotient of a Weyl group

For the programmer
==================

The object intervalBruhat, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4402:0.

Parabolic -- the class of parabolic subgroups of Weyl groups
************************************************************

Description
===========

A parabolic subgroup is represented by the set of indices of generating
reflections.

Methods that use an object of class Parabolic:
==============================================

  * dynkinDiagram(DynkinDiagram,Parabolic)
    -- the Dynkin diagram of the
    Levy subgroup of a parabolic
  * isMinimalRepresentative(Parabolic,WeylGroupElement)
    -- check whether
    an element of a Weyl group is the minimal representative of a right coset
  * isMinimalRepresentative(Parabolic,WeylGroupElement,Parabolic),
    --
    check whether an element of a Weyl group is the minimal representative of a
    double coset
  * isMinimalRepresentative(WeylGroupElement,Parabolic)
    -- check whether
    an element of a Weyl group is the minimal representative of a left coset
  * isRoot(RootSystem,Parabolic,Root)
    -- check whether a root is in
    the sub root system of the parabolic
  * longestWeylGroupElement(RootSystem,Parabolic)
    -- the longest element
    of a parabolic subgroup of the Weyl group of a root system
  * Parabolic % WeylGroupElement -- the
    right coset defined by an element of Weyl group
  * Parabolic % WeylGroupLeftCoset, --
    the double coset defined by a left coset
  * Parabolic == Parabolic -- equality of
    parabolics
  * poincareSeries(RootSystem,Parabolic,RingElement)
    -- the generating
    series of a quotient of the Weyl group by length
  * positiveRoots(RootSystem,Parabolic)
    -- the set of all positive roots
    in a parabolic sugroups
  * rootSystem(RootSystem,Parabolic)
    -- the root system of the Levy
    subgroup of a parabolic
  * WeylGroupElement % Parabolic -- the
    left coset defined by an element of Weyl group
  * WeylGroupRightCoset % Parabolic, --
    the double coset defined by a right coset

For the programmer
==================

The object Parabolic, is a type (Macaulay2Doc),
with ancestor classes Set (Macaulay2Doc), < Tally (Macaulay2Doc)
< VirtualTally (Macaulay2Doc) <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3311:0.

WeylGroupLeftCoset -- the class of left cosets of Weyl groups by parabolic subgroup
***********************************************************************************

Description
===========

a coset {wW_P} is represented by the list consisting of a parabolic subgroup P
and the representative of minimal length w

Methods that use an object of class WeylGroupLeftCoset:
=======================================================

  * intervalBruhat(WeylGroupLeftCoset,WeylGroupLeftCoset)
    -- elements
    between two given ones for the Bruhat order on a quotient of a Weyl group
  * minimalRepresentative(WeylGroupLeftCoset)
    -- the minimal
    representative of a coset
  * Parabolic % WeylGroupLeftCoset, --
    the double coset defined by a left coset
  * WeylGroupElement * WeylGroupLeftCoset
    -- apply an element of a Weyl group to a left coset
  * WeylGroupLeftCoset == WeylGroupLeftCoset
    -- equality of left cosets

For the programmer
==================

The object WeylGroupLeftCoset, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3401:0.

WeylGroupRightCoset -- the class of right cosets of Weyl groups by parabolic subgroups
**************************************************************************************

Description
===========

a coset {W_Pw} is represented by the list consisting of a parabolic subgroup P
and the representative of minimal length w

Methods that use an object of class WeylGroupRightCoset:
========================================================

  * intervalBruhat(WeylGroupRightCoset,WeylGroupRightCoset)
    -- elements
    between two given ones for the Bruhat order on a quotient of a Weyl group
  * minimalRepresentative(WeylGroupRightCoset)
    -- the minimal
    representative of a coset
  * WeylGroupRightCoset % Parabolic, --
    the double coset defined by a right coset
  * WeylGroupRightCoset * WeylGroupElement
    -- apply an element of a Weyl group to a left coset
  * WeylGroupRightCoset == WeylGroupRightCoset
    -- equality of right cosets

For the programmer
==================

The object WeylGroupRightCoset, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3443:0.

WeylGroupDoubleCoset -- the class of double cosets of Weyl groups by pairs of parabolic subgroups
*************************************************************************************************

Description
===========

a coset {W_PwW_Q} is represented by the list consisting of parabolic subgroups
P and Q, and the representative of minimal length w

Methods that use an object of class WeylGroupDoubleCoset:
=========================================================

  * minimalRepresentative(WeylGroupDoubleCoset)
    -- the minimal
    representative of a coset
  * parabolic(WeylGroupDoubleCoset),
    -- the parabolic associated to a double coset
  * WeylGroupDoubleCoset == WeylGroupDoubleCoset
    -- equality of double cosets

For the programmer
==================

The object WeylGroupDoubleCoset, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3486:0.

DynkinDiagram -- the class of Dynkin diagrams
*********************************************

Description
===========

A Dynkin diagram contains lists representing vertices of the Dynkin diagram (in
other words a simple root). Each of these lists contains sublists of end points
of an edge from the vertex. There are in this order, the simple edges, double
edge to a smaller root, double edge to a larger root, triple edge to a smaller
root, triple edge to a larger root. If there is no such edge, we have an empty
sublist.

+-----------------------------------------------------------------------------+
|i1 : dynkinDiagram(rootSystemB(4))                                           |
|                                                                             |
|o1 = DynkinDiagram{{{2}, {}, {}, {}, {}}, {{1, 3}, {}, {}, {}, {}}, {{2},    |
|                                                                             |
|o1 : DynkinDiagram                                                           |
|-----------------------------------------------------------------------------|
|{4}, {}, {}, {}}, {{}, {}, {3}, {}, {}}}                                     |
+-----------------------------------------------------------------------------+
|i2 : dynkinDiagram(rootSystemD(4))                                           |
|                                                                             |
|o2 = DynkinDiagram{{{2}, {}, {}, {}, {}}, {{1, 3, 4}, {}, {}, {}, {}}, {{2}, |
|                                                                             |
|o2 : DynkinDiagram                                                           |
|-----------------------------------------------------------------------------|
|{}, {}, {}, {}}, {{2}, {}, {}, {}, {}}}                                      |
+-----------------------------------------------------------------------------+

Methods that use an object of class DynkinDiagram:
==================================================

  * connectedComponents(DynkinDiagram)
    -- the connected components of a
    Dynkin diagram
  * dynkinDiagram(DynkinDiagram,Parabolic)
    -- the Dynkin diagram of the
    Levy subgroup of a parabolic
  * dynkinType(DynkinDiagram) -- the
    Dynkin type of a Dynkin diagram
  * endVertices(DynkinDiagram) -- the
    vertices of a Dynkin diagram with at most one neighbor
  * rank(DynkinDiagram) -- the rank of a Dynkin
    diagram
  * rootSystem(DynkinDiagram) -- the root
    system corresponding to a Dynkin diagram

For the programmer
==================

The object DynkinDiagram, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3823:0.

DynkinType -- the class of Dynkin Types
***************************************

Description
===========

A Dynkin Type is a list of items representing Dynkin types of irreducible root
systems. These types are a string (the letter representing the family A, B, C,
D, E, F or G) and an integer, the rank.

+-------------------------------------+
|i1 : R=rootSystemB(4)++rootSystemA(6)|
|                                     |
|o1 = RootSystem{...8...}             |
|                                     |
|o1 : RootSystem                      |
+-------------------------------------+
|i2 : dynkinType(R)                   |
|                                     |
|o2 = DynkinType{{A, 6}, {B, 4}}      |
|                                     |
|o2 : DynkinType                      |
+-------------------------------------+

Methods that use an object of class DynkinType:
===============================================

  * dynkinExponents(DynkinType) -- the
    exponents of the Dynkin type
  * DynkinType ++ DynkinType -- the disjoint
    union of Dynkin Types
  * DynkinType == DynkinType -- the equality
    of Dynkin Types
  * numberOfPositiveRoots(DynkinType)
    -- the number of positive roots
  * rootSystem(DynkinType) -- the root
    system of a given type

For the programmer
==================

The object DynkinType, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc), < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3958:0.

HasseDiagram -- the class of Hasse diagrams
*******************************************

Description
===========

A Hasse diagram is a list describing the connexions in a Hasse diagram. It
contains sublists representing rows. Each row contains several vertices
together with edges to some element in the next row given by its position in
the row. This data format is intended for displaying.

Methods that use an object of class HasseDiagram:
=================================================

  * hasseDiagramToGraph(HasseDiagram)
    -- turning a hasse diagram into a
    graph (intended for graphic representation)
  * poincareSeries(HasseDiagram,RingElement)
    -- the generating series of
    a Hasse diagram

For the programmer
==================

The object HasseDiagram, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4359:0.

HasseGraph -- the class of Hasse graphs
***************************************

Description
===========

A Hasse graph is a Hasse diagram ready for display. It contains labels instead
of Weyl group elements and reflections.

Methods that use an object of class HasseGraph:
===============================================

  * hasseGraphToPicture(HasseGraph),
    -- Obtain a picture from a Hasse graph
  * storeHasseGraph(HasseGraph,String)
    -- store a Hasse graph in a file

For the programmer
==================

The object HasseGraph, is a type (Macaulay2Doc),
with ancestor classes BasicList (Macaulay2Doc), < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4374:0.

hasseDiagramToGraph -- turning a hasse diagram into a graph (intended for graphic representation)
*************************************************************************************************

Ways to use hasseDiagramToGraph:
================================

  * hasseDiagramToGraph(HasseDiagram)
    -- turning a hasse diagram into a
    graph (intended for graphic representation)

For the programmer
==================

The object hasseDiagramToGraph, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4520:0.

hasseGraphToPicture -- construct the picture of a Hasse Graph
*************************************************************

Ways to use hasseGraphToPicture:
================================

  * hasseGraphToPicture(HasseGraph),
    -- Obtain a picture from a Hasse graph

For the programmer
==================

The object hasseGraphToPicture, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4381:0.

storeHasseGraph -- store a Hasse graph in a file
************************************************

Ways to use storeHasseGraph:
============================

  * storeHasseGraph(HasseGraph,String)
    -- store a Hasse graph in a file

For the programmer
==================

The object storeHasseGraph, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4561:0.

loadHasseGraph -- load a Hasse graph from a file
************************************************

Ways to use loadHasseGraph:
===========================

  * loadHasseGraph(String) -- load a Hasse
    graph from a file

For the programmer
==================

The object loadHasseGraph, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4586:0.

- Weight -- the negative of a weight
************************************

  * Operator: - (Macaulay2Doc),
  * Usage:
        - p
  * Inputs:
      * p, an instance of the type Weight,
  * Outputs:
      * an instance of the type Weight, the negative of p

Description
===========

+------------------------+
|i1 : R=rootSystemA(4)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : M=cartanMatrix R   |
|                        |
|o2 = | 2  -1 0  0  |    |
|     | -1 2  -1 0  |    |
|     | 0  -1 2  -1 |    |
|     | 0  0  -1 2  |    |
|                        |
|              4       4 |
|o2 : Matrix ZZ  <-- ZZ  |
+------------------------+
|i3 : p=weight(R,M_2)    |
|                        |
|o3 = |  0 |             |
|     | -1 |             |
|     |  2 |             |
|     | -1 |             |
|                        |
|       4                |
|o3 : ZZ                 |
+------------------------+
|i4 : -p                 |
|                        |
|o4 = |  0 |             |
|     |  1 |             |
|     | -2 |             |
|     |  1 |             |
|                        |
|       4                |
|o4 : ZZ                 |
+------------------------+

Ways to use this method:
========================

  * - Weight -- the negative of a weight
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1976:0.

aboveBruhat(BasicList) -- The Weyl group elements just under the ones in the list for the Bruhat order
******************************************************************************************************

  * Function: aboveBruhat,
  * Usage:
        aboveBruhat(B)
  * Inputs:
      * B, a basic list (Macaulay2Doc), of WeylGroupElement
  * Outputs:
      * a list (Macaulay2Doc), of elements greater than the ones in
        B and of length one more together with the root of the reflection
        composed with (on the right) to obtain the element

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(3)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : L=aboveBruhat(neutralWeylGroupElement(R))                               |
|                                                                             |
|o2 = {{WeylGroupElement{RootSystem{...8...}, | -1 |}, |  2 |},               |
|                                             |  2 |   | -1 |                 |
|                                             |  1 |   |  0 |                 |
|     ------------------------------------------------------------------------|
|     {WeylGroupElement{RootSystem{...8...}, |  2 |}, | -1 |},                |
|                                            | -1 |   |  2 |                  |
|                                            |  2 |   | -1 |                  |
|     ------------------------------------------------------------------------|
|     {WeylGroupElement{RootSystem{...8...}, |  1 |}, |  0 |}}                |
|                                            |  2 |   | -1 |                  |
|                                            | -1 |   |  2 |                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : L1=apply(L,x->x#0)                                                      |
|                                                                             |
|o3 = {WeylGroupElement{RootSystem{...8...}, | -1 |},                         |
|                                            |  2 |                           |
|                                            |  1 |                           |
|     ------------------------------------------------------------------------|
|     WeylGroupElement{RootSystem{...8...}, |  2 |},                          |
|                                           | -1 |                            |
|                                           |  2 |                            |
|     ------------------------------------------------------------------------|
|     WeylGroupElement{RootSystem{...8...}, |  1 |}}                          |
|                                           |  2 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : aboveBruhat(L1)                                                         |
|                                                                             |
|o4 = {{WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, | -1 |}, {1, |  1 |
|                                             |  1 |        |  2 |       |  1 |
|                                             |  2 |        | -1 |       | -1 |
|     ------------------------------------------------------------------------|
|     |}}}, {WeylGroupElement{RootSystem{...8...}, | -1 |}, {{0, |  0 |}, {2, |
|     |                                            |  3 |        | -1 |       |
|     |                                            | -1 |        |  2 |       |
|     ------------------------------------------------------------------------|
|     |  2 |}}}, {WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0, |  1 |},|
|     | -1 |                                            | -2 |        |  1 |  |
|     |  0 |                                            |  3 |        | -1 |  |
|     ------------------------------------------------------------------------|
|     {1, |  2 |}}}, {WeylGroupElement{RootSystem{...8...}, |  2 |}, {{1, | -1|
|         | -1 |                                            |  1 |        |  1|
|         |  0 |                                            | -2 |        |  1|
|     ------------------------------------------------------------------------|
|     |}, {2, | -1 |}}}, {WeylGroupElement{RootSystem{...8...}, |  3 |}, {{1, |
|     |       |  2 |                                            | -2 |        |
|     |       | -1 |                                            |  1 |        |
|     ------------------------------------------------------------------------|
|     |  0 |}, {2, | -1 |}}}}                                                 |
|     | -1 |       |  1 |                                                     |
|     |  2 |       |  1 |                                                     |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * aboveBruhat(BasicList) -- The Weyl group
    elements just under the ones in the list for the Bruhat order
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4349:0.

aboveBruhat(WeylGroupElement) -- Weyl group elements just above a given one for the Bruhat order
************************************************************************************************

  * Function: aboveBruhat,
  * Usage:
        aboveBruhat(w)
  * Inputs:
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * a list (Macaulay2Doc), of elements greater than w and of
        length one more together with the root whose reflection is composed
        with w (on the right) to obtain the element

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(3)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : L=aboveBruhat(neutralWeylGroupElement(R))                               |
|                                                                             |
|o2 = {{WeylGroupElement{RootSystem{...8...}, | -1 |}, |  2 |},               |
|                                             |  2 |   | -1 |                 |
|                                             |  1 |   |  0 |                 |
|     ------------------------------------------------------------------------|
|     {WeylGroupElement{RootSystem{...8...}, |  2 |}, | -1 |},                |
|                                            | -1 |   |  2 |                  |
|                                            |  2 |   | -1 |                  |
|     ------------------------------------------------------------------------|
|     {WeylGroupElement{RootSystem{...8...}, |  1 |}, |  0 |}}                |
|                                            |  2 |   | -1 |                  |
|                                            | -1 |   |  2 |                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : apply(L,x->reducedDecomposition (x#0))                                  |
|                                                                             |
|o3 = {{1}, {2}, {3}}                                                         |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * aboveBruhat(WeylGroupElement), --
    Weyl group elements just above a given one for the Bruhat order
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4328:0.

cartanMatrix(RootSystem) -- the Cartan matrix of a root system
**************************************************************

  * Function: cartanMatrix,
  * Usage:
        cartanMatrix(R)
  * Inputs:
      * R, an instance of the type RootSystem,
  * Outputs:
      * a matrix (Macaulay2Doc), the Cartan matrix of R

Description
===========

+------------------------+
|i1 : R=rootSystemA(3)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : cartanMatrix R     |
|                        |
|o2 = | 2  -1 0  |       |
|     | -1 2  -1 |       |
|     | 0  -1 2  |       |
|                        |
|              3       3 |
|o2 : Matrix ZZ  <-- ZZ  |
+------------------------+

Ways to use this method:
========================

  * cartanMatrix(RootSystem) -- the Cartan
    matrix of a root system
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1603:0.

connectedComponents -- get the connected components
***************************************************

Ways to use connectedComponents:
================================

  * connectedComponents(DynkinDiagram)
    -- the connected components of a
    Dynkin diagram

For the programmer
==================

The object connectedComponents, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3888:0.

connectedComponents(DynkinDiagram) -- the connected components of a Dynkin diagram
**********************************************************************************

  * Function: connectedComponents,
  * Usage:
        connectedComponents(D)
  * Inputs:
      * D, an instance of the type DynkinDiagram,
  * Outputs:
      * a list (Macaulay2Doc), containing Dynkin diagrams that are
        connected and whose disjoint union is D

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemE(6)++rootSystemF4                                          |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : D=dynkinDiagram(R)                                                      |
|                                                                             |
|o2 = DynkinDiagram{{{3}, {}, {}, {}, {}}, {{4}, {}, {}, {}, {}}, {{1, 4}, {},|
|                                                                             |
|o2 : DynkinDiagram                                                           |
|-----------------------------------------------------------------------------|
|{}, {}, {}}, {{2, 3, 5}, {}, {}, {}, {}}, {{4, 6}, {}, {}, {}, {}}, {{5}, {},|
|-----------------------------------------------------------------------------|
|{}, {}, {}}, {{8}, {}, {}, {}, {}}, {{7}, {9}, {}, {}, {}}, {{10}, {}, {8},  |
|-----------------------------------------------------------------------------|
|{}, {}}, {{9}, {}, {}, {}, {}}}                                              |
+-----------------------------------------------------------------------------+
|i3 : connectedComponents(D)                                                  |
|                                                                             |
|o3 = {DynkinDiagram{{{3}, {}, {}, {}, {}}, {{4}, {}, {}, {}, {}}, {{1, 4},   |
|     ------------------------------------------------------------------------|
|     {}, {}, {}, {}}, {{2, 3, 5}, {}, {}, {}, {}}, {{4, 6}, {}, {}, {}, {}}, |
|     ------------------------------------------------------------------------|
|     {{5}, {}, {}, {}, {}}}, DynkinDiagram{{{2}, {}, {}, {}, {}}, {{1}, {3}, |
|     ------------------------------------------------------------------------|
|     {}, {}, {}}, {{4}, {}, {2}, {}, {}}, {{3}, {}, {}, {}, {}}}}            |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * connectedComponents(DynkinDiagram)
    -- the connected components of a
    Dynkin diagram
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3907:0.

coxeterLength(WeylGroupElement) -- the length of a reduced decomposition of an element of a Weyl group
******************************************************************************************************

  * Function: coxeterLength,
  * Usage:
        coxeterLength(w)
  * Inputs:
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * an integer (Macaulay2Doc), the number of simple reflections
        in a reduced decomposition of w

Description
===========

+-------------------------------------------------------+
|i1 : coxeterLength longestWeylGroupElement rootSystemF4|
|                                                       |
|o1 = 24                                                |
+-------------------------------------------------------+

Ways to use this method:
========================

  * coxeterLength(WeylGroupElement),
    -- the length of a reduced decomposition of an element of a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3199:0.

dynkinDiagram -- produce a Dynkin Diagram
*****************************************

Ways to use dynkinDiagram:
==========================

  * dynkinDiagram(DynkinDiagram,Parabolic)
    -- the Dynkin diagram of the
    Levy subgroup of a parabolic
  * dynkinDiagram(RootSystem) -- the
    Dynkin diagram of a root system

For the programmer
==================

The object dynkinDiagram, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3830:0.

dynkinDiagram(DynkinDiagram,Parabolic) -- the Dynkin diagram of the Levy subgroup of a parabolic
************************************************************************************************

  * Function: dynkinDiagram,
  * Usage:
        dynkinDiagram(D,P)
  * Inputs:
      * D, an instance of the type DynkinDiagram,
      * P, an instance of the type Parabolic,
  * Outputs:
      * an instance of the type DynkinDiagram, the Dynkin
        diagram of the root system of the Levy subgroup of the Parabolic P

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : D1=dynkinDiagram(R)                                                     |
|                                                                             |
|o2 = DynkinDiagram{{{2}, {}, {}, {}, {}}, {{1, 3}, {}, {}, {}, {}}, {{2, 4,  |
|                                                                             |
|o2 : DynkinDiagram                                                           |
|-----------------------------------------------------------------------------|
|5}, {}, {}, {}, {}}, {{3}, {}, {}, {}, {}}, {{3}, {}, {}, {}, {}}}           |
+-----------------------------------------------------------------------------+
|i3 : P=parabolic(R,set{1,3,4,5})                                             |
|                                                                             |
|o3 = set {1, 3, 4, 5}                                                        |
|                                                                             |
|o3 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i4 : D2=dynkinDiagram(D1,P)                                                  |
|                                                                             |
|o4 = DynkinDiagram{{{}, {}, {}, {}, {}}, {{3, 4}, {}, {}, {}, {}}, {{2}, {}, |
|                                                                             |
|o4 : DynkinDiagram                                                           |
|-----------------------------------------------------------------------------|
|{}, {}, {}}, {{2}, {}, {}, {}, {}}}                                          |
+-----------------------------------------------------------------------------+
|i5 : dynkinType(D2)                                                          |
|                                                                             |
|o5 = DynkinType{{A, 1}, {A, 3}}                                              |
|                                                                             |
|o5 : DynkinType                                                              |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * dynkinDiagram(DynkinDiagram,Parabolic)
    -- the Dynkin diagram of the
    Levy subgroup of a parabolic
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3872:0.

dynkinDiagram(RootSystem) -- the Dynkin diagram of a root system
****************************************************************

  * Function: dynkinDiagram,
  * Usage:
        dynkinDiagram(R)
  * Inputs:
      * R, an instance of the type RootSystem,
  * Outputs:
      * an instance of the type DynkinDiagram, the Dynkin
        diagram of the root system R

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R1=rootSystemA(5)                                                       |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : dynkinDiagram(R1)                                                       |
|                                                                             |
|o2 = DynkinDiagram{{{2}, {}, {}, {}, {}}, {{1, 3}, {}, {}, {}, {}}, {{2, 4}, |
|                                                                             |
|o2 : DynkinDiagram                                                           |
|-----------------------------------------------------------------------------|
|{}, {}, {}, {}}, {{3, 5}, {}, {}, {}, {}}, {{4}, {}, {}, {}, {}}}            |
+-----------------------------------------------------------------------------+
|i3 : R2=rootSystemF4                                                         |
|                                                                             |
|o3 = RootSystem{...8...}                                                     |
|                                                                             |
|o3 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i4 : dynkinDiagram(R2)                                                       |
|                                                                             |
|o4 = DynkinDiagram{{{2}, {}, {}, {}, {}}, {{1}, {3}, {}, {}, {}}, {{4}, {},  |
|                                                                             |
|o4 : DynkinDiagram                                                           |
|-----------------------------------------------------------------------------|
|{2}, {}, {}}, {{3}, {}, {}, {}, {}}}                                         |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * dynkinDiagram(RootSystem) -- the
    Dynkin diagram of a root system
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3850:0.

dynkinExponents -- the exponents associated to a type
*****************************************************

Ways to use dynkinExponents:
============================

  * dynkinExponents(DynkinType) -- the
    exponents of the Dynkin type

For the programmer
==================

The object dynkinExponents, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4085:0.

dynkinExponents(DynkinType) -- the exponents of the Dynkin type
***************************************************************

  * Function: dynkinExponents,
  * Usage:
        dynkinExponents(D)
  * Inputs:
      * D, an instance of the type DynkinType,
  * Outputs:
      * a list (Macaulay2Doc), of lists of integers, the exponents
        listed in the tables in Bourbaki, Lie groups and Lie algebras,
        following chapter 6.

Description
===========

+----------------------------------------------------------------------+
|i1 : R=rootSystemE(6)++rootSystemA(4)++rootSystemB(3)++rootSystemA(4);|
+----------------------------------------------------------------------+
|i2 : dynkinExponents(dynkinType(R))                                   |
|                                                                      |
|o2 = {{1, 2, 3, 4}, {1, 2, 3, 4}, {1, 3, 5}, {1, 4, 5, 7, 8, 11}}     |
|                                                                      |
|o2 : List                                                             |
+----------------------------------------------------------------------+

Ways to use this method:
========================

  * dynkinExponents(DynkinType) -- the
    exponents of the Dynkin type
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4103:0.

dynkinType -- obtaining a Dynkin type
*************************************

Ways to use dynkinType:
=======================

  * dynkinType(BasicList) -- constructing a
    Dynkin type
  * dynkinType(DynkinDiagram) -- the
    Dynkin type of a Dynkin diagram
  * dynkinType(RootSystem) -- the Dynkin
    type of a root system

For the programmer
==================

The object dynkinType, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4011:0.

DynkinType ++ DynkinType -- the disjoint union of Dynkin Types
**************************************************************

  * Operator: ++ (Macaulay2Doc),
  * Usage:
        T1 ++ T2
  * Inputs:
      * T1, an instance of the type DynkinType,
      * T2, an instance of the type DynkinType,
  * Outputs:
      * an instance of the type DynkinType, the disjoint
        union (concatenation) of T1 and T2

Description
===========

+----------------------------------+
|i1 : T1=dynkinType(rootSystemB(2))|
|                                  |
|o1 = DynkinType{{B, 2}}           |
|                                  |
|o1 : DynkinType                   |
+----------------------------------+
|i2 : T2=dynkinType(rootSystemA(3))|
|                                  |
|o2 = DynkinType{{A, 3}}           |
|                                  |
|o2 : DynkinType                   |
+----------------------------------+
|i3 : T1++T2                       |
|                                  |
|o3 = DynkinType{{B, 2}, {A, 3}}   |
|                                  |
|o3 : DynkinType                   |
+----------------------------------+

Note that it is not reordered.

Ways to use this method:
========================

  * DynkinType ++ DynkinType -- the disjoint
    union of Dynkin Types
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3980:0.

DynkinType == DynkinType -- the equality of Dynkin Types
********************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        T1 == T2
  * Inputs:
      * T1, an instance of the type DynkinType,
      * T2, an instance of the type DynkinType,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if T1 is isomorphic
        to T2 and false if not

Description
===========

+----------------------------------+
|i1 : T1=dynkinType(rootSystemB(2))|
|                                  |
|o1 = DynkinType{{B, 2}}           |
|                                  |
|o1 : DynkinType                   |
+----------------------------------+
|i2 : T2=dynkinType(rootSystemA(3))|
|                                  |
|o2 = DynkinType{{A, 3}}           |
|                                  |
|o2 : DynkinType                   |
+----------------------------------+
|i3 : (T1++T2) == (T2++T1)         |
|                                  |
|o3 = true                         |
+----------------------------------+

whereas

+--------------------------+
|i4 : (T1++T2) === (T2++T1)|
|                          |
|o4 = false                |
+--------------------------+

Ways to use this method:
========================

  * DynkinType == DynkinType -- the equality
    of Dynkin Types
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4004:0.

dynkinType(BasicList) -- constructing a Dynkin type
***************************************************

  * Function: dynkinType,
  * Usage:
        dynkinType(L)
  * Inputs:
      * L, a basic list (Macaulay2Doc), of irreducible types
        that are lists containing a string of one letter from A to F and a
        positive integer, the rank
  * Outputs:
      * an instance of the type DynkinType,

Description
===========

+----------------------------------+
|i1 : dynkinType({{"A",2},{"B",3}})|
|                                  |
|o1 = DynkinType{{A, 2}, {B, 3}}   |
|                                  |
|o1 : DynkinType                   |
+----------------------------------+

Note that low rank isomorphisms between classical groups are automatically used
so that the letter is alphabetically minimal and the elementary types are
irreducible (D2=A1xA1).

+---------------------------------------+
|i2 : dynkinType({{"A",2},{"B",1}})     |
|                                       |
|o2 = DynkinType{{A, 2}, {A, 1}}        |
|                                       |
|o2 : DynkinType                        |
+---------------------------------------+
|i3 : dynkinType({{"A",2},{"C",2}})     |
|                                       |
|o3 = DynkinType{{A, 2}, {B, 2}}        |
|                                       |
|o3 : DynkinType                        |
+---------------------------------------+
|i4 : dynkinType({{"A",2},{"D",2}})     |
|                                       |
|o4 = DynkinType{{A, 2}, {A, 1}, {A, 1}}|
|                                       |
|o4 : DynkinType                        |
+---------------------------------------+

Ways to use this method:
========================

  * dynkinType(BasicList) -- constructing a
    Dynkin type
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4053:0.

dynkinType(DynkinDiagram) -- the Dynkin type of a Dynkin diagram
****************************************************************

  * Function: dynkinType,
  * Usage:
        dynkinType(D)
  * Inputs:
      * D, an instance of the type DynkinDiagram,
  * Outputs:
      * a list (Macaulay2Doc), of types of the connected components
        of the Dynkin diagram D

Description
===========

+----------------------------------------------------------------------+
|i1 : R=rootSystemE(6)++rootSystemA(4)++rootSystemB(3)++rootSystemA(4);|
+----------------------------------------------------------------------+
|i2 : D=dynkinDiagram(R);                                              |
+----------------------------------------------------------------------+
|i3 : dynkinType(D)                                                    |
|                                                                      |
|o3 = DynkinType{{A, 4}, {A, 4}, {B, 3}, {E, 6}}                       |
|                                                                      |
|o3 : DynkinType                                                       |
+----------------------------------------------------------------------+

Ways to use this method:
========================

  * dynkinType(DynkinDiagram) -- the
    Dynkin type of a Dynkin diagram
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4030:0.

dynkinType(RootSystem) -- the Dynkin type of a root system
**********************************************************

  * Function: dynkinType,
  * Usage:
        dynkinType(R)
  * Inputs:
      * R, an instance of the type RootSystem,
  * Outputs:
      * a list (Macaulay2Doc), of types of the irreducible
        components of the root system R

Description
===========

+----------------------------------------------------------------------+
|i1 : R=rootSystemE(6)++rootSystemA(4)++rootSystemB(3)++rootSystemA(4);|
+----------------------------------------------------------------------+
|i2 : dynkinType(R)                                                    |
|                                                                      |
|o2 = DynkinType{{A, 4}, {A, 4}, {B, 3}, {E, 6}}                       |
|                                                                      |
|o2 : DynkinType                                                       |
+----------------------------------------------------------------------+

Ways to use this method:
========================

  * dynkinType(RootSystem) -- the Dynkin
    type of a root system
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4071:0.

endVertices -- the vertices with at most one edge
*************************************************

Ways to use endVertices:
========================

  * endVertices(DynkinDiagram) -- the
    vertices of a Dynkin diagram with at most one neighbor

For the programmer
==================

The object endVertices, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3920:0.

endVertices(DynkinDiagram) -- the vertices of a Dynkin diagram with at most one neighbor
****************************************************************************************

  * Function: endVertices,
  * Usage:
        connectedComponents(D)
  * Inputs:
      * D, an instance of the type DynkinDiagram,
  * Outputs:
      * a list (Macaulay2Doc), containing the vertices of D whose
        removal does not disconnect any part of D. They can have at most one
        neighbor.

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemE(6)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : D=dynkinDiagram(R)                                                      |
|                                                                             |
|o2 = DynkinDiagram{{{3}, {}, {}, {}, {}}, {{4}, {}, {}, {}, {}}, {{1, 4}, {},|
|                                                                             |
|o2 : DynkinDiagram                                                           |
|-----------------------------------------------------------------------------|
|{}, {}, {}}, {{2, 3, 5}, {}, {}, {}, {}}, {{4, 6}, {}, {}, {}, {}}, {{5}, {},|
|-----------------------------------------------------------------------------|
|{}, {}, {}}}                                                                 |
+-----------------------------------------------------------------------------+
|i3 : endVertices(D)                                                          |
|                                                                             |
|o3 = set {1, 6, 2}                                                           |
|                                                                             |
|o3 : Set                                                                     |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * endVertices(DynkinDiagram) -- the
    vertices of a Dynkin diagram with at most one neighbor
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3939:0.

eval -- evaluate the dual of a root at something
************************************************

Ways to use eval:
=================

  * eval(RootSystem,Weight,Root),
    -- evaluate the dual of a root at a Weight
  * eval(RootSystem,Weight,ZZ), --
    evaluate the dual of a simple root at a Weight
  * eval(RootSystem,ZZ,Root), --
    evaluate the dual of a root at a fundamental weight
  * eval(RootSystem,ZZ,ZZ) -- evaluate
    the dual of a simple root at another one

For the programmer
==================

The object eval, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2407:0.

eval(RootSystem,Weight,Root) -- evaluate the dual of a root at a Weight
***********************************************************************

  * Function: eval,
  * Usage:
        eval(R,v,r)
  * Inputs:
      * R, an instance of the type RootSystem,
      * v, an instance of the type Weight,
      * r, an instance of the type Root,
  * Outputs:
      * an integer (Macaulay2Doc), the dual of the root r evaluated
        at the weight v

Description
===========

+-------------------------------+
|i1 : R=rootSystemA(2)          |
|                               |
|o1 = RootSystem{...8...}       |
|                               |
|o1 : RootSystem                |
+-------------------------------+
|i2 : L=toList(positiveRoots(R))|
|                               |
|o2 = {| 1 |, |  2 |, | -1 |}   |
|      | 1 |  | -1 |  |  2 |    |
|                               |
|o2 : List                      |
+-------------------------------+
|i3 : v=weight(R,{1,2})         |
|                               |
|o3 = | 1 |                     |
|     | 2 |                     |
|                               |
|       2                       |
|o3 : ZZ                        |
+-------------------------------+
|i4 : eval(R,v,L#0)             |
|                               |
|o4 = 3                         |
+-------------------------------+
|i5 : eval(R,v,L#1)             |
|                               |
|o5 = 1                         |
+-------------------------------+
|i6 : eval(R,v,L#2)             |
|                               |
|o6 = 2                         |
+-------------------------------+

Ways to use this method:
========================

  * eval(RootSystem,Weight,Root),
    -- evaluate the dual of a root at a Weight
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2488:0.

eval(RootSystem,Weight,ZZ) -- evaluate the dual of a simple root at a Weight
****************************************************************************

  * Function: eval,
  * Usage:
        eval(R,v,i)
  * Inputs:
      * R, an instance of the type RootSystem,
      * v, an instance of the type Weight,
      * i, an integer (Macaulay2Doc), the number of the simple root
  * Outputs:
      * an integer (Macaulay2Doc), the dual of the i-th simple root
        evaluated at the weight v

Description
===========

+------------------------+
|i1 : R=rootSystemA(2)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : v=weight(R,{1,2})  |
|                        |
|o2 = | 1 |              |
|     | 2 |              |
|                        |
|       2                |
|o2 : ZZ                 |
+------------------------+
|i3 : eval(R,v,1)        |
|                        |
|o3 = 1                  |
+------------------------+

Ways to use this method:
========================

  * eval(RootSystem,Weight,ZZ), --
    evaluate the dual of a simple root at a Weight
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2458:0.

eval(RootSystem,ZZ,Root) -- evaluate the dual of a root at a fundamental weight
*******************************************************************************

  * Function: eval,
  * Usage:
        eval(R,i,r)
  * Inputs:
      * R, an instance of the type RootSystem,
      * i, an integer (Macaulay2Doc), the number of a weight
      * r, an instance of the type Root,
  * Outputs:
      * an integer (Macaulay2Doc), the dual of the root r evaluated
        at the i-th fundamental weight

Description
===========

+-------------------------------+
|i1 : R=rootSystemA(2)          |
|                               |
|o1 = RootSystem{...8...}       |
|                               |
|o1 : RootSystem                |
+-------------------------------+
|i2 : L=toList(positiveRoots(R))|
|                               |
|o2 = {| 1 |, |  2 |, | -1 |}   |
|      | 1 |  | -1 |  |  2 |    |
|                               |
|o2 : List                      |
+-------------------------------+
|i3 : eval(R,1,L#0)             |
|                               |
|o3 = 1                         |
+-------------------------------+
|i4 : eval(R,1,L#1)             |
|                               |
|o4 = 1                         |
+-------------------------------+
|i5 : eval(R,1,L#2)             |
|                               |
|o5 = 0                         |
+-------------------------------+

Ways to use this method:
========================

  * eval(RootSystem,ZZ,Root), --
    evaluate the dual of a root at a fundamental weight
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2512:0.

eval(RootSystem,ZZ,ZZ) -- evaluate the dual of a simple root at another one
***************************************************************************

  * Function: eval,
  * Usage:
        eval(R,i,j)
  * Inputs:
      * R, an instance of the type RootSystem,
      * i, an integer (Macaulay2Doc), the number of the first simple
        root
      * j, an integer (Macaulay2Doc), the number of the second simple
        root
  * Outputs:
      * an integer (Macaulay2Doc), the dual of the j-th simple root
        evaluated at the i-th simple root

Description
===========

+------------------------+
|i1 : R=rootSystemA(2)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : eval(R,1,1)        |
|                        |
|o2 = 2                  |
+------------------------+
|i3 : eval(R,1,2)        |
|                        |
|o3 = -1                 |
+------------------------+

Ways to use this method:
========================

  * eval(RootSystem,ZZ,ZZ) -- evaluate
    the dual of a simple root at another one
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2430:0.

halfSumOfRoots(RootSystem) -- the half-sum of positive roots
************************************************************

  * Function: halfSumOfRoots,
  * Usage:
        halfSumOfRoots(R)
  * Inputs:
      * R, an instance of the type RootSystem,
  * Outputs:
      * an instance of the type Weight, the half-sum of positive
        roots in R

Description
===========

+-----------------------------------+
|i1 : halfSumOfRoots(rootSystemE(6))|
|                                   |
|o1 = | 1 |                         |
|     | 1 |                         |
|     | 1 |                         |
|     | 1 |                         |
|     | 1 |                         |
|     | 1 |                         |
|                                   |
|       6                           |
|o1 : ZZ                            |
+-----------------------------------+

Ways to use this method:
========================

  * halfSumOfRoots(RootSystem) -- the
    half-sum of positive roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2150:0.

hasseDiagramToGraph(HasseDiagram) -- turning a hasse diagram into a graph (intended for graphic representation)
***************************************************************************************************************

  * Function: hasseDiagramToGraph,
  * Usage:
        hasseDiagramToGraph(h)
  * Inputs:
      * h, an instance of the type HasseDiagram,
  * Optional inputs (Macaulay2Doc),:
      * labels
  * Outputs:
      * an instance of the type HasseGraph,

Description
===========

By default, the HasseGraph will have vertices with empty labels.

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(3)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : w1 = reduce(R,{2})                                                      |
|                                                                             |
|o2 = WeylGroupElement{RootSystem{...8...}, |  2 |}                           |
|                                           | -1 |                            |
|                                           |  2 |                            |
|                                                                             |
|o2 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i3 : w2 = reduce(R,{1,2,1,3,2})                                              |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -2 |                            |
|                                           |  1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : myInterval=intervalBruhat(w1,w2)                                        |
|                                                                             |
|o4 = HasseDiagram{{{WeylGroupElement{RootSystem{...8...}, | -1 |}, {{0, | -1 |
|                                                          | -2 |        |  2 |
|                                                          |  1 |        | -1 |
|                                                                             |
|o4 : HasseDiagram                                                            |
|-----------------------------------------------------------------------------|
||}, {1, |  0 |}, {2, |  1 |}}}}, {{WeylGroupElement{RootSystem{...8...}, | -2|
||       | -1 |       |  1 |                                              | -1|
||       |  2 |       | -1 |                                              |  2|
|-----------------------------------------------------------------------------|
||}, {{1, |  0 |}, {2, | -1 |}, {4, |  2 |}}},                                |
||        | -1 |       |  1 |       | -1 |                                    |
||        |  2 |       |  1 |       |  0 |                                    |
|-----------------------------------------------------------------------------|
|{WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0, | 1 |}, {1, | -1 |}, {2,|
|                                       | -3 |        | 0 |       |  1 |      |
|                                       |  1 |        | 1 |       |  1 |      |
|-----------------------------------------------------------------------------|
|| -1 |}, {3, |  1 |}}}, {WeylGroupElement{RootSystem{...8...}, | -3 |}, {{0, |
||  2 |       |  1 |                                            |  2 |        |
|| -1 |       | -1 |                                            | -1 |        |
|-----------------------------------------------------------------------------|
||  0 |}, {3, | 1 |}, {4, | -1 |}}}}, {{WeylGroupElement{RootSystem{...8...}, |
|| -1 |       | 0 |       |  2 |                                              |
||  2 |       | 1 |       | -1 |                                              |
|-----------------------------------------------------------------------------|
|| -2 |}, {{0, | -1 |}, {2, |  1 |}}}, {WeylGroupElement{RootSystem{...8...}, |
||  3 |        |  1 |       |  1 |                                            |
|| -2 |        |  1 |       | -1 |                                            |
|-----------------------------------------------------------------------------|
|| -1 |}, {{0, |  2 |}, {1, | -1 |}}}, {WeylGroupElement{RootSystem{...8...}, |
|| -1 |        | -1 |       |  2 |                                            |
||  3 |        |  0 |       | -1 |                                            |
|-----------------------------------------------------------------------------|
||  2 |}, {{1, |  0 |}, {3, |  2 |}}}, {WeylGroupElement{RootSystem{...8...}, |
|| -3 |        | -1 |       | -1 |                                            |
||  2 |        |  2 |       |  0 |                                            |
|-----------------------------------------------------------------------------|
||  3 |}, {{2, |  0 |}, {3, | -1 |}}}, {WeylGroupElement{RootSystem{...8...}, |
|| -1 |        | -1 |       |  2 |                                            |
|| -1 |        |  2 |       | -1 |                                            |
|-----------------------------------------------------------------------------|
|| -3 |}, {{0, |  0 |}, {3, | 1 |}}}}, {{WeylGroupElement{RootSystem{...8...},|
||  1 |        | -1 |       | 0 |                                             |
||  1 |        |  2 |       | 1 |                                             |
|-----------------------------------------------------------------------------|
|| -2 |}, {{0, |  1 |}}}, {WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0,|
||  1 |        |  1 |                                            | -2 |       |
||  2 |        | -1 |                                            |  3 |       |
|-----------------------------------------------------------------------------|
||  2 |}}}, {WeylGroupElement{RootSystem{...8...}, |  2 |}, {{0, | -1 |}}},   |
|| -1 |                                            |  1 |        |  1 |       |
||  0 |                                            | -2 |        |  1 |       |
|-----------------------------------------------------------------------------|
|{WeylGroupElement{RootSystem{...8...}, |  3 |}, {{0, |  0 |}}}},             |
|                                       | -2 |        | -1 |                  |
|                                       |  1 |        |  2 |                  |
|-----------------------------------------------------------------------------|
|{{WeylGroupElement{RootSystem{...8...}, |  2 |}, {}}}}                       |
|                                        | -1 |                               |
|                                        |  2 |                               |
+-----------------------------------------------------------------------------+
|i5 : hasseDiagramToGraph(myInterval)                                         |
|                                                                             |
|o5 = HasseGraph{{{, {{, 0}, {, 1}, {, 2}}}}, {{, {{, 1}, {, 2}, {, 4}}}, {,  |
|                                                                             |
|o5 : HasseGraph                                                              |
|-----------------------------------------------------------------------------|
|{{, 0}, {, 1}, {, 2}, {, 3}}}, {, {{, 0}, {, 3}, {, 4}}}}, {{, {{, 0}, {,    |
|-----------------------------------------------------------------------------|
|2}}}, {, {{, 0}, {, 1}}}, {, {{, 1}, {, 3}}}, {, {{, 2}, {, 3}}}, {, {{, 0}, |
|-----------------------------------------------------------------------------|
|{, 3}}}}, {{, {{, 0}}}, {, {{, 0}}}, {, {{, 0}}}, {, {{, 0}}}}, {{, {}}}}    |
+-----------------------------------------------------------------------------+

It is also possible to ask for reduced decompositions as labels by changing the
option "labels" as below.

+-----------------------------------------------------------------------------+
|i6 : hasseDiagramToGraph(myInterval,"labels"=>"reduced decomposition")       |
|                                                                             |
|o6 = HasseGraph{{{12132, {{2, 0}, {3, 1}, {121, 2}}}}, {{1213, {{3, 1}, {232,|
|                                                                             |
|o6 : HasseGraph                                                              |
|-----------------------------------------------------------------------------|
|2}, {1, 4}}}, {2132, {{12321, 0}, {232, 1}, {2, 2}, {121, 3}}}, {1232, {{3,  |
|-----------------------------------------------------------------------------|
|0}, {12321, 3}, {2, 4}}}}, {{132, {{232, 0}, {121, 2}}}, {121, {{1, 0}, {2,  |
|-----------------------------------------------------------------------------|
|1}}}, {213, {{3, 1}, {1, 3}}}, {232, {{3, 2}, {2, 3}}}, {123, {{3, 0},       |
|-----------------------------------------------------------------------------|
|{12321, 3}}}}, {{12, {{121, 0}}}, {21, {{1, 0}}}, {32, {{232, 0}}}, {23, {{3,|
|-----------------------------------------------------------------------------|
|0}}}}, {{2, {}}}}                                                            |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * hasseDiagramToGraph(HasseDiagram)
    -- turning a hasse diagram into a
    graph (intended for graphic representation)
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4546:0.

hasseGraphToPicture(HasseGraph) -- Obtain a picture from a Hasse graph
**********************************************************************

  * Function: hasseGraphToPicture,
  * Usage:
        hasseGraphToPicture(H)
  * Inputs:
      * H, an instance of the type HasseGraph,
  * Optional inputs (Macaulay2Doc),:
      * edge options
      * horizontal space
      * left margin
      * point options
      * point radius
      * row space
      * tag distance
      * tag options
      * top margin
  * Outputs:
      * an instance of the type Picture (Graphics), describing
        the Hasse graph in the picture language of the package Graphics

Ways to use this method:
========================

  * hasseGraphToPicture(HasseGraph),
    -- Obtain a picture from a Hasse graph
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4395:0.

intervalBruhat(WeylGroupElement,WeylGroupElement) -- elements between two given ones for the Bruhat order on a Weyl group
*************************************************************************************************************************

  * Function: intervalBruhat,
  * Usage:
        intervalBruhat(u,v)
  * Inputs:
      * u, an instance of the type WeylGroupElement,
        the lower bound of the interval
      * v, an instance of the type WeylGroupElement,
        the upper bound of the interval
  * Outputs:
      * an instance of the type HasseDiagram, of elements
        smaller than u and bigger than v together with the reflections to go
        from an element to the next one (on the right) attached to the
        corresponding edge.

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(3)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : w1 = reduce(R,{2,1,2})                                                  |
|                                                                             |
|o2 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           |  3 |                            |
|                                                                             |
|o2 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i3 : w2 = reduce(R,{1,2,1,3,2})                                              |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -2 |                            |
|                                           |  1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : myInterval=intervalBruhat(w1,w2)                                        |
|                                                                             |
|o4 = HasseDiagram{{{WeylGroupElement{RootSystem{...8...}, | -1 |}, {{0, | -1 |
|                                                          | -2 |        |  2 |
|                                                          |  1 |        | -1 |
|                                                                             |
|o4 : HasseDiagram                                                            |
|-----------------------------------------------------------------------------|
||}, {1, |  0 |}}}}, {{WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, |  |
||       | -1 |                                              | -1 |        |  |
||       |  2 |                                              |  2 |        |  |
|-----------------------------------------------------------------------------|
| 0 |}}}, {WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0, | -1 |}}}},    |
|-1 |                                            | -3 |        |  1 |         |
| 2 |                                            |  1 |        |  1 |         |
|-----------------------------------------------------------------------------|
|{{WeylGroupElement{RootSystem{...8...}, | -1 |}, {}}}}                       |
|                                        | -1 |                               |
|                                        |  3 |                               |
+-----------------------------------------------------------------------------+

Each row of the Hasse diagram contains the elements of a certain length
together with their links to the next row.

+-----------------------------------------------------------------------------+
|i5 : myInterval#1                                                            |
|                                                                             |
|o5 = {{WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, |  0 |}}},        |
|                                             | -1 |        | -1 |            |
|                                             |  2 |        |  2 |            |
|     ------------------------------------------------------------------------|
|     {WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0, | -1 |}}}}         |
|                                            | -3 |        |  1 |             |
|                                            |  1 |        |  1 |             |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * intervalBruhat(WeylGroupElement,WeylGroupElement)
    -- elements
    between two given ones for the Bruhat order on a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4429:0.

intervalBruhat(WeylGroupLeftCoset,WeylGroupLeftCoset) -- elements between two given ones for the Bruhat order on a quotient of a Weyl group
*******************************************************************************************************************************************

  * Function: intervalBruhat,
  * Usage:
        intervalBruhat(u,v)
  * Inputs:
      * u, an instance of the type WeylGroupLeftCoset,
      * v, an instance of the type WeylGroupLeftCoset,
  * Outputs:
      * an instance of the type HasseDiagram, of elements
        of minimal length in their cosets, bigger than u and smaller than v,
        together with the reflections to go from an element to the next one (on
        the right) attached to the corresponding edge.

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(3)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set {3})                                                  |
|                                                                             |
|o2 = set {3}                                                                 |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w1 = reduce(R,{2})                                                      |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, |  2 |}                           |
|                                           | -1 |                            |
|                                           |  2 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : w2 = reduce(R,{1,2,1,3,2})                                              |
|                                                                             |
|o4 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -2 |                            |
|                                           |  1 |                            |
|                                                                             |
|o4 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i5 : myInterval=intervalBruhat(w1 % P,w2 % P)                                |
|                                                                             |
|o5 = HasseDiagram{{{WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0, | 1  |
|                                                          | -3 |        | 0  |
|                                                          |  1 |        | 1  |
|                                                                             |
|o5 : HasseDiagram                                                            |
|-----------------------------------------------------------------------------|
||}, {1, | -1 |}}}}, {{WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, |  |
||       |  1 |                                              |  3 |        |  |
||       |  1 |                                              | -2 |        |  |
|-----------------------------------------------------------------------------|
|-1 |}, {2, |  1 |}}}, {WeylGroupElement{RootSystem{...8...}, | -1 |}, {{0, | |
| 1 |       |  1 |                                            | -1 |        | |
| 1 |       | -1 |                                            |  3 |        | |
|-----------------------------------------------------------------------------|
| 2 |}, {1, | -1 |}}}}, {{WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, |
|-1 |       |  2 |                                              |  1 |        |
| 0 |       | -1 |                                              |  2 |        |
|-----------------------------------------------------------------------------|
||  1 |}}}, {WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0, |  2 |}}},   |
||  1 |                                            | -2 |        | -1 |       |
|| -1 |                                            |  3 |        |  0 |       |
|-----------------------------------------------------------------------------|
|{WeylGroupElement{RootSystem{...8...}, |  2 |}, {{0, | -1 |}}}},             |
|                                       |  1 |        |  1 |                  |
|                                       | -2 |        |  1 |                  |
|-----------------------------------------------------------------------------|
|{{WeylGroupElement{RootSystem{...8...}, |  2 |}, {}}}}                       |
|                                        | -1 |                               |
|                                        |  2 |                               |
+-----------------------------------------------------------------------------+

Each row of the Hasse diagram contains the elements of a certain length
together with their links to the next row.

+-----------------------------------------------------------------------------+
|i6 : myInterval#1                                                            |
|                                                                             |
|o6 = {{WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, | -1 |}, {2, |  1 |
|                                             |  3 |        |  1 |       |  1 |
|                                             | -2 |        |  1 |       | -1 |
|     ------------------------------------------------------------------------|
|     |}}}, {WeylGroupElement{RootSystem{...8...}, | -1 |}, {{0, |  2 |}, {1, |
|     |                                            | -1 |        | -1 |       |
|     |                                            |  3 |        |  0 |       |
|     ------------------------------------------------------------------------|
|     | -1 |}}}}                                                              |
|     |  2 |                                                                  |
|     | -1 |                                                                  |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * intervalBruhat(WeylGroupLeftCoset,WeylGroupLeftCoset)
    -- elements
    between two given ones for the Bruhat order on a quotient of a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4455:0.

intervalBruhat(WeylGroupRightCoset,WeylGroupRightCoset) -- elements between two given ones for the Bruhat order on a quotient of a Weyl group
*********************************************************************************************************************************************

  * Function: intervalBruhat,
  * Usage:
        intervalBruhat(u,v)
  * Inputs:
      * u, an instance of the type WeylGroupRightCoset,
      * v, an instance of the type WeylGroupRightCoset,
  * Outputs:
      * an instance of the type HasseDiagram, of elements
        of minimal length in their coset, bigger than u and smaller than v,
        together with the reflections to go from an element to the next one (on
        the right) attached to the corresponding edge.

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(3)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set {3})                                                  |
|                                                                             |
|o2 = set {3}                                                                 |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w1 = reduce(R,{2})                                                      |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, |  2 |}                           |
|                                           | -1 |                            |
|                                           |  2 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : w2 = reduce(R,{1,2,1,3,2})                                              |
|                                                                             |
|o4 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -2 |                            |
|                                           |  1 |                            |
|                                                                             |
|o4 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i5 : myInterval=intervalBruhat(P % w1,P % w2)                                |
|                                                                             |
|o5 = HasseDiagram{{{WeylGroupElement{RootSystem{...8...}, | -1 |}, {{0, |  0 |
|                                                          | -2 |        | -1 |
|                                                          |  1 |        |  2 |
|                                                                             |
|o5 : HasseDiagram                                                            |
|-----------------------------------------------------------------------------|
||}, {1, | -1 |}}}}, {{WeylGroupElement{RootSystem{...8...}, |  1 |}, {{1, |  |
||       |  2 |                                              | -3 |        |  |
||       | -1 |                                              |  1 |        |  |
|-----------------------------------------------------------------------------|
|-1 |}, {2, | -1 |}}}, {WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, | |
| 1 |       |  2 |                                            | -1 |        | |
| 1 |       | -1 |                                            |  2 |        | |
|-----------------------------------------------------------------------------|
| 2 |}, {1, |  0 |}, {2, | -1 |}}}}, {{WeylGroupElement{RootSystem{...8...}, ||
|-1 |       | -1 |       |  1 |                                              ||
| 0 |       |  2 |       |  1 |                                              ||
|-----------------------------------------------------------------------------|
|-3 |}, {{0, |  0 |}, {2, | 1 |}}}, {WeylGroupElement{RootSystem{...8...}, |  |
| 1 |        | -1 |       | 0 |                                            |  |
| 1 |        |  2 |       | 1 |                                            |  |
|-----------------------------------------------------------------------------|
|-1 |}, {{0, |  2 |}, {1, | -1 |}}}, {WeylGroupElement{RootSystem{...8...}, | |
|-1 |        | -1 |       |  2 |                                            | |
| 3 |        |  0 |       | -1 |                                            | |
|-----------------------------------------------------------------------------|
| 2 |}, {{1, |  0 |}, {2, |  2 |}}}}, {{WeylGroupElement{RootSystem{...8...}, |
|-3 |        | -1 |       | -1 |                                              |
| 2 |        |  2 |       |  0 |                                              |
|-----------------------------------------------------------------------------|
|| -2 |}, {{0, |  1 |}}}, {WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0,|
||  1 |        |  1 |                                            | -2 |       |
||  2 |        | -1 |                                            |  3 |       |
|-----------------------------------------------------------------------------|
||  2 |}}}, {WeylGroupElement{RootSystem{...8...}, |  3 |}, {{0, |  0 |}}}},  |
|| -1 |                                            | -2 |        | -1 |       |
||  0 |                                            |  1 |        |  2 |       |
|-----------------------------------------------------------------------------|
|{{WeylGroupElement{RootSystem{...8...}, |  2 |}, {}}}}                       |
|                                        | -1 |                               |
|                                        |  2 |                               |
+-----------------------------------------------------------------------------+

Each row of the Hasse diagram contains the elements of a certain length
together with their links to the next row.

+-----------------------------------------------------------------------------+
|i6 : myInterval#1                                                            |
|                                                                             |
|o6 = {{WeylGroupElement{RootSystem{...8...}, |  1 |}, {{1, | -1 |}, {2, | -1 |
|                                             | -3 |        |  1 |       |  2 |
|                                             |  1 |        |  1 |       | -1 |
|     ------------------------------------------------------------------------|
|     |}}}, {WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, |  2 |}, {1, |
|     |                                            | -1 |        | -1 |       |
|     |                                            |  2 |        |  0 |       |
|     ------------------------------------------------------------------------|
|     |  0 |}, {2, | -1 |}}}}                                                 |
|     | -1 |       |  1 |                                                     |
|     |  2 |       |  1 |                                                     |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * intervalBruhat(WeylGroupRightCoset,WeylGroupRightCoset)
    -- elements
    between two given ones for the Bruhat order on a quotient of a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4481:0.

inverse(WeylGroupElement) -- the inverse to an element of a Weyl group
**********************************************************************

  * Function: inverse (Macaulay2Doc),
  * Usage:
        inverse(w)
  * Inputs:
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * an instance of the type WeylGroupElement, the
        inverse to w

Description
===========

+--------------------------------------------------+
|i1 : w=reduce(rootSystemE(6),{1,2,3})             |
|                                                  |
|o1 = WeylGroupElement{RootSystem{...8...}, | -2 |}|
|                                           | -1 | |
|                                           |  1 | |
|                                           |  3 | |
|                                           |  1 | |
|                                           |  1 | |
|                                                  |
|o1 : WeylGroupElement                             |
+--------------------------------------------------+
|i2 : inverse w                                    |
|                                                  |
|o2 = WeylGroupElement{RootSystem{...8...}, |  1 |}|
|                                           | -1 | |
|                                           | -2 | |
|                                           |  4 | |
|                                           |  1 | |
|                                           |  1 | |
|                                                  |
|o2 : WeylGroupElement                             |
+--------------------------------------------------+

Ways to use this method:
========================

  * inverse(WeylGroupElement) -- the
    inverse to an element of a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2893:0.

isLtBruhat(WeylGroupElement,WeylGroupElement) -- compare two Weyl group elements in the Bruhat order
****************************************************************************************************

  * Function: isLtBruhat,
  * Usage:
        isLtBruhat(w1,w2)
  * Inputs:
      * w1, an instance of the type WeylGroupElement,
      * w2, an instance of the type WeylGroupElement,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if w1 is less then
        w2 in the Bruhat order

Description
===========

+------------------------------+
|i1 : R=rootSystemA(3)         |
|                              |
|o1 = RootSystem{...8...}      |
|                              |
|o1 : RootSystem               |
+------------------------------+
|i2 : w1=reduce(R,{3,1,2});    |
+------------------------------+
|i3 : w2=reduce(R,{1,2,3,2,1});|
+------------------------------+
|i4 : isLtBruhat(w1,w2)        |
|                              |
|o4 = true                     |
+------------------------------+

Ways to use this method:
========================

  * isLtBruhat(WeylGroupElement,WeylGroupElement)
    -- compare two Weyl
    group elements in the Bruhat order
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4246:0.

isMinimalRepresentative -- check whether an element of a Weyl group is the minimal representative of a coset
************************************************************************************************************

Ways to use isMinimalRepresentative:
====================================

  * isMinimalRepresentative(Parabolic,WeylGroupElement)
    -- check whether
    an element of a Weyl group is the minimal representative of a right coset
  * isMinimalRepresentative(Parabolic,WeylGroupElement,Parabolic),
    --
    check whether an element of a Weyl group is the minimal representative of a
    double coset
  * isMinimalRepresentative(WeylGroupElement,Parabolic)
    -- check whether
    an element of a Weyl group is the minimal representative of a left coset

For the programmer
==================

The object isMinimalRepresentative, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3728:0.

isMinimalRepresentative(Parabolic,WeylGroupElement) -- check whether an element of a Weyl group is the minimal representative of a right coset
**********************************************************************************************************************************************

  * Function: isMinimalRepresentative,
  * Usage:
        minimalRepresentative(P,w)
  * Inputs:
      * P, an instance of the type Parabolic,
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if w is the
        representative of minimal length of a right coset, and false otherwise

Description
===========

+--------------------------------------------------------------+
|i1 : R=rootSystemE(6)                                         |
|                                                              |
|o1 = RootSystem{...8...}                                      |
|                                                              |
|o1 : RootSystem                                               |
+--------------------------------------------------------------+
|i2 : P=parabolic(R,set{1,2,3,4,5})                            |
|                                                              |
|o2 = set {1, 2, 3, 4, 5}                                      |
|                                                              |
|o2 : Parabolic                                                |
+--------------------------------------------------------------+
|i3 : w=minimalRepresentative (P % (longestWeylGroupElement R))|
|                                                              |
|o3 = WeylGroupElement{RootSystem{...8...}, |  1  |}           |
|                                           |  1  |            |
|                                           |  1  |            |
|                                           |  1  |            |
|                                           |  1  |            |
|                                           | -11 |            |
|                                                              |
|o3 : WeylGroupElement                                         |
+--------------------------------------------------------------+
|i4 : isMinimalRepresentative(P,w)                             |
|                                                              |
|o4 = true                                                     |
+--------------------------------------------------------------+

Ways to use this method:
========================

  * isMinimalRepresentative(Parabolic,WeylGroupElement)
    -- check whether
    an element of a Weyl group is the minimal representative of a right coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3772:0.

isMinimalRepresentative(Parabolic,WeylGroupElement,Parabolic) -- check whether an element of a Weyl group is the minimal representative of a double coset
*********************************************************************************************************************************************************

  * Function: isMinimalRepresentative,
  * Usage:
        minimalRepresentative(P,w,Q)
  * Inputs:
      * P, an instance of the type Parabolic,
      * w, an instance of the type WeylGroupElement,
      * Q, an instance of the type Parabolic,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if w is the
        representative of minimal length of a double coset, and false otherwise

Description
===========

+--------------------------------------------------------------------+
|i1 : R=rootSystemE(6)                                               |
|                                                                    |
|o1 = RootSystem{...8...}                                            |
|                                                                    |
|o1 : RootSystem                                                     |
+--------------------------------------------------------------------+
|i2 : P=parabolic(R,set{1,2,3,4,5})                                  |
|                                                                    |
|o2 = set {1, 2, 3, 4, 5}                                            |
|                                                                    |
|o2 : Parabolic                                                      |
+--------------------------------------------------------------------+
|i3 : Q=parabolic(R,set{2,3,4,5,6})                                  |
|                                                                    |
|o3 = set {2, 3, 4, 5, 6}                                            |
|                                                                    |
|o3 : Parabolic                                                      |
+--------------------------------------------------------------------+
|i4 : w=minimalRepresentative ((P % (longestWeylGroupElement R)) % Q)|
|                                                                    |
|o4 = WeylGroupElement{RootSystem{...8...}, |  1  |}                 |
|                                           |  1  |                  |
|                                           |  1  |                  |
|                                           |  1  |                  |
|                                           |  1  |                  |
|                                           | -11 |                  |
|                                                                    |
|o4 : WeylGroupElement                                               |
+--------------------------------------------------------------------+
|i5 : isMinimalRepresentative(P,w,Q)                                 |
|                                                                    |
|o5 = true                                                           |
+--------------------------------------------------------------------+

Ways to use this method:
========================

  * isMinimalRepresentative(Parabolic,WeylGroupElement,Parabolic),
    --
    check whether an element of a Weyl group is the minimal representative of a
    double coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3795:0.

isMinimalRepresentative(WeylGroupElement,Parabolic) -- check whether an element of a Weyl group is the minimal representative of a left coset
*********************************************************************************************************************************************

  * Function: isMinimalRepresentative,
  * Usage:
        minimalRepresentative(w,P)
  * Inputs:
      * w, an instance of the type WeylGroupElement,
      * P, an instance of the type Parabolic,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if w is the
        representative of minimal length of a left coset, and false otherwise

Description
===========

+--------------------------------------------------------------+
|i1 : R=rootSystemE(6)                                         |
|                                                              |
|o1 = RootSystem{...8...}                                      |
|                                                              |
|o1 : RootSystem                                               |
+--------------------------------------------------------------+
|i2 : P=parabolic(R,set{1,2,3,4,5})                            |
|                                                              |
|o2 = set {1, 2, 3, 4, 5}                                      |
|                                                              |
|o2 : Parabolic                                                |
+--------------------------------------------------------------+
|i3 : w=minimalRepresentative ((longestWeylGroupElement R) % P)|
|                                                              |
|o3 = WeylGroupElement{RootSystem{...8...}, | -11 |}           |
|                                           |  1  |            |
|                                           |  1  |            |
|                                           |  1  |            |
|                                           |  1  |            |
|                                           |  1  |            |
|                                                              |
|o3 : WeylGroupElement                                         |
+--------------------------------------------------------------+
|i4 : isMinimalRepresentative(w,P)                             |
|                                                              |
|o4 = true                                                     |
+--------------------------------------------------------------+

Caveat
======

This function is less efficient than the corresponding function for right
cosets.

Ways to use this method:
========================

  * isMinimalRepresentative(WeylGroupElement,Parabolic)
    -- check whether
    an element of a Weyl group is the minimal representative of a left coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3751:0.

isPositiveRoot(RootSystem,Weight) -- check whether a weight is a positive root
******************************************************************************

  * Function: isPositiveRoot,
  * Usage:
        isPositiveRoot(R,p)
  * Inputs:
      * R, an instance of the type RootSystem,
      * p, an instance of the type Weight,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if p is a positive
        root in R and false otherwise

Description
===========

+------------------------+
|i1 : R=rootSystemE(6)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : p=halfSumOfRoots(R)|
|                        |
|o2 = | 1 |              |
|     | 1 |              |
|     | 1 |              |
|     | 1 |              |
|     | 1 |              |
|     | 1 |              |
|                        |
|       6                |
|o2 : ZZ                 |
+------------------------+
|i3 : isPositiveRoot(R,p)|
|                        |
|o3 = false              |
+------------------------+

Ways to use this method:
========================

  * isPositiveRoot(RootSystem,Weight)
    -- check whether a weight is a
    positive root
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2182:0.

isReduced(BasicList,WeylGroupElement) -- whether an Weyl group element can be multiplied by some simple reflections with length increasing at each step
*******************************************************************************************************************************************************

  * Function: isReduced,
  * Usage:
        isReduced(L,w)
  * Inputs:
      * L, a basic list (Macaulay2Doc), of indices of simple
        reflections
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if the length of
        the product (on the left) of these simple reflections by w is the
        length of w plus their number, and false if not

Description
===========

+--------------------------------------------------+
|i1 : R=rootSystemA(3)                             |
|                                                  |
|o1 = RootSystem{...8...}                          |
|                                                  |
|o1 : RootSystem                                   |
+--------------------------------------------------+
|i2 : w=reduce(R,{1,2,1})                          |
|                                                  |
|o2 = WeylGroupElement{RootSystem{...8...}, | -1 |}|
|                                           | -1 | |
|                                           |  3 | |
|                                                  |
|o2 : WeylGroupElement                             |
+--------------------------------------------------+
|i3 : isReduced({2,3},w)                           |
|                                                  |
|o3 = true                                         |
+--------------------------------------------------+
|i4 : isReduced({1},w)                             |
|                                                  |
|o4 = false                                        |
+--------------------------------------------------+

Ways to use this method:
========================

  * isReduced(BasicList,WeylGroupElement)
    -- whether an Weyl group
    element can be multiplied by some simple reflections with length increasing
    at each step
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3168:0.

isReduced(RootSystem,BasicList) -- whether a decomposition in simple reflections is reduced
*******************************************************************************************

  * Function: isReduced,
  * Usage:
        isReduced(R,L)
  * Inputs:
      * R, an instance of the type RootSystem,
      * L, a basic list (Macaulay2Doc), of indices of simple
        reflections
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if the length of
        the product of these simple reflections is indeed their number, and
        false if not

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemF4                                                          |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : L=reducedDecomposition longestWeylGroupElement R                        |
|                                                                             |
|o2 = {1, 2, 1, 3, 2, 1, 3, 2, 3, 4, 3, 2, 1, 3, 2, 3, 4, 3, 2, 1, 3, 2, 3, 4}|
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : isReduced(R,L)                                                          |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+
|i4 : L={1,1}                                                                 |
|                                                                             |
|o4 = {1, 1}                                                                  |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : isReduced(R,L)                                                          |
|                                                                             |
|o5 = false                                                                   |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * isReduced(RootSystem,BasicList)
    -- whether a decomposition in simple
    reflections is reduced
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3138:0.

isReflection(WeylGroupElement) -- checks whether an element of a Weyl group is a reflection
*******************************************************************************************

  * Function: isReflection,
  * Usage:
        isReflection(w)
  * Inputs:
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if w is a
        reflection and false otherwise

Description
===========

+--------------------------------------------------+
|i1 : R=rootSystemD(5)                             |
|                                                  |
|o1 = RootSystem{...8...}                          |
|                                                  |
|o1 : RootSystem                                   |
+--------------------------------------------------+
|i2 : w=reduce(R,{3})                              |
|                                                  |
|o2 = WeylGroupElement{RootSystem{...8...}, |  1 |}|
|                                           |  2 | |
|                                           | -1 | |
|                                           |  2 | |
|                                           |  2 | |
|                                                  |
|o2 : WeylGroupElement                             |
+--------------------------------------------------+
|i3 : isReflection(w)                              |
|                                                  |
|o3 = true                                         |
+--------------------------------------------------+

Ways to use this method:
========================

  * isReflection(WeylGroupElement),
    -- checks whether an element of a Weyl group is a reflection
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3263:0.

isRoot(RootSystem,Parabolic,Root) -- check whether a root is in the sub root system of the parabolic
****************************************************************************************************

  * Function: isRoot,
  * Usage:
        isRoot(R,P,r)
  * Inputs:
      * R, an instance of the type RootSystem,
      * P, an instance of the type Parabolic,
      * r, an instance of the type Root,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if p is a root in
        the sub root system of R defined by P and false otherwise

Description
===========

+----------------------------+
|i1 : R=rootSystemE(6)       |
|                            |
|o1 = RootSystem{...8...}    |
|                            |
|o1 : RootSystem             |
+----------------------------+
|i2 : P=parabolic(R,set{1,3})|
|                            |
|o2 = set {1, 3}             |
|                            |
|o2 : Parabolic              |
+----------------------------+
|i3 : r1=simpleRoot(R,1)     |
|                            |
|o3 = |  2 |                 |
|     |  0 |                 |
|     | -1 |                 |
|     |  0 |                 |
|     |  0 |                 |
|     |  0 |                 |
|                            |
|       6                    |
|o3 : ZZ                     |
+----------------------------+
|i4 : r2=simpleRoot(R,2)     |
|                            |
|o4 = |  0 |                 |
|     |  2 |                 |
|     |  0 |                 |
|     | -1 |                 |
|     |  0 |                 |
|     |  0 |                 |
|                            |
|       6                    |
|o4 : ZZ                     |
+----------------------------+
|i5 : isRoot(R,P,r1)         |
|                            |
|o5 = true                   |
+----------------------------+
|i6 : isRoot(R,P,r2)         |
|                            |
|o6 = false                  |
+----------------------------+

Ways to use this method:
========================

  * isRoot(RootSystem,Parabolic,Root)
    -- check whether a root is in
    the sub root system of the parabolic
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2249:0.

isRoot(RootSystem,Weight) -- check whether a weight is a positive root
**********************************************************************

  * Function: isRoot,
  * Usage:
        isRoot(R,p)
  * Inputs:
      * R, an instance of the type RootSystem,
      * p, an instance of the type Weight,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if p is a root in R
        and false otherwise

Description
===========

+-------------------------+
|i1 : R=rootSystemE(6)    |
|                         |
|o1 = RootSystem{...8...} |
|                         |
|o1 : RootSystem          |
+-------------------------+
|i2 : p=simpleRoot(R,1)   |
|                         |
|o2 = |  2 |              |
|     |  0 |              |
|     | -1 |              |
|     |  0 |              |
|     |  0 |              |
|     |  0 |              |
|                         |
|       6                 |
|o2 : ZZ                  |
+-------------------------+
|i3 : isPositiveRoot(R,-p)|
|                         |
|o3 = false               |
+-------------------------+
|i4 : isRoot(R,-p)        |
|                         |
|o4 = true                |
+-------------------------+

Ways to use this method:
========================

  * isRoot(RootSystem,Weight) -- check
    whether a weight is a positive root
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2218:0.

listWeylGroupElements(RootSystem,ZZ) -- list all elements of a given length in a Weyl group
*******************************************************************************************

  * Function: listWeylGroupElements,
  * Usage:
        listWeylGroupElements(R,k)
  * Inputs:
      * R, an instance of the type RootSystem,
      * k, an integer (Macaulay2Doc),
  * Outputs:
      * a list (Macaulay2Doc), of all elements of length k in the
        Weyl group of R

Description
===========

+-----------------------------------------------------------------------------+
|i1 : listWeylGroupElements(rootSystemG2,4)                                   |
|                                                                             |
|o1 = {WeylGroupElement{RootSystem{...8...}, | -5 |},                         |
|                                            |  2 |                           |
|     ------------------------------------------------------------------------|
|     WeylGroupElement{RootSystem{...8...}, |  4 |}}                          |
|                                           | -3 |                            |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * listWeylGroupElements(RootSystem,ZZ)
    -- list all elements of a given
    length in a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2698:0.

loadHasseGraph(String) -- load a Hasse graph from a file
********************************************************

  * Function: loadHasseGraph,
  * Usage:
        loadHasseGraph(f)
  * Inputs:
      * f, a string (Macaulay2Doc), a file name

Description
===========

Will load a Hasse graph from the file f.

See also
========

  * storeHasseGraph(HasseGraph,String)
    -- store a Hasse graph in a file

Ways to use this method:
========================

  * loadHasseGraph(String) -- load a Hasse
    graph from a file
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4603:0.

longestWeylGroupElement(RootSystem) -- the longest element of the Weyl group of a root system
*********************************************************************************************

  * Function: longestWeylGroupElement,
  * Usage:
        longestWeylGroupElement(R)
  * Inputs:
      * R, an instance of the type RootSystem,
  * Outputs:
      * an instance of the type WeylGroupElement, the
        longest element of the Weyl group of R

Description
===========

+--------------------------------------------------+
|i1 : longestWeylGroupElement rootSystemF4         |
|                                                  |
|o1 = WeylGroupElement{RootSystem{...8...}, | -1 |}|
|                                           | -1 | |
|                                           | -1 | |
|                                           | -1 | |
|                                                  |
|o1 : WeylGroupElement                             |
+--------------------------------------------------+

Ways to use this method:
========================

  * longestWeylGroupElement(RootSystem)
    -- the longest element of the Weyl
    group of a root system
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2994:0.

longestWeylGroupElement(RootSystem,Parabolic) -- the longest element of a parabolic subgroup of the Weyl group of a root system
*******************************************************************************************************************************

  * Function: longestWeylGroupElement,
  * Usage:
        longestWeylGroupElement(R,P)
  * Inputs:
      * R, an instance of the type RootSystem,
      * P, an instance of the type Parabolic,
  * Outputs:
      * an instance of the type WeylGroupElement, the
        longest element of the parabolic sugroup of the Weyl group of R
        generated by the reflections in P

Description
===========

+-----------------------------------------------------+
|i1 : R=rootSystemF4;                                 |
+-----------------------------------------------------+
|i2 : longestWeylGroupElement(R,parabolic(R,set{1,2}))|
|                                                     |
|o2 = WeylGroupElement{RootSystem{...8...}, | -1 |}   |
|                                           | -1 |    |
|                                           |  5 |    |
|                                           |  1 |    |
|                                                     |
|o2 : WeylGroupElement                                |
+-----------------------------------------------------+

Ways to use this method:
========================

  * longestWeylGroupElement(RootSystem,Parabolic)
    -- the longest element
    of a parabolic subgroup of the Weyl group of a root system
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3017:0.

minimalRepresentative -- the minimal representative of a coset
**************************************************************

Ways to use minimalRepresentative:
==================================

  * minimalRepresentative(WeylGroupDoubleCoset)
    -- the minimal
    representative of a coset
  * minimalRepresentative(WeylGroupLeftCoset)
    -- the minimal
    representative of a coset
  * minimalRepresentative(WeylGroupRightCoset)
    -- the minimal
    representative of a coset

For the programmer
==================

The object minimalRepresentative, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3658:0.

minimalRepresentative(WeylGroupDoubleCoset) -- the minimal representative of a coset
************************************************************************************

  * Function: minimalRepresentative,
  * Usage:
        minimalRepresentative(c)
  * Inputs:
      * c, an instance of the type WeylGroupDoubleCoset,
  * Outputs:
      * an instance of the type WeylGroupElement, the
        representative of minimal length

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemF4                                                          |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{1,2,3})                                               |
|                                                                             |
|o2 = set {1, 2, 3}                                                           |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : c=P % (w % P)                                                           |
|                                                                             |
|o4 = WeylGroupDoubleCoset{set {1, 2, 3}, set {1, 2, 3},                      |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupDoubleCoset                                                    |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, |  1  |}}                              |
|                                      |  1  |                                |
|                                      |  1  |                                |
|                                      | -10 |                                |
+-----------------------------------------------------------------------------+
|i5 : minimalRepresentative c                                                 |
|                                                                             |
|o5 = WeylGroupElement{RootSystem{...8...}, |  1  |}                          |
|                                           |  1  |                           |
|                                           |  1  |                           |
|                                           | -10 |                           |
|                                                                             |
|o5 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * minimalRepresentative(WeylGroupDoubleCoset)
    -- the minimal
    representative of a coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3721:0.

minimalRepresentative(WeylGroupLeftCoset) -- the minimal representative of a coset
**********************************************************************************

  * Function: minimalRepresentative,
  * Usage:
        minimalRepresentative(c)
  * Inputs:
      * c, an instance of the type WeylGroupLeftCoset,
  * Outputs:
      * an instance of the type WeylGroupElement, the
        representative of minimal length

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemF4                                                          |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{1,2,3})                                               |
|                                                                             |
|o2 = set {1, 2, 3}                                                           |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : c=w % P                                                                 |
|                                                                             |
|o4 = WeylGroupLeftCoset{set {1, 2, 3}, WeylGroupElement{RootSystem{...8...}, |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupLeftCoset                                                      |
|-----------------------------------------------------------------------------|
||  1  |}}                                                                    |
||  1  |                                                                      |
||  1  |                                                                      |
|| -10 |                                                                      |
+-----------------------------------------------------------------------------+
|i5 : minimalRepresentative c                                                 |
|                                                                             |
|o5 = WeylGroupElement{RootSystem{...8...}, |  1  |}                          |
|                                           |  1  |                           |
|                                           |  1  |                           |
|                                           | -10 |                           |
|                                                                             |
|o5 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * minimalRepresentative(WeylGroupLeftCoset)
    -- the minimal
    representative of a coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3679:0.

minimalRepresentative(WeylGroupRightCoset) -- the minimal representative of a coset
***********************************************************************************

  * Function: minimalRepresentative,
  * Usage:
        minimalRepresentative(c)
  * Inputs:
      * c, an instance of the type WeylGroupRightCoset,
  * Outputs:
      * an instance of the type WeylGroupElement, the
        representative of minimal length

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemF4                                                          |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{1,2,3})                                               |
|                                                                             |
|o2 = set {1, 2, 3}                                                           |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : c=P % w                                                                 |
|                                                                             |
|o4 = WeylGroupRightCoset{set {1, 2, 3}, WeylGroupElement{RootSystem{...8...},|
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupRightCoset                                                     |
|-----------------------------------------------------------------------------|
||  1  |}}                                                                    |
||  1  |                                                                      |
||  1  |                                                                      |
|| -10 |                                                                      |
+-----------------------------------------------------------------------------+
|i5 : minimalRepresentative c                                                 |
|                                                                             |
|o5 = WeylGroupElement{RootSystem{...8...}, |  1  |}                          |
|                                           |  1  |                           |
|                                           |  1  |                           |
|                                           | -10 |                           |
|                                                                             |
|o5 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * minimalRepresentative(WeylGroupRightCoset)
    -- the minimal
    representative of a coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3700:0.

neutralWeylGroupElement(RootSystem) -- the neutral element of the Weyl group of a root system
*********************************************************************************************

  * Function: neutralWeylGroupElement,
  * Usage:
        neutralWeylGroupElement(R)
  * Inputs:
      * R, an instance of the type RootSystem,
  * Outputs:
      * an instance of the type WeylGroupElement, the
        neutral element of the Weyl group of R

Description
===========

+-------------------------------------------------+
|i1 : neutralWeylGroupElement rootSystemF4        |
|                                                 |
|o1 = WeylGroupElement{RootSystem{...8...}, | 1 |}|
|                                           | 1 | |
|                                           | 1 | |
|                                           | 1 | |
|                                                 |
|o1 : WeylGroupElement                            |
+-------------------------------------------------+

Ways to use this method:
========================

  * neutralWeylGroupElement(RootSystem)
    -- the neutral element of the Weyl
    group of a root system
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3046:0.

numberOfPositiveRoots(DynkinType) -- the number of positive roots
*****************************************************************

  * Function: numberOfPositiveRoots,
  * Usage:
        numberOfPositiveRoots(D)
  * Inputs:
      * D, an instance of the type DynkinType,
  * Outputs:
      * an integer (Macaulay2Doc), the number of positive roots of D

Description
===========

+----------------------------------+
|i1 : D=dynkinType{{"A",5},{"E",6}}|
|                                  |
|o1 = DynkinType{{A, 5}, {E, 6}}   |
|                                  |
|o1 : DynkinType                   |
+----------------------------------+
|i2 : numberOfPositiveRoots(D)     |
|                                  |
|o2 = 51                           |
+----------------------------------+

Ways to use this method:
========================

  * numberOfPositiveRoots(DynkinType)
    -- the number of positive roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2666:0.

numberOfPositiveRoots(RootSystem) -- the number of positive roots
*****************************************************************

  * Function: numberOfPositiveRoots,
  * Usage:
        numberOfPositiveRoots(R)
  * Inputs:
      * R, an instance of the type RootSystem,
  * Outputs:
      * an integer (Macaulay2Doc), the number of positive roots of R

Description
===========

+------------------------------------------+
|i1 : numberOfPositiveRoots(rootSystemD(4))|
|                                          |
|o1 = 12                                   |
+------------------------------------------+

Ways to use this method:
========================

  * numberOfPositiveRoots(RootSystem)
    -- the number of positive roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2648:0.

parabolic -- construct a parabolic
**********************************

Ways to use parabolic:
======================

  * parabolic(RootSystem,Set), --
    construct a parabolic from a set of simple roots
  * parabolic(WeylGroupDoubleCoset),
    -- the parabolic associated to a double coset

For the programmer
==================

The object parabolic, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3318:0.

Parabolic % WeylGroupElement -- the right coset defined by an element of Weyl group
***********************************************************************************

  * Operator: % (Macaulay2Doc),
  * Usage:
        P % w
  * Inputs:
      * P, an instance of the type Parabolic,
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * an instance of the type WeylGroupLeftCoset,
        W_Pw

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{2,3,4,5})                                             |
|                                                                             |
|o2 = set {2, 3, 4, 5}                                                        |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : P % w                                                                   |
|                                                                             |
|o4 = WeylGroupRightCoset{set {2, 3, 4, 5},                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupRightCoset                                                     |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * Parabolic % WeylGroupElement -- the
    right coset defined by an element of Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3560:0.

Parabolic % WeylGroupLeftCoset -- the double coset defined by a left coset
**************************************************************************

  * Operator: % (Macaulay2Doc),
  * Usage:
        P % c
  * Inputs:
      * P, an instance of the type Parabolic,
      * c, an instance of the type WeylGroupLeftCoset,
  * Outputs:
      * an instance of the type WeylGroupDoubleCoset,
        W_Pc

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{2,3,4,5})                                             |
|                                                                             |
|o2 = set {2, 3, 4, 5}                                                        |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : Q=parabolic(R,set{1,2,3,4})                                             |
|                                                                             |
|o3 = set {1, 2, 3, 4}                                                        |
|                                                                             |
|o3 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i4 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o4 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o4 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i5 : c = w % Q                                                               |
|                                                                             |
|o5 = WeylGroupLeftCoset{set {1, 2, 3, 4},                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o5 : WeylGroupLeftCoset                                                      |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, |  1 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      | -7 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i6 : P % c                                                                   |
|                                                                             |
|o6 = WeylGroupDoubleCoset{set {2, 3, 4, 5}, set {1, 2, 3, 4},                |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o6 : WeylGroupDoubleCoset                                                    |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -4 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  3 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * Parabolic % WeylGroupLeftCoset, --
    the double coset defined by a left coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3583:0.

Parabolic == Parabolic -- equality of parabolics
************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        P1 == P2
  * Inputs:
      * P1, an instance of the type Parabolic,
      * P2, an instance of the type Parabolic,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if the underlying
        sets are equal

Description
===========

+-----------------------------+
|i1 : R=rootSystemA(3)        |
|                             |
|o1 = RootSystem{...8...}     |
|                             |
|o1 : RootSystem              |
+-----------------------------+
|i2 : P1=parabolic(R,set{1,2})|
|                             |
|o2 = set {1, 2}              |
|                             |
|o2 : Parabolic               |
+-----------------------------+
|i3 : P2=parabolic(R,set{1,2})|
|                             |
|o3 = set {1, 2}              |
|                             |
|o3 : Parabolic               |
+-----------------------------+
|i4 : P1==P2                  |
|                             |
|o4 = true                    |
+-----------------------------+

Ways to use this method:
========================

  * Parabolic == Parabolic -- equality of
    parabolics
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3339:0.

parabolic(RootSystem,Set) -- construct a parabolic from a set of simple roots
*****************************************************************************

  * Function: parabolic,
  * Usage:
        parabolic(R,S)
  * Inputs:
      * R, an instance of the type RootSystem,
      * S, a set (Macaulay2Doc), the subsets of simple roots
        defining the standard parabolic
  * Outputs:
      * an instance of the type Parabolic, a standard
        parabolic subgroup represented by a set of simple roots

Description
===========

+---------------------------------------+
|i1 : parabolic(rootSystemA(5),set{1,2})|
|                                       |
|o1 = set {1, 2}                        |
|                                       |
|o1 : Parabolic                         |
+---------------------------------------+

Ways to use this method:
========================

  * parabolic(RootSystem,Set), --
    construct a parabolic from a set of simple roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3358:0.

parabolic(WeylGroupDoubleCoset) -- the parabolic associated to a double coset
*****************************************************************************

  * Function: parabolic,
  * Usage:
        parabolic(d)
  * Inputs:
      * d, an instance of the type WeylGroupDoubleCoset,
  * Outputs:
      * an instance of the type Parabolic, a standard
        parabolic subgroup corresponding to the coset d as in Carter, Finite
        Groups of Lie Type, p. 65, thm 2.7.4.

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(4)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{1,2,4})                                               |
|                                                                             |
|o2 = set {4, 1, 2}                                                           |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=reduce(R,{3,2,4,3})                                                   |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, |  3 |}                           |
|                                           |  1 |                            |
|                                           | -3 |                            |
|                                           |  1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : d= P % w % P                                                            |
|                                                                             |
|o4 = WeylGroupDoubleCoset{set {4, 1, 2}, set {4, 1, 2},                      |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupDoubleCoset                                                    |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, |  3 |}}                               |
|                                      |  1 |                                 |
|                                      | -3 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i5 : parabolic(d)                                                            |
|                                                                             |
|o5 = set {4, 2}                                                              |
|                                                                             |
|o5 : Parabolic                                                               |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * parabolic(WeylGroupDoubleCoset),
    -- the parabolic associated to a double coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3383:0.

poincareSeries -- a generating series for number of elements in a Weyl group
****************************************************************************

Ways to use poincareSeries:
===========================

  * poincareSeries(HasseDiagram,RingElement)
    -- the generating series of
    a Hasse diagram
  * poincareSeries(RootSystem,Parabolic,RingElement)
    -- the generating
    series of a quotient of the Weyl group by length
  * poincareSeries(RootSystem,RingElement)
    -- the generating series of
    the Weyl group by length

For the programmer
==================

The object poincareSeries, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4115:0.

poincareSeries(HasseDiagram,RingElement) -- the generating series of a Hasse diagram
************************************************************************************

  * Function: poincareSeries,
  * Usage:
        poincareSeries(H,x)
  * Inputs:
      * H, an instance of the type HasseDiagram,
      * x, a ring element (Macaulay2Doc),
  * Outputs:
      * a ring element (Macaulay2Doc), a polynomial in the
        variable x where the coefficient in front of x^i is the number of
        elements in the i-th row of H (counting from 0).

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(2)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : H=intervalBruhat(neutralWeylGroupElement R, longestWeylGroupElement R)  |
|                                                                             |
|o2 = HasseDiagram{{{WeylGroupElement{RootSystem{...8...}, | -1 |}, {{0, | -1 |
|                                                          | -1 |        |  2 |
|                                                                             |
|o2 : HasseDiagram                                                            |
|-----------------------------------------------------------------------------|
||}, {1, |  2 |}}}}, {{WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0, | 1|
||       | -1 |                                              | -2 |        | 1|
|-----------------------------------------------------------------------------|
||}, {1, |  2 |}}}, {WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, | -1 |
||       | -1 |                                            |  1 |        |  2 |
|-----------------------------------------------------------------------------|
||}, {1, | 1 |}}}}, {{WeylGroupElement{RootSystem{...8...}, | -1 |}, {{0, |  2|
||       | 1 |                                              |  2 |        | -1|
|-----------------------------------------------------------------------------|
||}}}, {WeylGroupElement{RootSystem{...8...}, |  2 |}, {{0, | -1 |}}}},       |
||                                            | -1 |        |  2 |            |
|-----------------------------------------------------------------------------|
|{{WeylGroupElement{RootSystem{...8...}, | 1 |}, {}}}}                        |
|                                        | 1 |                                |
+-----------------------------------------------------------------------------+
|i3 : ZZ[x]                                                                   |
|                                                                             |
|o3 = ZZ[x]                                                                   |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : poincareSeries(H,x)                                                     |
|                                                                             |
|      3     2                                                                |
|o4 = x  + 2x  + 2x + 1                                                       |
|                                                                             |
|o4 : ZZ[x]                                                                   |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * poincareSeries(HasseDiagram,RingElement)
    -- the generating series of
    a Hasse diagram
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4186:0.

poincareSeries(RootSystem,Parabolic,RingElement) -- the generating series of a quotient of the Weyl group by length
*******************************************************************************************************************

  * Function: poincareSeries,
  * Usage:
        poincareSeries(R,P,x)
  * Inputs:
      * R, an instance of the type RootSystem,
      * P, an instance of the type Parabolic,
      * x, a ring element (Macaulay2Doc),
  * Outputs:
      * a ring element (Macaulay2Doc), a polynomial in the
        variable x where the coefficient in front of x^i is the number of
        cosets in the Weyl group of R modulo the Weyl group of P where the
        minimal element is of length i.

Description
===========

+----------------------------+
|i1 : R=rootSystemA(3)       |
|                            |
|o1 = RootSystem{...8...}    |
|                            |
|o1 : RootSystem             |
+----------------------------+
|i2 : P=parabolic(R,set{1,2})|
|                            |
|o2 = set {1, 2}             |
|                            |
|o2 : Parabolic              |
+----------------------------+
|i3 : ZZ[x]                  |
|                            |
|o3 = ZZ[x]                  |
|                            |
|o3 : PolynomialRing         |
+----------------------------+
|i4 : poincareSeries(R,P,x)  |
|                            |
|      3    2                |
|o4 = x  + x  + x + 1        |
|                            |
|o4 : ZZ[x]                  |
+----------------------------+

Ways to use this method:
========================

  * poincareSeries(RootSystem,Parabolic,RingElement)
    -- the generating
    series of a quotient of the Weyl group by length
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4157:0.

poincareSeries(RootSystem,RingElement) -- the generating series of the Weyl group by length
*******************************************************************************************

  * Function: poincareSeries,
  * Usage:
        poincareSeries(R,x)
  * Inputs:
      * R, an instance of the type RootSystem,
      * x, a ring element (Macaulay2Doc),
  * Outputs:
      * a ring element (Macaulay2Doc), a polynomial in the
        variable x where the coefficient in front of x^i is the number of
        elements in the Weyl group of R of length i.

Description
===========

+------------------------+
|i1 : R=rootSystemA(2)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : ZZ[x]              |
|                        |
|o2 = ZZ[x]              |
|                        |
|o2 : PolynomialRing     |
+------------------------+
|i3 : poincareSeries(R,x)|
|                        |
|      3     2           |
|o3 = x  + 2x  + 2x + 1  |
|                        |
|o3 : ZZ[x]              |
+------------------------+

Ways to use this method:
========================

  * poincareSeries(RootSystem,RingElement)
    -- the generating series of
    the Weyl group by length
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4135:0.

positiveRoots(RootSystem) -- the set of all positive roots
**********************************************************

  * Function: positiveRoots,
  * Usage:
        positiveRoots(R)
  * Inputs:
      * R, an instance of the type RootSystem,
  * Outputs:
      * a set (Macaulay2Doc), of all positive roots of R

Description
===========

+--------------------------------------------------------+
|i1 : positiveRoots(rootSystemA(3))                      |
|                                                        |
|o1 = set {| 1 |, |  1 |, |  2 |, |  0 |, | -1 |, | -1 |}|
|          | 0 |  |  1 |  | -1 |  | -1 |  |  1 |  |  2 | |
|          | 1 |  | -1 |  |  0 |  |  2 |  |  1 |  | -1 | |
|                                                        |
|o1 : Set                                                |
+--------------------------------------------------------+

Ways to use this method:
========================

  * positiveRoots(RootSystem) -- the set
    of all positive roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2604:0.

positiveRoots(RootSystem,Parabolic) -- the set of all positive roots in a parabolic sugroups
********************************************************************************************

  * Function: positiveRoots,
  * Usage:
        positiveRoots(R,P)
  * Inputs:
      * R, an instance of the type RootSystem,
      * P, an instance of the type Parabolic,
  * Outputs:
      * a set (Macaulay2Doc), of all positive roots of R that are
        written as sums of roots corresponding to reflexions in P

Description
===========

+---------------------------------+
|i1 : R=rootSystemA(4)            |
|                                 |
|o1 = RootSystem{...8...}         |
|                                 |
|o1 : RootSystem                  |
+---------------------------------+
|i2 : P=parabolic(R,set{1,2})     |
|                                 |
|o2 = set {1, 2}                  |
|                                 |
|o2 : Parabolic                   |
+---------------------------------+
|i3 : positiveRoots(R,P)          |
|                                 |
|o3 = set {| -1 |, |  1 |, |  2 |}|
|          |  2 |  |  1 |  | -1 | |
|          | -1 |  | -1 |  |  0 | |
|          |  0 |  |  0 |  |  0 | |
|                                 |
|o3 : Set                         |
+---------------------------------+

Ways to use this method:
========================

  * positiveRoots(RootSystem,Parabolic)
    -- the set of all positive roots
    in a parabolic sugroups
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2624:0.

rank(DynkinDiagram) -- the rank of a Dynkin diagram
***************************************************

  * Function: rank (Macaulay2Doc),
  * Usage:
        rank(D)
  * Inputs:
      * D, an instance of the type DynkinDiagram,
  * Outputs:
      * an integer (Macaulay2Doc), the number of vertices of the
        Dynkin diagram D

Description
===========

+------------------------+
|i1 : R=rootSystemE(6)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : D=dynkinDiagram(R);|
+------------------------+
|i3 : rank(D)            |
|                        |
|o3 = 6                  |
+------------------------+

Ways to use this method:
========================

  * rank(DynkinDiagram) -- the rank of a Dynkin
    diagram
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4212:0.

reduce(RootSystem,BasicList) -- the product of several reflections with respect to simple roots
***********************************************************************************************

  * Function: reduce,
  * Usage:
        reduce(R,L)
  * Inputs:
      * R, an instance of the type RootSystem,
      * L, a basic list (Macaulay2Doc),
  * Outputs:
      * an instance of the type WeylGroupElement,
        s_{L_0}...s_{L_{\#L-1}}

Description
===========

+--------------------------------------------------+
|i1 : reduce(rootSystemF4,{1,2,3,4})               |
|                                                  |
|o1 = WeylGroupElement{RootSystem{...8...}, | -4 |}|
|                                           |  1 | |
|                                           |  4 | |
|                                           |  1 | |
|                                                  |
|o1 : WeylGroupElement                             |
+--------------------------------------------------+

Ways to use this method:
========================

  * reduce(RootSystem,BasicList), --
    the product of several reflections with respect to simple roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3075:0.

reducedDecomposition(WeylGroupElement) -- the reduced decomposition of an element of a Weyl group
*************************************************************************************************

  * Function: reducedDecomposition,
  * Usage:
        reducedDecomposition(w)
  * Inputs:
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * a list (Macaulay2Doc), the lexicographically least reduced
        decomposition of w

Description
===========

+-----------------------------------------------------------------------------+
|i1 : reducedDecomposition longestWeylGroupElement rootSystemF4               |
|                                                                             |
|o1 = {1, 2, 1, 3, 2, 1, 3, 2, 3, 4, 3, 2, 1, 3, 2, 3, 4, 3, 2, 1, 3, 2, 3, 4}|
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * reducedDecomposition(WeylGroupElement)
    -- the reduced decomposition of
    an element of a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3104:0.

reflect -- apply the reflection with respect to a root
******************************************************

Ways to use reflect:
====================

  * reflect(RootSystem,BasicList,Root)
    -- apply to a root several
    reflections with respect to simple roots
  * reflect(RootSystem,BasicList,Weight)
    -- apply to a weight several
    reflections with respect to roots
  * reflect(RootSystem,ZZ,Root), --
    apply to a root the reflection with respect to a simple root
  * reflect(RootSystem,ZZ,Weight),
    -- apply to a weight the reflection with respect to a root

For the programmer
==================

The object reflect, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2709:0.

reflect(RootSystem,BasicList,Root) -- apply to a root several reflections with respect to simple roots
******************************************************************************************************

  * Function: reflect,
  * Usage:
        reflect(R,L,r)
  * Inputs:
      * R, an instance of the type RootSystem,
      * L, a basic list (Macaulay2Doc),
      * r, an instance of the type Root,
  * Outputs:
      * an instance of the type Weight,
        s_{L_0}...s_{L_{\#L-1}}(r)

Description
===========

+---------------------------+
|i1 : R = rootSystemB(4)    |
|                           |
|o1 = RootSystem{...8...}   |
|                           |
|o1 : RootSystem            |
+---------------------------+
|i2 : r = simpleRoot(R,3)   |
|                           |
|o2 = |  0 |                |
|     | -1 |                |
|     |  2 |                |
|     | -2 |                |
|                           |
|       4                   |
|o2 : ZZ                    |
+---------------------------+
|i3 : reflect(R,{1,2,3,4},r)|
|                           |
|o3 = |  1 |                |
|     |  0 |                |
|     | -1 |                |
|     |  2 |                |
|                           |
|       4                   |
|o3 : ZZ                    |
+---------------------------+

Ways to use this method:
========================

  * reflect(RootSystem,BasicList,Root)
    -- apply to a root several
    reflections with respect to simple roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2793:0.

reflect(RootSystem,BasicList,Weight) -- apply to a weight several reflections with respect to roots
***************************************************************************************************

  * Function: reflect,
  * Usage:
        reflect(R,L,p)
  * Inputs:
      * R, an instance of the type RootSystem,
      * L, a basic list (Macaulay2Doc),
      * p, an instance of the type Weight,
  * Outputs:
      * an instance of the type Weight,
        s_{L_0}...s_{L_{\#L-1}}(p)

Description
===========

+---------------------------+
|i1 : R = rootSystemB(4)    |
|                           |
|o1 = RootSystem{...8...}   |
|                           |
|o1 : RootSystem            |
+---------------------------+
|i2 : p = halfSumOfRoots(R) |
|                           |
|o2 = | 1 |                 |
|     | 1 |                 |
|     | 1 |                 |
|     | 1 |                 |
|                           |
|       4                   |
|o2 : ZZ                    |
+---------------------------+
|i3 : reflect(R,{1,2,3,4},p)|
|                           |
|o3 = | -4 |                |
|     |  1 |                |
|     |  1 |                |
|     |  3 |                |
|                           |
|       4                   |
|o3 : ZZ                    |
+---------------------------+

Ways to use this method:
========================

  * reflect(RootSystem,BasicList,Weight)
    -- apply to a weight several
    reflections with respect to roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2751:0.

reflect(RootSystem,ZZ,Root) -- apply to a root the reflection with respect to a simple root
*******************************************************************************************

  * Function: reflect,
  * Usage:
        reflect(R,i,r)
  * Inputs:
      * R, an instance of the type RootSystem,
      * i, an integer (Macaulay2Doc),
      * r, an instance of the type Root,
  * Outputs:
      * an instance of the type Weight, s_i(r)

Description
===========

+------------------------+
|i1 : R = rootSystemB(4) |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : r = simpleRoot(R,3)|
|                        |
|o2 = |  0 |             |
|     | -1 |             |
|     |  2 |             |
|     | -2 |             |
|                        |
|       4                |
|o2 : ZZ                 |
+------------------------+
|i3 : reflect(R,4,r)     |
|                        |
|o3 = |  0 |             |
|     | -1 |             |
|     |  0 |             |
|     |  2 |             |
|                        |
|       4                |
|o3 : ZZ                 |
+------------------------+

Ways to use this method:
========================

  * reflect(RootSystem,ZZ,Root), --
    apply to a root the reflection with respect to a simple root
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2772:0.

reflect(RootSystem,ZZ,Weight) -- apply to a weight the reflection with respect to a root
****************************************************************************************

  * Function: reflect,
  * Usage:
        reflect(R,i,p)
  * Inputs:
      * R, an instance of the type RootSystem,
      * i, an integer (Macaulay2Doc),
      * p, an instance of the type Weight,
  * Outputs:
      * an instance of the type Weight, s_i(p)

Description
===========

+--------------------------+
|i1 : R = rootSystemB(4)   |
|                          |
|o1 = RootSystem{...8...}  |
|                          |
|o1 : RootSystem           |
+--------------------------+
|i2 : p = halfSumOfRoots(R)|
|                          |
|o2 = | 1 |                |
|     | 1 |                |
|     | 1 |                |
|     | 1 |                |
|                          |
|       4                  |
|o2 : ZZ                   |
+--------------------------+
|i3 : reflect(R,4,p)       |
|                          |
|o3 = |  1 |               |
|     |  1 |               |
|     |  2 |               |
|     | -1 |               |
|                          |
|       4                  |
|o3 : ZZ                   |
+--------------------------+

Ways to use this method:
========================

  * reflect(RootSystem,ZZ,Weight),
    -- apply to a weight the reflection with respect to a root
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2730:0.

reflection(RootSystem,Root) -- the reflection with respect to a root
********************************************************************

  * Function: reflection,
  * Usage:
        reflection(R,r)
  * Inputs:
      * R, an instance of the type RootSystem,
      * r, an instance of the type Root,
  * Outputs:
      * an instance of the type WeylGroupElement, the
        reflection with respect to r

Description
===========

+--------------------------------------------------+
|i1 : R=rootSystemE(8)                             |
|                                                  |
|o1 = RootSystem{...8...}                          |
|                                                  |
|o1 : RootSystem                                   |
+--------------------------------------------------+
|i2 : r=addRoots(R,simpleRoot(R,1),simpleRoot(R,3))|
|                                                  |
|o2 = |  1 |                                       |
|     |  0 |                                       |
|     |  1 |                                       |
|     | -1 |                                       |
|     |  0 |                                       |
|     |  0 |                                       |
|     |  0 |                                       |
|     |  0 |                                       |
|                                                  |
|       8                                          |
|o2 : ZZ                                           |
+--------------------------------------------------+
|i3 : reflection(R,r)                              |
|                                                  |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}|
|                                           |  1 | |
|                                           | -1 | |
|                                           |  3 | |
|                                           |  1 | |
|                                           |  1 | |
|                                           |  1 | |
|                                           |  1 | |
|                                                  |
|o3 : WeylGroupElement                             |
+--------------------------------------------------+

Ways to use this method:
========================

  * reflection(RootSystem,Root), --
    the reflection with respect to a root
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3231:0.

rootCoefficients(RootSystem,Root) -- the coefficients at the simple roots
*************************************************************************

  * Function: rootCoefficients,
  * Usage:
        rootCoefficients(R,r)
  * Inputs:
      * R, an instance of the type RootSystem,
      * r, an instance of the type Root,
  * Outputs:
      * a vector (Macaulay2Doc), whose components are the
        coefficients of r at the simple roots of R

Description
===========

+------------------------------+
|i1 : R=rootSystemE(8)         |
|                              |
|o1 = RootSystem{...8...}      |
|                              |
|o1 : RootSystem               |
+------------------------------+
|i2 : r1=simpleRoot(R,1)       |
|                              |
|o2 = |  2 |                   |
|     |  0 |                   |
|     | -1 |                   |
|     |  0 |                   |
|     |  0 |                   |
|     |  0 |                   |
|     |  0 |                   |
|     |  0 |                   |
|                              |
|       8                      |
|o2 : ZZ                       |
+------------------------------+
|i3 : r2=simpleRoot(R,2)       |
|                              |
|o3 = |  0 |                   |
|     |  2 |                   |
|     |  0 |                   |
|     | -1 |                   |
|     |  0 |                   |
|     |  0 |                   |
|     |  0 |                   |
|     |  0 |                   |
|                              |
|       8                      |
|o3 : ZZ                       |
+------------------------------+
|i4 : rootCoefficients(R,r1+r2)|
|                              |
|o4 = | 1 |                    |
|     | 1 |                    |
|     | 0 |                    |
|     | 0 |                    |
|     | 0 |                    |
|     | 0 |                    |
|     | 0 |                    |
|     | 0 |                    |
|                              |
|       8                      |
|o4 : QQ                       |
+------------------------------+

Ways to use this method:
========================

  * rootCoefficients(RootSystem,Root)
    -- the coefficients at the simple
    roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2553:0.

rootCoefficients(RootSystem,Weight) -- the coefficients at the simple roots
***************************************************************************

  * Function: rootCoefficients,
  * Usage:
        rootCoefficients(R,p)
  * Inputs:
      * R, an instance of the type RootSystem,
      * p, an instance of the type Weight,
  * Outputs:
      * a vector (Macaulay2Doc), whose components are the
        coefficients of p at the simple roots of R

Description
===========

+------------------------------------------+
|i1 : R=rootSystemE(6)                     |
|                                          |
|o1 = RootSystem{...8...}                  |
|                                          |
|o1 : RootSystem                           |
+------------------------------------------+
|i2 : rootCoefficients(R,halfSumOfRoots(R))|
|                                          |
|o2 = |  8 |                               |
|     | 11 |                               |
|     | 15 |                               |
|     | 21 |                               |
|     | 15 |                               |
|     |  8 |                               |
|                                          |
|       6                                  |
|o2 : QQ                                   |
+------------------------------------------+

Ways to use this method:
========================

  * rootCoefficients(RootSystem,Weight)
    -- the coefficients at the
    simple roots
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2572:0.

RootSystem ++ RootSystem -- the direct sum of root systems
**********************************************************

  * Operator: ++ (Macaulay2Doc),
  * Usage:
        R1 ++ R2
  * Inputs:
      * R1, an instance of the type RootSystem,
      * R2, an instance of the type RootSystem,
  * Outputs:
      * an instance of the type RootSystem, the direct sum
        of R1 and R2

Description
===========

+------------------------+
|i1 : R1=rootSystemA(2)  |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : R2=rootSystemA(3)  |
|                        |
|o2 = RootSystem{...8...}|
|                        |
|o2 : RootSystem         |
+------------------------+
|i3 : R1++R2             |
|                        |
|o3 = RootSystem{...8...}|
|                        |
|o3 : RootSystem         |
+------------------------+

Ways to use this method:
========================

  * RootSystem ++ RootSystem -- the direct sum
    of root systems
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1651:0.

RootSystem == RootSystem -- equality of root systems
****************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        R1 == R2
  * Inputs:
      * R1, an instance of the type RootSystem,
      * R2, an instance of the type RootSystem,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if the Cartan
        matrices of R1 and R2 coincide and false otherwise

Description
===========

+------------------------+
|i1 : R1=rootSystemA(2)  |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : R2=rootSystemA(2)  |
|                        |
|o2 = RootSystem{...8...}|
|                        |
|o2 : RootSystem         |
+------------------------+
|i3 : R1==R2             |
|                        |
|o3 = true               |
+------------------------+

Ways to use this method:
========================

  * RootSystem == RootSystem -- equality of
    root systems
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1671:0.

rootSystemF4 -- the root system of type F4
******************************************

For the programmer
==================

The object rootSystemF4, is an instance of the type
RootSystem.

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1765:0.

rootSystemG2 -- the root system of type G2
******************************************

For the programmer
==================

The object rootSystemG2, is an instance of the type
RootSystem.

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1772:0.

scalarProduct -- compute a scalar product (invariant by the Weyl group)
***********************************************************************

Ways to use scalarProduct:
==========================

  * scalarProduct(RootSystem,Weight,Weight)
    -- the scalar product of
    two weights
  * scalarProduct(RootSystem,ZZ,Weight)
    -- the scalar product of a
    fundamental weight and a weight
  * scalarProduct(RootSystem,ZZ,ZZ)
    -- the scalar product of two
    fundamental weights

For the programmer
==================

The object scalarProduct, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2312:0.

scalarProduct(RootSystem,Weight,Weight) -- the scalar product of two weights
****************************************************************************

  * Function: scalarProduct,
  * Usage:
        scalarProduct(R,u,v)
  * Inputs:
      * R, an instance of the type RootSystem,
      * u, an instance of the type Weight, the first weight
      * v, an instance of the type Weight, the second weight
  * Outputs:
      * a rational number (Macaulay2Doc), the scalar product of u and
        v

Description
===========

+-------------------------+
|i1 : R=rootSystemA(2)    |
|                         |
|o1 = RootSystem{...8...} |
|                         |
|o1 : RootSystem          |
+-------------------------+
|i2 : u=weight(R,{1,2})   |
|                         |
|o2 = | 1 |               |
|     | 2 |               |
|                         |
|       2                 |
|o2 : ZZ                  |
+-------------------------+
|i3 : v=weight(R,{0,3})   |
|                         |
|o3 = | 0 |               |
|     | 3 |               |
|                         |
|       2                 |
|o3 : ZZ                  |
+-------------------------+
|i4 : scalarProduct(R,u,v)|
|                         |
|     5                   |
|o4 = -                   |
|     2                   |
|                         |
|o4 : QQ                  |
+-------------------------+

Ways to use this method:
========================

  * scalarProduct(RootSystem,Weight,Weight)
    -- the scalar product of
    two weights
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2393:0.

scalarProduct(RootSystem,ZZ,Weight) -- the scalar product of a fundamental weight and a weight
**********************************************************************************************

  * Function: scalarProduct,
  * Usage:
        scalarProduct(R,i,v)
  * Inputs:
      * R, an instance of the type RootSystem,
      * i, an integer (Macaulay2Doc), the number of the fundamental
        weight
      * v, an instance of the type Weight, the other weight
  * Outputs:
      * a rational number (Macaulay2Doc), the scalar product of the
        i-th fundamental weight with the weight v

Description
===========

+-------------------------+
|i1 : R=rootSystemA(2)    |
|                         |
|o1 = RootSystem{...8...} |
|                         |
|o1 : RootSystem          |
+-------------------------+
|i2 : v=weight(R,{1,2})   |
|                         |
|o2 = | 1 |               |
|     | 2 |               |
|                         |
|       2                 |
|o2 : ZZ                  |
+-------------------------+
|i3 : scalarProduct(R,1,v)|
|                         |
|     2                   |
|o3 = -                   |
|     3                   |
|                         |
|o3 : QQ                  |
+-------------------------+

Ways to use this method:
========================

  * scalarProduct(RootSystem,ZZ,Weight)
    -- the scalar product of a
    fundamental weight and a weight
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2363:0.

scalarProduct(RootSystem,ZZ,ZZ) -- the scalar product of two fundamental weights
********************************************************************************

  * Function: scalarProduct,
  * Usage:
        scalarProduct(R,i,j)
  * Inputs:
      * R, an instance of the type RootSystem,
      * i, an integer (Macaulay2Doc), the number of the first
        fundamental weight
      * j, an integer (Macaulay2Doc), the number of the second
        fundamental weight
  * Outputs:
      * a rational number (Macaulay2Doc), the scalar product of the
        i-th fundamental weight with the j-th

Description
===========

+-------------------------+
|i1 : R=rootSystemA(2)    |
|                         |
|o1 = RootSystem{...8...} |
|                         |
|o1 : RootSystem          |
+-------------------------+
|i2 : scalarProduct(R,1,1)|
|                         |
|     1                   |
|o2 = -                   |
|     3                   |
|                         |
|o2 : QQ                  |
+-------------------------+
|i3 : scalarProduct(R,1,2)|
|                         |
|     1                   |
|o3 = -                   |
|     6                   |
|                         |
|o3 : QQ                  |
+-------------------------+
|i4 : scalarProduct(R,2,2)|
|                         |
|     1                   |
|o4 = -                   |
|     3                   |
|                         |
|o4 : QQ                  |
+-------------------------+

Ways to use this method:
========================

  * scalarProduct(RootSystem,ZZ,ZZ)
    -- the scalar product of two
    fundamental weights
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2336:0.

simpleRoot(RootSystem,ZZ) -- the n-th simple root
*************************************************

  * Function: simpleRoot,
  * Usage:
        simpleRoot(R,n)
  * Inputs:
      * R, an instance of the type RootSystem,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type Root, the n-th simple root of R

Description
===========

+---------------------------------+
|i1 : simpleRoot(rootSystemE(6),2)|
|                                 |
|o1 = |  0 |                      |
|     |  2 |                      |
|     |  0 |                      |
|     | -1 |                      |
|     |  0 |                      |
|     |  0 |                      |
|                                 |
|       6                         |
|o1 : ZZ                          |
+---------------------------------+

Ways to use this method:
========================

  * simpleRoot(RootSystem,ZZ) -- the
    n-th simple root
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2283:0.

storeHasseGraph(HasseGraph,String) -- store a Hasse graph in a file
*******************************************************************

  * Function: storeHasseGraph,
  * Usage:
        storeHasseGraph(H,f)
  * Inputs:
      * H, an instance of the type HasseGraph,
      * f, a string (Macaulay2Doc), a file name

Description
===========

Will store the Hasse graph H in the file f so that it can be retrieved later
with "loadHasseGraph".

See also
========

  * loadHasseGraph(String) -- load a Hasse
    graph from a file

Ways to use this method:
========================

  * storeHasseGraph(HasseGraph,String)
    -- store a Hasse graph in a file
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4579:0.

underBruhat(BasicList) -- Weyl group elements just under the ones in the list for the Bruhat order
**************************************************************************************************

  * Function: underBruhat,
  * Usage:
        underBruhat(B)
  * Inputs:
      * B, a basic list (Macaulay2Doc), of WeylGroupElement
  * Outputs:
      * a list (Macaulay2Doc), of elements smaller than the ones in
        B and of length one less together with the root of the reflection
        composed with (on the right) to obtain the element

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(3)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : L=underBruhat(longestWeylGroupElement(R))                               |
|                                                                             |
|o2 = {{WeylGroupElement{RootSystem{...8...}, | -1 |}, |  2 |},               |
|                                             | -2 |   | -1 |                 |
|                                             |  1 |   |  0 |                 |
|     ------------------------------------------------------------------------|
|     {WeylGroupElement{RootSystem{...8...}, | -2 |}, | -1 |},                |
|                                            |  1 |   |  2 |                  |
|                                            | -2 |   | -1 |                  |
|     ------------------------------------------------------------------------|
|     {WeylGroupElement{RootSystem{...8...}, |  1 |}, |  0 |}}                |
|                                            | -2 |   | -1 |                  |
|                                            | -1 |   |  2 |                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : L1=apply(L,x->x#0)                                                      |
|                                                                             |
|o3 = {WeylGroupElement{RootSystem{...8...}, | -1 |},                         |
|                                            | -2 |                           |
|                                            |  1 |                           |
|     ------------------------------------------------------------------------|
|     WeylGroupElement{RootSystem{...8...}, | -2 |},                          |
|                                           |  1 |                            |
|                                           | -2 |                            |
|     ------------------------------------------------------------------------|
|     WeylGroupElement{RootSystem{...8...}, |  1 |}}                          |
|                                           | -2 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : underBruhat(L1)                                                         |
|                                                                             |
|o4 = {{WeylGroupElement{RootSystem{...8...}, |  1 |}, {{0, |  0 |}, {2, |  2 |
|                                             | -3 |        | -1 |       | -1 |
|                                             |  1 |        |  2 |       |  0 |
|     ------------------------------------------------------------------------|
|     |}}}, {WeylGroupElement{RootSystem{...8...}, |  2 |}, {{1, | -1 |}, {2, |
|     |                                            | -1 |        |  1 |       |
|     |                                            | -2 |        |  1 |       |
|     ------------------------------------------------------------------------|
|     | -1 |}}}, {WeylGroupElement{RootSystem{...8...}, | -3 |}, {{0, |  1 |},|
|     |  2 |                                            |  2 |        |  1 |  |
|     | -1 |                                            | -1 |        | -1 |  |
|     ------------------------------------------------------------------------|
|     {1, |  2 |}}}, {WeylGroupElement{RootSystem{...8...}, | -2 |}, {{0, | -1|
|         | -1 |                                            | -1 |        |  2|
|         |  0 |                                            |  2 |        | -1|
|     ------------------------------------------------------------------------|
|     |}, {1, |  1 |}}}, {WeylGroupElement{RootSystem{...8...}, | -1 |}, {{1, |
|     |       |  1 |                                            |  2 |        |
|     |       | -1 |                                            | -3 |        |
|     ------------------------------------------------------------------------|
|     |  0 |}, {2, | -1 |}}}}                                                 |
|     | -1 |       |  1 |                                                     |
|     |  2 |       |  1 |                                                     |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * underBruhat(BasicList) -- Weyl group
    elements just under the ones in the list for the Bruhat order
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4302:0.

underBruhat(WeylGroupElement) -- Weyl group elements just under a given one for the Bruhat order
************************************************************************************************

  * Function: underBruhat,
  * Usage:
        underBruhat(w)
  * Inputs:
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * a list (Macaulay2Doc), of elements smaller than w and of
        length one less together with the root whose reflection is composed
        with w (on the right) to obtain the element

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemA(3)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : L=underBruhat(longestWeylGroupElement(R))                               |
|                                                                             |
|o2 = {{WeylGroupElement{RootSystem{...8...}, | -1 |}, |  2 |},               |
|                                             | -2 |   | -1 |                 |
|                                             |  1 |   |  0 |                 |
|     ------------------------------------------------------------------------|
|     {WeylGroupElement{RootSystem{...8...}, | -2 |}, | -1 |},                |
|                                            |  1 |   |  2 |                  |
|                                            | -2 |   | -1 |                  |
|     ------------------------------------------------------------------------|
|     {WeylGroupElement{RootSystem{...8...}, |  1 |}, |  0 |}}                |
|                                            | -2 |   | -1 |                  |
|                                            | -1 |   |  2 |                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : apply(L,x->reducedDecomposition (x#0))                                  |
|                                                                             |
|o3 = {{1, 2, 1, 3, 2}, {1, 2, 3, 2, 1}, {2, 1, 3, 2, 1}}                     |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * underBruhat(WeylGroupElement), --
    Weyl group elements just under a given one for the Bruhat order
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:4281:0.

Weight + Weight -- the sum of two weights
*****************************************

  * Operator: + (Macaulay2Doc),
  * Usage:
        p1 + p2
  * Inputs:
      * p1, an instance of the type Weight,
      * p2, an instance of the type Weight,
  * Outputs:
      * an instance of the type Weight, the sum of p1 and p2

Description
===========

+------------------------+
|i1 : R=rootSystemA(4)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : M=cartanMatrix R   |
|                        |
|o2 = | 2  -1 0  0  |    |
|     | -1 2  -1 0  |    |
|     | 0  -1 2  -1 |    |
|     | 0  0  -1 2  |    |
|                        |
|              4       4 |
|o2 : Matrix ZZ  <-- ZZ  |
+------------------------+
|i3 : p1=weight(R,M_0)   |
|                        |
|o3 = |  2 |             |
|     | -1 |             |
|     |  0 |             |
|     |  0 |             |
|                        |
|       4                |
|o3 : ZZ                 |
+------------------------+
|i4 : p2=weight(R,M_1)   |
|                        |
|o4 = | -1 |             |
|     |  2 |             |
|     | -1 |             |
|     |  0 |             |
|                        |
|       4                |
|o4 : ZZ                 |
+------------------------+
|i5 : p1+p2              |
|                        |
|o5 = |  1 |             |
|     |  1 |             |
|     | -1 |             |
|     |  0 |             |
|                        |
|       4                |
|o5 : ZZ                 |
+------------------------+

Ways to use this method:
========================

  * Weight + Weight -- the sum of two weights
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1893:0.

Weight - Weight -- the difference of two weights
************************************************

  * Operator: - (Macaulay2Doc),
  * Usage:
        p1 - p2
  * Inputs:
      * p1, an instance of the type Weight,
      * p2, an instance of the type Weight,
  * Outputs:
      * an instance of the type Weight, the difference of p1 and
        p2

Description
===========

+------------------------+
|i1 : R=rootSystemA(4)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : M=cartanMatrix R   |
|                        |
|o2 = | 2  -1 0  0  |    |
|     | -1 2  -1 0  |    |
|     | 0  -1 2  -1 |    |
|     | 0  0  -1 2  |    |
|                        |
|              4       4 |
|o2 : Matrix ZZ  <-- ZZ  |
+------------------------+
|i3 : p1=weight(R,M_0)   |
|                        |
|o3 = |  2 |             |
|     | -1 |             |
|     |  0 |             |
|     |  0 |             |
|                        |
|       4                |
|o3 : ZZ                 |
+------------------------+
|i4 : p2=weight(R,M_1)   |
|                        |
|o4 = | -1 |             |
|     |  2 |             |
|     | -1 |             |
|     |  0 |             |
|                        |
|       4                |
|o4 : ZZ                 |
+------------------------+
|i5 : p1-p2              |
|                        |
|o5 = |  3 |             |
|     | -3 |             |
|     |  1 |             |
|     |  0 |             |
|                        |
|       4                |
|o5 : ZZ                 |
+------------------------+

Ways to use this method:
========================

  * Weight - Weight -- the difference of two weights
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1922:0.

WeylGroupDoubleCoset == WeylGroupDoubleCoset -- equality of double cosets
*************************************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        w1 == w2
  * Inputs:
      * w1, an instance of the type WeylGroupDoubleCoset,
      * w2, an instance of the type WeylGroupDoubleCoset,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if w1 and w2 belong
        to the same quotient and coincide, and false otherwise

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{2,3,4,5})                                             |
|                                                                             |
|o2 = set {2, 3, 4, 5}                                                        |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : w1=P % (w % P)                                                          |
|                                                                             |
|o4 = WeylGroupDoubleCoset{set {2, 3, 4, 5}, set {2, 3, 4, 5},                |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupDoubleCoset                                                    |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i5 : w2=P % ((reduce(R,{4}) * w * reduce(R,{2,3})) % P)                      |
|                                                                             |
|o5 = WeylGroupDoubleCoset{set {2, 3, 4, 5}, set {2, 3, 4, 5},                |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o5 : WeylGroupDoubleCoset                                                    |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i6 : w1==w2                                                                  |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupDoubleCoset == WeylGroupDoubleCoset
    -- equality of double cosets
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3509:0.

WeylGroupElement % Parabolic -- the left coset defined by an element of Weyl group
**********************************************************************************

  * Operator: % (Macaulay2Doc),
  * Usage:
        w % P
  * Inputs:
      * w, an instance of the type WeylGroupElement,
      * P, an instance of the type Parabolic,
  * Outputs:
      * an instance of the type WeylGroupLeftCoset,
        wW_P

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{2,3,4,5})                                             |
|                                                                             |
|o2 = set {2, 3, 4, 5}                                                        |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : w % P                                                                   |
|                                                                             |
|o4 = WeylGroupLeftCoset{set {2, 3, 4, 5},                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupLeftCoset                                                      |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupElement % Parabolic -- the
    left coset defined by an element of Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3539:0.

WeylGroupElement * Root -- apply an element of a Weyl group to a root
*********************************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        w * r
  * Inputs:
      * w, an instance of the type WeylGroupElement,
      * r, an instance of the type Root,
  * Outputs:
      * an instance of the type Root, w applied to r

Description
===========

+--------------------------------------------------+
|i1 : R=rootSystemC(4)                             |
|                                                  |
|o1 = RootSystem{...8...}                          |
|                                                  |
|o1 : RootSystem                                   |
+--------------------------------------------------+
|i2 : w=reduce(R,{1})                              |
|                                                  |
|o2 = WeylGroupElement{RootSystem{...8...}, | -1 |}|
|                                           |  2 | |
|                                           |  1 | |
|                                           |  1 | |
|                                                  |
|o2 : WeylGroupElement                             |
+--------------------------------------------------+
|i3 : r=simpleRoot(R,2)                            |
|                                                  |
|o3 = | -1 |                                       |
|     |  2 |                                       |
|     | -1 |                                       |
|     |  0 |                                       |
|                                                  |
|       4                                          |
|o3 : ZZ                                           |
+--------------------------------------------------+
|i4 : w*r                                          |
|                                                  |
|o4 = |  1 |                                       |
|     |  1 |                                       |
|     | -1 |                                       |
|     |  0 |                                       |
|                                                  |
|       4                                          |
|o4 : ZZ                                           |
+--------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupElement * Root -- apply an
    element of a Weyl group to a root
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2963:0.

WeylGroupElement * Weight -- apply an element of a Weyl group to a weight
*************************************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        w * p
  * Inputs:
      * w, an instance of the type WeylGroupElement,
      * p, an instance of the type Weight,
  * Outputs:
      * an instance of the type Weight, w applied to p

Description
===========

+--------------------------------------------------+
|i1 : R=rootSystemC(4)                             |
|                                                  |
|o1 = RootSystem{...8...}                          |
|                                                  |
|o1 : RootSystem                                   |
+--------------------------------------------------+
|i2 : w=reduce(R,{1})                              |
|                                                  |
|o2 = WeylGroupElement{RootSystem{...8...}, | -1 |}|
|                                           |  2 | |
|                                           |  1 | |
|                                           |  1 | |
|                                                  |
|o2 : WeylGroupElement                             |
+--------------------------------------------------+
|i3 : p=halfSumOfRoots R                           |
|                                                  |
|o3 = | 1 |                                        |
|     | 1 |                                        |
|     | 1 |                                        |
|     | 1 |                                        |
|                                                  |
|       4                                          |
|o3 : ZZ                                           |
+--------------------------------------------------+
|i4 : w*p                                          |
|                                                  |
|o4 = | -1 |                                       |
|     |  2 |                                       |
|     |  1 |                                       |
|     |  1 |                                       |
|                                                  |
|       4                                          |
|o4 : ZZ                                           |
+--------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupElement * Weight -- apply an
    element of a Weyl group to a weight
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2942:0.

WeylGroupElement * WeylGroupElement -- the product of two elements of a Weyl group
**********************************************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        w1 * w2
  * Inputs:
      * w1, an instance of the type WeylGroupElement,
      * w2, an instance of the type WeylGroupElement,
  * Outputs:
      * an instance of the type WeylGroupElement, the
        product of w1 and w2

Description
===========

+--------------------------------------------------+
|i1 : R=rootSystemC(4)                             |
|                                                  |
|o1 = RootSystem{...8...}                          |
|                                                  |
|o1 : RootSystem                                   |
+--------------------------------------------------+
|i2 : w1=reduce(R,{1})                             |
|                                                  |
|o2 = WeylGroupElement{RootSystem{...8...}, | -1 |}|
|                                           |  2 | |
|                                           |  1 | |
|                                           |  1 | |
|                                                  |
|o2 : WeylGroupElement                             |
+--------------------------------------------------+
|i3 : w2=reduce(R,{2})                             |
|                                                  |
|o3 = WeylGroupElement{RootSystem{...8...}, |  2 |}|
|                                           | -1 | |
|                                           |  2 | |
|                                           |  1 | |
|                                                  |
|o3 : WeylGroupElement                             |
+--------------------------------------------------+
|i4 : w1*w2                                        |
|                                                  |
|o4 = WeylGroupElement{RootSystem{...8...}, | -2 |}|
|                                           |  1 | |
|                                           |  2 | |
|                                           |  1 | |
|                                                  |
|o4 : WeylGroupElement                             |
+--------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupElement * WeylGroupElement
    -- the product of two elements of a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2868:0.

WeylGroupElement * WeylGroupLeftCoset -- apply an element of a Weyl group to a left coset
*****************************************************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        w * c
  * Inputs:
      * w, an instance of the type WeylGroupElement,
      * c, an instance of the type WeylGroupLeftCoset,
  * Outputs:
      * an instance of the type WeylGroupLeftCoset,
        w applied to c

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{2,3,4,5})                                             |
|                                                                             |
|o2 = set {2, 3, 4, 5}                                                        |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : c=w % P                                                                 |
|                                                                             |
|o4 = WeylGroupLeftCoset{set {2, 3, 4, 5},                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupLeftCoset                                                      |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i5 : reduce(R,{1})*c                                                         |
|                                                                             |
|o5 = WeylGroupLeftCoset{set {2, 3, 4, 5},                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o5 : WeylGroupLeftCoset                                                      |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, |  7 |}}                               |
|                                      | -6 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupElement * WeylGroupLeftCoset
    -- apply an element of a Weyl group to a left coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3629:0.

WeylGroupElement == WeylGroupElement -- equality of elements of Weyl groups
***************************************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        w1 == w2
  * Inputs:
      * w1, an instance of the type WeylGroupElement,
      * w2, an instance of the type WeylGroupElement,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if w1 and w2 belong
        to the same Weyl group and coincide, and false otherwise

Description
===========

+--------------------------------------------------+
|i1 : w1=reduce(rootSystemD(5),{3})                |
|                                                  |
|o1 = WeylGroupElement{RootSystem{...8...}, |  1 |}|
|                                           |  2 | |
|                                           | -1 | |
|                                           |  2 | |
|                                           |  2 | |
|                                                  |
|o1 : WeylGroupElement                             |
+--------------------------------------------------+
|i2 : w1==inverse(w1)                              |
|                                                  |
|o2 = true                                         |
+--------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupElement == WeylGroupElement
    -- equality of elements of Weyl groups
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2842:0.

WeylGroupElement ^ ZZ -- the power of an element of a Weyl group
****************************************************************

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        w^n
  * Inputs:
      * w, an instance of the type WeylGroupElement,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type WeylGroupElement, the
        n-th power of w

Description
===========

+--------------------------------------------------+
|i1 : w=reduce(rootSystemE(6),{1,2,3})             |
|                                                  |
|o1 = WeylGroupElement{RootSystem{...8...}, | -2 |}|
|                                           | -1 | |
|                                           |  1 | |
|                                           |  3 | |
|                                           |  1 | |
|                                           |  1 | |
|                                                  |
|o1 : WeylGroupElement                             |
+--------------------------------------------------+
|i2 : w^10                                         |
|                                                  |
|o2 = WeylGroupElement{RootSystem{...8...}, | -2 |}|
|                                           |  1 | |
|                                           |  1 | |
|                                           |  2 | |
|                                           |  1 | |
|                                           |  1 | |
|                                                  |
|o2 : WeylGroupElement                             |
+--------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupElement ^ ZZ -- the power of an
    element of a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:2916:0.

WeylGroupLeftCoset == WeylGroupLeftCoset -- equality of left cosets
*******************************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        w1 == w2
  * Inputs:
      * w1, an instance of the type WeylGroupLeftCoset,
      * w2, an instance of the type WeylGroupLeftCoset,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if w1 and w2 belong
        to the same quotient and coincide, and false otherwise

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{2,3,4,5})                                             |
|                                                                             |
|o2 = set {2, 3, 4, 5}                                                        |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : w1=w % P                                                                |
|                                                                             |
|o4 = WeylGroupLeftCoset{set {2, 3, 4, 5},                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupLeftCoset                                                      |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i5 : w2=(w * reduce(R,{2,3})) % P                                            |
|                                                                             |
|o5 = WeylGroupLeftCoset{set {2, 3, 4, 5},                                    |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o5 : WeylGroupLeftCoset                                                      |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i6 : w1==w2                                                                  |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupLeftCoset == WeylGroupLeftCoset
    -- equality of left cosets
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3424:0.

WeylGroupRightCoset % Parabolic -- the double coset defined by a right coset
****************************************************************************

  * Operator: % (Macaulay2Doc),
  * Usage:
        c % Q
  * Inputs:
      * c, an instance of the type WeylGroupRightCoset,
      * Q, an instance of the type Parabolic,
  * Outputs:
      * an instance of the type WeylGroupDoubleCoset,
        cW_Q

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{2,3,4,5})                                             |
|                                                                             |
|o2 = set {2, 3, 4, 5}                                                        |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : Q=parabolic(R,set{1,2,3,4})                                             |
|                                                                             |
|o3 = set {1, 2, 3, 4}                                                        |
|                                                                             |
|o3 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i4 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o4 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o4 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i5 : c = P % w                                                               |
|                                                                             |
|o5 = WeylGroupRightCoset{set {2, 3, 4, 5},                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o5 : WeylGroupRightCoset                                                     |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i6 : c % Q                                                                   |
|                                                                             |
|o6 = WeylGroupDoubleCoset{set {2, 3, 4, 5}, set {1, 2, 3, 4},                |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o6 : WeylGroupDoubleCoset                                                    |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -4 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  3 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupRightCoset % Parabolic, --
    the double coset defined by a right coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3606:0.

WeylGroupRightCoset * WeylGroupElement -- apply an element of a Weyl group to a left coset
******************************************************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        c * w
  * Inputs:
      * c, an instance of the type WeylGroupRightCoset,
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * an instance of the type WeylGroupRightCoset,
        w applied to c

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{2,3,4,5})                                             |
|                                                                             |
|o2 = set {2, 3, 4, 5}                                                        |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : c=P % w                                                                 |
|                                                                             |
|o4 = WeylGroupRightCoset{set {2, 3, 4, 5},                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupRightCoset                                                     |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i5 : c*reduce(R,{1})                                                         |
|                                                                             |
|o5 = WeylGroupRightCoset{set {2, 3, 4, 5},                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o5 : WeylGroupRightCoset                                                     |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  2 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupRightCoset * WeylGroupElement
    -- apply an element of a Weyl group to a left coset
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3651:0.

WeylGroupRightCoset == WeylGroupRightCoset -- equality of right cosets
**********************************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        w1 == w2
  * Inputs:
      * w1, an instance of the type WeylGroupRightCoset,
      * w2, an instance of the type WeylGroupRightCoset,
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if w1 and w2 belong
        to the same quotient and coincide, and false otherwise

Description
===========

+-----------------------------------------------------------------------------+
|i1 : R=rootSystemD(5)                                                        |
|                                                                             |
|o1 = RootSystem{...8...}                                                     |
|                                                                             |
|o1 : RootSystem                                                              |
+-----------------------------------------------------------------------------+
|i2 : P=parabolic(R,set{2,3,4,5})                                             |
|                                                                             |
|o2 = set {2, 3, 4, 5}                                                        |
|                                                                             |
|o2 : Parabolic                                                               |
+-----------------------------------------------------------------------------+
|i3 : w=longestWeylGroupElement R                                             |
|                                                                             |
|o3 = WeylGroupElement{RootSystem{...8...}, | -1 |}                           |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                           | -1 |                            |
|                                                                             |
|o3 : WeylGroupElement                                                        |
+-----------------------------------------------------------------------------+
|i4 : w1=P % w                                                                |
|                                                                             |
|o4 = WeylGroupRightCoset{set {2, 3, 4, 5},                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : WeylGroupRightCoset                                                     |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i5 : w2=P % (reduce(R,{2,3})*w)                                              |
|                                                                             |
|o5 = WeylGroupRightCoset{set {2, 3, 4, 5},                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o5 : WeylGroupRightCoset                                                     |
|-----------------------------------------------------------------------------|
|WeylGroupElement{RootSystem{...8...}, | -7 |}}                               |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
|                                      |  1 |                                 |
+-----------------------------------------------------------------------------+
|i6 : w1==w2                                                                  |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * WeylGroupRightCoset == WeylGroupRightCoset
    -- equality of right cosets
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3466:0.

whoseReflection(WeylGroupElement) -- the positive root whose reflection is a given element of a Weyl group
**********************************************************************************************************

  * Function: whoseReflection,
  * Usage:
        whoseReflection(w)
  * Inputs:
      * w, an instance of the type WeylGroupElement,
  * Outputs:
      * an instance of the type Root, the root whose corresponding
        reflection is w

Description
===========

+--------------------------------------------------+
|i1 : R=rootSystemD(5)                             |
|                                                  |
|o1 = RootSystem{...8...}                          |
|                                                  |
|o1 : RootSystem                                   |
+--------------------------------------------------+
|i2 : w=reduce(R,{3})                              |
|                                                  |
|o2 = WeylGroupElement{RootSystem{...8...}, |  1 |}|
|                                           |  2 | |
|                                           | -1 | |
|                                           |  2 | |
|                                           |  2 | |
|                                                  |
|o2 : WeylGroupElement                             |
+--------------------------------------------------+
|i3 : if isReflection(w) then whoseReflection(w)   |
|                                                  |
|o3 = |  0 |                                       |
|     | -1 |                                       |
|     |  2 |                                       |
|     | -1 |                                       |
|     | -1 |                                       |
|                                                  |
|       5                                          |
|o3 : ZZ                                           |
+--------------------------------------------------+

Caveat
======

If w is not a reflection, an error occurs.

Ways to use this method:
========================

  * whoseReflection(WeylGroupElement)
    -- the positive root whose
    reflection is a given element of a Weyl group
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:3295:0.

ZZ * Weight -- the multiple of a weight
***************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        n * p
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * p, an instance of the type Weight,
  * Outputs:
      * an instance of the type Weight, n times p

Description
===========

+------------------------+
|i1 : R=rootSystemA(4)   |
|                        |
|o1 = RootSystem{...8...}|
|                        |
|o1 : RootSystem         |
+------------------------+
|i2 : M=cartanMatrix R   |
|                        |
|o2 = | 2  -1 0  0  |    |
|     | -1 2  -1 0  |    |
|     | 0  -1 2  -1 |    |
|     | 0  0  -1 2  |    |
|                        |
|              4       4 |
|o2 : Matrix ZZ  <-- ZZ  |
+------------------------+
|i3 : p=weight(R,M_2)    |
|                        |
|o3 = |  0 |             |
|     | -1 |             |
|     |  2 |             |
|     | -1 |             |
|                        |
|       4                |
|o3 : ZZ                 |
+------------------------+
|i4 : -2*p               |
|                        |
|o4 = |  0 |             |
|     |  2 |             |
|     | -4 |             |
|     |  2 |             |
|                        |
|       4                |
|o4 : ZZ                 |
+------------------------+

Ways to use this method:
========================

  * ZZ * Weight -- the multiple of a weight
-------------------------------------------------------------------------------

The source of this document is in WeylGroups.m2:1950:0.