passagemath-polyhedra 10.6.31rc3__cp314-cp314-musllinux_1_2_aarch64.whl

sage/geometry/fan_morphism.py

@@ -0,0 +1,1884 @@
+# sage_setup: distribution = sagemath-polyhedra
+# sage.doctest: needs sage.combinat sage.graphs
+r"""
+Morphisms between toric lattices compatible with fans
+
+This module is a part of the framework for toric varieties
+(:mod:`~sage.schemes.toric.variety`,
+:mod:`~sage.schemes.toric.fano_variety`). Its main purpose is to
+provide support for working with lattice morphisms compatible with fans via
+:class:`FanMorphism` class.
+
+AUTHORS:
+
+- Andrey Novoseltsev (2010-10-17): initial version.
+- Andrey Novoseltsev (2011-04-11): added tests for injectivity/surjectivity,
+    fibration, bundle, as well as some related methods.
+
+EXAMPLES:
+
+Let's consider the face and normal fans of the "diamond" and the projection
+to the `x`-axis::
+
+    sage: diamond = lattice_polytope.cross_polytope(2)
+    sage: face = FaceFan(diamond, lattice=ToricLattice(2))
+    sage: normal = NormalFan(diamond)
+    sage: N = face.lattice()
+    sage: H = End(N)
+    sage: phi = H([N.0, 0])
+    sage: phi
+    Free module morphism defined by the matrix
+    [1 0]
+    [0 0]
+    Domain: 2-d lattice N
+    Codomain: 2-d lattice N
+    sage: FanMorphism(phi, normal, face)
+    Traceback (most recent call last):
+    ...
+    ValueError: the image of generating cone #1 of the domain fan
+    is not contained in a single cone of the codomain fan!
+
+Some of the cones of the normal fan fail to be mapped to a single cone of the
+face fan. We can rectify the situation in the following way::
+
+    sage: fm = FanMorphism(phi, normal, face, subdivide=True)
+    sage: fm
+    Fan morphism defined by the matrix
+    [1 0]
+    [0 0]
+    Domain fan: Rational polyhedral fan in 2-d lattice N
+    Codomain fan: Rational polyhedral fan in 2-d lattice N
+    sage: fm.domain_fan().rays()
+    N( 1,  1),
+    N( 1, -1),
+    N(-1, -1),
+    N(-1,  1),
+    N( 0, -1),
+    N( 0,  1)
+    in 2-d lattice N
+    sage: normal.rays()
+    N( 1,  1),
+    N( 1, -1),
+    N(-1, -1),
+    N(-1,  1)
+    in 2-d lattice N
+
+As you see, it was necessary to insert two new rays (to prevent "upper" and
+"lower" cones of the normal fan from being mapped to the whole `x`-axis).
+"""
+
+
+# ****************************************************************************
+#       Copyright (C) 2010 Andrey Novoseltsev <novoselt@gmail.com>
+#       Copyright (C) 2010 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+import operator
+
+from sage.categories.homset import Hom
+from sage.geometry.cone import Cone
+from sage.geometry.fan import Fan, RationalPolyhedralFan
+from sage.matrix.constructor import matrix
+from sage.matrix.special import identity_matrix
+from sage.structure.element import Matrix
+from sage.misc.cachefunc import cached_method
+from sage.misc.misc_c import prod
+from sage.modules.free_module_morphism import FreeModuleMorphism
+from sage.rings.infinity import Infinity
+from sage.rings.integer_ring import ZZ
+from sage.rings.infinity import InfinityElement
+from functools import reduce
+
+
+class FanMorphism(FreeModuleMorphism):
+    r"""
+    Create a fan morphism.
+
+    Let `\Sigma_1` and `\Sigma_2` be two fans in lattices `N_1` and `N_2`
+    respectively. Let `\phi` be a morphism (i.e. a linear map) from `N_1` to
+    `N_2`. We say that `\phi` is *compatible* with `\Sigma_1` and `\Sigma_2`
+    if every cone `\sigma_1\in\Sigma_1` is mapped by `\phi` into a single cone
+    `\sigma_2\in\Sigma_2`, i.e. `\phi(\sigma_1)\subset\sigma_2` (`\sigma_2`
+    may be different for different `\sigma_1`).
+
+    By a **fan morphism** we understand a morphism between two lattices
+    compatible with specified fans in these lattices. Such morphisms behave in
+    exactly the same way as "regular" morphisms between lattices, but:
+
+    * fan morphisms have a special constructor allowing some automatic
+      adjustments to the initial fans (see below);
+    * fan morphisms are aware of the associated fans and they can be
+      accessed via :meth:`codomain_fan` and :meth:`domain_fan`;
+    * fan morphisms can efficiently compute :meth:`image_cone` of a given
+      cone of the domain fan and :meth:`preimage_cones` of a given cone of
+      the codomain fan.
+
+    INPUT:
+
+    - ``morphism`` -- either a morphism between domain and codomain, or an
+      integral matrix defining such a morphism;
+
+    - ``domain_fan`` -- a :class:`fan
+      <sage.geometry.fan.RationalPolyhedralFan>` in the domain
+
+    - ``codomain`` -- (default: ``None``) either a codomain lattice or a fan in
+      the codomain. If the codomain fan is not given, the image fan (fan
+      generated by images of generating cones) of ``domain_fan`` will be used,
+      if possible.
+
+    - ``subdivide`` -- boolean (default: ``False``); if ``True`` and ``domain_fan`` is
+      not compatible with the codomain fan because it is too coarse, it will be
+      automatically refined to become compatible (the minimal refinement is
+      canonical, so there are no choices involved)
+
+    - ``check`` -- boolean (default: ``True``); if ``False``, given fans and morphism
+      will be assumed to be compatible. Be careful when using this option,
+      since wrong assumptions can lead to wrong and hard-to-detect errors. On
+      the other hand, this option may save you some time.
+
+    - ``verbose`` -- boolean (default: ``False``); if ``True``, some information may be
+      printed during construction of the fan morphism
+
+    OUTPUT: a fan morphism
+
+    EXAMPLES:
+
+    Here we consider the face and normal fans of the "diamond" and the
+    projection to the `x`-axis::
+
+        sage: diamond = lattice_polytope.cross_polytope(2)
+        sage: face = FaceFan(diamond, lattice=ToricLattice(2))
+        sage: normal = NormalFan(diamond)
+        sage: N = face.lattice()
+        sage: H = End(N)
+        sage: phi = H([N.0, 0])
+        sage: phi
+        Free module morphism defined by the matrix
+        [1 0]
+        [0 0]
+        Domain: 2-d lattice N
+        Codomain: 2-d lattice N
+        sage: fm = FanMorphism(phi, face, normal)
+        sage: fm.domain_fan() is face
+        True
+
+    Note, that since ``phi`` is compatible with these fans, the returned
+    fan is exactly the same object as the initial ``domain_fan``. ::
+
+        sage: FanMorphism(phi, normal, face)
+        Traceback (most recent call last):
+        ...
+        ValueError: the image of generating cone #1 of the domain fan
+        is not contained in a single cone of the codomain fan!
+        sage: fm = FanMorphism(phi, normal, face, subdivide=True)
+        sage: fm.domain_fan() is normal
+        False
+        sage: fm.domain_fan().ngenerating_cones()
+        6
+
+    We had to subdivide two of the four cones of the normal fan, since
+    they were mapped by ``phi`` into non-strictly convex cones.
+
+    It is possible to omit the codomain fan, in which case the image fan will
+    be used instead of it::
+
+        sage: fm = FanMorphism(phi, face)
+        sage: fm.codomain_fan()
+        Rational polyhedral fan in 2-d lattice N
+        sage: fm.codomain_fan().rays()
+        N( 1, 0),
+        N(-1, 0)
+        in 2-d lattice N
+
+    Now we demonstrate a more subtle example. We take the first quadrant as our
+    domain fan. Then we divide the first quadrant into three cones, throw away
+    the middle one and take the other two as our codomain fan. These fans are
+    incompatible with the identity lattice morphism since the image of the
+    domain fan is out of the support of the codomain fan::
+
+        sage: N = ToricLattice(2)
+        sage: phi = End(N).identity()
+        sage: F1 = Fan(cones=[(0,1)], rays=[(1,0), (0,1)])
+        sage: F2 = Fan(cones=[(0,1), (2,3)],
+        ....:          rays=[(1,0), (2,1), (1,2), (0,1)])
+        sage: FanMorphism(phi, F1, F2)
+        Traceback (most recent call last):
+        ...
+        ValueError: the image of generating cone #0 of the domain fan
+        is not contained in a single cone of the codomain fan!
+        sage: FanMorphism(phi, F1, F2, subdivide=True)
+        Traceback (most recent call last):
+        ...
+        ValueError: morphism defined by
+        [1 0]
+        [0 1]
+        does not map
+        Rational polyhedral fan in 2-d lattice N
+        into the support of
+        Rational polyhedral fan in 2-d lattice N!
+
+    The problem was detected and handled correctly (i.e. an exception was
+    raised). However, the used algorithm requires extra checks for this
+    situation after constructing a potential subdivision and this can take
+    significant time. You can save about half the time using
+    ``check=False`` option, if you know in advance that it is possible to
+    make fans compatible with the morphism by subdividing the domain fan.
+    Of course, if your assumption was incorrect, the result will be wrong
+    and you will get a fan which *does* map into the support of the
+    codomain fan, but is **not** a subdivision of the domain fan. You
+    can test it on the example above::
+
+        sage: fm = FanMorphism(phi, F1, F2, subdivide=True,
+        ....:                  check=False, verbose=True)
+        Placing ray images (... ms)
+        Computing chambers (... ms)
+        Number of domain cones: 1.
+        Number of chambers: 2.
+        Cone 0 sits in chambers 0 1 (... ms)
+        sage: fm.domain_fan().is_equivalent(F2)
+        True
+    """
+
+    def __init__(self, morphism, domain_fan,
+                 codomain=None,
+                 subdivide=False,
+                 check=True,
+                 verbose=False):
+        r"""
+        Create a fan morphism.
+
+        See :class:`FanMorphism` for documentation.
+
+        TESTS::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2), quadrant_bl, quadrant)
+            sage: fm
+            Fan morphism defined by the matrix
+            [1 0]
+            [0 1]
+            Domain fan: Rational polyhedral fan in 2-d lattice N
+            Codomain fan: Rational polyhedral fan in 2-d lattice N
+            sage: TestSuite(fm).run(skip='_test_category')
+        """
+        assert isinstance(domain_fan, RationalPolyhedralFan)
+        if isinstance(codomain, RationalPolyhedralFan):
+            codomain, codomain_fan = codomain.lattice(), codomain
+        else:
+            codomain_fan = None
+        if isinstance(morphism, FreeModuleMorphism):
+            parent = morphism.parent()
+            A = morphism.matrix()
+        elif isinstance(morphism, Matrix):
+            A = morphism
+            if codomain is None:
+                raise ValueError("codomain (fan) must be given explicitly if "
+                                 "morphism is given by a matrix!")
+            parent = Hom(domain_fan.lattice(), codomain)
+        else:
+            raise TypeError("morphism must be either a FreeModuleMorphism "
+                            "or a matrix!\nGot: %s" % morphism)
+        super().__init__(parent, A)
+        self._domain_fan = domain_fan
+        self._image_cone = dict()
+        self._preimage_cones = dict()
+        self._preimage_fans = dict()
+        self._primitive_preimage_cones = dict()
+        if codomain_fan is None:
+            self._construct_codomain_fan(check)
+        else:
+            self._codomain_fan = codomain_fan
+            if subdivide:
+                self._subdivide_domain_fan(check, verbose)
+            elif check:
+                self._validate()
+
+    def __mul__(self, right):
+        """
+        Return the composition of ``self`` and ``right``.
+
+        INPUT:
+
+        - ``right`` -- a :class:`FanMorphism` whose :meth:`codomain_fan` can be
+          mapped to :meth:`domain_fan` of ``self`` via identity map of lattices
+
+        OUTPUT: a :class:`FanMorphism`
+
+        EXAMPLES::
+
+            sage: A2 = toric_varieties.A2()
+            sage: P3 = toric_varieties.P(3)                                             # needs palp
+            sage: m = matrix([(2,0,0), (1,1,0)])
+            sage: phi = A2.hom(m, P3).fan_morphism(); phi                               # needs palp
+            Fan morphism defined by the matrix
+            [2 0 0]
+            [1 1 0]
+            Domain fan: Rational polyhedral fan in 2-d lattice N
+            Codomain fan: Rational polyhedral fan in 3-d lattice N
+            sage: prod(phi.factor())  # indirect test                                   # needs palp
+            Fan morphism defined by the matrix
+            [2 0 0]
+            [1 1 0]
+            Domain fan: Rational polyhedral fan in 2-d lattice N
+            Codomain fan: Rational polyhedral fan in 3-d lattice N
+        """
+        if not isinstance(right, FanMorphism):
+            raise TypeError(
+                "fan morphisms should be composed with fan morphisms")
+        # We don't need it, we just check compatibility of fans:
+        FanMorphism(identity_matrix(self.domain().dimension()),
+                    right.codomain_fan(), self.domain_fan())
+        m = right.matrix() * self.matrix()
+        return FanMorphism(m, right.domain_fan(), self.codomain_fan())
+
+    def _RISGIS(self):
+        r"""
+        Return Ray Images Star Generator Indices Sets.
+
+        OUTPUT:
+
+        - a :class:`tuple` of :class:`frozenset`s of integers, the `i`-th set
+          is the set of indices of star generators for the minimal cone of the
+          :meth:`codomain_fan` containing the image of the `i`-th ray of the
+          :meth:`domain_fan`.
+
+        TESTS::
+
+            sage: diamond = lattice_polytope.cross_polytope(2)
+            sage: face = FaceFan(diamond)
+            sage: normal = NormalFan(diamond)
+            sage: N = face.lattice()
+            sage: fm = FanMorphism(identity_matrix(2),
+            ....:                  normal, face, subdivide=True)
+            sage: fm._RISGIS()
+            (frozenset({2}),
+             frozenset({3}),
+             frozenset({0}),
+             frozenset({1}),
+             frozenset({0, 1}),
+             frozenset({0, 3}),
+             frozenset({2, 3}),
+             frozenset({1, 2}))
+        """
+        if "_RISGIS_" not in self.__dict__:
+            try:
+                cones = [self._codomain_fan.cone_containing(self(ray))
+                         for ray in self._domain_fan.rays()]
+            except ValueError:
+                self._support_error()
+            self._RISGIS_ = tuple(frozenset(cone.star_generator_indices())
+                                  for cone in cones)
+        return self._RISGIS_
+
+    def _chambers(self):
+        r"""
+        Return chambers in the domain corresponding to the codomain fan.
+
+        This function is used during automatic refinement of the domain fans,
+        see :meth:`_subdivide_domain_fan`.
+
+        OUTPUT:
+
+        - a :class:`tuple` ``(chambers, cone_to_chamber)``, where
+
+        - ``chambers`` is a :class:`list` of :class:`cones
+          <sage.geometry.cone.ConvexRationalPolyhedralCone>` in the domain of
+          ``self``
+
+        - ``cone_to_chamber`` is a :class:`list` of integers, if its `i`-th
+          element is `j`, then the `j`-th element of ``chambers`` is the
+          inverse image of the `i`-th generating cone of the codomain fan.
+
+        TESTS::
+
+            sage: F = NormalFan(lattice_polytope.cross_polytope(2))
+            sage: N = F.lattice()
+            sage: H = End(N)
+            sage: phi = H([N.0, 0])
+            sage: fm = FanMorphism(phi, F, F, subdivide=True)
+            sage: fm._chambers()
+            ([2-d cone in 2-d lattice N,
+              1-d cone in 2-d lattice N,
+              2-d cone in 2-d lattice N],
+             [0, 1, 2, 1])
+        """
+        kernel_rays = []
+        for ray in self.kernel().basis():
+            kernel_rays.append(ray)
+            kernel_rays.append(-ray)
+        image_rays = []
+        for ray in self.image().basis():
+            image_rays.append(ray)
+            image_rays.append(-ray)
+        image = Cone(image_rays)
+        chambers = []
+        cone_to_chamber = []
+        for cone in self._codomain_fan:
+            chamber = Cone([self.lift(ray) for ray in cone.intersection(image)]
+                           + kernel_rays, lattice=self.domain())
+            cone_to_chamber.append(len(chambers))
+            for i, old_chamber in enumerate(chambers):
+                if old_chamber.is_equivalent(chamber):
+                    cone_to_chamber[-1] = i
+                    break
+            if cone_to_chamber[-1] == len(chambers):
+                chambers.append(chamber)
+        return (chambers, cone_to_chamber)
+
+    def _construct_codomain_fan(self, check):
+        r"""
+        Construct the codomain fan as the image of the domain one.
+
+        .. WARNING::
+
+            This method should be called only during initialization.
+
+        INPUT:
+
+        - ``check`` -- passed on to the fan constructor
+
+        OUTPUT: none, but the codomain fan of ``self`` is set to the constructed fan
+
+        TESTS::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2), quadrant_bl)
+            Traceback (most recent call last):
+            ...
+            ValueError: codomain (fan) must be given explicitly
+            if morphism is given by a matrix!
+            sage: fm = FanMorphism(identity_matrix(2), quadrant_bl, ZZ^2)
+            sage: fm.codomain_fan().rays()  # indirect doctest
+            (1, 0),
+            (0, 1),
+            (1, 1)
+            in Ambient free module of rank 2
+            over the principal ideal domain Integer Ring
+        """
+        # We literally try to construct the image fan and hope that it works.
+        # If it does not, the fan constructor will raise an exception.
+        domain_fan = self._domain_fan
+        self._codomain_fan = Fan(cones=(domain_cone.ambient_ray_indices()
+                                        for domain_cone in domain_fan),
+                                 rays=(self(ray) for ray in domain_fan.rays()),
+                                 lattice=self.codomain(),
+                                 discard_faces=True, check=check)
+
+    def _latex_(self):
+        r"""
+        Return the `\LaTeX` representation of ``self``.
+
+        OUTPUT: a :class:`string`
+
+        EXAMPLES::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2), quadrant_bl, quadrant)
+            sage: fm
+            Fan morphism defined by the matrix
+            [1 0]
+            [0 1]
+            Domain fan: Rational polyhedral fan in 2-d lattice N
+            Codomain fan: Rational polyhedral fan in 2-d lattice N
+            sage: print(fm._latex_())
+            \left(\begin{array}{rr}
+            1 & 0 \\
+            0 & 1
+            \end{array}\right) : \Sigma^{2} \to \Sigma^{2}
+        """
+        from sage.misc.latex import latex
+        return (r"%s : %s \to %s" % (latex(self.matrix()),
+                        latex(self.domain_fan()), latex(self.codomain_fan())))
+
+    @cached_method
+    def _ray_index_map(self):
+        r"""
+        Return the map between indices of rays in domain and codomain fans.
+
+        OUTPUT:
+
+        - a tuple of integers. If the `i`-th entry is -1, the `i`-th ray of the
+          domain fan is mapped to the origin. If it is `j`, then the `i`-th ray
+          of the domain fan is mapped onto the `j`-th ray of the codomain fan.
+          If there is a ray in the domain fan which is mapped into the relative
+          interior of a higher dimensional cone, a :exc:`ValueError`
+          exception is raised.
+
+        .. NOTE::
+
+            This method is used by :meth:`is_bundle` and :meth:`is_fibration`.
+
+        TESTS::
+
+            sage: # needs palp
+            sage: Sigma = toric_varieties.dP8().fan()
+            sage: Sigma_p = toric_varieties.P1().fan()
+            sage: phi = FanMorphism(matrix([[1], [-1]]), Sigma, Sigma_p)
+            sage: phi._ray_index_map()
+            (-1, 1, -1, 0)
+            sage: xi = FanMorphism(matrix([[1, 0]]), Sigma_p, Sigma)
+            sage: xi._ray_index_map()
+            Traceback (most recent call last):
+            ...
+            ValueError: ray #1 is mapped into a 2-d cone!
+        """
+        Sigma = self.domain_fan()
+        ray_index_map = [-1] * Sigma.nrays()
+        for i, rho in enumerate(Sigma(1)):
+            sigma_p = self.image_cone(rho)
+            if sigma_p.nrays() > 1:
+                raise ValueError("ray #%d is mapped into a %d-d cone!" %
+                                 (i, sigma_p.dim()))
+            elif sigma_p.nrays() == 1:
+                ray_index_map[i] = sigma_p.ambient_ray_indices()[0]
+        return tuple(ray_index_map)
+
+    def _repr_(self):
+        r"""
+        Return the string representation of ``self``.
+
+        OUTPUT: a :class:`string`
+
+        EXAMPLES::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2), quadrant_bl, quadrant)
+            sage: print(fm._repr_())
+            Fan morphism defined by the matrix
+            [1 0]
+            [0 1]
+            Domain fan: Rational polyhedral fan in 2-d lattice N
+            Codomain fan: Rational polyhedral fan in 2-d lattice N
+        """
+        return ("Fan morphism defined by the matrix\n"
+                "%s\n"
+                "Domain fan: %s\n"
+                "Codomain fan: %s"
+                % (self.matrix(), self.domain_fan(), self.codomain_fan()))
+
+    def _subdivide_domain_fan(self, check, verbose):
+        r"""
+        Subdivide the domain fan to make it compatible with the codomain fan.
+
+        .. WARNING::
+
+            This method should be called only during initialization.
+
+        INPUT:
+
+        - ``check`` -- boolean (default: ``True``); if ``False``, some of the
+          consistency checks will be omitted, which saves time but can
+          potentially lead to wrong results. Currently, with
+          ``check=False`` option there will be no check that ``domain_fan``
+          maps to ``codomain_fan``
+
+        - ``verbose`` -- boolean (default: ``False``); if ``True``, some timing
+          information will be printed in the process
+
+        OUTPUT:
+
+        - none, but the domain fan of ``self`` is replaced with its minimal
+          refinement, if possible. Otherwise a :exc:`ValueError`
+          exception is raised.
+
+        TESTS::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2), quadrant, quadrant_bl)
+            Traceback (most recent call last):
+            ...
+            ValueError: the image of generating cone #0 of the domain fan
+            is not contained in a single cone of the codomain fan!
+            sage: fm = FanMorphism(identity_matrix(2), quadrant,
+            ....:                  quadrant_bl, subdivide=True)
+            sage: fm.domain_fan().rays()  # indirect doctest
+            N(1, 0),
+            N(0, 1),
+            N(1, 1)
+            in 2-d lattice N
+
+        Now we demonstrate a more subtle example. We take the first quadrant
+        as our ``domain_fan``. Then we divide the first quadrant into three
+        cones, throw away the middle one and take the other two as our
+        ``codomain_fan``. These fans are incompatible with the identity
+        lattice morphism since the image of ``domain_fan`` is out of the
+        support of ``codomain_fan``::
+
+            sage: N = ToricLattice(2)
+            sage: phi = End(N).identity()
+            sage: F1 = Fan(cones=[(0,1)], rays=[(1,0), (0,1)])
+            sage: F2 = Fan(cones=[(0,1), (2,3)],
+            ....:          rays=[(1,0), (2,1), (1,2), (0,1)])
+            sage: FanMorphism(phi, F1, F2)
+            Traceback (most recent call last):
+            ...
+            ValueError: the image of generating cone #0 of the domain fan
+            is not contained in a single cone of the codomain fan!
+            sage: FanMorphism(phi, F1, F2, subdivide=True)
+            Traceback (most recent call last):
+            ...
+            ValueError: morphism defined by
+            [1 0]
+            [0 1]
+            does not map
+            Rational polyhedral fan in 2-d lattice N
+            into the support of
+            Rational polyhedral fan in 2-d lattice N!
+
+        We check that :issue:`10943` is fixed::
+
+            sage: Sigma = Fan(rays=[(1,1,0), (1,-1,0)], cones=[(0,1)])
+            sage: Sigma_prime = FaceFan(lattice_polytope.cross_polytope(3))
+            sage: fm = FanMorphism(identity_matrix(3),
+            ....:                  Sigma, Sigma_prime, subdivide=True)
+            sage: fm.domain_fan().rays()
+            N(1,  1, 0),
+            N(1, -1, 0),
+            N(1,  0, 0)
+            in 3-d lattice N
+            sage: [cone.ambient_ray_indices() for cone in fm.domain_fan()]
+            [(0, 2), (1, 2)]
+
+            sage: sigma = Cone([(0,1), (3,1)])
+            sage: Sigma = Fan([sigma])
+            sage: Sigma_prime = Sigma.subdivide([(1,1), (2,1)])
+            sage: FanMorphism(identity_matrix(2),
+            ....:             Sigma, Sigma_prime, subdivide=True)
+            Fan morphism defined by the matrix
+            [1 0]
+            [0 1]
+            Domain fan: Rational polyhedral fan in 2-d lattice N
+            Codomain fan: Rational polyhedral fan in 2-d lattice N
+        """
+        domain_fan = self._domain_fan
+        lattice_dim = self.domain().dimension()
+        if verbose:
+            from sage.misc.timing import walltime
+            start = walltime()
+            print("Placing ray images", end=" ")
+        # Figure out where 1-dimensional cones (i.e. rays) are mapped.
+        RISGIS = self._RISGIS()
+        if verbose:
+            print("(%.3f ms)" % walltime(start))
+        # Subdivide cones that require it.
+        chambers = None # preimages of codomain cones, computed if necessary
+        new_cones = []
+        for cone_index, domain_cone in enumerate(domain_fan):
+            if reduce(operator.and_,
+                      (RISGIS[i] for i in domain_cone.ambient_ray_indices())):
+                # There is a codomain cone containing all rays of this domain
+                # cone, no need to subdivide it.
+                new_cones.append(domain_cone)
+                continue
+            dim = domain_cone.dim()
+            if chambers is None:
+                if verbose:
+                    start = walltime()
+                    print("Computing chambers", end=" ")
+                chambers, cone_to_chamber = self._chambers()
+                if verbose:
+                    print("(%.3f ms)" % walltime(start))
+                    print("Number of domain cones: %d.\n"
+                          "Number of chambers: %d." %
+                          (domain_fan.ngenerating_cones(), len(chambers)))
+            # Subdivide domain_cone.
+            if verbose:
+                start = walltime()
+                print("Cone %d sits in chambers" % cone_index, end=" ")
+            # It seems that there is no quick way to determine which chambers
+            # do NOT intersect this domain cone, so we go over all of them.
+            parts = []
+            for chamber_index, chamber in enumerate(chambers):
+                # If chamber is small, intersection will be small.
+                if chamber.dim() < dim:
+                    continue
+                new_part = domain_cone.intersection(chamber)
+                # If intersection is small, it is not a generating cone.
+                if new_part.dim() < dim:
+                    continue
+                # Small cones may have repetitive intersections with chambers.
+                if (dim == lattice_dim or
+                    not any(part.is_equivalent(new_part) for part in parts)):
+                    parts.append(new_part)
+                    if verbose:
+                        print(chamber_index, end=" ")
+            if check:
+                # Check if the subdivision is complete, i.e. there are no
+                # missing pieces of domain_cone. To do this, we construct a
+                # fan from the obtained parts and check that interior points
+                # of boundary cones of this fan are in the interior of the
+                # original cone. In any case we know that we are constructing
+                # a valid fan, so passing check=False to Fan(...) is OK.
+                if verbose:
+                    print("(%.3f ms)" % walltime(start))
+                    start = walltime()
+                    print("Checking for missing pieces", end=" ")
+                cone_subdivision = Fan(parts, check=False)
+                for cone in cone_subdivision(dim - 1):
+                    if len(cone.star_generators()) == 1:
+                        if domain_cone.relative_interior_contains(
+                                                            sum(cone.rays())):
+                            self._support_error()
+            new_cones.extend(parts)
+            if verbose:
+                print("(%.3f ms)" % walltime(start))
+        if len(new_cones) > domain_fan.ngenerating_cones():
+            # Construct a new fan keeping old rays in the same order
+            new_rays = list(domain_fan.rays())
+            for cone in new_cones:
+                for ray in cone:
+                    if ray not in new_rays:
+                        new_rays.append(ray)
+            # Replace domain_fan, this is OK since this method must be called
+            # only during initialization of the FanMorphism.
+            self._domain_fan = Fan(new_cones, new_rays, domain_fan.lattice(),
+                                   check=False)
+            # Also remove RISGIS for the old fan
+            del self._RISGIS_
+
+    def _support_error(self):
+        r"""
+        Raise a :exc:`ValueError` exception due to support incompatibility.
+
+        OUTPUT: none, a :exc:`ValueError` exception is raised
+
+        TESTS:
+
+        We deliberately construct an invalid morphism for this demonstration::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2),
+            ....:                  quadrant, quadrant_bl, check=False)
+
+        Now we report that the morphism is invalid::
+
+            sage: fm._support_error()
+            Traceback (most recent call last):
+            ...
+            ValueError: morphism defined by
+            [1 0]
+            [0 1]
+            does not map
+            Rational polyhedral fan in 2-d lattice N
+            into the support of
+            Rational polyhedral fan in 2-d lattice N!
+        """
+        raise ValueError("morphism defined by\n"
+                         "%s\n"
+                         "does not map\n"
+                         "%s\n"
+                         "into the support of\n"
+                         "%s!"
+                    % (self.matrix(), self.domain_fan(), self.codomain_fan()))
+
+    def _validate(self):
+        r"""
+        Check if ``self`` is indeed compatible with domain and codomain fans.
+
+        OUTPUT:
+
+        - none, but a :exc:`ValueError` exception is raised if there is
+          a cone of the domain fan of ``self`` which is not completely
+          contained in a single cone of the codomain fan of ``self``,
+          or if one of these fans does not sit in the appropriate lattice.
+
+        EXAMPLES::
+
+            sage: N3 = ToricLattice(3, "N3")
+            sage: N2 = ToricLattice(2, "N2")
+            sage: H = Hom(N3, N2)
+            sage: phi = H([N2.0, N2.1, N2.0])
+            sage: F1 = Fan(cones=[(0,1,2), (1,2,3)],
+            ....:          rays=[(1,1,1), (1,1,-1), (1,-1,1), (1,-1,-1)],
+            ....:          lattice=N3)
+            sage: F1.rays()
+            N3(1,  1,  1),
+            N3(1,  1, -1),
+            N3(1, -1,  1),
+            N3(1, -1, -1)
+            in 3-d lattice N3
+            sage: [phi(ray) for ray in F1.rays()]
+            [N2(2, 1), N2(0, 1), N2(2, -1), N2(0, -1)]
+            sage: F2 = Fan(cones=[(0,1,2), (1,2,3)],
+            ....:          rays=[(1,1,1), (1,1,-1), (1,2,1), (1,2,-1)],
+            ....:          lattice=N3)
+            sage: F2.rays()
+            N3(1, 1,  1),
+            N3(1, 1, -1),
+            N3(1, 2,  1),
+            N3(1, 2, -1)
+            in 3-d lattice N3
+            sage: [phi(ray) for ray in F2.rays()]
+            [N2(2, 1), N2(0, 1), N2(2, 2), N2(0, 2)]
+            sage: F3 = Fan(cones=[(0,1), (1,2)],
+            ....:          rays=[(1,0), (2,1), (0,1)],
+            ....:          lattice=N2)
+            sage: FanMorphism(phi, F2, F3)
+            Fan morphism defined by the matrix
+            [1 0]
+            [0 1]
+            [1 0]
+            Domain fan: Rational polyhedral fan in 3-d lattice N3
+            Codomain fan: Rational polyhedral fan in 2-d lattice N2
+            sage: FanMorphism(phi, F1, F3)  # indirect doctest
+            Traceback (most recent call last):
+            ...
+            ValueError: morphism defined by
+            [1 0]
+            [0 1]
+            [1 0]
+            does not map
+            Rational polyhedral fan in 3-d lattice N3
+            into the support of
+            Rational polyhedral fan in 2-d lattice N2!
+
+
+        TESTS::
+
+            sage: trivialfan2 = Fan([], [], lattice=ToricLattice(2))
+            sage: trivialfan3 = Fan([], [], lattice=ToricLattice(3))
+            sage: FanMorphism(zero_matrix(2,3), trivialfan2, trivialfan3)
+            Fan morphism defined by the matrix
+            [0 0 0]
+            [0 0 0]
+            Domain fan: Rational polyhedral fan in 2-d lattice N
+            Codomain fan: Rational polyhedral fan in 3-d lattice N
+        """
+        domain_fan = self._domain_fan
+        if domain_fan.lattice() is not self.domain():
+            raise ValueError("%s does not sit in %s!"
+                             % (domain_fan, self.domain()))
+        codomain_fan = self._codomain_fan
+        if codomain_fan.lattice() is not self.codomain():
+            raise ValueError("%s does not sit in %s!"
+                             % (codomain_fan, self.codomain()))
+        RISGIS = self._RISGIS()
+        for n, domain_cone in enumerate(domain_fan):
+            if not domain_cone.is_trivial() and \
+                    not reduce(operator.and_,
+                               (RISGIS[i] for i in domain_cone.ambient_ray_indices())):
+                raise ValueError("the image of generating cone #%d of the "
+                                 "domain fan is not contained in a single "
+                                 "cone of the codomain fan!" % n)
+
+    def codomain_fan(self, dim=None, codim=None):
+        r"""
+        Return the codomain fan of ``self``.
+
+        INPUT:
+
+        - ``dim`` -- dimension of the requested cones
+
+        - ``codim`` -- codimension of the requested cones
+
+        OUTPUT:
+
+        - :class:`rational polyhedral fan
+          <sage.geometry.fan.RationalPolyhedralFan>` if no parameters were
+          given, :class:`tuple` of :class:`cones
+          <sage.geometry.cone.ConvexRationalPolyhedralCone>` otherwise.
+
+        EXAMPLES::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2), quadrant_bl, quadrant)
+            sage: fm.codomain_fan()
+            Rational polyhedral fan in 2-d lattice N
+            sage: fm.codomain_fan() is quadrant
+            True
+        """
+        return self._codomain_fan(dim=dim, codim=codim)
+
+    def domain_fan(self, dim=None, codim=None):
+        r"""
+        Return the codomain fan of ``self``.
+
+        INPUT:
+
+        - ``dim`` -- dimension of the requested cones
+
+        - ``codim`` -- codimension of the requested cones
+
+        OUTPUT:
+
+        - :class:`rational polyhedral fan
+          <sage.geometry.fan.RationalPolyhedralFan>` if no parameters were
+          given, :class:`tuple` of :class:`cones
+          <sage.geometry.cone.ConvexRationalPolyhedralCone>` otherwise.
+
+        EXAMPLES::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2), quadrant_bl, quadrant)
+            sage: fm.domain_fan()
+            Rational polyhedral fan in 2-d lattice N
+            sage: fm.domain_fan() is quadrant_bl
+            True
+        """
+        return self._domain_fan(dim=dim, codim=codim)
+
+    def image_cone(self, cone):
+        r"""
+        Return the cone of the codomain fan containing the image of ``cone``.
+
+        INPUT:
+
+        - ``cone`` -- a :class:`cone
+          <sage.geometry.cone.ConvexRationalPolyhedralCone>` equivalent to a
+          cone of the :meth:`domain_fan` of ``self``.
+
+        OUTPUT:
+
+        - a :class:`cone <sage.geometry.cone.ConvexRationalPolyhedralCone>`
+          of the :meth:`codomain_fan` of ``self``.
+
+        EXAMPLES::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2), quadrant_bl, quadrant)
+            sage: fm.image_cone(Cone([(1,0)]))
+            1-d cone of Rational polyhedral fan in 2-d lattice N
+            sage: fm.image_cone(Cone([(1,1)]))
+            2-d cone of Rational polyhedral fan in 2-d lattice N
+
+        TESTS:
+
+        We check that complete codomain fans are handled correctly, since a
+        different algorithm is used in this case::
+
+            sage: diamond = lattice_polytope.cross_polytope(2)
+            sage: face = FaceFan(diamond, lattice=ToricLattice(2))
+            sage: normal = NormalFan(diamond)
+            sage: N = face.lattice()
+            sage: fm = FanMorphism(identity_matrix(2),
+            ....:                  normal, face, subdivide=True)
+            sage: fm.image_cone(Cone([(1,0)]))
+            1-d cone of Rational polyhedral fan in 2-d lattice N
+            sage: fm.image_cone(Cone([(1,1)]))
+            2-d cone of Rational polyhedral fan in 2-d lattice N
+        """
+        cone = self._domain_fan.embed(cone)
+        if cone not in self._image_cone:
+            codomain_fan = self._codomain_fan()
+            if cone.is_trivial():
+                self._image_cone[cone] = codomain_fan(0)[0]
+            elif codomain_fan.is_complete():
+                # Optimization for a common case
+                RISGIS = self._RISGIS()
+                CSGIS = set(reduce(operator.and_,
+                            (RISGIS[i] for i in cone.ambient_ray_indices())))
+                image_cone = codomain_fan.generating_cone(CSGIS.pop())
+                for i in CSGIS:
+                    image_cone = image_cone.intersection(
+                                            codomain_fan.generating_cone(i))
+                self._image_cone[cone] = image_cone
+            else:
+                self._image_cone[cone] = codomain_fan.cone_containing(
+                                                    self(ray) for ray in cone)
+        return self._image_cone[cone]
+
+    def index(self, cone=None):
+        r"""
+        Return the index of ``self`` as a map between lattices.
+
+        INPUT:
+
+        - ``cone`` -- (default: ``None``) a :class:`cone
+          <sage.geometry.cone.ConvexRationalPolyhedralCone>` of the
+          :meth:`codomain_fan` of ``self``.
+
+        OUTPUT: integer, infinity, or ``None``
+
+        If no cone was specified, this function computes the index of the
+        image of ``self`` in the codomain. If a cone `\sigma` was given, the
+        index of ``self`` over `\sigma` is computed in the sense of
+        Definition 2.1.7 of [HLY2002]_: if `\sigma'` is any cone of the
+        :meth:`domain_fan` of ``self`` whose relative interior is mapped to the
+        relative interior of `\sigma`, it is the index of the image of
+        `N'(\sigma')` in `N(\sigma)`, where `N'` and `N` are domain and codomain
+        lattices respectively. While that definition was formulated for the case
+        of the finite index only, we extend it to the infinite one as well and
+        return ``None`` if there is no `\sigma'` at all. See examples below for
+        situations when such things happen. Note also that the index of ``self``
+        is the same as index over the trivial cone.
+
+        EXAMPLES::
+
+            sage: # needs palp
+            sage: Sigma = toric_varieties.dP8().fan()
+            sage: Sigma_p = toric_varieties.P1().fan()
+            sage: phi = FanMorphism(matrix([[1], [-1]]), Sigma, Sigma_p)
+            sage: phi.index()
+            1
+            sage: psi = FanMorphism(matrix([[2], [-2]]), Sigma, Sigma_p)
+            sage: psi.index()
+            2
+            sage: xi = FanMorphism(matrix([[1, 0]]), Sigma_p, Sigma)
+            sage: xi.index()
+            +Infinity
+
+        Infinite index in the last example indicates that the image has positive
+        codimension in the codomain. Let's look at the rays of our fans::
+
+            sage: Sigma_p.rays()                                                        # needs palp
+            N( 1),
+            N(-1)
+            in 1-d lattice N
+            sage: Sigma.rays()                                                          # needs palp
+            N( 1,  1),
+            N( 0,  1),
+            N(-1, -1),
+            N( 1,  0)
+            in 2-d lattice N
+            sage: xi.factor()[0].domain_fan().rays()                                    # needs palp
+            N(-1, 0),
+            N( 1, 0)
+            in Sublattice <N(1, 0)>
+
+        We see that one of the rays of the fan of ``P1`` is mapped to a ray,
+        while the other one to the interior of some 2-d cone. Both rays
+        correspond to single points on ``P1``, yet one is mapped to the
+        distinguished point of a torus invariant curve of ``dP8`` (with the
+        rest of this curve being uncovered) and the other to a fixed point
+        of ``dP8`` (thus completely covering this torus orbit in ``dP8``).
+
+        We should therefore expect the following behaviour: all indices over
+        1-d cones are ``None``, except for one which is infinite, and all
+        indices over 2-d cones are ``None``, except for one which is 1::
+
+            sage: [xi.index(cone) for cone in Sigma(1)]                                 # needs palp
+            [None, None, None, +Infinity]
+            sage: [xi.index(cone) for cone in Sigma(2)]                                 # needs palp
+            [None, 1, None, None]
+
+        TESTS::
+
+            sage: # needs palp
+            sage: Sigma = toric_varieties.dP8().fan()
+            sage: Sigma_p = toric_varieties.Cube_nonpolyhedral().fan()
+            sage: m = matrix([[2,6,10], [7,11,13]])
+            sage: zeta = FanMorphism(m, Sigma, Sigma_p, subdivide=True)
+            sage: [zeta.index(cone) for cone in flatten(Sigma_p.cones())]
+            [+Infinity, None, None, None, None, None, None, None, None, None,
+             4, 4, None, 4, None, None, 2, None, 4, None, 4, 1, 1, 1, 1, 1, 1]
+            sage: zeta = prod(zeta.factor()[1:])
+            sage: Sigma_p = zeta.codomain_fan()
+            sage: [zeta.index(cone) for cone in flatten(Sigma_p.cones())]
+            [4, 4, 4, 1, 4, 4, 4, 1, 1, 1, 1, 1, 1]
+            sage: zeta.index() == zeta.index(Sigma_p(0)[0])
+            True
+        """
+        if cone is None:
+            try:
+                return self.matrix().image().index_in(self.codomain())
+            except ArithmeticError:
+                cone = Cone([], lattice=self.codomain())
+        cone = self._codomain_fan.embed(cone)
+        PPCs = self.primitive_preimage_cones(cone)
+        if not PPCs:
+            return None
+        Q = cone.sublattice_quotient()
+        S = Q.submodule([self(g)
+                         for g in PPCs[0].sublattice_complement().gens()])
+        i = prod((Q/S).invariants())
+        return i if i > 0 else Infinity
+
+    def is_birational(self):
+        r"""
+        Check if ``self`` is birational.
+
+        OUTPUT: ``True`` if ``self`` is birational, ``False`` otherwise
+
+        For fan morphisms this check is equivalent to ``self.index() == 1`` and
+        means that the corresponding map between toric varieties is birational.
+
+        EXAMPLES::
+
+            sage: # needs palp
+            sage: Sigma = toric_varieties.dP8().fan()
+            sage: Sigma_p = toric_varieties.P1().fan()
+            sage: phi = FanMorphism(matrix([[1], [-1]]), Sigma, Sigma_p)
+            sage: psi = FanMorphism(matrix([[2], [-2]]), Sigma, Sigma_p)
+            sage: xi = FanMorphism(matrix([[1, 0]]), Sigma_p, Sigma)
+            sage: phi.index(), psi.index(), xi.index()
+            (1, 2, +Infinity)
+            sage: phi.is_birational(), psi.is_birational(), xi.is_birational()
+            (True, False, False)
+        """
+        return self.index() == 1
+
+    @cached_method
+    def is_bundle(self):
+        r"""
+        Check if ``self`` is a bundle.
+
+        OUTPUT: ``True`` if ``self`` is a bundle, ``False`` otherwise
+
+        Let `\phi: \Sigma \to \Sigma'` be a fan morphism such that the
+        underlying lattice morphism `\phi: N \to N'` is surjective. Let
+        `\Sigma_0` be the kernel fan of `\phi`. Then `\phi` is a **bundle** (or
+        splitting) if there is a subfan `\widehat{\Sigma}` of `\Sigma` such
+        that the following two conditions are satisfied:
+
+            #. Cones of `\Sigma` are precisely the cones of the form
+               `\sigma_0 + \widehat{\sigma}`, where `\sigma_0 \in \Sigma_0` and
+               `\widehat{\sigma} \in \widehat{\Sigma}`.
+
+            #. Cones of `\widehat{\Sigma}` are in bijection with cones of
+               `\Sigma'` induced by `\phi` and `\phi` maps lattice points in
+               every cone `\widehat{\sigma} \in \widehat{\Sigma}` bijectively
+               onto lattice points in `\phi(\widehat{\sigma})`.
+
+        If a fan morphism `\phi: \Sigma \to \Sigma'` is a bundle, then
+        `X_\Sigma` is a fiber bundle over `X_{\Sigma'}` with fibers
+        `X_{\Sigma_0, N_0}`, where `N_0` is the kernel lattice of `\phi`. See
+        [CLS2011]_ for more details.
+
+        .. SEEALSO:: :meth:`is_fibration`, :meth:`kernel_fan`.
+
+        EXAMPLES:
+
+        We consider several maps between fans of a del Pezzo surface and the
+        projective line::
+
+            sage: # needs palp
+            sage: Sigma = toric_varieties.dP8().fan()
+            sage: Sigma_p = toric_varieties.P1().fan()
+            sage: phi = FanMorphism(matrix([[1], [-1]]), Sigma, Sigma_p)
+            sage: psi = FanMorphism(matrix([[2], [-2]]), Sigma, Sigma_p)
+            sage: xi = FanMorphism(matrix([[1, 0]]), Sigma_p, Sigma)
+            sage: phi.is_bundle()
+            True
+            sage: phi.is_fibration()
+            True
+            sage: phi.index()
+            1
+            sage: psi.is_bundle()
+            False
+            sage: psi.is_fibration()
+            True
+            sage: psi.index()
+            2
+            sage: xi.is_fibration()
+            False
+            sage: xi.index()
+            +Infinity
+
+        The first of these maps induces not only a fibration, but a fiber
+        bundle structure. The second map is very similar, yet it fails to be
+        a bundle, as its index is 2. The last map is not even a fibration.
+        """
+        if self.index() != 1:
+            return False    # Not surjective between lattices.
+        Sigma = self.domain_fan()
+        Sigma_p = self.codomain_fan()
+        Sigma_0 = self.kernel_fan()
+        if (Sigma.ngenerating_cones() !=
+            Sigma_0.ngenerating_cones() * Sigma_p.ngenerating_cones()):
+            return False    # Definitely no splitting.
+        try:
+            ray_index_map = self._ray_index_map()
+        except ValueError:
+            return False  # Rays are not mapped onto rays or the origin.
+        # Figure out how Sigma_0 sits inside Sigma in terms of ray indices.
+        I_0s = [Sigma.embed(sigma_0).ambient_ray_indices()
+                for sigma_0 in Sigma_0]
+        # We examine only generating cones, this is sufficient.
+        for sigma_p in Sigma_p:
+            primitive_cones = self.primitive_preimage_cones(sigma_p)
+            if len(primitive_cones) != 1:   # Should be only sigma_hat.
+                return False
+            sigma_hat = primitive_cones[0]
+            if sigma_p.dim() != sigma_hat.dim():
+                return False    # sigma -> sigma_p is not a bijection
+            I_p = sigma_p.ambient_ray_indices()
+            I_hat = sigma_hat.ambient_ray_indices()
+            if I_p != tuple(sorted(ray_index_map[i] for i in I_hat)):
+                return False    # sigma -> sigma_p is not a bijection
+            # Check that sigma_hat + sigma_0 is always in Sigma.
+            for I_0 in I_0s:
+                I = tuple(sorted(I_hat + I_0))
+                if all(sigma.ambient_ray_indices() != I for sigma in Sigma):
+                    return False
+        return True
+
+    @cached_method
+    def is_fibration(self):
+        r"""
+        Check if ``self`` is a fibration.
+
+        OUTPUT: ``True`` if ``self`` is a fibration, ``False`` otherwise
+
+        A fan morphism `\phi: \Sigma \to \Sigma'` is a **fibration**
+        if for any cone `\sigma' \in \Sigma'` and any primitive
+        preimage cone `\sigma \in \Sigma` corresponding to `\sigma'`
+        the linear map of vector spaces `\phi_\RR` induces a bijection
+        between `\sigma` and `\sigma'`, and, in addition, `\phi` is
+        :meth:`dominant <is_dominant>` (that is, `\phi_\RR: N_\RR \to
+        N'_\RR` is surjective).
+
+        If a fan morphism `\phi: \Sigma \to \Sigma'` is a fibration, then the
+        associated morphism between toric varieties `\tilde{\phi}: X_\Sigma \to
+        X_{\Sigma'}` is a fibration in the sense that it is surjective and all
+        of its fibers have the same dimension, namely `\dim X_\Sigma -
+        \dim X_{\Sigma'}`. These fibers do *not* have to be isomorphic, i.e. a
+        fibration is not necessarily a fiber bundle. See [HLY2002]_ for more
+        details.
+
+        .. SEEALSO:: :meth:`is_bundle`, :meth:`primitive_preimage_cones`.
+
+        EXAMPLES:
+
+        We consider several maps between fans of a del Pezzo surface and the
+        projective line::
+
+            sage: # needs palp
+            sage: Sigma = toric_varieties.dP8().fan()
+            sage: Sigma_p = toric_varieties.P1().fan()
+            sage: phi = FanMorphism(matrix([[1], [-1]]), Sigma, Sigma_p)
+            sage: psi = FanMorphism(matrix([[2], [-2]]), Sigma, Sigma_p)
+            sage: xi = FanMorphism(matrix([[1, 0]]), Sigma_p, Sigma)
+            sage: phi.is_bundle()
+            True
+            sage: phi.is_fibration()
+            True
+            sage: phi.index()
+            1
+            sage: psi.is_bundle()
+            False
+            sage: psi.is_fibration()
+            True
+            sage: psi.index()
+            2
+            sage: xi.is_fibration()
+            False
+            sage: xi.index()
+            +Infinity
+
+        The first of these maps induces not only a fibration, but a fiber
+        bundle structure. The second map is very similar, yet it fails to be
+        a bundle, as its index is 2. The last map is not even a fibration.
+
+        TESTS:
+
+        We check that reviewer's example on :issue:`11200` works as expected::
+
+            sage: P1 = toric_varieties.P1()
+            sage: A1 = toric_varieties.A1()
+            sage: phi = FanMorphism(matrix([[1]]), A1.fan(), P1.fan())
+            sage: phi.is_fibration()
+            False
+        """
+        if not self.is_surjective():
+            return False
+        try:
+            ray_index_map = self._ray_index_map()
+        except ValueError:
+            return False    # Rays are not mapped onto rays or the origin.
+        Sigma_p = self.codomain_fan()
+        # Rays are already checked, the origin is trivial, start with 2-cones.
+        for d in range(2, Sigma_p.dim() + 1):
+            for sigma_p in Sigma_p(d):
+                I_p = sigma_p.ambient_ray_indices()
+                for sigma in self.primitive_preimage_cones(sigma_p):
+                    if sigma.dim() != d:
+                        return False    # sigma -> sigma_p is not a bijection
+                    I = sigma.ambient_ray_indices()
+                    if I_p != tuple(sorted(ray_index_map[i] for i in I)):
+                        return False    # sigma -> sigma_p is not a bijection
+        return True
+
+    @cached_method
+    def is_injective(self):
+        r"""
+        Check if ``self`` is injective.
+
+        OUTPUT: ``True`` if ``self`` is injective, ``False`` otherwise
+
+        Let `\phi: \Sigma \to \Sigma'` be a fan morphism such that the
+        underlying lattice morphism `\phi: N \to N'` bijectively maps `N` to a
+        *saturated* sublattice of `N'`. Let `\psi: \Sigma \to \Sigma'_0` be the
+        restriction of `\phi` to the image. Then `\phi` is **injective** if the
+        map between cones corresponding to `\psi` (injectively) maps each cone
+        of `\Sigma` to a cone of the same dimension.
+
+        If a fan morphism `\phi: \Sigma \to \Sigma'` is injective, then the
+        associated morphism between toric varieties `\tilde{\phi}: X_\Sigma \to
+        X_{\Sigma'}` is injective.
+
+        .. SEEALSO:: :meth:`factor`.
+
+        EXAMPLES:
+
+        Consider the fan of the affine plane::
+
+            sage: A2 = toric_varieties.A(2).fan()
+
+        We will map several fans consisting of a single ray into the interior
+        of the 2-cone::
+
+            sage: Sigma = Fan([Cone([(1,1)])])
+            sage: m = identity_matrix(2)
+            sage: FanMorphism(m, Sigma, A2).is_injective()
+            False
+
+        This morphism was not injective since (in the toric varieties
+        interpretation) the 1-dimensional orbit corresponding to the ray was
+        mapped to the 0-dimensional orbit corresponding to the 2-cone. ::
+
+            sage: Sigma = Fan([Cone([(1,)])])
+            sage: m = matrix(1, 2, [1,1])
+            sage: FanMorphism(m, Sigma, A2).is_injective()
+            True
+
+        While the fans in this example are close to the previous one, here the
+        ray corresponds to a 0-dimensional orbit. ::
+
+            sage: Sigma = Fan([Cone([(1,)])])
+            sage: m = matrix(1, 2, [2,2])
+            sage: FanMorphism(m, Sigma, A2).is_injective()
+            False
+
+        Here the problem is that ``m`` maps the domain lattice to a
+        non-saturated sublattice of the codomain. The corresponding map of the
+        toric varieties is a two-sheeted cover of its image.
+
+        We also embed the affine plane into the projective one::
+
+            sage: P2 = toric_varieties.P(2).fan()                                       # needs palp
+            sage: m = identity_matrix(2)
+            sage: FanMorphism(m, A2, P2).is_injective()                                 # needs palp
+            True
+        """
+        if self.matrix().index_in_saturation() != 1:
+            return False
+        if self.image().dimension() < self.codomain().dimension():
+            return prod(self.factor()[1:]).is_injective()
+        # Now we know that underlying lattice morphism is bijective.
+        Sigma = self.domain_fan()
+        return all(self.image_cone(sigma).dim() == d
+                   for d in range(1, Sigma.dim() + 1) for sigma in Sigma(d))
+
+    @cached_method
+    def is_surjective(self):
+        r"""
+        Check if ``self`` is surjective.
+
+        OUTPUT: ``True`` if ``self`` is surjective, ``False`` otherwise
+
+        A fan morphism `\phi: \Sigma \to \Sigma'` is **surjective** if the
+        corresponding map between cones is surjective, i.e. for each cone
+        `\sigma' \in \Sigma'` there is at least one preimage cone `\sigma \in
+        \Sigma` such that the relative interior of `\sigma` is mapped to the
+        relative interior of `\sigma'` and, in addition,
+        `\phi_\RR: N_\RR \to N'_\RR` is surjective.
+
+        If a fan morphism `\phi: \Sigma \to \Sigma'` is surjective, then the
+        associated morphism between toric varieties `\tilde{\phi}: X_\Sigma \to
+        X_{\Sigma'}` is surjective.
+
+        .. SEEALSO:: :meth:`is_bundle`, :meth:`is_fibration`,
+            :meth:`preimage_cones`, :meth:`is_complete`.
+
+        EXAMPLES:
+
+        We check that the blow up of the affine plane at the origin is
+        surjective::
+
+            sage: A2 = toric_varieties.A(2).fan()
+            sage: Bl = A2.subdivide([(1,1)])
+            sage: m = identity_matrix(2)
+            sage: FanMorphism(m, Bl, A2).is_surjective()
+            True
+
+        It remains surjective if we throw away "south and north poles" of the
+        exceptional divisor::
+
+            sage: FanMorphism(m, Fan(Bl.cones(1)), A2).is_surjective()
+            True
+
+        But a single patch of the blow up does not cover the plane::
+
+            sage: F = Fan([Bl.generating_cone(0)])
+            sage: FanMorphism(m, F, A2).is_surjective()
+            False
+
+        TESTS:
+
+        We check that reviewer's example on :issue:`11200` works as expected::
+
+            sage: P1 = toric_varieties.P1()
+            sage: A1 = toric_varieties.A1()
+            sage: phi = FanMorphism(matrix([[1]]), A1.fan(), P1.fan())
+            sage: phi.is_surjective()
+            False
+        """
+        if isinstance(self.index(), InfinityElement):
+            return False    # Not surjective between vector spaces.
+        for dcones in self.codomain_fan().cones():
+            for sigma_p in dcones:
+                if not self.preimage_cones(sigma_p):
+                    return False
+        return True
+
+    @cached_method
+    def is_dominant(self):
+        r"""
+        Return whether the fan morphism is dominant.
+
+        A fan morphism `\phi` is dominant if it is surjective as a map
+        of vector spaces. That is, `\phi_\RR: N_\RR \to N'_\RR` is
+        surjective.
+
+        If the domain fan is :meth:`complete
+        <sage.geometry.fan.RationalPolyhedralFan.is_complete>`, then
+        this implies that the fan morphism is :meth:`surjective
+        <is_surjective>`.
+
+        If the fan morphism is dominant, then the associated morphism
+        of toric varieties is dominant in the algebraic-geometric
+        sense (that is, surjective onto a dense subset).
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: P1 = toric_varieties.P1()
+            sage: A1 = toric_varieties.A1()
+            sage: phi = FanMorphism(matrix([[1]]), A1.fan(), P1.fan())
+            sage: phi.is_dominant()
+            True
+            sage: phi.is_surjective()
+            False
+        """
+        return self.matrix().rank() == self.codomain_fan().dim()
+
+    @cached_method
+    def kernel_fan(self):
+        r"""
+        Return the subfan of the domain fan mapped into the origin.
+
+        OUTPUT: a :class:`fan <sage.geometry.fan.RationalPolyhedralFan>`
+
+        .. NOTE::
+
+            The lattice of the kernel fan is the :meth:`kernel` sublattice of
+            ``self``.
+
+        .. SEEALSO:: :meth:`preimage_fan`.
+
+        EXAMPLES::
+
+            sage: fan = Fan(rays=[(1,0), (1,1), (0,1)], cones=[(0,1), (1,2)])
+            sage: fm = FanMorphism(matrix(2, 1, [1,-1]), fan, ToricLattice(1))
+            sage: fm.kernel_fan()
+            Rational polyhedral fan in Sublattice <N(1, 1)>
+            sage: _.rays()
+            N(1, 1)
+            in Sublattice <N(1, 1)>
+            sage: fm.kernel_fan().cones()
+            ((0-d cone of Rational polyhedral fan in Sublattice <N(1, 1)>,),
+             (1-d cone of Rational polyhedral fan in Sublattice <N(1, 1)>,))
+        """
+        fan = self.preimage_fan(Cone([], lattice=self.codomain()))
+        return Fan((cone.ambient_ray_indices() for cone in fan), fan.rays(),
+                   lattice=self.kernel(), check=False)
+
+    def preimage_cones(self, cone):
+        r"""
+        Return cones of the domain fan whose :meth:`image_cone` is ``cone``.
+
+        INPUT:
+
+        - ``cone`` -- a :class:`cone
+          <sage.geometry.cone.ConvexRationalPolyhedralCone>` equivalent to a
+          cone of the :meth:`codomain_fan` of ``self``.
+
+        OUTPUT:
+
+        - a :class:`tuple` of :class:`cones
+          <sage.geometry.cone.ConvexRationalPolyhedralCone>` of the
+          :meth:`domain_fan` of ``self``, sorted by dimension.
+
+        .. SEEALSO:: :meth:`preimage_fan`.
+
+        EXAMPLES::
+
+            sage: quadrant = Cone([(1,0), (0,1)])
+            sage: quadrant = Fan([quadrant])
+            sage: quadrant_bl = quadrant.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2), quadrant_bl, quadrant)
+            sage: fm.preimage_cones(Cone([(1,0)]))
+            (1-d cone of Rational polyhedral fan in 2-d lattice N,)
+            sage: fm.preimage_cones(Cone([(1,0), (0,1)]))
+            (1-d cone of Rational polyhedral fan in 2-d lattice N,
+             2-d cone of Rational polyhedral fan in 2-d lattice N,
+             2-d cone of Rational polyhedral fan in 2-d lattice N)
+
+        TESTS:
+
+        We check that reviewer's example from :issue:`9972` is handled correctly::
+
+            sage: # needs palp
+            sage: N1 = ToricLattice(1)
+            sage: N2 = ToricLattice(2)
+            sage: Hom21 = Hom(N2, N1)
+            sage: pr = Hom21([N1.0,0])
+            sage: P1xP1 = toric_varieties.P1xP1()
+            sage: f = FanMorphism(pr, P1xP1.fan())
+            sage: c = f.image_cone(Cone([(1,0), (0,1)])); c
+            1-d cone of Rational polyhedral fan in 1-d lattice N
+            sage: f.preimage_cones(c)
+            (1-d cone of Rational polyhedral fan in 2-d lattice N,
+             2-d cone of Rational polyhedral fan in 2-d lattice N,
+             2-d cone of Rational polyhedral fan in 2-d lattice N)
+        """
+        cone = self._codomain_fan.embed(cone)
+        if cone not in self._preimage_cones:
+            # "Images of preimages" must sit in all of these generating cones
+            CSGI = cone.star_generator_indices()
+            RISGIS = self._RISGIS()
+            domain_fan = self._domain_fan
+            possible_rays = frozenset(i for i in range(domain_fan.nrays())
+                                      if RISGIS[i].issuperset(CSGI))
+            preimage_cones = []
+            for dcones in domain_fan.cones():
+                for dcone in dcones:
+                    if (possible_rays.issuperset(dcone.ambient_ray_indices())
+                        and self.image_cone(dcone) == cone):
+                        preimage_cones.append(dcone)
+            self._preimage_cones[cone] = tuple(preimage_cones)
+        return self._preimage_cones[cone]
+
+    def preimage_fan(self, cone):
+        r"""
+        Return the subfan of the domain fan mapped into ``cone``.
+
+        INPUT:
+
+        - ``cone`` -- a :class:`cone
+          <sage.geometry.cone.ConvexRationalPolyhedralCone>` equivalent to a
+          cone of the :meth:`codomain_fan` of ``self``
+
+        OUTPUT: a :class:`fan <sage.geometry.fan.RationalPolyhedralFan>`
+
+        .. NOTE::
+
+            The preimage fan of ``cone`` consists of all cones of the
+            :meth:`domain_fan` which are mapped into ``cone``, including those
+            that are mapped into its boundary. So this fan is not necessarily
+            generated by :meth:`preimage_cones` of ``cone``.
+
+        .. SEEALSO:: :meth:`kernel_fan`, :meth:`preimage_cones`.
+
+        EXAMPLES::
+
+            sage: quadrant_cone = Cone([(1,0), (0,1)])
+            sage: quadrant_fan = Fan([quadrant_cone])
+            sage: quadrant_bl = quadrant_fan.subdivide([(1,1)])
+            sage: fm = FanMorphism(identity_matrix(2),
+            ....:                  quadrant_bl, quadrant_fan)
+            sage: fm.preimage_fan(Cone([(1,0)])).cones()
+            ((0-d cone of Rational polyhedral fan in 2-d lattice N,),
+             (1-d cone of Rational polyhedral fan in 2-d lattice N,))
+            sage: fm.preimage_fan(quadrant_cone).ngenerating_cones()
+            2
+            sage: len(fm.preimage_cones(quadrant_cone))
+            3
+        """
+        cone = self._codomain_fan.embed(cone)
+        if cone not in self._preimage_fans:
+            # Find all cones mapped into the given one, including its boundary.
+            domain_fan = self._domain_fan
+            cones = []
+            for dcones in reversed(domain_fan.cones()):
+                for dcone in dcones:
+                    if (not any(dcone.is_face_of(other) for other in cones) and
+                        self.image_cone(dcone).is_face_of(cone)):
+                        cones.append(dcone)
+            # Now form the fan from these cones, keeping the ray order.
+            ray_indices = set(cones[0].ambient_ray_indices())
+            for c in cones[1:]:
+                ray_indices.update(c.ambient_ray_indices())
+            self._preimage_fans[cone] = Fan(cones,
+                            domain_fan.rays(sorted(ray_indices)), check=False)
+        return self._preimage_fans[cone]
+
+    def primitive_preimage_cones(self, cone):
+        r"""
+        Return the primitive cones of the domain fan corresponding to ``cone``.
+
+        INPUT:
+
+        - ``cone`` -- a :class:`cone
+          <sage.geometry.cone.ConvexRationalPolyhedralCone>` equivalent to a
+          cone of the :meth:`codomain_fan` of ``self``
+
+        OUTPUT: a :class:`cone <sage.geometry.cone.ConvexRationalPolyhedralCone>`
+
+        Let `\phi: \Sigma \to \Sigma'` be a fan morphism, let `\sigma \in
+        \Sigma`, and let `\sigma' = \phi(\sigma)`. Then `\sigma` is a
+        **primitive cone corresponding to** `\sigma'` if there is no proper
+        face `\tau` of `\sigma` such that `\phi(\tau) = \sigma'`.
+
+        Primitive cones play an important role for fibration morphisms.
+
+        .. SEEALSO:: :meth:`is_fibration`, :meth:`preimage_cones`,
+            :meth:`preimage_fan`.
+
+        EXAMPLES:
+
+        Consider a projection of a del Pezzo surface onto the projective line::
+
+            sage: Sigma = toric_varieties.dP6().fan()                                   # needs palp
+            sage: Sigma.rays()                                                          # needs palp
+            N( 0,  1),
+            N(-1,  0),
+            N(-1, -1),
+            N( 0, -1),
+            N( 1,  0),
+            N( 1,  1)
+            in 2-d lattice N
+            sage: Sigma_p = toric_varieties.P1().fan()
+            sage: phi = FanMorphism(matrix([[1], [-1]]), Sigma, Sigma_p)                # needs palp
+
+        Under this map, one pair of rays is mapped to the origin, one in the
+        positive direction, and one in the negative one. Also three
+        2-dimensional cones are mapped in the positive direction and three in
+        the negative one, so there are 5 preimage cones corresponding to either
+        of the rays of the codomain fan ``Sigma_p``::
+
+            sage: len(phi.preimage_cones(Cone([(1,)])))                                 # needs palp
+            5
+
+        Yet only rays are primitive::
+
+            sage: phi.primitive_preimage_cones(Cone([(1,)]))                            # needs palp
+            (1-d cone of Rational polyhedral fan in 2-d lattice N,
+             1-d cone of Rational polyhedral fan in 2-d lattice N)
+
+        Since all primitive cones are mapped onto their images bijectively, we
+        get a fibration::
+
+            sage: phi.is_fibration()                                                    # needs palp
+            True
+
+        But since there are several primitive cones corresponding to the same
+        cone of the codomain fan, this map is not a bundle, even though its
+        index is 1::
+
+            sage: phi.is_bundle()                                                       # needs palp
+            False
+            sage: phi.index()                                                           # needs palp
+            1
+        """
+        sigma_p = self._codomain_fan.embed(cone) # Necessary if used as a key
+        if sigma_p not in self._primitive_preimage_cones:
+            primitive_cones = []
+            for sigma in self.preimage_cones(sigma_p):  # Sorted by dimension
+                if not any(tau.is_face_of(sigma) for tau in primitive_cones):
+                    primitive_cones.append(sigma)
+            self._primitive_preimage_cones[sigma_p] = tuple(primitive_cones)
+        return self._primitive_preimage_cones[sigma_p]
+
+    def factor(self):
+        r"""
+        Factor ``self`` into injective * birational * surjective morphisms.
+
+        OUTPUT:
+
+        - a triple of :class:`FanMorphism` `(\phi_i, \phi_b, \phi_s)`, such that
+          `\phi_s` is surjective, `\phi_b` is birational, `\phi_i` is injective,
+          and ``self`` is equal to `\phi_i \circ \phi_b \circ \phi_s`.
+
+        Intermediate fans live in the saturation of the image of ``self``
+        as a map between lattices and are the image of the :meth:`domain_fan`
+        and the restriction of the :meth:`codomain_fan`, i.e. if ``self`` maps
+        `\Sigma \to \Sigma'`, then we have factorization into
+
+        .. MATH::
+
+            \Sigma
+            \twoheadrightarrow
+            \Sigma_s
+            \to
+            \Sigma_i
+            \hookrightarrow
+            \Sigma.
+
+        .. NOTE::
+
+            * `\Sigma_s` is the finest fan with the smallest support that is
+              compatible with ``self``: any fan morphism from `\Sigma` given by
+              the same map of lattices as ``self`` factors through `\Sigma_s`.
+
+            * `\Sigma_i` is the coarsest fan of the largest support that is
+              compatible with ``self``: any fan morphism into `\Sigma'` given by
+              the same map of lattices as ``self`` factors though `\Sigma_i`.
+
+        EXAMPLES:
+
+        We map an affine plane into a projective 3-space in such a way, that it
+        becomes "a double cover of a chart of the blow up of one of the
+        coordinate planes"::
+
+            sage: A2 = toric_varieties.A2()
+            sage: P3 = toric_varieties.P(3)                                             # needs palp
+            sage: m = matrix([(2,0,0), (1,1,0)])
+            sage: phi = A2.hom(m, P3)                                                   # needs palp
+            sage: phi.as_polynomial_map()                                               # needs palp
+            Scheme morphism:
+              From: 2-d affine toric variety
+              To:   3-d CPR-Fano toric variety covered by 4 affine patches
+              Defn: Defined on coordinates by sending [x : y] to
+                    [x^2*y : y : 1 : 1]
+
+        Now we will work with the underlying fan morphism::
+
+            sage: # needs palp
+            sage: phi = phi.fan_morphism(); phi
+            Fan morphism defined by the matrix
+            [2 0 0]
+            [1 1 0]
+            Domain fan: Rational polyhedral fan in 2-d lattice N
+            Codomain fan: Rational polyhedral fan in 3-d lattice N
+            sage: phi.is_surjective(), phi.is_birational(), phi.is_injective()
+            (False, False, False)
+            sage: phi_i, phi_b, phi_s = phi.factor()
+            sage: phi_s.is_surjective(), phi_b.is_birational(), phi_i.is_injective()
+            (True, True, True)
+            sage: prod(phi.factor()) == phi
+            True
+
+        Double cover (surjective)::
+
+            sage: A2.fan().rays()
+            N(1, 0),
+            N(0, 1)
+            in 2-d lattice N
+            sage: phi_s                                                                 # needs palp
+            Fan morphism defined by the matrix
+            [2 0]
+            [1 1]
+            Domain fan: Rational polyhedral fan in 2-d lattice N
+            Codomain fan: Rational polyhedral fan in Sublattice <N(1, 0, 0), N(0, 1, 0)>
+            sage: phi_s.codomain_fan().rays()                                           # needs palp
+            N(1, 0, 0),
+            N(1, 1, 0)
+            in Sublattice <N(1, 0, 0), N(0, 1, 0)>
+
+        Blowup chart (birational)::
+
+            sage: phi_b                                                                 # needs palp
+            Fan morphism defined by the matrix
+            [1 0]
+            [0 1]
+            Domain fan: Rational polyhedral fan in Sublattice <N(1, 0, 0), N(0, 1, 0)>
+            Codomain fan: Rational polyhedral fan in Sublattice <N(1, 0, 0), N(0, 1, 0)>
+            sage: phi_b.codomain_fan().rays()                                           # needs palp
+            N(-1, -1, 0),
+            N( 0,  1, 0),
+            N( 1,  0, 0)
+            in Sublattice <N(1, 0, 0), N(0, 1, 0)>
+
+        Coordinate plane inclusion (injective)::
+
+            sage: phi_i                                                                 # needs palp
+            Fan morphism defined by the matrix
+            [1 0 0]
+            [0 1 0]
+            Domain fan: Rational polyhedral fan in Sublattice <N(1, 0, 0), N(0, 1, 0)>
+            Codomain fan: Rational polyhedral fan in 3-d lattice N
+            sage: phi.codomain_fan().rays()                                             # needs palp
+            N( 1,  0,  0),
+            N( 0,  1,  0),
+            N( 0,  0,  1),
+            N(-1, -1, -1)
+            in 3-d lattice N
+
+        TESTS::
+
+            sage: phi_s.matrix() * phi_b.matrix() * phi_i.matrix() == m                 # needs palp
+            True
+
+            sage: # needs palp
+            sage: phi.domain_fan() is phi_s.domain_fan()
+            True
+            sage: phi_s.codomain_fan() is phi_b.domain_fan()
+            True
+            sage: phi_b.codomain_fan() is phi_i.domain_fan()
+            True
+            sage: phi_i.codomain_fan() is phi.codomain_fan()
+            True
+
+            sage: trivialfan2 = Fan([], [], lattice=ToricLattice(2))
+            sage: trivialfan3 = Fan([], [], lattice=ToricLattice(3))
+            sage: f = FanMorphism(zero_matrix(2,3), trivialfan2, trivialfan3)
+            sage: [phi.matrix().dimensions() for phi in f.factor()]
+            [(0, 3), (0, 0), (2, 0)]
+        """
+        L = self.image().saturation()
+        d = L.dimension()
+        m = self.matrix()
+        m = matrix(ZZ, m.nrows(), d, (L.coordinates(c) for c in m.rows()))
+        phi_s = FanMorphism(m, self.domain_fan(), L, check=False)
+        Sigma_prime = self.codomain_fan()
+        L_cone = Cone(sum(([g, -g] for g in L.gens()), []), lattice=L)
+        Sigma_i = Fan(cones=(L_cone.intersection(cone) for cone in Sigma_prime),
+                      lattice=L, discard_faces=True, check=False)
+        phi_b = FanMorphism(identity_matrix(d), phi_s.codomain_fan(), Sigma_i,
+                            check=False)
+        phi_i = FanMorphism(L.basis_matrix(), Sigma_i, Sigma_prime, check=False)
+        return (phi_i, phi_b, phi_s)
+
+    def relative_star_generators(self, domain_cone):
+        """
+        Return the relative star generators of ``domain_cone``.
+
+        INPUT:
+
+        - ``domain_cone`` -- a cone of the :meth:`domain_fan` of ``self``
+
+        OUTPUT:
+
+        - :meth:`~RationalPolyhedralFan.star_generators` of ``domain_cone``
+          viewed as a cone of :meth:`preimage_fan` of :meth:`image_cone` of
+          ``domain_cone``.
+
+        EXAMPLES::
+
+            sage: A2 = toric_varieties.A(2).fan()
+            sage: Bl = A2.subdivide([(1,1)])
+            sage: f = FanMorphism(identity_matrix(2), Bl, A2)
+            sage: for c1 in Bl(1):
+            ....:     print(f.relative_star_generators(c1))
+            (1-d cone of Rational polyhedral fan in 2-d lattice N,)
+            (1-d cone of Rational polyhedral fan in 2-d lattice N,)
+            (2-d cone of Rational polyhedral fan in 2-d lattice N,
+             2-d cone of Rational polyhedral fan in 2-d lattice N)
+        """
+        base_cone = self.image_cone(domain_cone)
+        preimg_fan = self.preimage_fan(base_cone)
+        return preimg_fan.embed(domain_cone).star_generators()