code: def _(expr, assumptions):
      """
      Return True if expr is bounded, False if not and None if unknown.
  
      Truth Table:
  
      +-------+-----+-----------+-----------+
      |       |     |           |           |
      |       |  B  |     U     |     ?     |
      |       |     |           |           |
      +-------+-----+---+---+---+---+---+---+
      |       |     |   |   |   |   |   |   |
      |       |     |'+'|'-'|'x'|'+'|'-'|'x'|
      |       |     |   |   |   |   |   |   |
      +-------+-----+---+---+---+---+---+---+
      |       |     |           |           |
      |   B   |  B  |     U     |     ?     |
      |       |     |           |           |
      +---+---+-----+---+---+---+---+---+---+
      |   |   |     |   |   |   |   |   |   |
      |   |'+'|     | U | ? | ? | U | ? | ? |
      |   |   |     |   |   |   |   |   |   |
      |   +---+-----+---+---+---+---+---+---+
      |   |   |     |   |   |   |   |   |   |
      | U |'-'|     | ? | U | ? | ? | U | ? |
      |   |   |     |   |   |   |   |   |   |
      |   +---+-----+---+---+---+---+---+---+
      |   |   |     |           |           |
      |   |'x'|     |     ?     |     ?     |
      |   |   |     |           |           |
      +---+---+-----+---+---+---+---+---+---+
      |       |     |           |           |
      |   ?   |     |           |     ?     |
      |       |     |           |           |
      +-------+-----+-----------+---+---+---+
  
          * 'B' = Bounded
  
          * 'U' = Unbounded
  
          * '?' = unknown boundedness
  
          * '+' = positive sign
  
          * '-' = negative sign
  
          * 'x' = sign unknown
  
          * All Bounded -> True
  
          * 1 Unbounded and the rest Bounded -> False
  
          * >1 Unbounded, all with same known sign -> False
  
          * Any Unknown and unknown sign -> None
  
          * Else -> None
  
      When the signs are not the same you can have an undefined
      result as in oo - oo, hence 'bounded' is also undefined.
      """
      sign = -1  # sign of unknown or infinite
      result = True
      for arg in expr.args:
          _bounded = ask(Q.finite(arg), assumptions)
          if _bounded:
              continue
          s = ask(Q.extended_positive(arg), assumptions)
          # if there has been more than one sign or if the sign of this arg
          # is None and Bounded is None or there was already
          # an unknown sign, return None
          if (
              sign != -1
              and s != sign
              or s is None
              and None in (_bounded, sign)
          ):
              return None
          else:
              sign = s
          # once False, do not change
          if result is not False:
              result = _bounded
      return result
  
file_path: sympy/sympy/assumptions/handlers/calculus.py
imports: from sympy.assumptions import Q, ask
  from sympy.core import Add, Mul, Pow, Symbol
  from sympy.core.numbers import NegativeInfinity, GoldenRatio, Infinity, Exp1, ComplexInfinity, ImaginaryUnit, NaN, Number, Pi, E, TribonacciConstant
  from sympy.functions import cos, exp, log, sign, sin
  from sympy.logic.boolalg import conjuncts
  from ..predicates.calculus import FinitePredicate, InfinitePredicate, PositiveInfinitePredicate, NegativeInfinitePredicate
label_desc: Use image node_id 2 for calling a global function with example usage: _(expr, assumptions) and returns: result, None