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: Create a new RootSystem object
  
  This method assigns an attribute called cartan_type to each instance of
  a RootSystem object.  When an instance of RootSystem is called, it
  needs an argument, which should be an instance of a simple Lie algebra.
  We then take the CartanType of this argument and set it as the
  cartan_type attribute of the RootSystem instance.
code: def __new__(cls, cartantype):
      """Create a new RootSystem object
  
      This method assigns an attribute called cartan_type to each instance of
      a RootSystem object.  When an instance of RootSystem is called, it
      needs an argument, which should be an instance of a simple Lie algebra.
      We then take the CartanType of this argument and set it as the
      cartan_type attribute of the RootSystem instance.
  
      """
      obj = Atom.__new__(cls)
      obj.cartan_type = CartanType(cartantype)
      return obj
  
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 1 for calling the RootSystem obj's underlying member method code with example usage: obj.__new__(cls, cartantype) and returns: obj