docs: def _initialize_pvariables(self,
              pvariables: Dict[str, PVariable],
              ordering: List[str],
              initializer: Optional[InitializerList] = None) -> List[Tuple[str, TensorFluent]]:
          '''Instantiates `pvariables` given an initialization list and
          returns a list of TensorFluents in the given `ordering`.
  
          Returns:
              List[Tuple[str, TensorFluent]]: A list of pairs of fluent name and fluent tensor.
          '''
          if initializer is not None:
              init = dict()
              for ((name, args), value) in initializer:
                  arity = len(args) if args is not None else 0
                  name = '{}/{}'.format(name, arity)
                  init[name] = init.get(name, [])
                  init[name].append((args, value))
  
          fluents = []
  
          for name in ordering:
              pvar = pvariables[name]
              shape = self.rddl._param_types_to_shape(pvar.param_types)
              dtype = utils.range_type_to_dtype(pvar.range)
              fluent = np.full(shape, pvar.default)
  
              if initializer is not None:
                  for args, val in init.get(name, []):
                      if args is not None:
                          idx = []
                          for ptype, arg in zip(pvar.param_types, args):
                              idx.append(self.rddl.object_table[ptype]['idx'][arg])
                          idx = tuple(idx)
                          fluent[idx] = val
                      else:
                          fluent = val
  
              with self.graph.as_default():
                  t = tf.constant(fluent, dtype=dtype, name=utils.identifier(name))
                  scope = [None] * len(t.shape)
                  fluent = TensorFluent(t, scope, batch=False)
                  fluent_pair = (name, fluent)
                  fluents.append(fluent_pair)
  
          return fluents