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: Return tuples for each argument of self that give
  the expression and the interval in which it is valid
  which is contained within the given domain.
  If a condition cannot be converted to a set, an error
  will be raised. The variable of the conditions is
  assumed to be real; sets of real values are returned.
  
  Examples
  ========
  
  >>> from sympy import Piecewise, Interval
  >>> from sympy.abc import x
  >>> p = Piecewise(
  ...     (1, x < 2),
  ...     (2,(x > 0) & (x < 4)),
  ...     (3, True))
  >>> p.as_expr_set_pairs()
  [(1, Interval.open(-oo, 2)),
   (2, Interval.Ropen(2, 4)),
   (3, Interval(4, oo))]
  >>> p.as_expr_set_pairs(Interval(0, 3))
  [(1, Interval.Ropen(0, 2)),
   (2, Interval(2, 3))]
docstr_tok: ["Return","tuples","for","each","argument","of","self","that","give","the","expression","and","the","interval","in","which","it","is","valid","which","is","contained","within","the","given","domain",".","If","a","condition","can","not","be","converted","to","a","set",",","an","error","will","be","raised",".","The","variable","of","the","conditions","is","assumed","to","be","real",";","sets","of","real","values","are","returned",".","Examples","========",">",">",">","from","sympy","import","Piecewise",",","Interval",">",">",">","from","sympy.abc","import","x",">",">",">","p","=","Piecewise","(","...","(","1",",","x","<","2",")",",","...","(","2",",","(","x",">","0",")","&","(","x","<","4",")",")",",","...","(","3",",","True",")",")",">",">",">","p.as_expr_set_pairs","(",")","[","(","1",",","Interval.open","(","-oo",",","2",")",")",",","(","2",",","Interval.Ropen","(","2",",","4",")",")",",","(","3",",","Interval","(","4",",","oo",")",")","]",">",">",">","p.as_expr_set_pairs","(","Interval","(","0",",","3",")",")","[","(","1",",","Interval.Ropen","(","0",",","2",")",")",",","(","2",",","Interval","(","2",",","3",")",")","]"]
code: def as_expr_set_pairs(self, domain=None):
      """Return tuples for each argument of self that give
      the expression and the interval in which it is valid
      which is contained within the given domain.
      If a condition cannot be converted to a set, an error
      will be raised. The variable of the conditions is
      assumed to be real; sets of real values are returned.
  
      Examples
      ========
  
      >>> from sympy import Piecewise, Interval
      >>> from sympy.abc import x
      >>> p = Piecewise(
      ...     (1, x < 2),
      ...     (2,(x > 0) & (x < 4)),
      ...     (3, True))
      >>> p.as_expr_set_pairs()
      [(1, Interval.open(-oo, 2)),
       (2, Interval.Ropen(2, 4)),
       (3, Interval(4, oo))]
      >>> p.as_expr_set_pairs(Interval(0, 3))
      [(1, Interval.Ropen(0, 2)),
       (2, Interval(2, 3))]
      """
      if domain is None:
          domain = S.Reals
      exp_sets = []
      U = domain
      complex = not domain.is_subset(S.Reals)
      cond_free = set()
      for expr, cond in self.args:
          cond_free |= cond.free_symbols
          if len(cond_free) > 1:
              raise NotImplementedError(
                  filldedent(
                      """
                      multivariate conditions are not handled."""
                  )
              )
          if complex:
              for i in cond.atoms(Relational):
                  if not isinstance(i, (Eq, Ne)):
                      raise ValueError(
                          filldedent(
                              """
                              Inequalities in the complex domain are
                              not supported. Try the real domain by
                              setting domain=S.Reals"""
                          )
                      )
          cond_int = U.intersect(cond.as_set())
          U = U - cond_int
          if cond_int != S.EmptySet:
              exp_sets.append((expr, cond_int))
      return exp_sets
  
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 22 for calling the Piecewise obj's underlying member method code with example usage: obj.as_expr_set_pairs(domain) and returns: exp_sets