passagemath-schemes 10.8.1a4__cp314-cp314t-macosx_13_0_arm64.whl

sage/schemes/elliptic_curves/weierstrass_transform.py

@@ -0,0 +1,200 @@
+# sage_setup: distribution = sagemath-schemes
+"""
+Morphism to bring a genus-one curve into Weierstrass form
+
+You should use
+:func:`~sage.schemes.elliptic_curves.constructor.EllipticCurve_from_cubic`
+or
+:func:`~sage.schemes.elliptic_curves.constructor.EllipticCurve_from_curve`
+to construct the transformation starting with a cubic or with a genus
+one curve.
+
+EXAMPLES::
+
+    sage: R.<u,v,w> = QQ[]
+    sage: f = EllipticCurve_from_cubic(u^3 + v^3 + w^3, [1,-1,0], morphism=True);  f
+    Scheme morphism:
+      From: Projective Plane Curve over Rational Field defined by u^3 + v^3 + w^3
+      To:   Elliptic Curve defined by y^2 - 9*y = x^3 - 27 over Rational Field
+      Defn: Defined on coordinates by sending (u : v : w) to
+            (-w : 3*u : 1/3*u + 1/3*v)
+
+    sage: finv = f.inverse();  finv
+    Scheme morphism:
+      From: Elliptic Curve defined by y^2 - 9*y = x^3 - 27 over Rational Field
+      To:   Projective Plane Curve over Rational Field defined by u^3 + v^3 + w^3
+      Defn: Defined on coordinates by sending (x : y : z) to
+            (1/3*y : -1/3*y + 3*z : -x)
+
+    sage: (u^3 + v^3 + w^3)(f.inverse().defining_polynomials()) * f.inverse().post_rescaling()
+    -x^3 + y^2*z - 9*y*z^2 + 27*z^3
+
+    sage: E = finv.domain()
+    sage: E.defining_polynomial()(f.defining_polynomials()) * f.post_rescaling()
+    u^3 + v^3 + w^3
+
+    sage: f([1,-1,0])
+    (0 : 1 : 0)
+    sage: f([1,0,-1])
+    (3 : 9 : 1)
+    sage: f([0,1,-1])
+    (3 : 0 : 1)
+"""
+
+##############################################################################
+#       Copyright (C) 2013 Volker Braun <vbraun.name@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+##############################################################################
+
+from sage.schemes.generic.morphism import SchemeMorphism_polynomial
+
+
+class WeierstrassTransformation(SchemeMorphism_polynomial):
+
+    def __init__(self, domain, codomain, defining_polynomials, post_multiplication):
+        r"""
+        A morphism of a genus-one curve to/from the Weierstrass form.
+
+        INPUT:
+
+        - ``domain``, ``codomain`` -- two schemes, one of which is an
+          elliptic curve
+
+        - ``defining_polynomials`` -- triplet of polynomials that
+          define the transformation
+
+        - ``post_multiplication`` -- a polynomial to homogeneously
+          rescale after substituting the defining polynomials
+
+        EXAMPLES::
+
+            sage: P2.<u,v,w> = ProjectiveSpace(2,QQ)
+            sage: C = P2.subscheme(u^3 + v^3 + w^3)
+            sage: E = EllipticCurve([2, -1, -1/3, 1/3, -1/27])
+            sage: from sage.schemes.elliptic_curves.weierstrass_transform import WeierstrassTransformation
+            sage: f = WeierstrassTransformation(C, E, [w, -v-w, -3*u-3*v], 1);  f
+            Scheme morphism:
+              From: Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
+              u^3 + v^3 + w^3
+              To:   Elliptic Curve defined by y^2 + 2*x*y - 1/3*y = x^3 - x^2 + 1/3*x - 1/27
+                    over Rational Field
+              Defn: Defined on coordinates by sending (u : v : w) to
+                    (w : -v - w : -3*u - 3*v)
+
+            sage: f([-1, 1, 0])
+            (0 : 1 : 0)
+            sage: f([-1, 0, 1])
+            (1/3 : -1/3 : 1)
+            sage: f([ 0,-1, 1])
+            (1/3 : 0 : 1)
+
+            sage: A2.<a,b> = AffineSpace(2,QQ)
+            sage: C = A2.subscheme(a^3 + b^3 + 1)
+            sage: f = WeierstrassTransformation(C, E, [1, -b-1, -3*a-3*b], 1);  f
+            Scheme morphism:
+              From: Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:
+              a^3 + b^3 + 1
+              To:   Elliptic Curve defined by y^2 + 2*x*y - 1/3*y
+                    = x^3 - x^2 + 1/3*x - 1/27 over Rational Field
+              Defn: Defined on coordinates by sending (a, b) to
+                    (1 : -b - 1 : -3*a - 3*b)
+            sage: f([-1,0])
+            (1/3 : -1/3 : 1)
+            sage: f([0,-1])
+            (1/3 : 0 : 1)
+        """
+        Hom = domain.Hom(codomain)
+        super().__init__(Hom, defining_polynomials)
+        self._post = post_multiplication
+
+    def post_rescaling(self):
+        """
+        Return the homogeneous rescaling to apply after the coordinate
+        substitution.
+
+        OUTPUT: a polynomial; see the example below
+
+        EXAMPLES::
+
+            sage: R.<a,b,c> = QQ[]
+            sage: cubic =  a^3+7*b^3+64*c^3
+            sage: P = [2,2,-1]
+            sage: f = EllipticCurve_from_cubic(cubic, P, morphism=True).inverse()
+            sage: f.post_rescaling()
+            -1/7
+
+        So here is what it does. If we just plug in the coordinate
+        transformation, we get the defining polynomial up to
+        scale. This method returns the overall rescaling of the
+        equation to bring the result into the standard form::
+
+            sage: cubic(f.defining_polynomials())
+            7*x^3 - 7*y^2*z + 1806336*y*z^2 - 155373797376*z^3
+            sage: cubic(f.defining_polynomials()) * f.post_rescaling()
+            -x^3 + y^2*z - 258048*y*z^2 + 22196256768*z^3
+        """
+        return self._post
+
+
+def WeierstrassTransformationWithInverse(domain, codomain,
+                                         defining_polynomials, post_multiplication,
+                                         inv_defining_polynomials, inv_post_multiplication):
+    """
+    Construct morphism of a genus-one curve to/from the Weierstrass
+    form with its inverse.
+
+    EXAMPLES::
+
+        sage: R.<u,v,w> = QQ[]
+        sage: f = EllipticCurve_from_cubic(u^3 + v^3 + w^3, [1,-1,0], morphism=True);  f
+        Scheme morphism:
+          From: Projective Plane Curve over Rational Field defined by u^3 + v^3 + w^3
+          To:   Elliptic Curve defined by y^2 - 9*y = x^3 - 27 over Rational Field
+          Defn: Defined on coordinates by sending (u : v : w) to
+            (-w : 3*u : 1/3*u + 1/3*v)
+
+        Scheme morphism:
+          From: Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
+          u^3 + v^3 + w^3
+          To:   Elliptic Curve defined by y^2 + 2*x*y + 1/3*y
+                = x^3 - x^2 - 1/3*x - 1/27 over Rational Field
+          Defn: Defined on coordinates by sending (u : v : w) to
+                (-w : -v + w : 3*u + 3*v)
+    """
+    fwd = WeierstrassTransformationWithInverse_class(
+        domain, codomain, defining_polynomials, post_multiplication)
+    inv = WeierstrassTransformationWithInverse_class(
+        codomain, domain, inv_defining_polynomials, inv_post_multiplication)
+    fwd._inverse = inv
+    inv._inverse = fwd
+    return fwd
+
+
+class WeierstrassTransformationWithInverse_class(WeierstrassTransformation):
+
+    def inverse(self):
+        """
+        Return the inverse.
+
+        OUTPUT:
+
+        A morphism in the opposite direction. This may be a rational
+        inverse or an analytic inverse.
+
+        EXAMPLES::
+
+            sage: R.<u,v,w> = QQ[]
+            sage: f = EllipticCurve_from_cubic(u^3 + v^3 + w^3, [1,-1,0], morphism=True)
+            sage: f.inverse()
+            Scheme morphism:
+              From: Elliptic Curve defined by y^2 - 9*y = x^3 - 27 over Rational Field
+              To:   Projective Plane Curve over Rational Field defined by u^3 + v^3 + w^3
+              Defn: Defined on coordinates by sending (x : y : z) to
+              (1/3*y : -1/3*y + 3*z : -x)
+        """
+        return self._inverse

