Ticket #14353: trac_14353_factor_fan_morphism.patch

sage/geometry/fan_morphism.py

@@ -1686 +1686 @@
                                         for cone in self.codomain_fan()),
                     lattice=L, check=False)
         return FanMorphism(m, self.domain_fan(), Sigma)
+
+    def factor(self):
+        r"""
+        Factor the fan morphism into a surjection and a generically
+        injective map.
+
+        OUTPUT:
+
+        Starting with a fan morphism $f$, this method returns a pair
+        $(f_1, f_2)$ of fan morphisms such that
+
+        * $f = f_1 \circ f_2$,
+
+        * $f_2$ is surjective, and
+
+        * $f_1$ is injective at a generic point of the domain (in
+          particular, on the maximal torus).
+
+        The intermediate fan (that is, the codomain fan of $f_1$) is
+        the image of the support of the domain fan (which is a cone)
+        intersected with the codomain fan of $f$, see
+        :meth:`~sage.geometry.fan.RationalPolyhedralFan.intersection`. The
+        map $f_2$ is the embedding of this intersection in the whole
+        codomain fan of $f$.
+
+        EXAMPLES::
+
+            sage: N = ToricLattice(3)
+            sage: n1 = N( 1,1,1)
+            sage: n2 = N( 0,1,1)
+            sage: n3 = N(-1,1,1)
+            sage: domain_fan = Fan([Cone([n1,n2]), Cone([n2,n3])])
+            sage: m = matrix([[0,1,3], [0,1,3]]).transpose()
+            sage: image_fan = Fan([Cone([(1,0), (0,1)])])
+            sage: fm = FanMorphism(m, domain_fan, image_fan)
+            sage: fm1, fm2 = fm.factor()
+
+            sage: fm2.is_surjective()
+            True
+            sage: fm1.is_injective()
+            True
+            sage: fm1 * fm2 == fm
+            True
+            sage: fm2.matrix() * fm1.matrix() == m
+            True
+
+            sage: fm.domain_fan() is fm2.domain_fan()
+            True
+            sage: fm.codomain_fan() is fm1.codomain_fan()                  
+            True
+            sage: fm2.codomain_fan() is fm1.domain_fan()
+            True
+
+        The second map need not be injective everywhere, for example
+        here ``fm1`` is injective on the maximal torus but not on the
+        divisor $z_1=0$ ::
+
+            sage: BlC2_patch = ToricVariety(Fan([Cone([(1,0),(1,1)])]))
+            sage: C2 = toric_varieties.A2()
+            sage: f = BlC2_patch.hom(identity_matrix(2), C2)
+            sage: fm1, fm2 = f.fan_morphism().factor()
+            sage: fm2.is_surjective()
+            True
+            sage: fm1.is_injective()
+            False
+            sage: f.as_polynomial_map()
+            Scheme morphism:
+              From: 2-d affine toric variety
+              To:   2-d affine toric variety
+              Defn: Defined on coordinates by sending [z0 : z1] to
+                    [z0*z1 : z1]
+        """
+        fan1 = self.domain_fan()
+        fan2 = self.codomain_fan()
+        # Construct fan1 --fm1--> fan ---fm2--> fan2
+        D, U, V = self.matrix().smith_form()
+        Vinv = V.inverse().change_ring(ZZ)
+        rk = D.rank()
+        # m1 and m2 are the matrices defining fm1 and fm2
+        # self.matrix() == m1 * m2
+        m1 = (self.matrix()*V).submatrix(col=0, ncols=rk)
+        m2 = Vinv.submatrix(row=0, nrows=rk)
+        m2_inv = V.submatrix(col=0, ncols=rk)  # right inverse of m2
+        # the natural morphism only using matrix and domain fan
+        minimal_model = FanMorphism(self, self.domain_fan())
+        # construct the intermediate fan
+        fan_img = fan2.intersection(minimal_model.codomain_fan())
+        fan = Fan([Cone([r*m2_inv for r in c.rays()])
+                   for c in fan_img.generating_cones()])
+        # construct the two fan morphisms
+        fm1 = FanMorphism(m1, fan1, fan)
+        fm2 = FanMorphism(m2, fan, fan2)
+        return fm2, fm1

sage/schemes/toric/homset.py

@@ -231 +231 @@
         raise TypeError, "x must be a fan morphism or a list/tuple of polynomials"
 
 
