code: def find_measurable_max_neg(
      fgraph: FunctionGraph, node: Node
  ) -> Optional[List[TensorVariable]]:
      rv_map_feature = getattr(fgraph, "preserve_rv_mappings", None)
  
      if rv_map_feature is None:
          return None  # pragma: no cover
  
      if isinstance(node.op, MeasurableMaxNeg):
          return None  # pragma: no cover
  
      base_var = node.inputs[0]
  
      if base_var.owner is None:
          return None
  
      if not rv_map_feature.request_measurable(node.inputs):
          return None
  
      # Min is the Max of the negation of the same distribution. Hence, op must be Elemwise
      if not isinstance(base_var.owner.op, Elemwise):
          return None
  
      # negation is rv * (-1). Hence the scalar_op must be Mul
      try:
          if not (
              isinstance(base_var.owner.op.scalar_op, Mul)
              and len(base_var.owner.inputs) == 2
              and get_underlying_scalar_constant_value(
                  base_var.owner.inputs[1]
              )
              == -1
          ):
              return None
      except NotScalarConstantError:
          return None
  
      base_rv = base_var.owner.inputs[0]
  
      # Non-univariate distributions and non-RVs must be rejected
      if not (
          isinstance(base_rv.owner.op, RandomVariable)
          and base_rv.owner.op.ndim_supp == 0
      ):
          return None
  
      # TODO: We are currently only supporting continuous rvs
      if isinstance(
          base_rv.owner.op, RandomVariable
      ) and base_rv.owner.op.dtype.startswith("int"):
          return None
  
      # univariate i.i.d. test which also rules out other distributions
      for params in base_rv.owner.inputs[3:]:
          if params.type.ndim != 0:
              return None
  
      # Check whether axis is supported or not
      axis = set(node.op.axis)
      base_var_dims = set(range(base_var.ndim))
      if axis != base_var_dims:
          return None
  
      measurable_min = MeasurableMaxNeg(list(axis))
      min_rv_node = measurable_min.make_node(base_var)
      min_rv = min_rv_node.outputs
  
      return min_rv
  
imports: from typing import List, Optional
  import pytensor.tensor
  from pytensor.graph.basic import Node
  from pytensor.graph.fg import FunctionGraph
  from pytensor.graph.rewriting.basic import node_rewriter
  from pytensor.scalar.basic import Mul
  from pytensor.tensor.basic import get_underlying_scalar_constant_value
  from pytensor.tensor.elemwise import Elemwise
  from pytensor.tensor.exceptions import NotScalarConstantError
  from pytensor.tensor.math import Max
  from pytensor.tensor.random.op import RandomVariable
  from pytensor.tensor.variable import TensorVariable
  from pymc.logprob.abstract import MeasurableVariable, _logcdf_helper, _logprob, _logprob_helper
  from pymc.logprob.rewriting import measurable_ir_rewrites_db
  from pymc.math import logdiffexp
  from pymc.pytensorf import constant_fold
label_desc: Use image node_id 4 for calling a global function with example usage: find_measurable_max_neg(fgraph, node) and returns: min_rv, None, None, None, None, None, None, None, None, None, None, None