Recog An/Sn unknown degree: conder, holt by ssiccha · Pull Request #265 · gap-packages/recog

ssiccha · 2021-04-09T15:25:27Z

A PR based on #176.

We are going to implement the extensions by Conder and Derek Holt's
GuessAltSymDegree.

ssiccha · 2021-04-12T12:12:12Z

Rebased the last commit onto the current version of #176.

codecov · 2021-04-12T12:21:57Z

Codecov Report

❌ Patch coverage is 75.32468% with 95 lines in your changes missing coverage. Please review.
✅ Project coverage is 70.48%. Comparing base (c309d8a) to head (16bace0).

Files with missing lines	Patch %	Lines
gap/generic/SnAnUnknownDegree.gi	75.13%	95 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##           master     #265      +/-   ##
==========================================
+ Coverage   69.12%   70.48%   +1.35%     
==========================================
  Files          43       43              
  Lines       18321    18637     +316     
==========================================
+ Hits        12665    13136     +471     
+ Misses       5656     5501     -155

Files with missing lines	Coverage Δ
gap/matrix.gi	`92.97% <100.00%> (+0.01%)`	⬆️
gap/perm.gi	`79.76% <100.00%> (+0.07%)`	⬆️
gap/projective.gi	`83.17% <100.00%> (+0.08%)`	⬆️
gap/generic/SnAnUnknownDegree.gi	`85.07% <75.13%> (-5.02%)`	⬇️

... and 12 files with indirect coverage changes

🚀 New features to boost your workflow:

❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

FriedrichRober · 2022-03-28T19:53:53Z

Link to our Hackmd

ssiccha · 2022-03-29T23:35:23Z

We should be almost done. We think there are two TODOs left: clean up the tests and figure out what to do with small classical groups like: Omega(-1,4,3). It has element orders <= 5, thus slips through our heuristics to weed out groups which are not isomorphic to An or Sn. Hence the SnAnUnknownDegree algorithm takes forever until it realizes, that the group in question is not an An or Sn. We think we should be able to alleviate this by simply saying that we're NeverApplicable if the vector space our group acts has less than e.g. 100 elements. And then we'll post a challenge on slack or the GAP forum whether somebody can find a small group, which makes the algorithm run slow.

And get the tests to pass again. :)

And in Make CallMethods directly write into the RecogNode update the docs of CallMethods.

And, @FriedrichRober is writing a short text, how all the parts fit together, that is how our implementation differs from a "vanilla" implementation of the JLNP algorithm according to the paper.

fingolfin · 2022-03-30T13:45:31Z

Awesome, thank you!

fingolfin · 2022-04-06T22:29:37Z

@FriedrichRober do you think you can finish this on your own, now that @ssiccha is gone? Perhaps I can help a bit?

FriedrichRober · 2022-04-07T06:47:22Z

Yes, I think I can finish this on my own. The code is finished (except for handling small classical groups). What is missing now is to finish the documentation (comments) and looking at the runtime of the test suite.

FriedrichRober · 2022-11-07T03:42:42Z

