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: Add two roots together if and only if their sum is also a root
  
  It takes as input two vectors which should be roots.  It then computes
  their sum and checks if it is in the list of all possible roots.  If it
  is, it returns the sum.  Otherwise it returns a string saying that the
  sum is not a root.
  
  Examples
  ========
  
  >>> from sympy.liealgebras.root_system import RootSystem
  >>> c = RootSystem("A3")
  >>> c.add_as_roots([1, 0, -1, 0], [0, 0, 1, -1])
  [1, 0, 0, -1]
  >>> c.add_as_roots([1, -1, 0, 0], [0, 0, -1, 1])
  'The sum of these two roots is not a root'
code: def add_as_roots(self, root1, root2):
      """Add two roots together if and only if their sum is also a root
  
      It takes as input two vectors which should be roots.  It then computes
      their sum and checks if it is in the list of all possible roots.  If it
      is, it returns the sum.  Otherwise it returns a string saying that the
      sum is not a root.
  
      Examples
      ========
  
      >>> from sympy.liealgebras.root_system import RootSystem
      >>> c = RootSystem("A3")
      >>> c.add_as_roots([1, 0, -1, 0], [0, 0, 1, -1])
      [1, 0, 0, -1]
      >>> c.add_as_roots([1, -1, 0, 0], [0, 0, -1, 1])
      'The sum of these two roots is not a root'
  
      """
      alpha = self.all_roots()
      newroot = [r1 + r2 for r1, r2 in zip(root1, root2)]
      if newroot in alpha.values():
          return newroot
      else:
          return "The sum of these two roots is not a root"
  
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 6 for calling the RootSystem obj's underlying member method code with example usage: obj.add_as_roots(root1, root2) and returns: newroot, str