Method `word_problem` of `PermutationGroupElement` is severely broken #36419

Tc14Hd · 2023-10-07T09:57:16Z

Steps To Reproduce

Take this code snippet as an example:

P = PermutationGroup([[(1, 2)], [(1, 2, 3, 4)]])
p = P([(1, 4)])
p.word_problem(P.gens())

Expected Behavior

The string representation of the solution should match the list representation.

Actual Behavior

This is the output:

x1^-1*x2^-1*(x2^-1*x1^-1)^2*x2
[['(1,2)', -1], ['(1,2,3,4)', -1], ['((1,2,3,4)', -1], ['(1,2)', 1], ['(1,2,3,4)', 1]]

The third permutation of the list contains an excess parenthesis and the exponent of the fourth element is wrong. It seems like the method can't process the (x2^-1*x1^-1)^2 part correctly.

Additional Information

This bug has already been described here.

I also looked at the implementation of word_problem:

sage/src/sage/groups/perm_gps/permgroup_element.pyx

Lines 2013 to 2047 in 1cf0c13

    
           if not self._parent._has_natural_domain(): 
        
               raise NotImplementedError 
        
           def convert_back(string): 
        
               L = copy.copy(string) 
        
               for i, w_i in enumerate(words): 
        
                   L = L.replace("x" + str(i + 1), str(w_i)) 
        
               return L 
        
           g = words[0].parent()(self) 
        
           H = libgap.Group(words) 
        
           ans = H.EpimorphismFromFreeGroup().PreImagesRepresentative(g) 
        
           l1 = str(ans) 
        
           l2 = convert_back(l1) 
        
           if display or as_list: 
        
               l3 = l1.split("*") 
        
               l4 = [] 
        
               for m in l3:  # parsing the word for display 
        
                   m_split = m.split("^") 
        
                   if len(m_split) == 2: 
        
                       l4.append([m_split[0], int(m_split[1])]) 
        
                   else: 
        
                       l4.append([m_split[0], 1]) 
        
               l5 = [[convert_back(w), e] for w, e in l4] 
        
           if display: 
        
               print(l1) 
        
               print(l5) 
        
           if as_list: 
        
               return l5 
        
           else: 
        
               return l1, l2

I hate to say it, but there's so much wrong with this: The code parses the string output of GAP instead of using built-in functions, which is already a bad idea. The parsing doesn't take into account that there can be parentheses in the output, which explains why my code produces wrong results.

Furthermore, the helper function convert_back is also very problematic. It replaces the variable identifiers contained in the string with their value, but does so by naive find and replace. This means that variables like x10 will also be partially replaced during the replacement of x1. The following code demonstrates that:

P = PermutationGroup([[(1, 2)]] * 9 + [[(3, 4, 5)]], canonicalize=False)
p = P([(3, 4, 5)])
p.word_problem(P.gens())

Output:

x10
[['(1,2)0', 1]]

The L = copy.copy(string) in line 2017 is also unnecessary because strings are immutable in Python, but that's just a minor complaint.

But I not only want to complain, so here's a draft of how I would implement it:

element = words[0].parent()(self)
group = libgap.Group(words)
solution = group.EpimorphismFromFreeGroup().PreImagesRepresentative(element)

solutionList = []
for i in range(1, solution.NumberSyllables() + 1):
    generator = int(solution.GeneratorSyllable(i))
    exponent = int(solution.ExponentSyllable(i))
    solutionList.append((generator, exponent))

Note that this avoids parsing strings by using the built-in methods NumberSyllables, GeneratorSyllable and ExponentSyllable. Also note that the list now contains the indices of the generators and not their string representations, which is much more useful to the user of the method.
I would flesh this out to a working pull request, but first someone has to tell me whether (or how much) I'm allowed to break backward compatibility.

Environment

OS: Ubuntu 20.04
Sage Version: 9.0
GAP Version: 4.10.2 of 19-Jun-2019

Checklist

I have searched the existing issues for a bug report that matches the one I want to file, without success.
I have read the documentation and troubleshoot guide

The text was updated successfully, but these errors were encountered:

fchapoton · 2023-10-29T15:51:38Z

please make a pull request

fchapoton · 2023-10-29T15:52:17Z

and check before the situation with the latest version of sage (10.2.beta8)

Tc14Hd · 2023-10-29T16:06:38Z

@fchapoton Thank you for your reply! I'm planning to make a pull request, but first I have to know your policy on backward compatibility. As I already mentioned in the issue, I want to change the string representation of the elements in the list to an index representation because I think that would greatly improve the usefulness of the method. Is such a breaking change likely to be accepted or do you require 100% backward compatibility?

fchapoton · 2023-10-29T19:42:19Z

We have a standard deprecation policy : one year after the first stable release containing the merge request.

I suggest to add your code as the new default algorithm and keep the old code as an optional algorithm, with deprecation.

EigenVector22 · 2025-03-29T10:17:07Z

Hello @fchapoton, i think i have fixed this issue, basically what i have done is

I’ve introduced a syllable-based algorithm while keeping the legacy string-parsing method for backward compatibility:

i have added the algorithm parameter with two options:

'syllable' (now the default): that is using GAP’s syllable functions for parsing, avoiding the problems with string replacements that caused the original issue.

'legacy': is Keeping the old string-parsing approach but marks it as deprecated with a warning, so anyone can still access it if needed.

This replaces the fragile string parsing in PermutationGroupElement.word_problem with a stable method using GAP's syllable functions (NumberSyllables, GeneratorSyllable, ExponentSyllable). This resolves parsing errors involving parentheses and generator name conflicts (e.g., x10 vs x1). Introduces an 'algorithm' parameter: - 'syllable' (Now default): Returns 1-based generator indices when as_list=True. - 'legacy': Old implementation, preserved for testing but deprecated due to known bugs. Returns generator strings when as_list=True. Updated docstrings and examples accordingly. Fixes sagemath#36419 Related: sagemath#28556

Tc14Hd added the t: bug label Oct 7, 2023

mkoeppe added the c: group theory label Feb 17, 2024

EigenVector22 linked a pull request Mar 29, 2025 that will close this issue

Corrected word_problem parsing and added algorithm option #39820

Open

5 tasks

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Method `word_problem` of `PermutationGroupElement` is severely broken #36419

Method `word_problem` of `PermutationGroupElement` is severely broken #36419

Tc14Hd commented Oct 7, 2023 •

edited

Loading

fchapoton commented Oct 29, 2023

fchapoton commented Oct 29, 2023

Tc14Hd commented Oct 29, 2023

fchapoton commented Oct 29, 2023

EigenVector22 commented Mar 29, 2025 •

edited

Loading

Method word_problem of PermutationGroupElement is severely broken #36419

Method word_problem of PermutationGroupElement is severely broken #36419

Comments

Tc14Hd commented Oct 7, 2023 • edited Loading

Steps To Reproduce

Expected Behavior

Actual Behavior

Additional Information

Environment

Checklist

fchapoton commented Oct 29, 2023

fchapoton commented Oct 29, 2023

Tc14Hd commented Oct 29, 2023

fchapoton commented Oct 29, 2023

EigenVector22 commented Mar 29, 2025 • edited Loading

Method `word_problem` of `PermutationGroupElement` is severely broken #36419

Method `word_problem` of `PermutationGroupElement` is severely broken #36419

Tc14Hd commented Oct 7, 2023 •

edited

Loading

EigenVector22 commented Mar 29, 2025 •

edited

Loading