code: def assemble_partfrac_list(partial_list):
      r"""Reassemble a full partial fraction decomposition
      from a structured result obtained by the function ``apart_list``.
  
      Examples
      ========
  
      This example is taken from Bronstein's original paper:
  
      >>> from sympy.polys.partfrac import apart_list, assemble_partfrac_list
      >>> from sympy.abc import x
  
      >>> f = 36 / (x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2)
      >>> pfd = apart_list(f)
      >>> pfd
      (1,
      Poly(0, x, domain='ZZ'),
      [(Poly(_w - 2, _w, domain='ZZ'), Lambda(_a, 4), Lambda(_a, -_a + x), 1),
      (Poly(_w**2 - 1, _w, domain='ZZ'), Lambda(_a, -3*_a - 6), Lambda(_a, -_a + x), 2),
      (Poly(_w + 1, _w, domain='ZZ'), Lambda(_a, -4), Lambda(_a, -_a + x), 1)])
  
      >>> assemble_partfrac_list(pfd)
      -4/(x + 1) - 3/(x + 1)**2 - 9/(x - 1)**2 + 4/(x - 2)
  
      If we happen to know some roots we can provide them easily inside the structure:
  
      >>> pfd = apart_list(2/(x**2-2))
      >>> pfd
      (1,
      Poly(0, x, domain='ZZ'),
      [(Poly(_w**2 - 2, _w, domain='ZZ'),
      Lambda(_a, _a/2),
      Lambda(_a, -_a + x),
      1)])
  
      >>> pfda = assemble_partfrac_list(pfd)
      >>> pfda
      RootSum(_w**2 - 2, Lambda(_a, _a/(-_a + x)))/2
  
      >>> pfda.doit()
      -sqrt(2)/(2*(x + sqrt(2))) + sqrt(2)/(2*(x - sqrt(2)))
  
      >>> from sympy import Dummy, Poly, Lambda, sqrt
      >>> a = Dummy("a")
      >>> pfd = (1, Poly(0, x, domain='ZZ'), [([sqrt(2),-sqrt(2)], Lambda(a, a/2), Lambda(a, -a + x), 1)])
  
      >>> assemble_partfrac_list(pfd)
      -sqrt(2)/(2*(x + sqrt(2))) + sqrt(2)/(2*(x - sqrt(2)))
  
      See Also
      ========
  
      apart, apart_list
      """
      # Common factor
      common = partial_list[0]
  
      # Polynomial part
      polypart = partial_list[1]
      pfd = polypart.as_expr()
  
      # Rational parts
      for r, nf, df, ex in partial_list[2]:
          if isinstance(r, Poly):
              # Assemble in case the roots are given implicitly by a polynomials
              an, nu = nf.variables, nf.expr
              ad, de = df.variables, df.expr
              # Hack to make dummies equal because Lambda created new Dummies
              de = de.subs(ad[0], an[0])
              func = Lambda(tuple(an), nu / de**ex)
              pfd += RootSum(r, func, auto=False, quadratic=False)
          else:
              # Assemble in case the roots are given explicitly by a list of algebraic numbers
              for root in r:
                  pfd += nf(root) / df(root) ** ex
  
      return common * pfd
  
file_path: sympy/sympy/polys/partfrac.py
imports: from sympy.core import S, Add, sympify, Function, Lambda, Dummy
  from sympy.core.traversal import preorder_traversal
  from sympy.polys import Poly, RootSum, cancel, factor
  from sympy.polys.polyerrors import PolynomialError
  from sympy.polys.polyoptions import allowed_flags, set_defaults
  from sympy.polys.polytools import parallel_poly_from_expr
  from sympy.utilities import numbered_symbols, take, xthreaded, public
label_desc: Use image node_id 6 for calling a global function with example usage: assemble_partfrac_list(partial_list) and returns: unknown