finish the batyrev factory and introduce the subclass smooth fano toric variety

local-ring · local-ring · commit 5b42c6503895 · 2025-07-15T19:22:01.000-04:00
diff --git a/src/sage/schemes/toric/all.py b/src/sage/schemes/toric/all.py
@@ -5,6 +5,7 @@
 lazy_import('sage.schemes.toric.variety', ['AffineToricVariety', 'ToricVariety'])
 lazy_import('sage.schemes.toric.library', 'toric_varieties')
 lazy_import('sage.schemes.toric.fano_variety', ['FanoToricVariety', 'CPRFanoToricVariety'])
-lazy_import('sage.schemes.toric.batyrev_library', 'smooth_fano_toric_varieties')
+lazy_import('sage.schemes.toric.batyrev', 'SmoothFanoToricVariety')
+lazy_import('sage.schemes.toric.batyrev_library', 'BTF')
 lazy_import('sage.schemes.toric.ideal', 'ToricIdeal')
 del lazy_import
diff --git a/src/sage/schemes/toric/batyrev.py b/src/sage/schemes/toric/batyrev.py
@@ -1,28 +1,28 @@
+r""""
+Smooth Fano toric varieties.
 
-from sage.structure.sage_object import SageObject
-
-from sage.matrix.constructor import matrix
-from sage.matrix.special import identity_matrix
+This module provides support for smooth Fano toric varieties, which has been classified by Batyrev in dimensions up to 4.
+"""
 from sage.geometry.cone import Cone
 from sage.geometry.fan import Fan, FaceFan
 from sage.geometry.lattice_polytope import LatticePolytope
 from sage.geometry.toric_lattice import ToricLattice
-from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
 from sage.arith.misc import GCD as gcd
 from sage.schemes.toric.variety import (DEFAULT_PREFIX,
                                         ToricVariety_field,
                                         normalize_names)
+from sage.schemes.toric.fano_variety import FanoToricVariety_field
 
 from sage.categories.fields import Fields
 _Fields = Fields()
 
 
 
 # TODO: add the method to fix a basis of the Picard group, and express divisors in this basis
-class SmoothFanoToricVariety_field(ToricVariety_field):
+class SmoothFanoToricVariety_field(FanoToricVariety_field):
     r"""
-    Construct a Fano smooth toric variety from a reflexive polytope.
+    Construct a smooth Fano toric variety from a reflexive polytope.
 
     INPUT:
     - ``P`` -- reflexive polytope
@@ -45,190 +45,115 @@ class SmoothFanoToricVariety_field(ToricVariety_field):
     OUTPUT: :class:`smooth Fano toric variety <SmoothFanoToricVariety_field>`
     """
 
