Add constructive recognition of SL(2,q) in natural representation 2.0

[Till-Eisen]

This PR replaces PR #389, which encountered merge conflicts. Starting fresh with a clean branch.

It is about adding Frank Lübeck's RECOG.RecogNaturalSL2 algorithm for constructive recognition of SL(2,q) in natural representation, along with RECOG.ConRecogNaturalSL2 which wraps it and produces output in the same format as RECOG.RecogniseSL2NaturalEvenChar / RECOG.RecogniseSL2NaturalOddCharUsingBSGS.
For q=3 where RecogNaturalSL2 does not work, the function falls back to existing recognition methods.

[codecov]

Codecov Report

❌ Patch coverage is 96.65738% with 12 lines in your changes missing coverage. Please review.
✅ Project coverage is 87.46%. Comparing base (1451603) to head (060db70).
⚠️ Report is 30 commits behind head on master.

Files with missing lines	Patch %	Lines
gap/projective/sl2_natural.gi	96.62%	12 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##           master     #398      +/-   ##
==========================================
+ Coverage   80.07%   87.46%   +7.38%     
==========================================
  Files          44       45       +1     
  Lines       18382    18873     +491     
==========================================
+ Hits        14720    16507    +1787     
+ Misses       3662     2366    -1296     

Files with missing lines	Coverage Δ
gap/projective/classicalnatural.gi	69.47% <100.00%> (-22.79%)	⬇️
gap/projective/sl.gi	98.41% <100.00%> (-0.02%)	⬇️
gap/projective/sl2_natural.gi	96.62% <96.62%> (ø)

... and 17 files with indirect coverage changes

🚀 New features to boost your workflow:

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

[Till-Eisen]

After the recent changes, I benchmarked RECOG.ConRecogNaturalSL2 against RECOG.RecogniseSL2NaturalEvenChar. For small fields of characteristic 2, the new implementation performs better. However, for larger fields, RECOG.RecogniseSL2NaturalEvenChar becomes faster.

The following timings illustrate this behaviour:

gap> q := 2^3;;
gap> f := GF(q);;
gap> G := Group(List([1..15], i -> PseudoRandom(SL(2,q))));;
gap> for i in [1..100] do RECOG.ConRecogNaturalSL2(G,f);; od; time;
77
gap> for i in [1..100] do RECOG.RecogNaturalSL2(G,q);; od; time;
33
gap> for i in [1..100] do RECOG.RecogniseSL2NaturalEvenChar(G,f,false);;od; time;
94

 
gap> q := 2^8;;
gap> f := GF(q);;
gap> G := Group(List([1..15], i -> PseudoRandom(SL(2,q))));;
gap> for i in [1..100] do RECOG.ConRecogNaturalSL2(G,f);; od; time;
131
gap> for i in [1..100] do RECOG.RecogNaturalSL2(G,q);; od; time;
46
gap> for i in [1..100] do RECOG.RecogniseSL2NaturalEvenChar(G,f,false);;od; time;
218


gap> q := 2^40;;
gap> f := GF(q);;
gap> G := Group(List([1..15], i -> PseudoRandom(SL(2,q))));;
gap> for i in [1..100] do RECOG.ConRecogNaturalSL2(G,f);; od; time;
11747 
gap> for i in [1..100] do RECOG.RecogNaturalSL2(G,q);; od; time;
9170 
gap> for i in [1..100] do RECOG.RecogniseSL2NaturalEvenChar(G,f,false);;od; time;
7659

[frankluebeck]

Your observation about RECOG.RecogniseSL2NaturalEvenChar for large base fields sounds reasonable.

The generic algorithm uses a discrete logarithm computation in the base field to find a unipotent element.

I have not checked in detail what RECOG.RecogniseSL2NaturalEvenChar does but would guess that it is based on some variant of the algorithm by Kantor and Kassabov Black box groups isomorphic to PGL(2,2^e). They have a nice trick to produce a unipotent element much quicker (unfortunately, no such trick is known in odd characteristic).