Args:
            state (DFA state): The dfa state
            state_training_data (list): The training data set
        Returns:
            list: A list of transitions

def _get_predicate_guards(self, state, state_training_data):
        """
        Args:
            state (DFA state): The dfa state
            state_training_data (list): The training data set
        Returns:
            list: A list of transitions
        """
        # choose the sink transition.

        # First option: Just the maximum transition
        # sink = max(state_training_data, key=lambda x: len(x[1]))[0]

        # Second option: Heuristics based on RE filters properties
        max_size_trans = max(state_training_data, key=lambda x: len(x[1]))
        max_size_trans_l = [x for x in state_training_data if
                            len(x[1]) == len(max_size_trans[1])]

        target_states = [t[0] for t in max_size_trans_l]
        if len(max_size_trans_l) == 1:
            sink = max_size_trans[0]
        elif '' in target_states:
            sink = ''
        elif state in target_states:
            sink = state
        else:
            sink = random.choice(target_states)
        # End of sink selection

        transitions = []
        known_symbols = []
        for (t, data) in state_training_data:
            if t == sink:
                continue
            pred = SetPredicate(data)
            transitions.append((t, pred))
            known_symbols += data
        transitions.append(
            (sink, SetPredicate(set(self.alphabet) - set(known_symbols))))
        return transitions