docs: def _init_using_k_equivalence(self, given_graph, sfa=False):
          """
          Args:
              given_graph (DFA): The DFA states
              sfa (boolean): A boolean for chosing SFA
          Return:
              list, list, list: sm_vector, smi_vector, em_vector initialization vectors
          """
          graph = DFA(self.alphabet)
          graph.init_from_acceptor(given_graph)
          graph.fixminimized(self.alphabet)
  
          # Access Strings
          self.access_strings_map = self._bfs_path_states(graph, sorted(
              graph.states, key=attrgetter('initial'), reverse=True)[0])
  
          # Find Q
          set_q = set(self._object_set_to_state_list(graph.states))
          # We will work with states addresses here instead of states stateid for
          # more convenience
          set_f = set(self._object_set_to_state_list(self._get_accepted(graph)))
          # Perform P := {F, Q-F}
          set_nf = set_q.copy() - set_f.copy()
          self.groups = [set_f.copy(), set_nf.copy()]
          self.bookeeping = [(set_f, set_nf, '')]
  
          done = False
          while not done:
              done = True
              new_groups = []
              for selectgroup in self.groups:
                  # _check for each letter if it splits the current group
                  for character in self.alphabet:
                      # print 'Testing symbol: ', c
                      target = defaultdict(list)
                      target_states = defaultdict(int)
                      new_g = [set(selectgroup)]
                      for sid in selectgroup:
                          # _check if all transitions using c are going in a state
                          # in the same group. If they are going on a different
                          # group then split
                          deststate = self._delta(graph, graph[sid], character)
                          destgroup = self._get_group_from_state(
                              deststate.stateid)
                          target[destgroup].append(sid)
                          target_states[destgroup] = deststate.stateid
                      if len(target) > 1:
  
                          inv_target_states = {
                              v: k for k, v in target_states.iteritems()}
                          new_g = [set(selectedstate) for selectedstate in target.values()]
                          done = False
                          # Get all the partitions of destgroups
                          queue = [set([x for x in target_states.values()])]
                          while queue:
                              top = queue.pop(0)
                              (group1, group2, distinguish_string) = self._partition_group(top)
                              ng1 = self._reverse_to_source(
                                  target, [inv_target_states[x] for x in group1])
                              ng2 = self._reverse_to_source(
                                  target, [inv_target_states[x] for x in group2])
                              dist_string = character + distinguish_string
  
                              self.bookeeping.append((ng1, ng2, dist_string))
  
                              if len(group1) > 1:
                                  queue.append(group1)
                              if len(group2) > 1:
                                  queue.append(group2)
                          break
                  new_groups += new_g
  
              # End of iteration for the k-equivalence
              # Assign new groups and check if any change occured
              self.groups = new_groups
  
          sm_vector = [
              i for (a, i) in sorted(
                  self.access_strings_map.items(),
                  key=lambda x: len(x[1]))]
          if not sfa:
              smi_vector = ['{}{}'.format(a, b)
                            for b in self.alphabet for a in sm_vector]
          else:
              smi_vector = self._init_smi(graph, self.access_strings_map)
          em_vector = [distinguish_string for (_, _, distinguish_string) in self.bookeeping]
  
          return sm_vector, smi_vector, em_vector