gh-36297: using more libgap instead of gap
    
just a few more uses of libgap instead of gap

### 📝 Checklist

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [ ] I have created tests covering the changes.
- [ ] I have updated the documentation accordingly.
    
URL: #36297
Reported by: Frédéric Chapoton
Reviewer(s): Dima Pasechnik

Author: Release Manager

src/doc/en/thematic_tutorials/lie/weyl_groups.rst

@@ -125,10 +125,9 @@ and whose values are the roots, you may use the inverse family::
     The behaviour of this function was changed in :trac:`20027`.
 
 The Weyl group is implemented as a GAP matrix group. You therefore can
-display its character table. The character table is returned as a
-string, which you can print::
+display its character table as follows::
 
-    sage: print(WeylGroup("D4").character_table())
+    sage: WeylGroup("D4").character_table()
     CT1
     <BLANKLINE>
           2  6  4  5  1  3  5  5  4  3  3  1  4  6

src/sage/arith/misc.py

@@ -377,22 +377,18 @@ def bernoulli(n, algorithm='default', num_threads=1):
             warn("flint is known to not be accurate for large Bernoulli numbers")
         from sage.libs.flint.arith import bernoulli_number as flint_bernoulli
         return flint_bernoulli(n)
-    elif algorithm == 'pari':
+    elif algorithm == 'pari' or algorithm == 'gp':
         from sage.libs.pari.all import pari
         x = pari(n).bernfrac()         # Use the PARI C library
         return Rational(x)
     elif algorithm == 'gap':
-        import sage.interfaces.gap
-        x = sage.interfaces.gap.gap('Bernoulli(%s)' % n)
+        from sage.libs.gap.libgap import libgap
+        x = libgap.Bernoulli(n).sage()
         return Rational(x)
     elif algorithm == 'magma':
         import sage.interfaces.magma
         x = sage.interfaces.magma.magma('Bernoulli(%s)' % n)
         return Rational(x)
-    elif algorithm == 'gp':
-        import sage.interfaces.gp
-        x = sage.interfaces.gp.gp('bernfrac(%s)' % n)
-        return Rational(x)
     elif algorithm == 'bernmm':
         import sage.rings.bernmm
         return sage.rings.bernmm.bernmm_bern_rat(n, num_threads)
@@ -448,12 +444,10 @@ def factorial(n, algorithm='gmp'):
         sage: factorial(mpz(4))
         24
 
-
     PERFORMANCE: This discussion is valid as of April 2006. All timings
     below are on a Pentium Core Duo 2Ghz MacBook Pro running Linux with
     a 2.6.16.1 kernel.
 
-
     -  It takes less than a minute to compute the factorial of
        `10^7` using the GMP algorithm, and the factorial of
        `10^6` takes less than 4 seconds.
@@ -482,7 +476,7 @@ def factorial(n, algorithm='gmp'):
         raise ValueError('unknown algorithm')
 
 
-def is_prime(n):
+def is_prime(n) -> bool:
     r"""
     Determine whether `n` is a prime element of its parent ring.
 

src/sage/combinat/matrices/latin.py

@@ -135,9 +135,9 @@
 from sage.matrix.matrix_integer_dense import Matrix_integer_dense
 from sage.groups.perm_gps.permgroup_element import PermutationGroupElement
 from sage.groups.perm_gps.constructor import PermutationGroupElement as PermutationConstructor
-from sage.interfaces.gap import GapElement
+from sage.libs.gap.libgap import libgap
+from sage.libs.gap.element import GapElement
 from sage.combinat.permutation import Permutation
-from sage.interfaces.gap import gap
 from sage.groups.perm_gps.permgroup import PermutationGroup
 from sage.arith.misc import is_prime
 from sage.rings.finite_rings.finite_field_constructor import FiniteField
@@ -2327,14 +2327,14 @@ def group_to_LatinSquare(G):
 
     ::
 
-        sage: G = gap.Group(PermutationGroupElement((1,2,3)))
+        sage: G = libgap.Group(PermutationGroupElement((1,2,3)))
         sage: group_to_LatinSquare(G)
         [0 1 2]
         [1 2 0]
         [2 0 1]
     """
     if isinstance(G, GapElement):
-        rows = (list(x) for x in list(gap.MultiplicationTable(G)))
+        rows = (list(x) for x in list(libgap.MultiplicationTable(G)))
         new_rows = []
 
         for x in rows:
@@ -2454,15 +2454,15 @@ def p3_group_bitrade_generators(p):
 
         sage: from sage.combinat.matrices.latin import *
         sage: p3_group_bitrade_generators(3)