@fingolfin, ich habe nun die Änderungen implementiert, wie wir es besprochen haben. Wir geben früher auf, und speichern uns die Iteratoren im recog node ab, um sie später weiter zu verwenden. Trotzdem dauert die Test-Suite auf meinem Rechner 3-4 Minuten länger als auf dem master. Meiner Meinung nach ist dieser Zustand inakzeptabel, um das einfach so zu mergen :(

Ich muss dann nochmal genau schauen, an welchen Stellen wir zu viel Zeit verschwenden, und ob sich da was machen lässt.

FriedrichRober · 2025-12-09T15:57:05Z

@fingolfin, the pull request is ready now. The test suite on my laptop was as quick as on master, however some unrelated errors occures. Two where the stamp is not what was expected in the test file. One where the group was wrongly recognized which would require further investigation. I assume that this is a random error which simply occured from inserting the recognition method into the database.

fingolfin · 2025-12-11T19:09:07Z

Fantastic, @FriedrichRober, thank you so much!

fingolfin · 2025-12-11T21:22:30Z

doc/recog.bib

+    AUTHOR = {Conder, Jonathan},
+     TITLE = {Algorithms for Permutation Groups},
+      YEAR = {2012},
+      NOTE = {TODO},


Could this be filled in by someone? At which university was this thesis written; what kind of thesis was it?

I talked to @aniemeyer and learned that this was a thesis in Auckland, but I didn't find something initially. But now it seems this was indeed a B.Sc. thesis there, and it was written by @jonathan-conder . I have now pinged them, and will also write an email. Perhaps we get permissions to post the thesis somewhere, or perhaps Jonathan is willing to put it on e.g. the arXiv (I am not sure if they accept such things, but it seems to contain original research, and they definitely have at least phd theses?)

Jonathan replied to my email and generously gave permission to share copies of his thesis, and he also made it available at https://jonathan-conder.github.io/afpg.pdf -- this should keep working for the foreseeable future, and I also made sure archive.org has a snapshot. Still, we should probably see if we can also get this onto e.g. Zenodo or so.

Anyway, that gives us enough info to complete this bib record. I'll do so eventually (if nobody beats me to it).

See https://web.archive.org/web/20251219002033/https://jonathan-conder.github.io/afpg.pdf -- we could point there

Suggested change

NOTE = {TODO},

NOTE = {https://web.archive.org/web/20251219002033/https://jonathan-conder.github.io/afpg.pdf},

fingolfin

Thank you! I've pushed a bunch of changes (see commit log). I'll try to understand the errors better tomorrow

fingolfin · 2025-12-11T21:24:45Z

gap/generic/SnAnUnknownDegree.gi

+    # This is usually much smaller than RECOG.SnAnUpperBoundForDegree.
+    # The number to compare N with was chosen arbitrarily as a "large" degree.
+    # if N > 20 then
+    #     degreeData := RECOG.GuessSnAnDegree(ri);
+    #     if degreeData = fail then
+    #         cache.N := TemporaryFailure;
+    #         return;
+    #     fi;
+    #     N := Minimum(N, degreeData.degree);
+    #     cache.N := N;
+    # fi;


Is this the only call to RECOG.GuessSnAnDegree?? If so... do we need it at all?

I think we want to keep it just for the sake of Issue #348. But right now the code is not used by SnAnUnknownDegree, and we can surely move it somewhere else.

gap/projective.gi

gap/generic/SnAnUnknownDegree.gi

fingolfin · 2025-12-11T22:21:26Z

gap/generic/SnAnUnknownDegree.gi

-    constants := RECOG.ThreeCycleCandidatesConstants(1. / 4., N);
-    for i in [1 .. T] do
-        iterator := RECOG.ThreeCycleCandidatesIterator(ri, constants);
+# This is the main method used by RECOG.RecogniseSnAn and RECOG.RecogniseSnAnLazy.


As far as I can tell, RECOG.RecogniseSnAn is not used anymore. Can we just remove it then, and perhaps rename RECOG.RecogniseSnAnLazy to RECOG.RecogniseSnAn ?

So, in theory RECOG.RecogniseSnAn is the algorithm that you can run with an arbitrary epsilon and it guarantees you to recognise SnAn with this error bound, so it is running all iterations as often as computed in the respective paper. However, in practice it is too expensive to run this method for the recog tree, so we wrote the lazy variant that exits the iterations way sooner. Whether we want to keep it or not depends on whether or not it is interesting to have this version of the algorithm to play around with, which I honestly do not have a strong opinion on. We can definitely rename the functions to RECOG.RecogniseSnAnExact or something like this and then drop the lazy from the other :)

I think we should keep the code, but rename as Friedrich suggested.

FriedrichRober · 2025-12-12T19:52:17Z

Thank you! I've pushed a bunch of changes (see commit log). I'll try to understand the errors better tomorrow

The rest of the changes look good to me

gap/generic/SnAnUnknownDegree.gi

TWiedemann · 2026-03-10T09:43:28Z

gap/generic/SnAnUnknownDegree.gi

 # eps : real number, the error bound
 # N : integer, upper bound for the degree of G
 #
 # Returns a record of constants used in ThreeCyclesCanditatesIterator.


Suggested change

# Returns a record of constants used in ThreeCycleCandidatesIterator. # The meaning of these constants is documented under "Changes" at the beginning of this file and their values are from [JLNP13, 4.1].

Typo (not from this PR), ThreeCycleCandidatesIterator was misspelled.
I find it difficult to rememer the meaning of the constant names B, T, ..., but it is probably best to follow the notation from [JLNP13].

Yes, the constants are named as in [JLNP13]. If we ever renamed constants, it should be hopefully noted in a comment above the function.

gap/generic/SnAnUnknownDegree.gi

Co-authored-by: Torben Wiedemann <7226617+TWiedemann@users.noreply.github.com>

Co-authored-by: Max Horn <max@quendi.de>

TWiedemann · 2026-03-11T09:14:07Z

gap/generic/SnAnUnknownDegree.gi

+# determine this. It is based on the Magma function heuristicThreeCycleTest.
+# R is a list of logInt2N+1 many random elements of the group of ri.
+RECOG.HeuristicThreeCycleTest := function(ri, c, logInt2N, R)
+    local r, y, yTo5, k;


Suggested change

local r, y, yTo5, k;

local r, y, y2, y3, k;

Update local variables.

fingolfin · 2026-03-13T10:12:11Z

doc/recog.bib

      NOTE = {https://doi.org/10.1017/CBO9780511565830.007},
 }

+@article{C12,


It seems Bibtex and GAPDoc only know mastersthesis and phdthesis but not bscthesis or bachelorthesis. Ah well. Let's then do

Suggested change

@article{C12,

@misc{C12,

I'll check this Pr out locally to try what actually works and then will push an improvement

TWiedemann · 2026-03-16T15:32:02Z

gap/generic/SnAnUnknownDegree.gi

+                # We make a small improvement to the version described in
+                # <Cite Key="JLNP13"/>. The order of r ^ M is a 2-power.
+                # It can be at most 2 ^ logInt2N. Thus, if we find an r such that
+                # (r ^ M) ^ (2 ^ logInt2N) is non-trivial, then we can return
+                # NeverApplicable.


Suggested change

# We make a small improvement to the version described in

# <Cite Key="JLNP13"/>. The order of r ^ M is a 2-power.

# It can be at most 2 ^ logInt2N. Thus, if we find an r such that

# (r ^ M) ^ (2 ^ logInt2N) is non-trivial, then we can return

# NeverApplicable.

# We make a small improvement to the version described in

# <Cite Key="JLNP13"/>. The order of r ^ M is a 2-power.

# It can be at most 2 ^ logInt2N. Thus, if we find an r such that

# (r ^ M) ^ (2 ^ logInt2N) is non-trivial, then we can return

# NeverApplicable. I.e. we need one iteration less than in [JLNP13],

# which also computes (r ^ M) ^ (2 ^ (longInt2N + 1))

Make the difference between the code and JLNP13 more explicit (hoping that I understood this correctly, I am not sure).

TWiedemann · 2026-03-16T16:15:42Z

gap/generic/SnAnUnknownDegree.gi

+                    Li := L;
+                    Li := Minimum(Li, B);
+                    Ki := Ki + K;
+                    Ki := Minimum(Ki, C);
+                    curInvolutionPos := 1;
+                    return SnAnTryLater;
+                elif curInvolutionPos = Li then
+                    Li := Li + L;
+                    Li := Minimum(Li, B);


Suggested change

Li := L;

Li := Minimum(Li, B);

Ki := Ki + K;

Ki := Minimum(Ki, C);

curInvolutionPos := 1;

return SnAnTryLater;

elif curInvolutionPos = Li then

Li := Li + L;

Li := Minimum(Li, B);

# Last involution reached. Restart with next batch of conjugates later.

Li := Minimum(L, B); # Reset Li to initial value

Ki := Minimum(Ki+K, C); # Try up to K more conjugates later

curInvolutionPos := 1; # Restart from first involution

return SnAnTryLater;

elif curInvolutionPos = Li then

# End of batch of involutions reached. Try next batch later.

Li := Minimum(Li+L, B);

The new Minimum statements should be equivalent to the old ones. Also added some comments.

TWiedemann · 2026-03-16T16:20:59Z

@FriedrichRober I went through ThreeCycleCandidatesIterator and it looks good to me! The only other comment I have is that I think whenever you write "commutating", you actually mean "non-commutating": The algorithm looks for conjugates of the involution t that do not commute with t, and counts how many it has found already. Hence I think nrCommutatingConjugates should be appropriately renamed, and some comments adapted.

TWiedemann · 2026-03-16T16:26:51Z

gap/generic/SnAnUnknownDegree.gi

+    curInvolutionPos := 1;
+    Ki := Minimum(K, C);
+    Li := Minimum(L, B);
    # Counts the elements c in step 4 that we use to conjugate the current


Suggested change

# Counts the elements c in step 4 that we use to conjugate the current

# Entry i of this list counts the elements c in step 4 that we use to conjugate the current

Clarification.

It is actually 'commuting' and 'non-commuting' instead of 'commutating' and 'non-commutating"

TWiedemann · 2026-03-16T16:27:42Z

gap/generic/SnAnUnknownDegree.gi

    # counts the size of the set Gamma_i in step 4 for the current involution
    # t_i


Suggested change

# counts the size of the set Gamma_i in step 4 for the current involution

# t_i

# Entry i of this list counts the size of the set Gamma_i in step 4

# for the current involution t_i

As above.

TWiedemann · 2026-03-16T16:28:49Z

gap/generic/SnAnUnknownDegree.gi

+    # counts the actual number of three cycle candidates considered
+    # which are filtered from the Gamma_i via heuristic order tests.


Suggested change

# counts the actual number of three cycle candidates considered

# which are filtered from the Gamma_i via heuristic order tests.

# Entry i of this list counts the actual number of three cycle candidates considered

# which are filtered from the Gamma_i via heuristic order tests.

As above.

ssiccha marked this pull request as draft April 9, 2021 15:26

ssiccha mentioned this pull request Apr 12, 2021

Implement "recognize An/Sn of unknown degree" algorithm by Jambor et al. #176

Merged

ssiccha force-pushed the frss/AnSnRecogUnknownDegree-2 branch from 5ae5367 to d40a988 Compare April 12, 2021 12:11

ssiccha force-pushed the frss/AnSnRecogUnknownDegree-2 branch from d40a988 to dc4a895 Compare April 12, 2021 12:32

FriedrichRober force-pushed the frss/AnSnRecogUnknownDegree-2 branch from dc4a895 to f162f36 Compare June 23, 2021 14:20

ssiccha force-pushed the frss/AnSnRecogUnknownDegree-2 branch from cca25fd to 35a39de Compare June 23, 2021 16:37

ssiccha mentioned this pull request Oct 5, 2021

Wrong size for finite deleted permutation module #296

Open

ssiccha force-pushed the frss/AnSnRecogUnknownDegree-2 branch from 96f9a25 to 705504c Compare March 28, 2022 22:01

FriedrichRober force-pushed the frss/AnSnRecogUnknownDegree-2 branch 3 times, most recently from e63f4a8 to 956884d Compare March 29, 2022 22:51

ssiccha force-pushed the frss/AnSnRecogUnknownDegree-2 branch 2 times, most recently from 3b12114 to daceec3 Compare March 29, 2022 23:52

FriedrichRober force-pushed the frss/AnSnRecogUnknownDegree-2 branch 2 times, most recently from d45adbb to 7ba5ec6 Compare June 1, 2022 13:32

FriedrichRober force-pushed the frss/AnSnRecogUnknownDegree-2 branch 4 times, most recently from 85ca56f to deb2974 Compare November 7, 2022 03:36

fingolfin added the recog days 2025 label Dec 8, 2025

ssiccha added 2 commits December 8, 2025 15:23

Add option infoLevel to RECOG.TestGroup

f381cc7

Fix for howtowritearecogmethod.autodoc

2aed139

fingolfin reviewed Dec 11, 2025

View reviewed changes

fingolfin added 6 commits December 11, 2025 22:34

Merge branch 'master' into frss/AnSnRecogUnknownDegree-2

2959e1a

Removing duplicate of RECOG.GuessSnAnDegree

01f39bf

Turn RECOG_SnAn into a code comment

0a3e5a9

Get rid of SnAnRepeatImmediately

a6d26f9

trivial tweaks

7f2e750

restore bug fix

16bace0

fingolfin reviewed Dec 11, 2025

View reviewed changes

TWiedemann reviewed Mar 10, 2026

View reviewed changes

gap/generic/SnAnUnknownDegree.gi Outdated Show resolved Hide resolved

TWiedemann reviewed Mar 10, 2026

View reviewed changes

gap/generic/SnAnUnknownDegree.gi Outdated Show resolved Hide resolved

TWiedemann reviewed Mar 10, 2026

View reviewed changes

gap/generic/SnAnUnknownDegree.gi Show resolved Hide resolved

TWiedemann reviewed Mar 10, 2026

View reviewed changes

gap/generic/SnAnUnknownDegree.gi Show resolved Hide resolved

FriedrichRober and others added 3 commits March 10, 2026 11:45

Fix typos

59e8a4b

Co-authored-by: Torben Wiedemann <7226617+TWiedemann@users.noreply.github.com>

Improve HeuristicThreeCycleTest

1213ebb

Co-authored-by: Max Horn <max@quendi.de>

Remove nonexistent function from FindHomDbProjective

d50b2d9

Co-authored-by: Max Horn <max@quendi.de>

TWiedemann reviewed Mar 11, 2026

View reviewed changes

fingolfin reviewed Mar 13, 2026

View reviewed changes

fingolfin added 3 commits March 13, 2026 11:15

Fix RECOG.HeuristicThreeCycleTest

925dd37

Improve bib

56099bb

fix url

c3d49e9

TWiedemann reviewed Mar 16, 2026

View reviewed changes

	NOTE = {TODO},
	NOTE = {https://web.archive.org/web/20251219002033/https://jonathan-conder.github.io/afpg.pdf},

	# Counts the elements c in step 4 that we use to conjugate the current
	# Entry i of this list counts the elements c in step 4 that we use to conjugate the current

		# counts the size of the set Gamma_i in step 4 for the current involution
		# t_i

-    # counts the size of the set Gamma_i in step 4 for the current involution
-    # t_i
+# Entry i of this list counts the size of the set Gamma_i in step 4
+# for the current involution t_i

		# counts the actual number of three cycle candidates considered
		# which are filtered from the Gamma_i via heuristic order tests.

Conversation

ssiccha commented Apr 9, 2021

Uh oh!

ssiccha commented Apr 12, 2021

Uh oh!

codecov bot commented Apr 12, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

FriedrichRober commented Mar 28, 2022

Uh oh!

ssiccha commented Mar 29, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

fingolfin commented Mar 30, 2022

Uh oh!

fingolfin commented Apr 6, 2022

Uh oh!

FriedrichRober commented Apr 7, 2022

Uh oh!

FriedrichRober commented Nov 7, 2022

Uh oh!

FriedrichRober commented Dec 9, 2025

Uh oh!

fingolfin commented Dec 11, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

fingolfin left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

FriedrichRober commented Dec 12, 2025

Uh oh!

Uh oh!

Uh oh!

TWiedemann Mar 10, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

TWiedemann commented Mar 16, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

codecov bot commented Apr 12, 2021 •

edited

Loading

ssiccha commented Mar 29, 2022 •

edited

Loading

TWiedemann Mar 10, 2026 •

edited

Loading