Update Zariski-van Kampen functions

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/schemes/curves/affine_curve.py

@@ -180,6 +180,7 @@ class AffineCurve(Curve_generic, AlgebraicScheme_subscheme_affine):
         sage: C = Curve([x^2 - z, z - 8*x], A); C                                       # optional - sage.rings.finite_rings
         Affine Curve over Finite Field of size 7 defined by x^2 - z, -x + z
     """
+
     def __init__(self, A, X):
         r"""
         Initialize.
@@ -271,6 +272,7 @@ class AffinePlaneCurve(AffineCurve):
     """
     Affine plane curves.
     """
+
     def __init__(self, A, f):
         r"""
         Initialize.
@@ -465,8 +467,8 @@ def plot(self, *args, **kwds):
             sage: C.plot()
             Graphics object consisting of 1 graphics primitive
         """
-        I = self.defining_ideal()
-        return I.plot(*args, **kwds)
+        Id = self.defining_ideal()
+        return Id.plot(*args, **kwds)
 
     def is_transverse(self, C, P):
         r"""
@@ -689,7 +691,7 @@ def tangents(self, P, factor=True):
                     fact.extend([vars[1] - roots[i][0]*vars[0] for i in range(len(roots))])
             return [ff(coords) for ff in fact]
         else:
-            return [l[0](coords) for l in T.factor()]
+            return [ll[0](coords) for ll in T.factor()]
 
     def is_ordinary_singularity(self, P):
         r"""
@@ -1009,10 +1011,10 @@ def projection(self, indices, AS=None):
             removecoords.pop(indices[i])
         J = self.defining_ideal().elimination_ideal(removecoords)
         K = Hom(AA.coordinate_ring(), AA2.coordinate_ring())
-        l = [0]*(n)
+        ll = [0]*(n)
         for i in range(len(indices)):
-            l[indices[i]] = AA2.gens()[i]
-        phi = K(l)
+            ll[indices[i]] = AA2.gens()[i]
+        phi = K(ll)
         G = [phi(f) for f in J.gens()]
         try:
             C = AA2.curve(G)
@@ -1519,6 +1521,7 @@ def resolution_of_singularities(self, extend=False):
             working over a number field use extend=True
         """
         # helper function for extending the base field (in the case of working over a number field)
+
         def extension(self):
             F = self.base_ring()
             pts = self.change_ring(F.embeddings(QQbar)[0]).rational_points()
@@ -1720,11 +1723,11 @@ def tangent_line(self, p):
         from sage.schemes.curves.constructor import Curve
 
         # translate to p
-        I = []
+        I0 = []
         for poly in Tp.defining_polynomials():
-            I.append(poly.subs({x: x - c for x, c in zip(gens, p)}))
+            I0.append(poly.subs({x: x - c for x, c in zip(gens, p)}))
 
-        return Curve(I, A)
+        return Curve(I0, A)
 
 
 class AffinePlaneCurve_field(AffinePlaneCurve, AffineCurve_field):
@@ -1733,11 +1736,33 @@ class AffinePlaneCurve_field(AffinePlaneCurve, AffineCurve_field):
     """
     _point = AffinePlaneCurvePoint_field
 
