Ticket #6099: 6099-1.patch

sage/categories/category_types.py

@@ -373 +373 @@
 #############################################################
 # Semigroup
 #############################################################
-
 class Semigroups(Category_uniq):
     """
     The category of all semigroups.
@@ -1288 +1287 @@
     Objects                : [Sets],\
     Sets                   : [],\
     GSets                  : [Sets],\
+    SimplicialComplexes    : [Sets],\
     Semigroups             : [Sets],\
     Monoids                : [Semigroups, Sets],\
     Groups                 : [Monoids, Semigroups, Sets],\

sage/categories/homset.py

@@ -154 +154 @@
         from sage.schemes.generic.homset import SchemeHomset
         H = SchemeHomset(X, Y)
         
+    elif cat._is_subclass(category_types.SimplicialComplexes):
+
+        from sage.homology.simplicial_complex_homset import SimplicialComplexHomset
+        H = SimplicialComplexHomset(X,Y)
+
     else:  # default
         if hasattr(X, '_base') and X._base is not X and X._base is not None:
             H = HomsetWithBase(X, Y, cat)

sage/homology/all.py

@@ -2 +2 @@
 
 from simplicial_complex import SimplicialComplex
 
+from simplicial_complex_morphism import SimplicialComplexMorphism
+
 from examples import simplicial_complexes

sage/homology/simplicial_complex.py

@@ -762 +762 @@
         """
         return self._vertex_set
 
