class_docstr: Represent the root system of a simple Lie algebra
  
  Every simple Lie algebra has a unique root system.  To find the root
  system, we first consider the Cartan subalgebra of g, which is the maximal
  abelian subalgebra, and consider the adjoint action of g on this
  subalgebra.  There is a root system associated with this action. Now, a
  root system over a vector space V is a set of finite vectors Phi (called
  roots), which satisfy:
  
  1.  The roots span V
  2.  The only scalar multiples of x in Phi are x and -x
  3.  For every x in Phi, the set Phi is closed under reflection
      through the hyperplane perpendicular to x.
  4.  If x and y are roots in Phi, then the projection of y onto
      the line through x is a half-integral multiple of x.
  
  Now, there is a subset of Phi, which we will call Delta, such that:
  1.  Delta is a basis of V
  2.  Each root x in Phi can be written x = sum k_y y for y in Delta
  
  The elements of Delta are called the simple roots.
  Therefore, we see that the simple roots span the root space of a given
  simple Lie algebra.
  
  References
  ==========
  
  .. [1] https://en.wikipedia.org/wiki/Root_system
  .. [2] Lie Algebras and Representation Theory - Humphreys
docstr: Return the span of the simple roots
  
  The root space is the vector space spanned by the simple roots, i.e. it
  is a vector space with a distinguished basis, the simple roots.  This
  method returns a string that represents the root space as the span of
  the simple roots, alpha[1],...., alpha[n].
  
  Examples
  ========
  
  >>> from sympy.liealgebras.root_system import RootSystem
  >>> c = RootSystem("A3")
  >>> c.root_space()
  'alpha[1] + alpha[2] + alpha[3]'
code: def root_space(self):
      """Return the span of the simple roots
  
      The root space is the vector space spanned by the simple roots, i.e. it
      is a vector space with a distinguished basis, the simple roots.  This
      method returns a string that represents the root space as the span of
      the simple roots, alpha[1],...., alpha[n].
  
      Examples
      ========
  
      >>> from sympy.liealgebras.root_system import RootSystem
      >>> c = RootSystem("A3")
      >>> c.root_space()
      'alpha[1] + alpha[2] + alpha[3]'
  
      """
      n = self.cartan_type.rank()
      rs = " + ".join("alpha[" + str(i) + "]" for i in range(1, n + 1))
      return rs
  
file_path: sympy/sympy/liealgebras/root_system.py
imports: from .cartan_type import CartanType
  from sympy.core.basic import Atom
label_desc: Use image node_id 4 for calling the RootSystem obj's underlying member method code with example usage: obj.root_space() and returns: rs