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