class_docstr: Represents a piecewise function.
  
  Usage:
  
    Piecewise( (expr,cond), (expr,cond), ... )
      - Each argument is a 2-tuple defining an expression and condition
      - The conds are evaluated in turn returning the first that is True.
        If any of the evaluated conds are not explicitly False,
        e.g. ``x < 1``, the function is returned in symbolic form.
      - If the function is evaluated at a place where all conditions are False,
        nan will be returned.
      - Pairs where the cond is explicitly False, will be removed and no pair
        appearing after a True condition will ever be retained. If a single
        pair with a True condition remains, it will be returned, even when
        evaluation is False.
  
  Examples
  ========
  
  >>> from sympy import Piecewise, log, piecewise_fold
  >>> from sympy.abc import x, y
  >>> f = x**2
  >>> g = log(x)
  >>> p = Piecewise((0, x < -1), (f, x <= 1), (g, True))
  >>> p.subs(x,1)
  1
  >>> p.subs(x,5)
  log(5)
  
  Booleans can contain Piecewise elements:
  
  >>> cond = (x < y).subs(x, Piecewise((2, x < 0), (3, True))); cond
  Piecewise((2, x < 0), (3, True)) < y
  
  The folded version of this results in a Piecewise whose
  expressions are Booleans:
  
  >>> folded_cond = piecewise_fold(cond); folded_cond
  Piecewise((2 < y, x < 0), (3 < y, True))
  
  When a Boolean containing Piecewise (like cond) or a Piecewise
  with Boolean expressions (like folded_cond) is used as a condition,
  it is converted to an equivalent :class:`~.ITE` object:
  
  >>> Piecewise((1, folded_cond))
  Piecewise((1, ITE(x < 0, y > 2, y > 3)))
  
  When a condition is an ``ITE``, it will be converted to a simplified
  Boolean expression:
  
  >>> piecewise_fold(_)
  Piecewise((1, ((x >= 0) | (y > 2)) & ((y > 3) | (x < 0))))
  
  See Also
  ========
  
  piecewise_fold
  piecewise_exclusive
  ITE
docstr: Either return a modified version of the args or, if no
  modifications were made, return None.
  
  Modifications that are made here:
  
  1. relationals are made canonical
  2. any False conditions are dropped
  3. any repeat of a previous condition is ignored
  4. any args past one with a true condition are dropped
  
  If there are no args left, nan will be returned.
  If there is a single arg with a True condition, its
  corresponding expression will be returned.
  
  EXAMPLES
  ========
  
  >>> from sympy import Piecewise
  >>> from sympy.abc import x
  >>> cond = -x < -1
  >>> args = [(1, cond), (4, cond), (3, False), (2, True), (5, x < 1)]
  >>> Piecewise(*args, evaluate=False)
  Piecewise((1, -x < -1), (4, -x < -1), (2, True))
  >>> Piecewise(*args)
  Piecewise((1, x > 1), (2, True))
docstr_tok: ["Either","return","a","modified","version","of","the","args","or",",","if","no","modifications","were","made",",","return","None",".","Modifications","that","are","made","here",":","1.","relationals","are","made","canonical","2.","any","False","conditions","are","dropped","3.","any","repeat","of","a","previous","condition","is","ignored","4.","any","args","past","one","with","a","true","condition","are","dropped","If","there","are","no","args","left",",","nan","will","be","returned",".","If","there","is","a","single","arg","with","a","True","condition",",","its","corresponding","expression","will","be","returned",".","EXAMPLES","========",">",">",">","from","sympy","import","Piecewise",">",">",">","from","sympy.abc","import","x",">",">",">","cond","=","-x","<","-1",">",">",">","args","=","[","(","1",",","cond",")",",","(","4",",","cond",")",",","(","3",",","False",")",",","(","2",",","True",")",",","(","5",",","x","<","1",")","]",">",">",">","Piecewise","(","*","args",",","evaluate=False",")","Piecewise","(","(","1",",","-x","<","-1",")",",","(","4",",","-x","<","-1",")",",","(","2",",","True",")",")",">",">",">","Piecewise","(","*","args",")","Piecewise","(","(","1",",","x",">","1",")",",","(","2",",","True",")",")"]
code: def eval(cls, *_args):
      """Either return a modified version of the args or, if no
      modifications were made, return None.
  
      Modifications that are made here:
  
      1. relationals are made canonical
      2. any False conditions are dropped
      3. any repeat of a previous condition is ignored
      4. any args past one with a true condition are dropped
  
      If there are no args left, nan will be returned.
      If there is a single arg with a True condition, its
      corresponding expression will be returned.
  
      EXAMPLES
      ========
  
      >>> from sympy import Piecewise
      >>> from sympy.abc import x
      >>> cond = -x < -1
      >>> args = [(1, cond), (4, cond), (3, False), (2, True), (5, x < 1)]
      >>> Piecewise(*args, evaluate=False)
      Piecewise((1, -x < -1), (4, -x < -1), (2, True))
      >>> Piecewise(*args)
      Piecewise((1, x > 1), (2, True))
      """
      if not _args:
          return Undefined
  
      if len(_args) == 1 and _args[0][-1] == True:
          return _args[0][0]
  
      newargs = _piecewise_collapse_arguments(_args)
  
      # some conditions may have been redundant
      missing = len(newargs) != len(_args)
      # some conditions may have changed
      same = all(a == b for a, b in zip(newargs, _args))
      # if either change happened we return the expr with the
      # updated args
      if not newargs:
          raise ValueError(
              filldedent(
                  """
                  There are no conditions (or none that
                  are not trivially false) to define an
                  expression."""
              )
          )
      if missing or not same:
          return cls(*newargs)
  
imports: from sympy.core import S, Function, diff, Tuple, Dummy, Mul
  from sympy.core.basic import Basic, as_Basic
  from sympy.core.numbers import Rational, NumberSymbol, _illegal
  from sympy.core.parameters import global_parameters
  from sympy.core.relational import Lt, Gt, Eq, Ne, Relational, _canonical, _canonical_coeff
  from sympy.core.sorting import ordered
  from sympy.functions.elementary.miscellaneous import Max, Min
  from sympy.logic.boolalg import And, Boolean, distribute_and_over_or, Not, true, false, Or, ITE, simplify_logic, to_cnf, distribute_or_over_and
  from sympy.utilities.iterables import uniq, sift, common_prefix
  from sympy.utilities.misc import filldedent, func_name
  from itertools import product
label_desc: Use image node_id 2 for calling the Piecewise obj's underlying member method code with example usage: obj.eval(cls) and returns: Undefined, _args, cls