-        ((2,6,7)(3,8,9), (1,2,3)(4,7,8)(5,6,9), (1,9,2)(3,7,4)(5,8,6), Permutation Group with generators [(2,6,7)(3,8,9), (1,2,3)(4,7,8)(5,6,9)])
+        ((2,6,7)(3,8,9),
+         (1,2,3)(4,7,8)(5,6,9),
+         (1,9,2)(3,7,4)(5,8,6),
+         Permutation Group with generators [(2,6,7)(3,8,9), (1,2,3)(4,7,8)(5,6,9)])
     """
     assert is_prime(p)
 
-    F = gap.new("FreeGroup(3)")
-
-    a = F.gen(1)
-    b = F.gen(2)
-    c = F.gen(3)
+    F = libgap.FreeGroup(3)
+    a, b, c = F.GeneratorsOfGroup()
 
     rels = []
     rels.append(a**p)
@@ -2473,11 +2473,12 @@ def p3_group_bitrade_generators(p):
     rels.append(c*b*((b*c)**(-1)))
 
     G = F.FactorGroupFpGroupByRels(rels)
+    u, v, _ = G.GeneratorsOfGroup()
 
-    iso = gap.IsomorphismPermGroup(G)
+    iso = libgap.IsomorphismPermGroup(G)
 
-    x = PermutationConstructor(gap.Image(iso, G.gen(1)))
-    y = PermutationConstructor(gap.Image(iso, G.gen(2)))
+    x = PermutationConstructor(libgap.Image(iso, u))
+    y = PermutationConstructor(libgap.Image(iso, v))
 
     return (x, y, (x*y)**(-1), PermutationGroup([x, y]))
 
@@ -2504,7 +2505,7 @@ def check_bitrade_generators(a, b, c):
     if a*b != c**(-1):
         return False
 
-    X = gap.Intersection(gap.Intersection(A, B), C)
+    X = libgap.Intersection(libgap.Intersection(A, B), C)
     return X.Size() == 1
 
 
@@ -2648,11 +2649,11 @@ def bitrade_from_group(a, b, c, G):
         [ 2  1  3 -1]
         [ 0  3 -1  2]
     """
-    hom = gap.ActionHomomorphism(G, gap.RightCosets(G, gap.TrivialSubgroup(G)), gap.OnRight)
+    hom = libgap.ActionHomomorphism(G, libgap.RightCosets(G, libgap.TrivialSubgroup(G)), libgap.OnRight)
 
-    t1 = gap.Image(hom, a)
-    t2 = gap.Image(hom, b)
-    t3 = gap.Image(hom, c)
+    t1 = libgap.Image(hom, a)
+    t2 = libgap.Image(hom, b)
+    t3 = libgap.Image(hom, c)
 
     t1 = Permutation(str(t1).replace('\n', ''))
     t2 = Permutation(str(t2).replace('\n', ''))

src/sage/combinat/root_system/weyl_group.py

@@ -45,7 +45,7 @@
 from sage.groups.perm_gps.permgroup import PermutationGroup_generic
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
-from sage.interfaces.gap import gap
+from sage.libs.gap.libgap import libgap
 from sage.misc.cachefunc import cached_method
 from sage.combinat.root_system.cartan_type import CartanType
 from sage.combinat.root_system.cartan_matrix import CartanMatrix
@@ -252,7 +252,6 @@ def __init__(self, domain, prefix):
         # FinitelyGeneratedMatrixGroup_gap takes plain matrices as input
         gens_matrix = [self.morphism_matrix(self.domain().simple_reflection(i))
                        for i in self.index_set()]
-        from sage.libs.gap.libgap import libgap
         if not gens_matrix:
             libgap_group = libgap.Group([], matrix(ZZ, 1, 1, [1]))
         else:
@@ -435,8 +434,8 @@ def character_table(self):
             X.4     3 -1  1  . -1
             X.5     1  1  1  1  1
         """
-        gens_str = ', '.join(str(g.gap()) for g in self.gens())
-        ctbl = gap('CharacterTable(Group({0}))'.format(gens_str))
+        G = libgap.Group([libgap(g) for g in self.gens()])
+        ctbl = libgap.CharacterTable(G)
         return ctbl.Display()
 
     @cached_method

src/sage/modular/arithgroup/arithgroup_perm.py

@@ -1551,14 +1551,15 @@ def surgroups(self):
             sage: l
             [6, 3, 4, 8, 4, 8, 4, 12, 4, 6, 6, 8, 8]
         """
-        from sage.interfaces.gap import gap
-        P = self.perm_group()._gap_()
+        from sage.libs.gap.libgap import libgap
+        P = libgap(self.perm_group())
         for b in P.AllBlocks():
-            orbit = P.Orbit(b, gap.OnSets)
-            action = P.Action(orbit, gap.OnSets)
-            S2,S3,L,R = action.GeneratorsOfGroup()
+            orbit = P.Orbit(b, libgap.OnSets)
+            action = P.Action(orbit, libgap.OnSets)
+            S2, S3, L, R = action.GeneratorsOfGroup()
             yield ArithmeticSubgroup_Permutation(S2=S2, S3=S3, L=L, R=R, check=False)
 
+
 class OddArithmeticSubgroup_Permutation(ArithmeticSubgroup_Permutation_class):
     r"""
     An arithmetic subgroup of `\SL(2, \ZZ)` not containing `-1`,
@@ -2635,6 +2636,7 @@ def odd_subgroups(self):
 
         return res
 
+
 def HsuExample10():
     r"""
     An example of an index 10 arithmetic subgroup studied by Tim Hsu.
@@ -2654,6 +2656,7 @@ def HsuExample10():
             R="(1,7,9,10,6)(2,3)(4,5,8)",
             relabel=False)
 
+
 def HsuExample18():
     r"""
     An example of an index 18 arithmetic subgroup studied by Tim Hsu.