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
code: def _eval_rewrite_as_ITE(self, *args, **kwargs):
      byfree = {}
      args = list(args)
      default = any(c == True for b, c in args)
      for i, (b, c) in enumerate(args):
          if not isinstance(b, Boolean) and b != True:
              raise TypeError(
                  filldedent(
                      """
                      Expecting Boolean or bool but got `%s`
                      """
                      % func_name(b)
                  )
              )
          if c == True:
              break
          # loop over independent conditions for this b
          for c in c.args if isinstance(c, Or) else [c]:
              free = c.free_symbols
              x = free.pop()
              try:
                  byfree[x] = byfree.setdefault(x, S.EmptySet).union(
                      c.as_set()
                  )
              except NotImplementedError:
                  if not default:
                      raise NotImplementedError(
                          filldedent(
                              """
                              A method to determine whether a multivariate
                              conditional is consistent with a complete coverage
                              of all variables has not been implemented so the
                              rewrite is being stopped after encountering `%s`.
                              This error would not occur if a default expression
                              like `(foo, True)` were given.
                              """
                              % c
                          )
                      )
              if byfree[x] in (S.UniversalSet, S.Reals):
                  # collapse the ith condition to True and break
                  args[i] = list(args[i])
                  c = args[i][1] = True
                  break
          if c == True:
              break
      if c != True:
          raise ValueError(
              filldedent(
                  """
                  Conditions must cover all reals or a final default
                  condition `(foo, True)` must be given.
                  """
              )
          )
      last, _ = args[i]  # ignore all past ith arg
      for a, c in reversed(args[:i]):
          last = ITE(c, a, last)
      return _canonical(last)
  
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 23 for calling the Piecewise obj's underlying member method code with example usage: obj._eval_rewrite_as_ITE() and returns: _canonical