docs: def _init_smi(self, graph, access_strings_map):
          """
          Args:
              graph (DFA): The DFA states
              access_strings_map (list): a dict containing all the access strings for each state
          Return:
              list: SMI transition table
          """
          smi = []
          for selected_state in sorted(graph.states, key=attrgetter('initial'), reverse=True):
              # Initially gather all transitions of the state into a dictionary
              transitions_map = defaultdict(list)
              for character in self.alphabet:
                  destination_state = self._delta(graph, selected_state, character)
                  transitions_map[destination_state.stateid].append(character)
  
              chars_in_smi = []
              sorted_transitions = sorted(
                  transitions_map.items(),
                  key=lambda x: len(
                      x[1]))
  
              if len(sorted_transitions) == 1:
                  # Just put 1 symbol is enough all other'input_string will be generalized
                  # by the guardgen algorithm
                  chars_in_smi.append(self.alphabet[0])
              else:
                  # Otherwise insert in smi_vector all transitions as explicit except
                  # the one from the sink transition where we add just enough
                  # explicity transitions to make sure that this state will be
                  # selected as the sink state.
                  #
                  # If no transition has a clear advantage in terms of symbols then
                  # just add all transitions in explicit form because it may be the
                  # case the guardgen() will generalize in the wrong transition.
                  for (_, char_list) in sorted_transitions[:-1]:
                      chars_in_smi += char_list
  
                  sink_chars = len(sorted_transitions[-2][1]) + 1
                  chars_in_smi.extend(sorted_transitions[-1][1][:sink_chars])
  
              access_string = access_strings_map[selected_state.stateid]
              smi.extend([access_string + character for character in chars_in_smi])
          return smi