gh-35376: Update Zariski-van Kampen functions
    
### 📚 Description

This PR has been cleaned and I think it is ready for review. The main
goal of this PR is to update, create and make faster some functions in
``zariski_vankampen.py``. I describe here the functions created or
modified and the reasons:

- `discrim`: It applies now to a list or tuple of polynomials instead of
a polynomial. Since only the zeroes of $\textrm{disc}_y f$ are needed,
we compute (using `@parallel`) the discriminant of each polynomial and
the pairwise resultants. Moreover the computations are not done in
`QQbar` but in the number field of definition (only the roots are in
`QQbar`). Some other functions are only changed to be applied to tuples
or lists as `roots_interval`, `roots_interval_cached`,
`populate_roots_interval_cache`, `braid_in_segment`.
- `orient_circuit`: If we know that the circuit is convex a much faster
and precise method is used.
- `voronoi_cells`: It is a new function whose input is a *corrected
Voronoi diagram*; the output is the graph of the diagram, the
counterclock-wise boundary, a base point in the boundary, and the dual
graph. It has been isolated for clarity.
- `fieldI`: It is a new function whose function is the ground field `F`
(a subfield of `QQbar`) and the output is the smallest subfield of
`QQbar` containing `F` and `I`. Since the vertices of the Voronoi
diagrams are Gauss rationals, it allows to express everything in a
subfield of `QQbar` where computations are much faster than in `QQbar`.
- `populate_roots_interval_cache`: We add a hack (inspired by the
original `braid_monodromy` function to avoid some random fails when
parallelizing.
- `braid_in_segment`: We replace the complex numbers of the input by
Gauss rational and we add as input a dictionnary `precision` to be
recurrently used in order to increase the precision of the interval
computations and avoid hangs of the original function.
- `geometric_basis`: This function produces a geometric basis of the
free group $\pi_1(\mathbb{C}\setminus\Delta;p)$ where $\Delta$ is the
set of discriminant points; the elements of the basis are meridians
around each point such that its product is the counterclockwise boundary
of a big disk. The input is basically the output of `voronoi_cells`;
there is a new method to produce such a basis since the previous one
gave an error for some diagrams.
- `strand_components`: This function adds a new feature. It applies to
lists or tuples of polynomials and assign each strand of the braids to
the index of the polynomial associated with this strand. It is not a
hard computation and adds usefuel information that can be long (or
impossible) to be retrieved once the braid monodromy is computed
- `braid_monodromy`: The core of this function remains unchanged. The
output includes now a dictionnary associating each strand to an element
of an optional tuple of polynomials in the input.
- `conjugate_positive_form` is an auxiliary function which processes the
special braids appearing in the braid monodromy to make faster he
computation of the fundamental group since the mapping class group
action of the braid group on the free group can be very slow.
- `braid2rels`: this is a separate function to return a minimal set of
relations produced by the action of a braid on a free group.
- `fundamental_group_from_braid_mon`. This function computes the
fundamental group from braid monodromy
- `fundamental_group`: This function admits the optional argument
`puiseux` (`braid2rels` is used to get a smaller set of relations).
- `fundamental_group_arrangement`. The input is a list of polynomials
and, besides the fundamental group a dictionnary is given, associating
to each factor some meridians of these components.
The methods `fundamental_group` and `braid_monodromy` for affine curves
have been adapted. A new class of *arrangements of curves* should be
created to take advantage of the new features.
Actually, in another branch I created a method `fundamental_group` for
hyperplane arrangements which take care of the meridian of each
hyperplane. I encountered some problems since the class of hyperplane
arrangements ordered in a rigid way the meridians and I plan to create a
class of *ordered hyperplane arrangements* to avoid this problem.
What it is called a Puiseux presentation of the $\pi_1$ of the
complement of an affine curve has the same homotopy type as this
complement (as proved by Libgober).
Tests and documentation have been updated (probably not enough).

Fixes #34415.
### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. It should be `[x]` not `[x
]`. -->

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [x] I have updated the documentation accordingly.

### ⌛ Dependencies
    
URL: #35376
Reported by: Enrique Manuel Artal Bartolo
Reviewer(s): Enrique Manuel Artal Bartolo, Matthias Köppe, miguelmarco

Author: Release Manager

src/doc/en/reference/curves/index.rst

@@ -10,6 +10,7 @@ Curves
    sage/schemes/curves/projective_curve
    sage/schemes/curves/point
    sage/schemes/curves/closed_point
+   sage/schemes/curves/zariski_vankampen
 
    sage/schemes/jacobians/abstract_jacobian
 

src/sage/groups/finitely_presented.py

@@ -135,6 +135,7 @@
 from sage.libs.gap.libgap import libgap
 from sage.libs.gap.element import GapElement
 from sage.misc.cachefunc import cached_method
+from sage.groups.free_group import FreeGroup
 from sage.groups.free_group import FreeGroupElement
 from sage.functions.generalized import sign
 from sage.matrix.constructor import matrix
@@ -1426,6 +1427,35 @@ def simplified(self):
         """
         return self.simplification_isomorphism().codomain()
 
+    def sorted_presentation(self):
+        """
+        Return the same presentation with the relations sorted to ensure equality.
+
+        OUTPUT:
+
+        A new finitely presented group with the relations sorted.
+
+        EXAMPLES::
+
+            sage: G = FreeGroup(2) / [(1, 2, -1, -2), ()]; G
+            Finitely presented group < x0, x1 | x0*x1*x0^-1*x1^-1, 1 >
+            sage: G.sorted_presentation()
+            Finitely presented group < x0, x1 | 1, x1^-1*x0^-1*x1*x0 >
+        """
+        F = FreeGroup(self.ngens())
+        L0 = [r.Tietze() for r in self.relations()]
+        L1 = []
+        for rel in L0:
+            C = [rel]
+            for j in range(len(rel) - 1):
+                C.append(rel[j + 1:] + rel[:j + 1])
+            C1 = [tuple(-j for j in reversed(l)) for l in C]
+            C += C1
+            C.sort()
+            L1.append(C[0])
+        L1.sort()
+        return F/L1
+
     def epimorphisms(self, H):
         r"""
         Return the epimorphisms from `self` to `H`, up to automorphism of `H`.