code: def euler_equations(L, funcs=(), vars=()):
      r"""
      Find the Euler-Lagrange equations [1]_ for a given Lagrangian.
  
      Parameters
      ==========
  
      L : Expr
          The Lagrangian that should be a function of the functions listed
          in the second argument and their derivatives.
  
          For example, in the case of two functions $f(x,y)$, $g(x,y)$ and
          two independent variables $x$, $y$ the Lagrangian has the form:
  
              .. math:: L\left(f(x,y),g(x,y),\frac{\partial f(x,y)}{\partial x},
                        \frac{\partial f(x,y)}{\partial y},
                        \frac{\partial g(x,y)}{\partial x},
                        \frac{\partial g(x,y)}{\partial y},x,y\right)
  
          In many cases it is not necessary to provide anything, except the
          Lagrangian, it will be auto-detected (and an error raised if this
          cannot be done).
  
      funcs : Function or an iterable of Functions
          The functions that the Lagrangian depends on. The Euler equations
          are differential equations for each of these functions.
  
      vars : Symbol or an iterable of Symbols
          The Symbols that are the independent variables of the functions.
  
      Returns
      =======
  
      eqns : list of Eq
          The list of differential equations, one for each function.
  
      Examples
      ========
  
      >>> from sympy import euler_equations, Symbol, Function
      >>> x = Function('x')
      >>> t = Symbol('t')
      >>> L = (x(t).diff(t))**2/2 - x(t)**2/2
      >>> euler_equations(L, x(t), t)
      [Eq(-x(t) - Derivative(x(t), (t, 2)), 0)]
      >>> u = Function('u')
      >>> x = Symbol('x')
      >>> L = (u(t, x).diff(t))**2/2 - (u(t, x).diff(x))**2/2
      >>> euler_equations(L, u(t, x), [t, x])
      [Eq(-Derivative(u(t, x), (t, 2)) + Derivative(u(t, x), (x, 2)), 0)]
  
      References
      ==========
  
      .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation
  
      """
  
      funcs = tuple(funcs) if iterable(funcs) else (funcs,)
  
      if not funcs:
          funcs = tuple(L.atoms(Function))
      else:
          for f in funcs:
              if not isinstance(f, Function):
                  raise TypeError("Function expected, got: %s" % f)
  
      vars = tuple(vars) if iterable(vars) else (vars,)
  
      if not vars:
          vars = funcs[0].args
      else:
          vars = tuple(sympify(var) for var in vars)
  
      if not all(isinstance(v, Symbol) for v in vars):
          raise TypeError("Variables are not symbols, got %s" % vars)
  
      for f in funcs:
          if not vars == f.args:
              raise ValueError(
                  "Variables %s do not match args: %s" % (vars, f)
              )
  
      order = max(
          [
              len(d.variables)
              for d in L.atoms(Derivative)
              if d.expr in funcs
          ]
          + [0]
      )
  
      eqns = []
      for f in funcs:
          eq = diff(L, f)
          for i in range(1, order + 1):
              for p in combinations_with_replacement(vars, i):
                  eq = eq + S.NegativeOne**i * diff(
                      L, diff(f, *p), *p
                  )
          new_eq = Eq(eq, 0)
          if isinstance(new_eq, Eq):
              eqns.append(new_eq)
  
      return eqns
  
file_path: sympy/sympy/calculus/euler.py
imports: from itertools import combinations_with_replacement
  from sympy.core.function import Derivative, Function, diff
  from sympy.core.relational import Eq
  from sympy.core.singleton import S
  from sympy.core.symbol import Symbol
  from sympy.core.sympify import sympify
  from sympy.utilities.iterables import iterable
label_desc: Use image node_id 1 for calling a global function with example usage: euler_equations(L, funcs, vars) and returns: eqns