+    def effective_vertices(self):
+        """
+        The set of vertices belonging to some face.
+
+        EXAMPLES::
+
+            sage: S = SimplicialComplex(15)
+            sage: S
+            Simplicial complex with 16 vertices and facets {()}
+            sage: S.effective_vertices()
+            ()
+
+            sage: S = SimplicialComplex(15,[[0,1,2,3],[6,7]])
+            sage: S
+            Simplicial complex with 16 vertices and facets {(6, 7), (0, 1, 2, 3)}
+            sage: S.effective_vertices()
+            (0, 1, 2, 3, 6, 7)
+
+        """
+        try:
+            v = self.faces()[0]
+        except KeyError:
+            return Simplex(-1)
+        f = []
+        for i in v:
+            f.append(i[0])
+        return Simplex(set(f))
+
+
     def maximal_faces(self):
         """
         The maximal faces (a.k.a. facets) of this simplicial complex.
@@ -2160 +2189 @@
         if len(facet_string) > facet_limit:
             facet_string = "%s facets" % len(facets)
         return "Simplicial complex " + vertex_string + " and " + facet_string
+
+    def generated_subcomplex(self,sub_vertex_set):
+        """
+        Returns the largest sub SimplicialComplex of self containing exactly the sub_vertex_set as vertices.
+
+        EXAMPLES::
+
+            sage: S = simplicial_complexes.Sphere(2)
+            sage: S
+            Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)}
+            sage: S.generated_subcomplex([0,1,2])
+            Simplicial complex with vertex set (0, 1, 2) and facets {(0, 1, 2)}
+
+        """
+        if not self.vertices().set().issuperset(sub_vertex_set):
+            raise TypeError, "input must be a subset of the vertex set."
+        faces = []
+        for i in range(self.dimension()+1):
+            for j in self.faces()[i]:
+                if j.set().issubset(sub_vertex_set):
+                    faces.append(j)
+        return SimplicialComplex(sub_vertex_set,faces,maximality_check=True)

new file sage/homology/simplicial_complex_homset.py

@@ +1 @@
+r"""
+Homsets between simplicial complexes
+
+EXAMPLES:
+
+::
+
+    sage: S = simplicial_complexes.Sphere(1)
+    sage: T = simplicial_complexes.Sphere(2)
+    sage: H = Hom(S,T)
+    sage: from sage.homology.simplicial_complex import Simplex
+    sage: f = {0:0,1:1,2:3}
+    sage: x = H(f)
+    sage: x
+    Simplicial complex morphism {0: 0, 1: 1, 2: 3} from Simplicial complex with vertex set (0, 1, 2) and facets {(1, 2), (0, 2), (0, 1)} to Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)}
+    sage: x.is_injective()
+    True
+    sage: x.is_surjective()
+    False
+    sage: x.image()
+    Simplicial complex with vertex set (0, 1, 3) and facets {(1, 3), (0, 3), (0, 1)}
+    sage: s = Simplex([1,2])
+    sage: x(s)
+    (1, 3)
+
+TESTS::
+
+    sage: S = simplicial_complexes.Sphere(1)
+    sage: T = simplicial_complexes.Sphere(2)
+    sage: H = Hom(S,T)
+    sage: loads(dumps(H))==H
+    True
+
+"""
+
+#*****************************************************************************
+# Copyright (C) 2009 D. Benjamin Antieau <d.ben.antieau@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful, 
+#    but WITHOUT ANY WARRANTY; without even the implied warranty 
+#    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# 
+#  See the GNU General Public License for more details; the full text 
+#  is available at:
+#
+#                  http://www.gnu.org/licenses/
+#
+#*****************************************************************************
+
+import sage.categories.homset
+import sage.homology.simplicial_complex as simplicial_complex
+import sage.homology.simplicial_complex_morphism as simplicial_complex_morphism
+
+def is_SimplicialComplexHomset(x):
+    """
+    Return True if and only if x is a simplicial complex homspace.
+
+    EXAMPLES::
+
+        sage: H = Hom(SimplicialComplex(2),SimplicialComplex(3))
+        sage: H
+        Set of Morphisms from Simplicial complex with vertex set (0, 1, 2) and facets {()} to Simplicial complex with vertex set (0, 1, 2, 3) and facets {()} in Category of simplicial complexes
+        sage: from sage.homology.simplicial_complex_homset import is_SimplicialComplexHomset
+        sage: is_SimplicialComplexHomset(H)
+        True
+    """
+    return isinstance(x, SimplicialComplexHomset)
+
+class SimplicialComplexHomset(sage.categories.homset.Homset):
+    def __call__(self, f):
+        """
+        INPUT:
+            f -- a dictionary with keys exactly the vertices of the domain and values vertices of the codomain
+
+        EXAMPLE::
+
+            sage: S = simplicial_complexes.Sphere(3)
+            sage: T = simplicial_complexes.Sphere(2)
+            sage: f = {0:0,1:1,2:2,3:2,4:2}
+            sage: H = Hom(S,T)
+            sage: x = H(f)
+            sage: x
+            Simplicial complex morphism {0: 0, 1: 1, 2: 2, 3: 2, 4: 2} from Simplicial complex with vertex set (0, 1, 2, 3, 4) and 5 facets to Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)}
+
+            
+        """
+        return simplicial_complex_morphism.SimplicialComplexMorphism(f,self.domain(),self.codomain())
+
+    def diagonal_morphism(self,rename_vertices=True):
+        """
+        Returns the diagonal morphism in Hom(S,SxS).
+
+        EXAMPLES::
+
+            sage: S = simplicial_complexes.Sphere(2)
+            sage: H = Hom(S,S.product(S))
+            sage: d = H.diagonal_morphism()
+            sage: d
+            Simplicial complex morphism {0: 'L0R0', 1: 'L1R1', 2: 'L2R2', 3: 'L3R3'} from Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)} to Simplicial complex with 16 vertices and 96 facets
+        
+            sage: T = SimplicialComplex(3)
+            sage: U = T.product(T,rename_vertices = False)
+            sage: G = Hom(T,U)
+            sage: e = G.diagonal_morphism(rename_vertices = False)
+            sage: e
+            Simplicial complex morphism {0: (0, 0), 1: (1, 1), 2: (2, 2), 3: (3, 3)} from Simplicial complex with vertex set (0, 1, 2, 3) and facets {()} to Simplicial complex with 16 vertices and facets {()}
+
+        """
+
+        if self._codomain == self._domain.product(self._domain,rename_vertices=rename_vertices):
+            X = self._domain.product(self._domain,rename_vertices=rename_vertices)
+            f = dict()
+            if rename_vertices:
+                for i in self._domain.vertices().set():
+                    f[i] = "L"+str(i)+"R"+str(i)
+            else:
+                for i in self._domain.vertices().set():
+                    f[i] = (i,i)
+            return simplicial_complex_morphism.SimplicialComplexMorphism(f,self._domain,X)
+        else:
+            raise TypeError, "Diagonal morphism is only defined for Hom(X,XxX)."
+        
+    def identity(self):
+        """
+        Returns the identity morphism of Hom(S,S).
+
+        EXAMPLES::
+
+            sage: S = simplicial_complexes.Sphere(2)
+            sage: H = Hom(S,S)
+            sage: i = H.identity()
+            sage: i.is_identity()
+            True
+
+            sage: T = SimplicialComplex(3,[[0,1]])
+            sage: G = Hom(T,T)
+            sage: G.identity()
+            Simplicial complex morphism {0: 0, 1: 1, 2: 2, 3: 3} from Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 1)} to Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 1)}
+
+        """
+        if self.is_endomorphism_set():
+            f = dict()
+            for i in self._domain.vertices().set():
+                f[i]=i
+            return simplicial_complex_morphism.SimplicialComplexMorphism(f,self._domain,self._codomain)
+        else:
+            raise TypeError, "Identity map is only defined for endomorphism sets."
+
+    def an_element(self):
+        """
+        Returns a (non-random) element of self.
+
+        EXAMPLES::
+
+            sage: S = simplicial_complexes.KleinBottle()
+            sage: T = simplicial_complexes.Sphere(5)
+            sage: H = Hom(S,T)
+            sage: x = H.an_element()
+            sage: x
+            Simplicial complex morphism {0: 0, 1: 0, 2: 0, 'R3': 0, 'L4': 0, 'L5': 0, 'L3': 0, 'R5': 0, 'R4': 0} from Simplicial complex with 9 vertices and 18 facets to Simplicial complex with vertex set (0, 1, 2, 3, 4, 5, 6) and 7 facets
+
+        """
+        X_vertices = self._domain.vertices().set()
+        try:
+            i = self._codomain.vertices().set().__iter__().next()
+        except StopIteration:
+            if len(X_vertices) == 0:
+                return dict()
+            else:
+                raise TypeError, "There are no morphisms from a non-empty simplicial complex to an empty simplicial comples."
+        f = dict()
+        for x in X_vertices:
+            f[x]=i
+        return simplicial_complex_morphism.SimplicialComplexMorphism(f,self._domain,self._codomain)

new file sage/homology/simplicial_complex_morphism.py

@@ +1 @@
+r"""
+Morphisms of simplicial complexes
+
+AUTHORS:
+
+- D. Benjamin Antieau <d.ben.antieau@gmail.com> (2009.06)
+
+This module implements morphisms of simplicial complexes. The input is given
+by a dictionary on the vertex set or the effective vertex set of a simplicial complex.
+The initialization checks that faces are sent to faces.
+
+There is also the capability to create the fiber product of two morphisms with the same codomain.
+
+EXAMPLES::
+
+    sage: S = SimplicialComplex(5,[[0,2],[1,5],[3,4]])
+    sage: H = Hom(S,S.product(S))
+    sage: H.diagonal_morphism()
+    Simplicial complex morphism {0: 'L0R0', 1: 'L1R1', 2: 'L2R2', 3: 'L3R3', 4: 'L4R4', 5: 'L5R5'} from Simplicial complex with vertex set (0, 1, 2, 3, 4, 5) and facets {(3, 4), (1, 5), (0, 2)} to Simplicial complex with 36 vertices and 18 facets
+
+    sage: S = SimplicialComplex(5,[[0,2],[1,5],[3,4]])
+    sage: T = SimplicialComplex(4,[[0,2],[1,3]])
+    sage: f = {0:0,1:1,2:2,3:1,4:3,5:3}
+    sage: H = Hom(S,T)
+    sage: x = H(f)
+    sage: x.image()
+    Simplicial complex with vertex set (0, 1, 2, 3) and facets {(1, 3), (0, 2)}
+    sage: x.is_surjective()
+    False
+    sage: x.is_injective()
+    False
+    sage: x.is_identity()
+    False
+
+    sage: S = simplicial_complexes.Sphere(2)
+    sage: H = Hom(S,S)
+    sage: i = H.identity()
+    sage: i.image()
+    Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)}
+    sage: i.is_surjective()
+    True
+    sage: i.is_injective()
+    True
+    sage: i.is_identity()
+    True
+
+    sage: S = simplicial_complexes.Sphere(2)
+    sage: H = Hom(S,S)
+    sage: i = H.identity()
+    sage: j = i.product(i)
+    sage: j
+    Simplicial complex morphism {'L1R1': 1, 'L3R3': 3, 'L2R2': 2, 'L0R0': 0} from Simplicial complex with 4 vertices and 4 facets to Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)}
+
+    sage: S = simplicial_complexes.Sphere(2)
+    sage: T = S.product(SimplicialComplex(1,[[0,1]]),rename_vertices = False)
+    sage: H = Hom(T,S)
+    sage: T
+    Simplicial complex with 8 vertices and 12 facets
+    sage: T.vertices()
+    ((0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1))
+    sage: f = {(0, 0): 0, (0, 1): 0, (1, 0): 1, (1, 1): 1, (2, 0): 2, (2, 1): 2, (3, 0): 3, (3, 1): 3}
+    sage: x = H(f)
+    sage: U = simplicial_complexes.Sphere(1)
+    sage: G = Hom(U,S)
+    sage: U
+    Simplicial complex with vertex set (0, 1, 2) and facets {(1, 2), (0, 2), (0, 1)}
+    sage: g = {0:0,1:1,2:2}
+    sage: y = G(g)
+    sage: z = y.product(x)
+    sage: z                                     # this is the mapping path space
+    Simplicial complex morphism {'L2R(2, 0)': 2, 'L2R(2, 1)': 2, 'L0R(0, 0)': 0, 'L0R(0, 1)': 0, 'L1R(1, 0)': 1, 'L1R(1, 1)': 1} from Simplicial complex with 6 vertices and 6 facets to Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)}
+
+
+"""
+
+#*****************************************************************************
+# Copyright (C) 2009 D. Benjamin Antieau <d.ben.antieau@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful, 
+#    but WITHOUT ANY WARRANTY; without even the implied warranty 
+#    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# 
+#  See the GNU General Public License for more details; the full text 
+#  is available at:
+#
+#                  http://www.gnu.org/licenses/
+#
+#*****************************************************************************
+
+import sage.homology.simplicial_complex as simplicial_complex
+import sage.matrix.all as matrix
+import sage.categories.category_types as category_types
+
+def is_SimplicialComplexMorphism(x):
+    return isinstance(x,SimplicialComplexMorphism)
+
+class SimplicialComplexMorphism(category_types.SageObject):
+    """
+    An element of this class is a morphism of simplicial complexes.
+    """
+    def __init__(self,f,X,Y):
+        """
+        Input is a dictionary f, the domain, and the codomain.
+
+        One can define the dictionary either on the vertices of X or on the effective vertices of X (X.effective_vertices()). Note that this
+        difference does matter. For instance, it changes the result of the image method, and hence it changes the result of the is_surjective method as well.
+        This is because two SimplicialComplexes with the same faces but different vertex sets are not equal.
+
+        EXAMPLES::
+
+            sage: S = SimplicialComplex(5,[[0,1],[3,4]])
+            sage: H = Hom(S,S)
+            sage: f = {0:0,1:1,2:2,3:3,4:4,5:5}
+            sage: g = {0:0,1:1,3:3,4:4}
+            sage: x = H(f)
+            sage: y = H(g)
+            sage: x==y
+            False
+            sage: x.image()
+            Simplicial complex with vertex set (0, 1, 2, 3, 4, 5) and facets {(3, 4), (0, 1)}
+            sage: y.image()
+            Simplicial complex with vertex set (0, 1, 3, 4) and facets {(3, 4), (0, 1)}
+            sage: x.image()==y.image()
+            False
+
+        """
+        if not isinstance(X,simplicial_complex.SimplicialComplex) or not isinstance(Y,simplicial_complex.SimplicialComplex):
+            raise ValueError, "X and Y must be SimplicialComplexes."
+        if not set(f.keys())==X._vertex_set.set() and not set(f.keys())==X.effective_vertices().set():
+            raise ValueError, "f must be a dictionary from the vertex set of X to single values in the vertex set of Y."
+        dim = X.dimension()
+        Y_faces = Y.faces()
+        for k in range(dim+1):
+            for i in X.faces()[k]:
+                tup = i.tuple()
+                fi = []
+                for j in tup:
+                    fi.append(f[j])
+                v = simplicial_complex.Simplex(set(fi))
+            if not v in Y_faces[v.dimension()]:
+                raise ValueError, "f must be a dictionary from the vertices of X to the vertices of Y."
+        self._vertex_dictionary = f
+        self._domain = X
+        self._codomain = Y
+    
+    def __eq__(self,x):
+        """
+        Returns True if and only if self == x.
+        
+        EXAMPLES::
+
+            sage: S = simplicial_complexes.Sphere(2)
+            sage: H = Hom(S,S)
+            sage: i = H.identity()
+            sage: i
+            Simplicial complex morphism {0: 0, 1: 1, 2: 2, 3: 3} from Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)} to Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)}
+            sage: f = {0:0,1:1,2:2,3:2}
+            sage: j = H(f)
+            sage: i==j
+            False
+            
+            sage: T = SimplicialComplex(3,[[1,2]])
+            sage: T
+            Simplicial complex with vertex set (0, 1, 2, 3) and facets {(1, 2)}
+            sage: G = Hom(T,T)
+            sage: k = G.identity()
+            sage: g = {0:0,1:1,2:2,3:3}
+            sage: l = G(g)
+            sage: k==l
+            True
+
+        """
+        if not isinstance(x,SimplicialComplexMorphism) or self._codomain != x._codomain or self._domain != x._domain or self._vertex_dictionary != x._vertex_dictionary:
+            return False
+        else:
+            return True
+
+    def __call__(self,x):
+        """
+        Input is a simplex of the domain. Output is the image simplex.
+        
+        EXAMPLES::
+
+            sage: S = simplicial_complexes.Sphere(2)
+            sage: T = simplicial_complexes.Sphere(3)
+            sage: S
+            Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)}
+            sage: T
+            Simplicial complex with vertex set (0, 1, 2, 3, 4) and 5 facets
+            sage: f = {0:0,1:1,2:2,3:3}
+            sage: H = Hom(S,T)
+            sage: x = H(f)
+            sage: from sage.homology.simplicial_complex import Simplex
+            sage: x(Simplex([0,2,3]))
+            (0, 2, 3)
+
+        """
+        dim = self._domain.dimension()
+        if not isinstance(x,simplicial_complex.Simplex) or x.dimension() > dim or not x in self._domain.faces()[x.dimension()]:
+            raise ValueError, "x must be a simplex of the source of f"
+        tup=x.tuple()
+        fx=[]
+        for j in tup:
+            fx.append(self._vertex_dictionary[j])
+        return simplicial_complex.Simplex(set(fx))
+
+    def _repr_(self):
+        """
+        Print representation
+
+        EXAMPLES::
+
+            sage: S = simplicial_complexes.Sphere(2)
+            sage: H = Hom(S,S)
+            sage: i = H.identity()
+            sage: i
+            Simplicial complex morphism {0: 0, 1: 1, 2: 2, 3: 3} from Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)} to Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)}
+
+        """
+        return "Simplicial complex morphism " + str(self._vertex_dictionary) + " from " + self._domain._repr_() + " to " + self._codomain._repr_()
+
+#    This is going to be implemented in the near future.
+#
+#    def associated_chain_complex_morphism(self,base_ring=ZZ,augmented=False,cochain=False):
+#        max_dim = max(self._domain.dimension(),self._codomain.dimension())
+#        min_dim = min(self._domain.dimension(),self._codomain.dimension())
+#        matrices={}
+#        if augmented is True:
+#            m=matrix.Matrix(base_ring,1,1,1)
+#            if not cochain:
+#                matrices[-1] = m
+#            else:
+#                matrices[-1] = m.transpose()
+#        for dim in range(min_dim+1):
+#            X_faces = list(self._domain.faces()[dim])
+#            Y_faces = list(self._codomain.faces()[dim])
+#            num_faces_X = len(X_faces)
+#            num_faces_Y = len(Y_faces)
+#            mval = [0 for i in range(num_faces_X*num_faces_Y)]
+#            for i in X_faces:
+#                y=self(i)
+#                if y.dimension() < dim:
+#                    pass
+#                else:
+#                    mval[X_faces.index(i)+(Y_faces.index(y)*num_faces_X)] = 1
+#            m = matrix.Matrix(base_ring,num_faces_Y,num_faces_X,mval,sparse=True)
+#            if not cochain:
+#                matrices[dim] = m
+#            else:
+#                matrices[dim] = m.transpose()
+#        for dim in range(min_dim+1,max_dim+1):
+#            m = zero_matrix(base_ring,len(self._codomain.faces()[dim]),len(self._domain.faces()[dim]),sparse=True)
+#            if not cochain:
+#                matrices[dim] = m
+#            else:
+#                matrices[dim] = m.transpose()
+#        if not cochain:
+#            return ChainComplexMorphism(matrices,self._domain.chain_complex(base_ring=base_ring,augmented=augmented,cochain=cochain),self._codomain.chain_complex(base_ring=base_ring,augmented=augmented,cochain=cochain))
+#        else:
+#            return ChainComplexMorphism(matrices,self._codomain.chain_complex(base_ring=base_ring,augmented=augmented,cochain=cochain),self._domain.chain_complex(base_ring=base_ring,augmented=augmented,cochain=cochain))
+        
+    def image(self):
+        """
+        Computes the image simplicial complex of f.
+        
+        EXAMPLES::
+
+            sage: S = SimplicialComplex(3,[[0,1],[2,3]])
+            sage: T = SimplicialComplex(1,[[0,1]])
+            sage: f = {0:0,1:1,2:0,3:1}
+            sage: H = Hom(S,T)
+            sage: x = H(f)
+            sage: x.image()
+            Simplicial complex with vertex set (0, 1) and facets {(0, 1)}
+
+            sage: S = SimplicialComplex(2)
+            sage: H = Hom(S,S)
+            sage: i = H.identity()
+            sage: i.image()
+            Simplicial complex with vertex set (0, 1, 2) and facets {()}
+            sage: i.is_surjective()
+            True
+            sage: S = SimplicialComplex(5,[[0,1]])
+            sage: T = SimplicialComplex(3,[[0,1]])
+            sage: f = {0:0,1:1}
+            sage: g = {0:0,1:1,2:2,3:3,4:4,5:5}
+            sage: H = Hom(S,T)
+            sage: x = H(f)
+            sage: y = H(g)
+            sage: x == y
+            False
+            sage: x.image()
+            Simplicial complex with vertex set (0, 1) and facets {(0, 1)}
+            sage: y.image()
+            Simplicial complex with vertex set (0, 1, 2, 3, 4, 5) and facets {(0, 1)}
+
+        """
+        fa = [self(i) for i in self._domain.facets]
+        return simplicial_complex.SimplicialComplex(set(self._vertex_dictionary.values()),fa,maximality_check=True)
+        
+    def is_surjective(self):
+        """
+        Returns True if and only if self is surjective.
+
+        EXAMPLES::
+
+            sage: S = SimplicialComplex(3,[(0,1,2)])
+            sage: S
+            Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 1, 2)}
+            sage: T = SimplicialComplex(2,[(0,1)])
+            sage: T
+            Simplicial complex with vertex set (0, 1, 2) and facets {(0, 1)}
+            sage: H = Hom(S,T)
+            sage: x = H({0:0,1:1,2:1,3:2})
+            sage: x.is_surjective()
+            True
+
+            sage: S = SimplicialComplex(3,[[0,1],[2,3]])
+            sage: T = SimplicialComplex(1,[[0,1]])
+            sage: f = {0:0,1:1,2:0,3:1}
+            sage: H = Hom(S,T)
+            sage: x = H(f)
+            sage: x.is_surjective()
+            True
+
+        """    
+        return self._codomain == self.image()
+        
+    def is_injective(self):
+        """
+        Returns True if and only if self is injective.
+
+        EXAMPLES::
+
+            sage: S = simplicial_complexes.Sphere(1)
+            sage: T = simplicial_complexes.Sphere(2)
+            sage: U = simplicial_complexes.Sphere(3)
+            sage: H = Hom(T,S)
+            sage: G = Hom(T,U)
+            sage: f = {0:0,1:1,2:0,3:1}
+            sage: x = H(f)
+            sage: g = {0:0,1:1,2:2,3:3}
+            sage: y = G(g)
+            sage: x.is_injective()
+            False
+            sage: y.is_injective()
+            True
+
+        """
+        v = [self._vertex_dictionary[i[0]] for i in self._domain.faces()[0]]
+        for i in v:
+            if v.count(i) > 1:
+                return False
+        return True
+
+    def is_identity(self):
+        """
+        If x is an identity morphism, returns True. Otherwise, False.
+
+        EXAMPLES::
+
+            sage: T = simplicial_complexes.Sphere(1)
+            sage: G = Hom(T,T)
+            sage: T
+            Simplicial complex with vertex set (0, 1, 2) and facets {(1, 2), (0, 2), (0, 1)}
+            sage: j = G({0:0,1:1,2:2})
+            sage: j.is_identity()
+            True
+
+            sage: S = simplicial_complexes.Sphere(2)
+            sage: T = simplicial_complexes.Sphere(3)
+            sage: H = Hom(S,T)
+            sage: f = {0:0,1:1,2:2,3:3}
+            sage: x = H(f)
+            sage: x
+            Simplicial complex morphism {0: 0, 1: 1, 2: 2, 3: 3} from Simplicial complex with vertex set (0, 1, 2, 3) and facets {(0, 2, 3), (0, 1, 2), (1, 2, 3), (0, 1, 3)} to Simplicial complex with vertex set (0, 1, 2, 3, 4) and 5 facets
+            sage: x.is_identity()
+            False
+
+        """
+        if self._domain != self._codomain:
+            return False
+        else:
+            f = dict()
+            for i in self._domain.vertices().set():
+                f[i] = i
+            if self._vertex_dictionary != f:
+                return False
+            else:
+                return True
+
+    def product(self,other,rename_vertices = True):
+        """
+        Fiber product of self and other. Both morphisms should have the same codomain. The method returns a morphism of simplicial complexes, which
+        is the morphism from the space of the fiber product to the codomain.
+
+        EXAMPLES::
+            
+            sage: S = SimplicialComplex(2,[[0,1],[1,2]])
+            sage: T = SimplicialComplex(2,[[0,2]])
+            sage: U = SimplicialComplex(1,[[0,1]])
+            sage: H = Hom(S,U)
+            sage: G = Hom(T,U)
+            sage: f = {0:0,1:1,2:0}
+            sage: g = {0:0,1:1,2:1}
+            sage: x = H(f)
+            sage: y = G(g)
+            sage: z = x.product(y)
+            sage: z
+            Simplicial complex morphism {'L1R2': 1, 'L2R0': 0, 'L0R0': 0} from Simplicial complex with vertex set ('L0R0', 'L1R2', 'L2R0') and facets {('L2R0',), ('L0R0', 'L1R2')} to Simplicial complex with vertex set (0, 1) and facets {(0, 1)}
+
+        """
+        if self._codomain != other._codomain:
+            raise ValueError, "self and other must have the same codomain."
+        X = self._domain.product(other._domain,rename_vertices = rename_vertices)
+        v = []
+        f = dict()
+        eff1 = self._domain.effective_vertices()
+        eff2 = other._domain.effective_vertices()
+        for i in eff1:
+            for j in eff2:
+                if self(simplicial_complex.Simplex([i])) == other(simplicial_complex.Simplex([j])):
+                    if rename_vertices:
+                        v.append("L"+str(i)+"R"+str(j))
+                        f["L"+str(i)+"R"+str(j)] = self._vertex_dictionary[i]
+                    else:
+                        v.append((i,j))
+                        f[(i,j)] = self._vertex_dictionary[i]
+        return SimplicialComplexMorphism(f,X.generated_subcomplex(v),self._codomain)