sage/schemes/hyperelliptic_curves/all.py

@@ -0,0 +1,6 @@
+# sage_setup: distribution = sagemath-schemes
+from sage.schemes.hyperelliptic_curves.constructor import HyperellipticCurve
+from sage.schemes.hyperelliptic_curves.kummer_surface import KummerSurface
+from sage.schemes.hyperelliptic_curves.mestre import (
+    Mestre_conic, HyperellipticCurve_from_invariants)
+from sage.schemes.hyperelliptic_curves import monsky_washnitzer

sage/schemes/hyperelliptic_curves/constructor.py

@@ -0,0 +1,369 @@
+# sage_setup: distribution = sagemath-schemes
+"""
+Hyperelliptic curve constructor
+
+AUTHORS:
+
+- David Kohel (2006): initial version
+
+- Anna Somoza (2019-04): dynamic class creation
+"""
+# ****************************************************************************
+#  Copyright (C) 2006 David Kohel <kohel@maths.usyd.edu>
+#                2019 Anna Somoza <anna.somoza.henares@gmail.com>
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from .hyperelliptic_generic import HyperellipticCurve_generic
+from .hyperelliptic_finite_field import HyperellipticCurve_finite_field
+from .hyperelliptic_rational_field import HyperellipticCurve_rational_field
+from .hyperelliptic_padic_field import HyperellipticCurve_padic_field
+from .hyperelliptic_g2 import HyperellipticCurve_g2
+
+import sage.rings.abc
+
+from sage.rings.finite_rings.finite_field_base import FiniteField
+from sage.rings.polynomial.polynomial_element import Polynomial
+from sage.rings.rational_field import RationalField
+from sage.schemes.projective.projective_space import ProjectiveSpace
+from sage.structure.dynamic_class import dynamic_class
+
+
+def _parse_multivariate_defining_equation(g):
+    """
+    Parse a defining equation for a hyperelliptic curve.
+    The input `g` should have the form `g(x, y) = y^2 + h(x) y - f(x)`,
+    or a constant multiple of that.
+
+    OUTPUT: tuple (f, h), each of them given as a list of coefficients.
+
+    TESTS::
+
+        sage: from sage.schemes.hyperelliptic_curves.constructor import _parse_multivariate_defining_equation
+        sage: R.<x,y> = QQ[]
+        sage: _parse_multivariate_defining_equation(y^2 + 3*x^2*y - (x^5 + x + 1))
+        ([1, 1, 0, 0, 0, 1], [0, 0, 3])
+        sage: _parse_multivariate_defining_equation(2*y^2 + 3*x^2*y - (x^5 + x + 1))
+        ([1/2, 1/2, 0, 0, 0, 1/2], [0, 0, 3/2])
+
+    The variable names are arbitrary::
+
+        sage: S.<z,t> = GF(13)[]
+        sage: _parse_multivariate_defining_equation(2*t^2 + 3*z^2*t - (z^5 + z + 1))
+        ([7, 7, 0, 0, 0, 7], [0, 0, 8])
+    """
+    from sage.rings.polynomial.multi_polynomial import MPolynomial
+    if not isinstance(g, MPolynomial):
+        raise ValueError("must be a multivariate polynomial")
+
+    variables = g.variables()
+    if len(variables) != 2:
+        raise ValueError("must be a polynomial in two variables")
+
+    y, x = sorted(variables, key=g.degree)
+    if g.degree(y) != 2:
+        raise ValueError("must be a polynomial of degree 2 in a variable")
+
+    f = []
+    h = []
+    for k, v in g:
+        dx = v.degree(x)
+        dy = v.degree(y)
+        if dy == 2:
+            if dx != 0:
+                raise ValueError(f"cannot have a term y*x^{dx}")
+            y2 = k
+        elif dy == 1:
+            while len(h) <= dx:
+                h.append(0)
+            h[dx] = k
+        else:
+            assert dy == 0
+            while len(f) <= dx:
+                f.append(0)
+            f[dx] = -k
+
+    if not y2.is_one():
+        y2_inv = y2.inverse_of_unit()
+        f = [c * y2_inv for c in f]
+        h = [c * y2_inv for c in h]
+
+    return f, h
+
+
+def HyperellipticCurve(f, h=None, names=None, PP=None, check_squarefree=True):
+    r"""
+    Return the hyperelliptic curve `y^2 + h y = f`, for
+    univariate polynomials `h` and `f`. If `h`
+    is not given, then it defaults to 0.
+
+    INPUT:
+
+    - ``f`` -- univariate polynomial
+
+    - ``h`` -- (optional) univariate polynomial
+
+    - ``names`` -- (default: ``["x","y"]``) names for the coordinate functions
+
+    - ``check_squarefree`` -- boolean (default: ``True``); test if the input
+      defines a hyperelliptic curve when f is homogenized to degree `2g+2` and
+      h to degree `g+1` for some `g`
+
+    .. WARNING::
+
+        When setting ``check_squarefree=False`` or using a base ring that is
+        not a field, the output curves are not to be trusted. For example, the
+        output of ``is_singular`` is always ``False``, without this being
+        properly tested in that case.
+
+    .. NOTE::
+
+        The words "hyperelliptic curve" are normally only used for curves of
+        genus at least two, but this class allows more general smooth double
+        covers of the projective line (conics and elliptic curves), even though
+        the class is not meant for those and some outputs may be incorrect.
+
+    EXAMPLES:
+
+    Basic examples::
+
+        sage: R.<x> = QQ[]
+        sage: HyperellipticCurve(x^5 + x + 1)
+        Hyperelliptic Curve over Rational Field defined by y^2 = x^5 + x + 1
+        sage: HyperellipticCurve(x^19 + x + 1, x - 2)
+        Hyperelliptic Curve over Rational Field defined by y^2 + (x - 2)*y = x^19 + x + 1
+
+        sage: k.<a> = GF(9); R.<x> = k[]                                                # needs sage.rings.finite_rings
+        sage: HyperellipticCurve(x^3 + x - 1, x+a)                                      # needs sage.rings.finite_rings
+        Hyperelliptic Curve over Finite Field in a of size 3^2
+         defined by y^2 + (x + a)*y = x^3 + x + 2
+
+    Construct from defining polynomial::
+
+        sage: R.<x,y> = QQ[]
+        sage: HyperellipticCurve(y^2 + 3*x^2*y - (x^5 + x + 1))
+        Hyperelliptic Curve over Rational Field defined by y^2 + 3*x^2*y = x^5 + x + 1
+
+    Characteristic two::
+
+        sage: # needs sage.rings.finite_rings
+        sage: P.<x> = GF(8, 'a')[]
+        sage: HyperellipticCurve(x^7 + 1, x)
+        Hyperelliptic Curve over Finite Field in a of size 2^3
+         defined by y^2 + x*y = x^7 + 1
+        sage: HyperellipticCurve(x^8 + x^7 + 1, x^4 + 1)
+        Hyperelliptic Curve over Finite Field in a of size 2^3
+         defined by y^2 + (x^4 + 1)*y = x^8 + x^7 + 1
+        sage: HyperellipticCurve(x^8 + 1, x)
+        Traceback (most recent call last):
+        ...
+        ValueError: not a hyperelliptic curve: highly singular at infinity
+        sage: HyperellipticCurve(x^8 + x^7 + 1, x^4)
+        Traceback (most recent call last):
+        ...
+        ValueError: not a hyperelliptic curve: singularity in the provided affine patch
+
+        sage: F.<t> = PowerSeriesRing(FiniteField(2))
+        sage: P.<x> = PolynomialRing(FractionField(F))
+        sage: HyperellipticCurve(x^5 + t, x)
+        Hyperelliptic Curve over Laurent Series Ring in t over Finite Field of size 2
+         defined by y^2 + x*y = x^5 + t
+
+    We can change the names of the variables in the output::
+
+        sage: k.<a> = GF(9); R.<x> = k[]                                                # needs sage.rings.finite_rings
+        sage: HyperellipticCurve(x^3 + x - 1, x + a, names=['X','Y'])                   # needs sage.rings.finite_rings
+        Hyperelliptic Curve over Finite Field in a of size 3^2
+         defined by Y^2 + (X + a)*Y = X^3 + X + 2
+
+    This class also allows curves of genus zero or one, which are strictly
+    speaking not hyperelliptic::
+
+        sage: P.<x> = QQ[]
+        sage: HyperellipticCurve(x^2 + 1)
+        Hyperelliptic Curve over Rational Field defined by y^2 = x^2 + 1
+        sage: HyperellipticCurve(x^4 - 1)
+        Hyperelliptic Curve over Rational Field defined by y^2 = x^4 - 1
+        sage: HyperellipticCurve(x^3 + 2*x + 2)
+        Hyperelliptic Curve over Rational Field defined by y^2 = x^3 + 2*x + 2
+
+    Double roots::
+
+        sage: P.<x> = GF(7)[]
+        sage: HyperellipticCurve((x^3-x+2)^2*(x^6-1))
+        Traceback (most recent call last):
+        ...
+        ValueError: not a hyperelliptic curve: singularity in the provided affine patch
+
+        sage: HyperellipticCurve((x^3-x+2)^2*(x^6-1), check_squarefree=False)
+        Hyperelliptic Curve over Finite Field of size 7 defined by
+         y^2 = x^12 + 5*x^10 + 4*x^9 + x^8 + 3*x^7 + 3*x^6 + 2*x^4 + 3*x^3 + 6*x^2 + 4*x + 3
+
+    The input for a (smooth) hyperelliptic curve of genus `g` should not
+    contain polynomials of degree greater than `2g+2`. In the following
+    example, the hyperelliptic curve has genus 2 and there exists a model
+    `y^2 = F` of degree 6, so the model `y^2 + yh = f` of degree 200 is not
+    allowed.::
+
+        sage: P.<x> = QQ[]
+        sage: h = x^100
+        sage: F = x^6 + 1
+        sage: f = F - h^2/4
+        sage: HyperellipticCurve(f, h)
+        Traceback (most recent call last):
+        ...
+        ValueError: not a hyperelliptic curve: highly singular at infinity
+
+        sage: HyperellipticCurve(F)
+        Hyperelliptic Curve over Rational Field defined by y^2 = x^6 + 1
+
+    An example with a singularity over an inseparable extension of the
+    base field::
+
+        sage: F.<t> = GF(5)[]
+        sage: P.<x> = F[]
+        sage: HyperellipticCurve(x^5 + t)
+        Traceback (most recent call last):
+        ...
+        ValueError: not a hyperelliptic curve: singularity in the provided affine patch
+
+    Input with integer coefficients creates objects with the integers
+    as base ring, but only checks smoothness over `\QQ`, not over Spec(`\ZZ`).
+    In other words, it is checked that the discriminant is nonzero, but it is
+    not checked whether the discriminant is a unit in `\ZZ^*`.::
+
+        sage: P.<x> = ZZ[]
+        sage: HyperellipticCurve(3*x^7 + 6*x + 6)
+        Hyperelliptic Curve over Integer Ring defined by y^2 = 3*x^7 + 6*x + 6
+
+    TESTS:
+
+    Check that `f` can be a constant (see :issue:`15516`)::
+
+        sage: R.<u> = PolynomialRing(Rationals())
+        sage: HyperellipticCurve(-12, u^4 + 7)
+        Hyperelliptic Curve over Rational Field defined by y^2 + (x^4 + 7)*y = -12
+
+    Check that two curves with the same class name have the same class type::
+
+        sage: # needs sage.rings.finite_rings
+        sage: R.<t> = PolynomialRing(GF(next_prime(10^9)))
+        sage: C = HyperellipticCurve(t^5 + t + 1)
+        sage: C2 = HyperellipticCurve(t^5 + 3*t + 1)
+        sage: type(C2) == type(C)
+        True
+
+    Check that the inheritance is correct::
+
+        sage: # needs sage.rings.finite_rings
+        sage: R.<t> = PolynomialRing(GF(next_prime(10^9)))
+        sage: C = HyperellipticCurve(t^5 + t + 1)
+        sage: type(C).mro()
+        [<class 'sage.schemes.hyperelliptic_curves.constructor.HyperellipticCurve_g2_FiniteField_with_category'>,
+         <class 'sage.schemes.hyperelliptic_curves.constructor.HyperellipticCurve_g2_FiniteField'>,
+         <class 'sage.schemes.hyperelliptic_curves.hyperelliptic_g2.HyperellipticCurve_g2'>,
+         <class 'sage.schemes.hyperelliptic_curves.hyperelliptic_finite_field.HyperellipticCurve_finite_field'>,
+         <class 'sage.schemes.hyperelliptic_curves.hyperelliptic_generic.HyperellipticCurve_generic'>,
+        ...]
+    """
+    # F is the discriminant; use this for the type check
+    # rather than f and h, one of which might be constant.
+    if h is None:
+        from sage.rings.polynomial.multi_polynomial import MPolynomial
+        if isinstance(f, MPolynomial) and len(f.parent().gens()) == 2:
+            from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+            P = PolynomialRing(f.base_ring(), 'x')
+            f, h = _parse_multivariate_defining_equation(f)
+            f, h = P(f), P(h)
+        else:
+            h = 0
+
+    F = h**2 + 4 * f
+    if not isinstance(F, Polynomial):
+        raise TypeError(f"arguments f = {f} and h = {h} must be polynomials")
+    P = F.parent()
+    f = P(f)
+    h = P(h)
+    df = f.degree()
+    dh_2 = 2 * h.degree()
+    if dh_2 < df:
+        g = (df - 1) // 2
+    else:
+        g = (dh_2 - 1) // 2
+    if check_squarefree:
+        # Assuming we are working over a field, this checks that after
+        # resolving the singularity at infinity, we get a smooth double cover
+        # of P^1.
+        if P(2) == 0:
+            # characteristic 2
+            if h == 0:
+                raise ValueError(
+                    f"for characteristic 2, argument h = {h} must be nonzero"
+                )
+            if h[g + 1] == 0 and f[2 * g + 1] ** 2 == f[2 * g + 2] * h[g] ** 2:
+                raise ValueError(
+                    "not a hyperelliptic curve: highly singular at infinity"
+                )
+            should_be_coprime = [h, f * h.derivative() ** 2 + f.derivative() ** 2]
+        else:
+            # characteristic not 2
+            if F.degree() not in [2 * g + 1, 2 * g + 2]:
+                raise ValueError(
+                    "not a hyperelliptic curve: highly singular at infinity"
+                )
+            should_be_coprime = [F, F.derivative()]
+        try:
+            smooth = should_be_coprime[0].gcd(should_be_coprime[1]).degree() == 0
+        except (AttributeError, NotImplementedError, TypeError):
+            try:
+                smooth = should_be_coprime[0].resultant(should_be_coprime[1]) != 0
+            except (AttributeError, NotImplementedError, TypeError):
+                raise NotImplementedError(
+                    "cannot determine whether "
+                    f"polynomials {should_be_coprime} have a common root, use "
+                    "check_squarefree=False to skip this check"
+                )
+        if not smooth:
+            raise ValueError(
+                "not a hyperelliptic curve: singularity in the provided affine patch"
+            )
+    R = P.base_ring()
+    PP = ProjectiveSpace(2, R)
+    if names is None:
+        names = ["x", "y"]
+
+    bases = []
+    cls_name = ["HyperellipticCurve"]
+
+    # For certain genus we specialise to subclasses with
+    # optimised methods
+    genus_classes = {2: HyperellipticCurve_g2}
+    if g in genus_classes:
+        bases.append(genus_classes[g])
+        cls_name.append(f"g{g}")
+
+    # For certain base fields, we specialise to subclasses
+    # with special case methods
+    fields = [
+        ("FiniteField", FiniteField, HyperellipticCurve_finite_field),
+        ("RationalField", RationalField, HyperellipticCurve_rational_field),
+        ("pAdicField", sage.rings.abc.pAdicField, HyperellipticCurve_padic_field),
+    ]
+
+    for name, base_ring_cls, cls in fields:
+        if isinstance(R, base_ring_cls):
+            bases.append(cls)
+            cls_name.append(name)
+            break
+
+    # If no specialised subclasses are identified, we simply use the
+    # generic class in the class construction
+    if not bases:
+        bases = [HyperellipticCurve_generic]
+
+    # Dynamically build a class from multiple inheritance. Note that
+    # all classes we select from are subclasses of HyperellipticCurve_generic
+    class_name = "_".join(cls_name)
+    cls = dynamic_class(class_name, tuple(bases), doccls=HyperellipticCurve)
+    return cls(PP, f, h, names=names, genus=g)