+    def _an_element_(self):
+        """
+        Construct a sample morphism.
+
+        OUTPUT:
+
+        An element of the homset.
+
+        EXAMPLES::
+
+            sage: P2 = toric_varieties.P2()
+            sage: homset = P2.Hom(P2)
+            sage: homset.an_element()   # indirect doctest
+            Scheme endomorphism of 2-d CPR-Fano toric variety covered by 3 affine patches
+              Defn: Defined by sending Rational polyhedral fan in 2-d lattice N to
+                    Rational polyhedral fan in 2-d lattice N.
+        """
+        from sage.matrix.constructor import zero_matrix
+        zero = zero_matrix(self.domain().dimension_relative(), 
+                           self.codomain().dimension_relative())
+        return self(zero)
+
 class SchemeHomset_points_toric_field(SchemeHomset_points):
     """
     Set of rational points of a toric variety.

sage/schemes/toric/morphism.py

@@ -710 +710 @@
                 polys[i] *= x**d
         return SchemeMorphism_polynomial_toric_variety(self.parent(), polys)
 
+    def is_injective(self):
+        r"""
+        Check if ``self`` is injective.
+        
+        See
+        :meth:`~sage.geometry.fan_morphism.FanMorphism.is_injective`
+        for a description of the toric algorithm.
+               
+        OUTPUT:
+        
+        Boolean. Whether ``self`` is injective.
+
+        EXAMPLES::
+        
+            sage: X = toric_varieties.A(2)
+            sage: m = identity_matrix(2)
+            sage: f = X.hom(m, X)
+            sage: f.is_injective()
+            True
+            
+            sage: Y = ToricVariety(Fan([Cone([(1,0), (1,1)])]))
+            sage: f = Y.hom(m, X)
+            sage: f.is_injective()
+            False
+        """        
+        return self.fan_morphism().is_injective()
+        
+    def is_surjective(self):
+        r"""
+        Check if ``self`` is surjective.
+        
+        See
+        :meth:`~sage.geometry.fan_morphism.FanMorphism.is_surjective`
+        for a description of the toric algorithm.
+               
+        OUTPUT:
+        
+        Boolean. Whether ``self`` is surjective.
+
+        EXAMPLES::
+        
+            sage: X = toric_varieties.A(2)
+            sage: m = identity_matrix(2)
+            sage: f = X.hom(m, X)
+            sage: f.is_surjective()
+            True
+            
+            sage: Y = ToricVariety(Fan([Cone([(1,0), (1,1)])]))
+            sage: f = Y.hom(m, X)
+            sage: f.is_surjective()
+            False
+        """        
+        return self.fan_morphism().is_surjective()
+
+    def factor(self):
+        r"""
+        Factor into a surjection and a generically injective map.
+
+        See
+        :meth:`~sage.geometry.fan_morphism.FanMorphism.factor`
+        for a description of the toric algorithm.
+
+        OUTPUT:
+
+        Starting with a toric morphism $f$, this method returns a pair
+        $(f_1, f_2)$ of toric morphisms such that
+
+        * $f = f_1 \circ f_2$,
+
+        * $f_2$ is surjective, and
+
+        * $f_1$ is injective at a generic point of the domain (in
+          particular, on the maximal torus).
+
+        EXAMPLES::
+
+            sage: N = ToricLattice(3)
+            sage: n1 = N( 1,1,1)
+            sage: n2 = N( 0,1,1)
+            sage: n3 = N(-1,1,1)
+            sage: domain = ToricVariety(Fan([Cone([n1,n2]), Cone([n2,n3])]))
+            sage: m = matrix([[0,1,3], [0,1,3]]).transpose()
+            sage: codomain = ToricVariety(Fan([Cone([(1,0), (0,1)])]))
+            sage: f = domain.hom(m, codomain)
+            sage: f1, f2 = f.factor()
+            sage: f2
+            Scheme morphism:
+              From: 3-d toric variety covered by 2 affine patches
+              To:   1-d affine toric variety
+              Defn: Defined by sending Rational polyhedral fan in 3-d lattice N
+                    to Rational polyhedral fan in 1-d lattice N.
+            sage: f1
+            Scheme morphism:
+              From: 1-d affine toric variety
+              To:   2-d affine toric variety
+              Defn: Defined by sending Rational polyhedral fan in 1-d lattice N
+                    to Rational polyhedral fan in 2-d lattice N.
+            
+            sage: f2.is_surjective()
+            True
+            sage: f1.is_injective()
+            True
+            sage: f1.fan_morphism() * f2.fan_morphism() == f.fan_morphism()
+            True
+        """
+        fm1, fm2 = self.fan_morphism().factor()
+        from sage.schemes.toric.all import ToricVariety
+        X = self.domain()
+        Y = ToricVariety(fm2.codomain_fan())
+        Z = self.codomain()
+        return Y.hom(fm1, Z), X.hom(fm2, Y)