text: from sympy.core.decorators import _sympifyit
  from sympy.core.parameters import global_parameters
  from sympy.core.logic import fuzzy_bool
  from sympy.core.singleton import S
  from sympy.core.sympify import _sympify
  
  from .sets import Set, FiniteSet, SetKind
  
  
  class PowerSet(Set):
      r"""A symbolic object representing a power set.
  
      Parameters
      ==========
  
      arg : Set
          The set to take power of.
  
      evaluate : bool
          The flag to control evaluation.
  
          If the evaluation is disabled for finite sets, it can take
          advantage of using subset test as a membership test.
  
      Notes
      =====
  
      Power set `\mathcal{P}(S)` is defined as a set containing all the
      subsets of `S`.
  
      If the set `S` is a finite set, its power set would have
      `2^{\left| S \right|}` elements, where `\left| S \right|` denotes
      the cardinality of `S`.
  
      Examples
      ========
  
      >>> from sympy import PowerSet, S, FiniteSet
  
      A power set of a finite set:
  
      >>> PowerSet(FiniteSet(1, 2, 3))
      PowerSet({1, 2, 3})
  
      A power set of an empty set:
  
      >>> PowerSet(S.EmptySet)
      PowerSet(EmptySet)
      >>> PowerSet(PowerSet(S.EmptySet))
      PowerSet(PowerSet(EmptySet))
  
      A power set of an infinite set:
  
      >>> PowerSet(S.Reals)
      PowerSet(Reals)
  
      Evaluating the power set of a finite set to its explicit form:
  
      >>> PowerSet(FiniteSet(1, 2, 3)).rewrite(FiniteSet)
      FiniteSet(EmptySet, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3})
  
      References
      ==========
  
      .. [1] https://en.wikipedia.org/wiki/Power_set
  
      .. [2] https://en.wikipedia.org/wiki/Axiom_of_power_set
      """
      def __new__(cls, arg, evaluate=None):
          if evaluate is None:
              evaluate=global_parameters.evaluate
  
          arg = _sympify(arg)
  
          if not isinstance(arg, Set):
              raise ValueError('{} must be a set.'.format(arg))
  
          return super().__new__(cls, arg)
  
      @property
      def arg(self):
          return self.args[0]
  
      def _eval_rewrite_as_FiniteSet(self, *args, **kwargs):
          arg = self.arg
          if arg.is_FiniteSet:
              return arg.powerset()
          return None
  
      @_sympifyit('other', NotImplemented)
      def _contains(self, other):
          if not isinstance(other, Set):
              return None
  
          return fuzzy_bool(self.arg.is_superset(other))
  
      def _eval_is_subset(self, other):
          if isinstance(other, PowerSet):
              return self.arg.is_subset(other.arg)
  
      def __len__(self):
          return 2 ** len(self.arg)
  
      def __iter__(self):
          found = [S.EmptySet]
          yield S.EmptySet
  
          for x in self.arg:
              temp = []
              x = FiniteSet(x)
              for y in found:
                  new = x + y
                  yield new
                  temp.append(new)
              found.extend(temp)
  
      @property
      def kind(self):
          return SetKind(self.arg.kind)
  