def _simplifyWithAlgo2(self, element): """ Find the simplest form of an element. For example, for the group of 1 generator x1 and 1 relation x1^5=0, [1,1,1,1] will return [3] This works with element in list form. """ #If element is [1,2,3], element_sublists will be [[1,2,3], [1,2], [2,3], [1], [2], [3]] if element == []: return [] element_sublists = sublists(element) transformed_element = element for sequence in element_sublists: #If it is not the case, realize the step above with stronger transformation, i.e, substitute with longer sequence transformed_sequence = self._shortenSequence(sequence) if transformed_sequence != sequence: transformed_sequence = self._shortenSequenceWithAlgo1(sequence) if transformed_sequence != sequence: position = position_of_list_in_list(sequence, element) transformed_element = element[:position] + transformed_sequence + element[position + len(sequence):] break if transformed_element != element: element = transformed_element return self._simplify(transformed_element) if len(element) <= self.nb_terms_in_simplest_form: #Stop if the simplified form is already short enough return element # When nothing changes, return the last form return element
def _simplifyWithAlgo1(self, element): """ Find the simplest form of an element. For example, for the group of 1 generator x1 and 1 relation x1^5=0, [1,1,1,1] will return [3] This works with element in list form. """ #If element is [1,2,3], element_sublists will be [[1,2,3], [1,2], [2,3], [1], [2], [3]] if element == []: return [] element_sublists = sublists(element) transformed_element = element for sequence in element_sublists: #Sequence is an element of sublists, is sth like [1,2,3] or [1,2] transformed_sequence = self._shortenSequence(sequence) #After this step, if there are some relation like [1,2,1] = [] then [1,2] will be replaced by [4] if transformed_sequence != sequence: position = position_of_list_in_list(sequence, element) transformed_element = element[:position] + transformed_sequence + element[position + len(sequence):] #It will be then substituted in [1,2,3], this latter become [4,3] break if transformed_element != element: #Recurse this step to have a shorter form element = transformed_element return self._simplify(transformed_element) if len(element) <= self.nb_terms_in_simplest_form: #Stop if the simplified form is already short enough return element # When nothing changes, return the last form return element
def _shortenSequenceInSpecifiedRelation(self, sequence, relation): """ Sequence is the list form of an element """ position = position_of_list_in_list(sequence, relation) remaining = remaining_of_list_after_removing(sequence, relation, position) transformed_sequence = self._inverse(remaining[0]) + self._inverse(remaining[1]) return transformed_sequence
def _shortenSequenceWithAlgo2(self, sequence): """ Sequence is the list form of an element """ ordered_generalized_relations = sorted(self.generalized_relations, key = lambda x: len(x)) transformed_sequence = sequence for relation in ordered_generalized_relations: #relation is sth like [0,1,2,2] if 2 * len(sequence) >= len(relation) and position_of_list_in_list(sequence, relation) >= 0: transformed_sequence = self._shortenSequenceInSpecifiedRelation(sequence, relation) break return transformed_sequence