code: def pde_separate(eq, fun, sep, strategy="mul"):
      """Separate variables in partial differential equation either by additive
      or multiplicative separation approach. It tries to rewrite an equation so
      that one of the specified variables occurs on a different side of the
      equation than the others.
  
      :param eq: Partial differential equation
  
      :param fun: Original function F(x, y, z)
  
      :param sep: List of separated functions [X(x), u(y, z)]
  
      :param strategy: Separation strategy. You can choose between additive
          separation ('add') and multiplicative separation ('mul') which is
          default.
  
      Examples
      ========
  
      >>> from sympy import E, Eq, Function, pde_separate, Derivative as D
      >>> from sympy.abc import x, t
      >>> u, X, T = map(Function, 'uXT')
  
      >>> eq = Eq(D(u(x, t), x), E**(u(x, t))*D(u(x, t), t))
      >>> pde_separate(eq, u(x, t), [X(x), T(t)], strategy='add')
      [exp(-X(x))*Derivative(X(x), x), exp(T(t))*Derivative(T(t), t)]
  
      >>> eq = Eq(D(u(x, t), x, 2), D(u(x, t), t, 2))
      >>> pde_separate(eq, u(x, t), [X(x), T(t)], strategy='mul')
      [Derivative(X(x), (x, 2))/X(x), Derivative(T(t), (t, 2))/T(t)]
  
      See Also
      ========
      pde_separate_add, pde_separate_mul
      """
  
      do_add = False
      if strategy == "add":
          do_add = True
      elif strategy == "mul":
          do_add = False
      else:
          raise ValueError("Unknown strategy: %s" % strategy)
  
      if isinstance(eq, Equality):
          if eq.rhs != 0:
              return pde_separate(
                  Eq(eq.lhs - eq.rhs, 0), fun, sep, strategy
              )
      else:
          return pde_separate(Eq(eq, 0), fun, sep, strategy)
  
      if eq.rhs != 0:
          raise ValueError("Value should be 0")
  
      # Handle arguments
      orig_args = list(fun.args)
      subs_args = [arg for s in sep for arg in s.args]
  
      if do_add:
          functions = reduce(operator.add, sep)
      else:
          functions = reduce(operator.mul, sep)
  
      # Check whether variables match
      if len(subs_args) != len(orig_args):
          raise ValueError("Variable counts do not match")
      # Check for duplicate arguments like  [X(x), u(x, y)]
      if has_dups(subs_args):
          raise ValueError("Duplicate substitution arguments detected")
      # Check whether the variables match
      if set(orig_args) != set(subs_args):
          raise ValueError("Arguments do not match")
  
      # Substitute original function with separated...
      result = eq.lhs.subs(fun, functions).doit()
  
      # Divide by terms when doing multiplicative separation
      if not do_add:
          eq = 0
          for i in result.args:
              eq += i / functions
          result = eq
  
      svar = subs_args[0]
      dvar = subs_args[1:]
      return _separate(result, svar, dvar)
  
imports: from functools import reduce
  from itertools import combinations_with_replacement
  from sympy.simplify import simplify
  from sympy.core import Add, S
  from sympy.core.function import Function, expand, AppliedUndef, Subs
  from sympy.core.relational import Equality, Eq
  from sympy.core.symbol import Symbol, Wild, symbols
  from sympy.functions import exp
  from sympy.integrals.integrals import Integral, integrate
  from sympy.utilities.iterables import has_dups, is_sequence
  from sympy.utilities.misc import filldedent
  from sympy.solvers.deutils import _preprocess, ode_order, _desolve
  from sympy.solvers.solvers import solve
  from sympy.simplify.radsimp import collect
  import operator
label_desc: Use image node_id 10 for calling a global function with example usage: pde_separate(eq, fun, sep, strategy) and returns: _separate, pde_separate, pde_separate