code: def state_to_operators(state, **options):
      """Returns the operator or set of operators corresponding to the
      given eigenstate
  
      A global function for mapping state classes to their associated
      operators or sets of operators. It takes either a state class
      or instance.
  
      This function can handle both instances of a given state or just
      the class itself (i.e. both XKet() and XKet)
  
      There are multiple use cases to consider:
  
      1) A state class is passed: In this case, we first try
      instantiating a default instance of the class. If this succeeds,
      then we try to call state._state_to_operators on that instance.
      If the creation of the default instance or if the calling of
      _state_to_operators fails, then either an operator class or set of
      operator classes is returned. Otherwise, the appropriate
      operator instances are returned.
  
      2) A state instance is returned: Here, state._state_to_operators
      is called for the instance. If this fails, then a class or set of
      operator classes is returned. Otherwise, the instances are returned.
  
      In either case, if the state's class does not exist in
      state_mapping, None is returned.
  
      Parameters
      ==========
  
      arg: StateBase class or instance (or subclasses)
           The class or instance of the state to be mapped to an
           operator or set of operators
  
      Examples
      ========
  
      >>> from sympy.physics.quantum.cartesian import XKet, PxKet, XBra, PxBra
      >>> from sympy.physics.quantum.operatorset import state_to_operators
      >>> from sympy.physics.quantum.state import Ket, Bra
      >>> state_to_operators(XKet)
      X
      >>> state_to_operators(XKet())
      X
      >>> state_to_operators(PxKet)
      Px
      >>> state_to_operators(PxKet())
      Px
      >>> state_to_operators(PxBra)
      Px
      >>> state_to_operators(XBra)
      X
      >>> state_to_operators(Ket)
      O
      >>> state_to_operators(Bra)
      O
      """
  
      if not (
          isinstance(state, StateBase) or issubclass(state, StateBase)
      ):
          raise NotImplementedError("Argument is not a state!")
  
      if state in state_mapping:  # state is a class
          state_inst = _make_default(state)
          try:
              ret = _get_ops(
                  state_inst, _make_set(state_mapping[state]), **options
              )
          except (NotImplementedError, TypeError):
              ret = state_mapping[state]
      elif type(state) in state_mapping:
          ret = _get_ops(
              state, _make_set(state_mapping[type(state)]), **options
          )
      elif (
          isinstance(state, BraBase)
          and state.dual_class() in state_mapping
      ):
          ret = _get_ops(
              state, _make_set(state_mapping[state.dual_class()])
          )
      elif (
          issubclass(state, BraBase)
          and state.dual_class() in state_mapping
      ):
          state_inst = _make_default(state)
          try:
              ret = _get_ops(
                  state_inst,
                  _make_set(state_mapping[state.dual_class()]),
              )
          except (NotImplementedError, TypeError):
              ret = state_mapping[state.dual_class()]
      else:
          ret = None
  
      return _make_set(ret)
  
file_path: sympy/sympy/physics/quantum/operatorset.py
imports: from sympy.physics.quantum.cartesian import XOp, YOp, ZOp, XKet, PxOp, PxKet, PositionKet3D
  from sympy.physics.quantum.operator import Operator
  from sympy.physics.quantum.state import StateBase, BraBase, Ket
  from sympy.physics.quantum.spin import JxOp, JyOp, JzOp, J2Op, JxKet, JyKet, JzKet
label_desc: Use image node_id 2 for calling a global function with example usage: state_to_operators(state) and returns: _make_set