-    def __init__(self, Delta_polar, fan, coordinate_points, point_to_ray,
+    def __init__(self, Delta_polar, fan,
                  coordinate_names, coordinate_name_indices, base_field):
         r"""
         See :class:`SmoothFanoToricVariety_field` for documentation.
 
         Use ``SmoothFanoToricVariety`` to construct a smooth Fano toric variety.
-
-        TESTS:
-
-            sage: 
         """
-        self._Delta_polar = Delta_polar
-        self._coordinate_points = tuple(coordinate_points)
-        self._point_to_ray = point_to_ray # AL: I may want to drop this later, 
-        if coordinate_name_indices is None:
-            coordinate_name_indices = coordinate_points
-        super().__init__(fan, coordinate_names, 
+        super().__init__(Delta_polar, fan, coordinate_names, 
                          coordinate_name_indices, base_field)
-        
-        # TODO: the _latex_ and _repr_ methods
 
-
-    def change_ring(self, F):
+    def _repr_(self):
         r"""
-        Return a smooth Fano toric variety over field ``F``, otherwise the same
-        as ``self``.
-
-        INPUT:
-
-        - ``F`` -- field
-
-        OUTPUT: :class:`smooth Fano toric variety <SmoothFanoToricVariety_field>` over ``F``
-
-        .. NOTE::
-
-            There is no need to have any relation between ``F`` and the base
-            field of ``self``. If you do want to have such a relation, use
-            :meth:`base_extend` instead.
+        Return a string representation of ``self``.
 
-        EXAMPLES::
+        OUTPUT: string
 
-        """
-        if self.base_ring() == F:
-            return self
-        elif F not in _Fields:
-            raise TypeError("need a field to construct a Fano toric variety!"
-                            "\n Got %s" % F)
-        else:
-            return SmoothFanoToricVariety_field(self._P, self._fan,
-                self._coordinate_points, self._point_to_ray,
-                self.variable_names(), None, F)
-                # coordinate_name_indices do not matter, we give explicit
-                # names for all variables
-
-    def coordinate_point_to_coordinate(self, point):
-        # TODO: if this is necessary
-        pass
-
-    def coordinate_points(self):
-        r"""
-        Return indices of points of :meth:`Delta_polar` used for coordinates.
+        TESTS::
 
-        OUTPUT: :class:`tuple` of integers
+            sage: P1xP1 = SmoothFanoToricVariety(
+            ....:     Delta_polar=lattice_polytope.cross_polytope(2))
+            sage: print(P1xP1._repr_())
+            2-d smooth Fano toric variety covered by 4 affine patches
         """
-        return self._coordinate_points
-
-    def Delta(self):
-        r"""
-        Return the reflexive polytope <sage.geometry.lattice_polytope.LatticePolytopeClass>` 
-        defining ``self``.
-
-        OUTPUT: 
-        
-        - reflexive :class:`lattice polytope`
+        return ("%d-d smooth Fano toric variety covered by %d affine patches"
+                % (self.dimension_relative(), self.fan().ngenerating_cones()))
 
-        EXAMPLES::
-
-        """
-        return self._Delta_polar.polar()
-    
-    def Delta_polar(self):
-        r"""
-        Return polar of :meth:`Delta`.
-
-        OUTPUT: 
-        
-        - reflexive :class:`lattice polytope`
-
-        EXAMPLES::
-
-        """
-        return self._Delta_polar
 
 def SmoothFanoToricVariety(Delta=None,
                         Delta_polar=None,
-                        coordinate_points=None,
-                        charts=None,
                         coordinate_names=None,
                         names=None,
                         coordinate_name_indices=None,
-                        make_simplicial=False,
                         base_ring=None,
                         base_field=None,
                         check=True):
     r"""
-    Construct a CPR-Fano toric variety.
+    Construct a smooth Fano toric variety.
+
+    INPUT:
+
+    - ``Delta`` -- reflexive :class:`lattice polytope
+      <sage.geometry.lattice_polytope.LatticePolytopeClass>`. The fan of the
+      constructed CPR-Fano toric variety will be a crepant subdivision of the
+      *normal fan* of ``Delta``. Either ``Delta`` or ``Delta_polar`` must be
+      given, but not both at the same time, since one is completely determined
+      by another via :meth:`polar
+      <sage.geometry.lattice_polytope.LatticePolytopeClass.polar>` method.
+
+    - ``Delta_polar`` -- reflexive :class:`lattice polytope
+      <sage.geometry.lattice_polytope.LatticePolytopeClass>`. The fan of the
+      constructed CPR-Fano toric variety will be a crepant subdivision of the
+      *face fan* of ``Delta_polar``. Either ``Delta`` or ``Delta_polar`` must
+      be given, but not both at the same time, since one is completely
+      determined by another via :meth:`polar
+      <sage.geometry.lattice_polytope.LatticePolytopeClass.polar>` method.
+
+    - ``coordinate_names`` -- names of variables for the coordinate ring, see
+      :func:`~sage.schemes.toric.variety.normalize_names`
+      for acceptable formats. If not given, indexed variable names will be
+      created automatically.
+
+    - ``names`` -- an alias of ``coordinate_names`` for internal
+      use. You may specify either ``names`` or ``coordinate_names``,
+      but not both.
+
+    - ``coordinate_name_indices`` -- list of integers, indices for indexed
+      variables. If not given, the index of each variable will coincide with
+      the index of the corresponding point of ``Delta_polar``.
+
+    - ``base_ring`` -- base field of the Fano toric variety
+      (default: `\QQ`)
+
+    - ``base_field`` -- alias for ``base_ring``. Takes precedence if
+      both are specified.
+
+    - ``check`` -- by default the input data will be checked for correctness
+      (e.g. that ``charts`` do form a subdivision of the normal fan of
+      ``Delta``). If you know for sure that the input is valid, you may
+      significantly decrease construction time using ``check=False`` option.
+
+    OUTPUT: :class:`smooth Fano toric variety <SmoothFanoToricVariety_field>`
     """
+    if names is not None:
+        if coordinate_names is not None:
+            raise ValueError('You must not specify both coordinate_names and names!')
+        coordinate_names = names
     if (Delta is None) == (Delta_polar is None):
         raise ValueError("exactly one of Delta and Delta_polar must be given")
     if Delta_polar is None:
         Delta_polar = Delta.polar()
 
-    # AL: maybe not checking reflexivity here, since we already have a database of smooth reflexive polytopes
-    #     unless the reflexivity check is not expensive here, we can add it for future more general use
-    # if not Delta_polar.is_reflexive():
-    #     raise ValueError("Delta_polar must be reflexive")
-
-    # Check/normalize coordinate_points and construct fan rays
-    if coordinate_points is None:
-        coordinate_points = list(range(Delta_polar.nvertices()))
-        if charts is not None:
-            for chart in charts:
-                for point in chart:
-                    if point not in coordinate_points:
-                        coordinate_points.append(point)
-    elif coordinate_points == "vertices":
-        coordinate_points = list(range(Delta_polar.nvertices()))
-    elif coordinate_points == "all":
-        coordinate_points = list(range(Delta_polar.npoints()))
-        coordinate_points.remove(Delta_polar.origin())
-    elif coordinate_points == "all but facets":
-        coordinate_points = Delta_polar.skeleton_points(Delta_polar.dim() - 2)
-    elif isinstance(coordinate_points, str):
-        raise ValueError("unrecognized description of the coordinate points!"
-                         "\nGot: %s" % coordinate_points)
-    elif check:
-        cp_set = set(coordinate_points)
-        if len(cp_set) != len(coordinate_points):
-            raise ValueError(
-                "no repetitions are allowed for coordinate points!\nGot: %s"
-                % coordinate_points)
-        if not cp_set.issuperset(list(range(Delta_polar.nvertices()))):
-            raise ValueError("all %d vertices of Delta_polar must be used "
-                "for coordinates!\nGot: %s"
-                % (Delta_polar.nvertices(), coordinate_points))
-        if Delta_polar.origin() in cp_set:
-            raise ValueError("the origin (point #%d) cannot be used for a "
-                "coordinate!\nGot: %s"
-                % (Delta_polar.origin(), coordinate_points))
-    point_to_ray = {point: n
-                    for n, point in enumerate(coordinate_points)}
+    if check and not Delta_polar.is_reflexive():
+        raise ValueError("Delta_polar must be reflexive")
     
-    # This can be simplified if LatticePolytopeClass is adjusted.
-    rays = [Delta_polar.point(p) for p in coordinate_points]
-    # Check/normalize charts and construct the fan based on them.
-    if charts is None:
-        # Start with the face fan
-        fan = FaceFan(Delta_polar)
-    else:
-        # First of all, check that each chart is completely contained in a
-        # single facet of Delta_polar, otherwise they do not form a
-        # subdivision of the face fan of Delta_polar
-        if check:
-            facet_sets = [frozenset(facet.ambient_point_indices())
-                          for facet in Delta_polar.facets()]
-            for chart in charts:
-                is_bad = True
-                for fset in facet_sets:
-                    if fset.issuperset(chart):
-                        is_bad = False
-                        break
-                if is_bad:
-                    raise ValueError(
-                        "%s does not form a chart of a subdivision of the "
-                        "face fan of %s!" % (chart, Delta_polar))
-        # AL: maybe skip this logic
-        cones = [Cone((rays[point_to_ray[point]] for point in chart),
-                      check=check)
-                 for chart in charts]
-        fan = Fan(cones, check=check)
-        if check and not fan.is_complete():
-            raise ValueError("given charts do not form a complete fan!")
+    fan = FaceFan(Delta_polar)
+
+    if check and not fan.is_smooth():
+        raise ValueError("the face fan of Delta_polar is not smooth")
+
+    # Check/normalize base_field
+    if base_field is not None:
+        base_ring = base_field
+    if base_ring is None:
+        base_ring = QQ
+    elif base_ring not in _Fields:
+        raise TypeError("need a field to construct a Fano toric variety!"
+                        "\n Got %s" % base_ring)
 
     return SmoothFanoToricVariety_field(
-        Delta_polar, fan, coordinate_points,
-        point_to_ray, coordinate_names, coordinate_name_indices, base_ring)
+        Delta_polar, fan, coordinate_names, 
+        coordinate_name_indices, base_ring)
 
diff --git a/src/sage/schemes/toric/batyrev_library.py b/src/sage/schemes/toric/batyrev_library.py
