text: # -*- coding: utf-8 -*-
  
  from sympy.core import Basic, Rational
  from sympy.core.compatibility import range
  from sympy.core.numbers import igcd
  from .cartan_type import CartanType
  from mpmath import fac
  from sympy.matrices import Matrix, eye
  
  class WeylGroup(Basic):
  
      """
      For each semisimple Lie group, we have a Weyl group.  It is a subgroup of
      the isometry group of the root system.  Specifically, it’s the subgroup
      that is generated by reflections through the hyperplanes orthogonal to
      the roots.  Therefore, Weyl groups are reflection groups, and so a Weyl
      group is a finite Coxeter group.
  
      """
  
      def __new__(cls, cartantype):
          obj = Basic.__new__(cls, cartantype)
          obj.cartan_type = CartanType(cartantype)
          return obj
  
      def generators(self):
          """
          This method creates the generating reflections of the Weyl group for
          a given Lie algebra.  For a Lie algebra of rank n, there are n
          different generating reflections.  This function returns them as
          a list.
  
          Example
          =======
          >>> from sympy.liealgebras.weyl_group import WeylGroup
          >>> c = WeylGroup("F4")
          >>> c.generators()
          ['r1', 'r2', 'r3', 'r4']
          """
          n = self.cartan_type.rank()
          generators = []
          for i in range(1, n+1):
              reflection = "r"+str(i)
              generators.append(reflection)
          return generators
  
      def group_order(self):
          """
          This method returns the order of the Weyl group.
          For types A, B, C, D, and E the order depends on
          the rank of the Lie algebra.  For types F and G,
          the order is fixed.
  
          Example
          =======
          >>> from sympy.liealgebras.weyl_group import WeylGroup
          >>> c = WeylGroup("D4")
          >>> c.group_order()
          192.0
          """
          n = self.cartan_type.rank()
          if self.cartan_type.series == "A":
              return fac(n+1)
  
          if self.cartan_type.series == "B" or self.cartan_type.series ==  "C":
              return fac(n)*(2**n)
  
          if self.cartan_type.series == "D":
              return fac(n)*(2**(n-1))
  
          if self.cartan_type.series == "E":
              if n == 6:
                  return 51840
              if n == 7:
                  return 2903040
              if n == 8:
                  return 696729600
          if self.cartan_type.series == "F":
              return 1152
  
          if self.cartan_type.series == "G":
              return 12
  
      def group_name(self):
          """
          This method returns some general information about the Weyl group for
          a given Lie algebra.  It returns the name of the group and the elements
          it acts on, if relevant.
          """
          n = self.cartan_type.rank()
          if self.cartan_type.series == "A":
              return "S"+str(n+1) + ": the symmetric group acting on " + str(n+1) + " elements."
  
          if self.cartan_type.series == "B" or self.cartan_type.series ==  "C":
              return "The hyperoctahedral group acting on " + str(2*n) + " elements."
  
          if self.cartan_type.series == "D":
              return "The symmetry group of the " + str(n) + "-dimensional demihypercube."
  
          if self.cartan_type.series == "E":
              if n == 6:
                  return "The symmetry group of the 6-polytope."
  
              if n == 7:
                  return "The symmetry group of the 7-polytope."
  
              if n == 8:
                  return "The symmetry group of the 8-polytope."
  
          if self.cartan_type.series == "F":
              return "The symmetry group of the 24-cell, or icositetrachoron."
  
          if self.cartan_type.series == "G":
              return "D6, the dihedral group of order 12, and symmetry group of the hexagon."
  
      def element_order(self, weylelt):
          """
          This method returns the order of a given Weyl group element, which should
          be specified by the user in the form of products of the generating
          reflections, i.e. of the form r1*r2 etc.
  
          For types A-F, this method current works by taking the matrix form of
          the specified element, and then finding what power of the matrix is the
          identity.  It then returns this power.
  
          Example
          ========
          >>> from sympy.liealgebras.weyl_group import WeylGroup
          >>> b = WeylGroup("B4")
          >>> b.element_order('r1*r4*r2')
          4
          """
          n = self.cartan_type.rank()
          if self.cartan_type.series == "A":
              a = self.matrix_form(weylelt)
              order = 1
              while a != eye(n+1):
                  a *= self.matrix_form(weylelt)
                  order += 1
              return order
  
          if self.cartan_type.series == "D":
              a = self.matrix_form(weylelt)
              order = 1
              while a != eye(n):
                  a *= self.matrix_form(weylelt)
                  order += 1
              return order
  
          if self.cartan_type.series == "E":
              a = self.matrix_form(weylelt)
              order = 1
              while a != eye(8):
                  a *= self.matrix_form(weylelt)
                  order += 1
              return order
  
          if self.cartan_type.series == "G":
              elts = list(weylelt)
              reflections = elts[1::3]
              m = self.delete_doubles(reflections)
              while self.delete_doubles(m) != m:
                  m = self.delete_doubles(m)
                  reflections = m
              if len(reflections) % 2 == 1:
                  return 2
  
              elif len(reflections) == 0:
                  return 1
  
              else:
                  if len(reflections) == 1:
                      return 2
                  else:
                      m = len(reflections) / 2
                      lcm = (6 * m)/ igcd(m, 6)
                  order = lcm / m
                  return order
  
  
          if self.cartan_type.series == 'F':
              a = self.matrix_form(weylelt)
              order = 1
              while a != eye(4):
                  a *= self.matrix_form(weylelt)
                  order += 1
              return order
  
  
          if self.cartan_type.series == "B" or self.cartan_type.series == "C":
              a = self.matrix_form(weylelt)
              order = 1
              while a != eye(n):
                  a *= self.matrix_form(weylelt)
                  order += 1
              return order
  
      def delete_doubles(self, reflections):
          """
          This is a helper method for determining the order of an element in the
          Weyl group of G2.  It takes a Weyl element and if repeated simple reflections
          in it, it deletes them.
          """
          counter = 0
          copy = list(reflections)
          for elt in copy:
              if counter < len(copy)-1:
                  if copy[counter + 1] == elt:
                      del copy[counter]
                      del copy[counter]
              counter += 1
  
  
          return copy
  
  
      def matrix_form(self, weylelt):
          """
          This method takes input from the user in the form of products of the
          generating reflections, and returns the matrix corresponding to the
          element of the Weyl group.  Since each element of the Weyl group is
          a reflection of some type, there is a corresponding matrix representation.
          This method uses the standard representation for all the generating
          reflections.
  
          Example
          =======
          >>> from sympy.liealgebras.weyl_group import WeylGroup
          >>> f = WeylGroup("F4")
          >>> f.matrix_form('r2*r3')
          Matrix([
          [1, 0, 0,  0],
          [0, 1, 0,  0],
          [0, 0, 0, -1],
          [0, 0, 1,  0]])
  
          """
          elts = list(weylelt)
          reflections = elts[1::3]
          n = self.cartan_type.rank()
          if self.cartan_type.series == 'A':
              matrixform = eye(n+1)
              for elt in reflections:
                  a = int(elt)
                  mat = eye(n+1)
                  mat[a-1, a-1] = 0
                  mat[a-1, a] = 1
                  mat[a, a-1] = 1
                  mat[a, a] = 0
                  matrixform *= mat
              return matrixform
  
          if self.cartan_type.series == 'D':
              matrixform = eye(n)
              for elt in reflections:
                  a = int(elt)
                  mat = eye(n)
                  if a < n:
                      mat[a-1, a-1] = 0
                      mat[a-1, a] = 1
                      mat[a, a-1] = 1
                      mat[a, a] = 0
                      matrixform *= mat
                  else:
                      mat[n-2, n-1] = -1
                      mat[n-2, n-2] = 0
                      mat[n-1, n-2] = -1
                      mat[n-1, n-1] = 0
                      matrixform *= mat
              return matrixform
  
          if self.cartan_type.series == 'G':
              matrixform = eye(3)
              for elt in reflections:
                  a = int(elt)
                  if a == 1:
                      gen1 = Matrix([[1, 0, 0], [0, 0, 1], [0, 1, 0]])
                      matrixform *= gen1
                  else:
                      gen2 = Matrix([[Rational(2, 3), Rational(2, 3), -Rational(1, 3)],
                          [Rational(2, 3), Rational(-1, 3), Rational(2, 3)], [Rational(-1, 3),
                              Rational(2, 3), Rational(2, 3)]])
                      matrixform *= gen2
              return matrixform
  
          if self.cartan_type.series == 'F':
              matrixform = eye(4)
              for elt in reflections:
                  a = int(elt)
                  if a == 1:
                      mat = Matrix([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]])
                      matrixform *= mat
                  elif a == 2:
                      mat = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
                      matrixform *= mat
                  elif a == 3:
                      mat = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]])
                      matrixform *= mat
                  else:
  
                      mat = Matrix([[Rational(1, 2), Rational(1, 2), Rational(1, 2), Rational(1, 2)],
                          [Rational(1, 2), Rational(1, 2), Rational(-1, 2), Rational(-1, 2)],
                          [Rational(1, 2), Rational(-1, 2), Rational(1, 2), Rational(-1, 2)],
                          [Rational(1, 2), Rational(-1, 2), Rational(-1, 2), Rational(1, 2)]])
                      matrixform *= mat
              return matrixform
  
          if self.cartan_type.series == 'E':
              matrixform = eye(8)
              for elt in reflections:
                  a = int(elt)
                  if a == 1:
                      mat = Matrix([[Rational(3, 4), Rational(1, 4), Rational(1, 4), Rational(1, 4),
                          Rational(1, 4), Rational(1, 4), Rational(1, 4), Rational(-1, 4)],
                          [Rational(1, 4), Rational(3, 4), Rational(-1, 4), Rational(-1, 4),
                              Rational(-1, 4), Rational(-1, 4), Rational(1, 4), Rational(-1, 4)],
                          [Rational(1, 4), Rational(-1, 4), Rational(3, 4), Rational(-1, 4),
                          Rational(-1, 4), Rational(-1, 4), Rational(-1, 4), Rational(1, 4)],
                          [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(3, 4),
                          Rational(-1, 4), Rational(-1, 4), Rational(-1, 4), Rational(1, 4)],
                          [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
                          Rational(3, 4), Rational(-1, 4), Rational(-1, 4), Rational(1, 4)],
                          [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
                          Rational(-1, 4), Rational(3, 4), Rational(-1, 4), Rational(1, 4)],
                          [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
                          Rational(-1, 4), Rational(-1, 4), Rational(-3, 4), Rational(1, 4)],
                          [Rational(1, 4), Rational(-1, 4), Rational(-1, 4), Rational(-1, 4),
                          Rational(-1, 4), Rational(-1, 4), Rational(-1, 4), Rational(3, 4)]])
                      matrixform *= mat
                  elif a == 2:
                      mat = eye(8)
                      mat[0, 0] = 0
                      mat[0, 1] = -1
                      mat[1, 0] = -1
                      mat[1, 1] = 0
                      matrixform *= mat
                  else:
                      mat = eye(8)
                      mat[a-3, a-3] = 0
                      mat[a-3, a-2] = 1
                      mat[a-2, a-3] = 1
                      mat[a-2, a-2] = 0
                      matrixform *= mat
              return matrixform
  
  
          if self.cartan_type.series == 'B' or self.cartan_type.series == 'C':
              matrixform = eye(n)
              for elt in reflections:
                  a = int(elt)
                  mat = eye(n)
                  if a == 1:
                      mat[0, 0] = -1
                      matrixform *= mat
                  else:
                      mat[a - 2, a - 2] = 0
                      mat[a-2, a-1] = 1
                      mat[a - 1, a - 2] = 1
                      mat[a -1, a - 1] = 0
                      matrixform *= mat
              return matrixform
  
  
  
      def coxeter_diagram(self):
          """
          This method returns the Coxeter diagram corresponding to a Weyl group.
          The Coxeter diagram can be obtained from a Lie algebra's Dynkin diagram
          by deleting all arrows; the Coxeter diagram is the undirected graph.
          The vertices of the Coxeter diagram represent the generating reflections
          of the Weyl group, , s_i.  An edge is drawn between s_i and s_j if the order
          m(i, j) of s_i*s_j is greater than two.  If there is one edge, the order
          m(i, j) is 3.  If there are two edges, the order m(i, j) is 4, and if there
          are three edges, the order m(i, j) is 6.
  
          Example
          ========
          >>> from sympy.liealgebras.weyl_group import WeylGroup
          >>> c = WeylGroup("B3")
          >>> print(c.coxeter_diagram())
          0---0===0
          1   2   3
          """
          n = self.cartan_type.rank()
          if self.cartan_type.series == "A" or self.cartan_type.series == "D" or self.cartan_type.series == "E":
              return self.cartan_type.dynkin_diagram()
  
          if self.cartan_type.series == "B" or self.cartan_type.series ==  "C":
              diag = "---".join("0" for i in range(1, n)) + "===0\n"
              diag += "   ".join(str(i) for i in range(1, n+1))
              return diag
  
          if self.cartan_type.series == "F":
              diag = "0---0===0---0\n"
              diag += "   ".join(str(i) for i in range(1, 5))
              return diag
  
          if self.cartan_type.series == "G":
              diag = "0≡≡≡0\n1   2"
              return diag
  