-    def fundamental_group(self):
+    @cached_method
+    def fundamental_group(self, simplified=True, puiseux=False):
         r"""
         Return a presentation of the fundamental group of the complement
         of ``self``.
 
+        INPUT:
+
+        - ``simplified`` -- (default: ``True``) boolean to simplify the presentation.
+
+        - ``puiseux`` -- (default: ``False``) boolean to decide if the
+          presentation is constructed in the classical way or using Puiseux
+          shortcut. If ``True``, ``simplified`` is set to ``False``.
+
+
+        OUTPUT:
+
+        A presentation with generators `x_1, \dots, x_d` and relations. If ``puiseux``
+        is ``False`` the relations are `(x_j\cdot \tau)\cdot x_j^{-1}` for `1\leq j<d`
+        and `tau` a braid in the braid monodromy; finally the presentation
+        is simplified. If ``puiseux`` is ``True``, each
+        `tau` is decomposed as `\alpha^{-1}\cdot\beta\cdot\alpha`, where `\beta` is
+        a positive braid; the relations are `((x_j\cdot \beta)\cdot x_j^{-1})\cdot \alpha`
+        where `j` is an integer of the ``Tietze`` word of `\beta`. This presentation
+        is not simplified by default since it represents the homotopy type of
+        the complement of the curve.
+
         .. NOTE::
 
             The curve must be defined over the rationals or a number field
@@ -1749,6 +1774,12 @@ def fundamental_group(self):
             sage: C = A.curve(y^2 - x^3 - x^2)
             sage: C.fundamental_group()             # optional - sirocco
             Finitely presented group < x0 |  >
+            sage: bm = C.braid_monodromy() # optional - sirocco
+            sage: g = C.fundamental_group(puiseux=True) # optional - sirocco
+            sage: g # optional - sirocco
+            Finitely presented group < x0, x1 | x1*x0^-1, x1*x0*x1^-1*x0^-1 >
+            sage: g.simplified() # optional - sirocco
+            Finitely presented group < x0 |  >
 
         In the case of number fields, they need to have an embedding
         to the algebraic field::
@@ -1766,15 +1797,10 @@ def fundamental_group(self):
 
             This functionality requires the sirocco package to be installed.
         """
-        from sage.schemes.curves.zariski_vankampen import fundamental_group
-        F = self.base_ring()
-        from sage.rings.qqbar import QQbar
-        if QQbar.coerce_map_from(F) is None:
-            raise NotImplementedError("the base field must have an embedding"
-                                      " to the algebraic field")
-        f = self.defining_polynomial()
-        return fundamental_group(f, projective=False)
+        from sage.schemes.curves.zariski_vankampen import fundamental_group_from_braid_mon
+        return fundamental_group_from_braid_mon(self.braid_monodromy(), simplified=simplified, puiseux=puiseux)
 
+    @cached_method
     def braid_monodromy(self):
         r"""
         Compute the braid monodromy of a projection of the curve.
@@ -1783,7 +1809,7 @@ def braid_monodromy(self):
 
         A list of braids. The braids correspond to paths based in the same point;
         each of this paths is the conjugated of a loop around one of the points
-        in the discriminant of the projection of `self`.
+        in the discriminant of the projection of ``self``.
 
         NOTE:
 
@@ -1808,7 +1834,8 @@ def braid_monodromy(self):
             raise NotImplementedError("the base field must have an embedding"
                                       " to the algebraic field")
         f = self.defining_polynomial()
-        return braid_monodromy(f)
+        bm = braid_monodromy(f)[0]
+        return bm
 
     def riemann_surface(self, **kwargs):
         r"""
@@ -2142,18 +2169,18 @@ def _nonsingular_model(self):
         from sage.rings.function_field.constructor import FunctionField
 
         k = self.base_ring()
-        I = self.defining_ideal()
+        I0 = self.defining_ideal()
 
         # invlex is the lex order with x < y < z for R = k[x,y,z] for instance
-        R = I.parent().ring().change_ring(order='invlex')
-        I = I.change_ring(R)
+        R = I0.parent().ring().change_ring(order='invlex')
+        I0 = I0.change_ring(R)
         n = R.ngens()
 
         names = R.variable_names()
 
-        gbasis = I.groebner_basis()
+        gbasis = I0.groebner_basis()
 
-        if not I.is_prime():
+        if not I0.is_prime():
             raise TypeError("the curve is not integral")
 
         # Suppose the generators of the defining ideal I of the curve is
@@ -2223,7 +2250,7 @@ def _nonsingular_model(self):
         lift_to_function_field = hom(R, M, coordinate_functions)
 
         # sanity check
-        assert all(lift_to_function_field(f).is_zero() for f in I.gens())
+        assert all(lift_to_function_field(f).is_zero() for f in I0.gens())
 
         return M, lift_to_function_field