Implemented splitting of vector bundles

vector_bundle/algebras.py

@@ -139,6 +139,9 @@ def wedderburn_malcev_basis(A):
         [0 1], [0 0]
         ]
     """
+    if not A.radical_basis():
+        return A.basis()
+    #A is not semi-simple
     k = A.base_ring()
     n = A.dimension()
     basis = A.basis()

vector_bundle/hom_bundle.py

@@ -377,6 +377,26 @@ class HomBundle(VectorBundle):
         image = VectorBundle(K, ideals, g_fi, identity_matrix(K, g_fi.ncols()))
         return image, C_inf
 
+    def is_isomorphism(self, f):
+        r"""
+        Check if f is an isomorphism from ``self.domain()`` to 
+        ``self.codomain()``
+
+        EXAMPLES::
+
+            sage: from vector_bundle import atiyah_bundle, canonical_bundle
+            sage: F.<x> = FunctionField(GF(7))
+            sage: R.<y> = F[]
+            sage: K.<y> = F.extension(y^2 - x^3 - x)
+            sage: V = atiyah_bundle(K, 2, 0)
+            sage: W = atiyah_bundle(K, 2, 0, canonical_bundle(K))
+            sage: isom = x^2/(x^2 + 3) * identity_matrix(K, 2)
+            sage: V.hom(W).is_isomorphism(isom)
+            True
+        """
+        dual = self.dual()
+        return self.is_in_h0(f) and dual.is_in_h0(f**-1)
+
             
 class EndBundle(HomBundle):
     r"""

vector_bundle/vector_bundle.py

@@ -1089,6 +1089,13 @@ class VectorBundle(SageObject):
                         for s, val in zip(series, self._h0_vs)],[]))
         return self._h0_matrix.solve_right(v)
 
+    def is_in_h0(self, v):
+        try:
+            self.coordinates_in_h0(v)
+        except ValueError:
+            return False
+        return True
+
     def h0_from_vector(self, v):
         r"""
         Return an element of `H^0(\mathrm{self})` from a vector of coordinates
@@ -1199,6 +1206,8 @@ class VectorBundle(SageObject):
             2
             sage: V._isomorphism_indecomposable(ind) is not None
             True
+            sage: ind.direct_sum_repeat(s).hom(W).is_isomorphism(isom)
+            True
         """
         End = self.end()
         A, to_A, from_A = End.global_algebra()
@@ -1220,6 +1229,62 @@ class VectorBundle(SageObject):
                 len(phis),
                 block_matrix(self._function_field, [phis]))
 
+    def split(self):
+        r"""
+        Return a list of indecomposable bundles ``inds``, a list of integers 
+        `ns` and an isomorphism from 
+        `\bigoplus_{\mathrm{ind} \in \mathrm{inds}} 
+        \mathrm{ind}^{n_\mathrm{ind}}` to ``self``.
+
+        EXAMPLES::
+
+            sage: # long time (20 seconds)
+            sage: from vector_bundle import atiyah_bundle, trivial_bundle
+            sage: F.<x> = FunctionField(GF(7))
+            sage: R.<y> = F[]
+            sage: K.<y> = F.extension(y^2 - x^3 - x)
+            sage: triv = trivial_bundle(K)
+            sage: V = atiyah_bundle(K, 2, 0)
+            sage: W = triv.direct_sum_repeat(2).direct_sum(V)
+            sage: T = matrix(K, 4, 4,
+            ....:            [x+1, 4, 3*x+4, 6*x+6,
+            ....:             4*x+5, 6*x+5, 2*x+1, 4*x+3,
+            ....:             3*x+1, 5*x, 3*x+1, x+6,
+            ....:             5*x+4, 6*x, 5*x+2, 6*x+6])           
+            sage: W = W.apply_isomorphism(T)
+            sage: inds, ns, isom = W.split()
+            sage: b1 = [ind.rank() for ind in inds] == [1, 2]
+            sage: b2 = [ind.rank() for ind in inds] == [2, 1]
+            sage: b1 or b2
+            True
+            sage: b1 = ns == [1, 2]
+            sage: b2 = ns == [2, 1]
+            sage: b1 or b2
+            True
+            sage: sum = inds[0].direct_sum_repeat(ns[0])
+            sage: sum = sum.direct_sum(inds[1].direct_sum_repeat(ns[1]))
+            sage: sum.hom(W).is_isomorphism(isom)
+            True
+        """
+        K = self._function_field
+        End = self.end()
+        A, to_A, from_A = End.global_algebra()
+        (S, to_S, from_S), splits = End._global_algebra_split()
+        injections = [[from_A(from_S(s.from_M(diagonal_matrix(
+            s._K,
+            [0]*i + [1] + [0]*(s._n-1-i))))) 
+                           for i in range(s._n)]
+                          for s in splits]
+        images = [[End.image(inj) for inj in injs] for injs in injections]
+        inds = [im[0][0] for im in images]
+        phis = [[ims[0][1]] 
+                + [im[1] * ind._isomorphism_indecomposable(im[0]) 
+                   for im in ims[1:]]
+                for ind,ims in zip(inds, images)]
+        ns = [len(injs) for injs in injections]
+        isom = block_matrix([sum(phis, [])])
+        return inds, ns, isom
+
     def isomorphism_to(self, other):
         r"""
         Return an isomorphism from self to other if it exists and None otherwise