Merge branch 'public/manifolds/vector_bundles' of git://trac.sagemath.org/sage into Sage 9.0.beta1

Author: egourgoulhon

src/doc/en/reference/categories/index.rst

@@ -181,6 +181,7 @@ Individual Categories
    sage/categories/triangular_kac_moody_algebras
    sage/categories/unique_factorization_domains
    sage/categories/unital_algebras
+   sage/categories/vector_bundles
    sage/categories/vector_spaces
    sage/categories/weyl_groups
 

src/doc/en/reference/manifolds/diff_manifold.rst

@@ -29,3 +29,5 @@ Differentiable Manifolds
    sage/manifolds/differentiable/affine_connection
 
    sage/manifolds/differentiable/differentiable_submanifold
+
+   sage/manifolds/differentiable/vector_bundle

src/doc/en/reference/manifolds/manifold.rst

@@ -19,3 +19,5 @@ Topological Manifolds
    continuous_map
 
    sage/manifolds/topological_submanifold
+
+   vector_bundle

src/doc/en/reference/manifolds/vector_bundle.rst

@@ -0,0 +1,19 @@
+Topological Vector Bundles
+==========================
+
+.. toctree::
+   :maxdepth: 2
+
+   sage/manifolds/vector_bundle
+
+   sage/manifolds/vector_bundle_fiber
+
+   sage/manifolds/vector_bundle_fiber_element
+
+   sage/manifolds/trivialization
+
+   sage/manifolds/local_frame
+
+   sage/manifolds/section_module
+
+   sage/manifolds/section

src/sage/categories/vector_bundles.py

@@ -0,0 +1,165 @@
+r"""
+Vector Bundles
+"""
+#*****************************************************************************
+#  Copyright (C) 2019 Michael Jung <micjung at uni-potsdam.de>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.categories.category_types import Category_over_base_ring
+from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.misc.cachefunc import cached_method
+from sage.categories.sets_cat import Sets
+from sage.categories.fields import Fields
+
+class VectorBundles(Category_over_base_ring):
+    r"""
+    The category of vector bundles over any base space and base field.
+
+    .. SEEALSO:: :class:`~sage.manifolds.vector_bundle.TopologicalVectorBundle`
+
+    EXAMPLES::
+
+        sage: M = Manifold(2, 'M', structure='top')
+        sage: from sage.categories.vector_bundles import VectorBundles
+        sage: C = VectorBundles(M, RR); C
+        Category of vector bundles over Real Field with 53 bits of precision
+         with base space 2-dimensional topological manifold M
+        sage: C.super_categories()
+        [Category of topological spaces]
+
+    TESTS::
+
+        sage: TestSuite(C).run(skip="_test_category_over_bases")
+
+    """
+    def __init__(self, base_space, base_field, name=None):
+        r"""
+        Initialize ``self``.
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M')
+            sage: from sage.categories.vector_bundles import VectorBundles
+            sage: C = VectorBundles(M, RR)
+            sage: TestSuite(C).run(skip="_test_category_over_bases")
+
+        """
+        if base_field not in Fields().Topological():
+            raise ValueError("base field must be a topological field")
+        self._base_space = base_space
+        Category_over_base_ring.__init__(self, base_field, name)
+
+    @cached_method
+    def super_categories(self):
+        r"""
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M')
+            sage: from sage.categories.vector_bundles import VectorBundles
+            sage: VectorBundles(M, RR).super_categories()
+            [Category of topological spaces]
+
+        """
+        return [Sets().Topological()]
+
+    def base_space(self):
+        r"""
+        Return the base space of this category.
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M', structure='top')
+            sage: from sage.categories.vector_bundles import VectorBundles
+            sage: VectorBundles(M, RR).base_space()
+            2-dimensional topological manifold M
+
+        """
+        return self._base_space
+
+    def _repr_object_names(self):
+        r"""
+        Return the name of the objects of this category.
+
+        .. SEEALSO:: :meth:`Category._repr_object_names`
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M')
+            sage: from sage.categories.vector_bundles import VectorBundles
+            sage: VectorBundles(M, RR)._repr_object_names()
+            'vector bundles over Real Field with 53 bits of precision with base
+             space 2-dimensional differentiable manifold M'
+
+        """
+        base_space = self._base_space
+        return Category_over_base_ring._repr_object_names(self) + \
+               " with base space %s"%base_space
+
+    class SubcategoryMethods:
+        @cached_method
+        def Differentiable(self):
+            r"""
+            Return the subcategory of the differentiable objects
+            of ``self``.
+
+            EXAMPLES::
+
+                sage: M = Manifold(2, 'M')
+                sage: from sage.categories.vector_bundles import VectorBundles
+                sage: VectorBundles(M, RR).Differentiable()
+                Category of differentiable vector bundles over Real Field with
+                 53 bits of precision with base space 2-dimensional
+                 differentiable manifold M
+
+            TESTS::
+
+                sage: TestSuite(VectorBundles(M, RR).Differentiable()).run()
+                sage: VectorBundles(M, RR).Differentiable.__module__
+                'sage.categories.vector_bundles'
+
+            """
+            return self._with_axiom('Differentiable')
+
+        @cached_method
+        def Smooth(self):
+            """
+            Return the subcategory of the smooth objects of ``self``.
+
+            EXAMPLES::
+
+                sage: M = Manifold(2, 'M')
+                sage: from sage.categories.vector_bundles import VectorBundles
+                sage: VectorBundles(M, RR).Smooth()
+                Category of smooth vector bundles over Real Field with 53 bits
+                 of precision with base space 2-dimensional differentiable
+                 manifold M
+
+            TESTS::
+
+                sage: TestSuite(VectorBundles(M, RR).Smooth()).run()
+                sage: VectorBundles(M, RR).Smooth.__module__
+                'sage.categories.vector_bundles'
+
+            """
+            return self._with_axiom('Smooth')
+
+    class Differentiable(CategoryWithAxiom_over_base_ring):
+        """
+        The category of differentiable vector bundles.
+
+        A differentiable vector bundle is a differentiable manifold with
+        differentiable surjective projection on a differentiable base space.
+
+        """
+
+    class Smooth(CategoryWithAxiom_over_base_ring):
+        """
+        The category of smooth vector bundles.
+
+        A smooth vector bundle is a smooth manifold with
+        smooth surjective projection on a smooth base space.
+
+        """

src/sage/manifolds/chart_func.py

@@ -855,6 +855,26 @@ def is_trivial_zero(self):
         curr = self._calc_method._current
         return self._calc_method.is_trivial_zero(self.expr(curr))
 
+    def is_unit(self):
+        r"""
+        Return ``True`` iff ``self`` is not identically zero since most chart
+        functions are invertible and an actual computation would take too much
+        time.
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M', structure='topological')
+            sage: X.<x,y> = M.chart()
+            sage: f = X.function(x^2+3*y+1)
+            sage: f.is_unit()
+            True
+            sage: zero = X.function(0)
+            sage: zero.is_unit()
+            False
+
+        """
+        return not self.is_zero()
+
     def copy(self):
         r"""
         Return an exact copy of the object.
@@ -2645,7 +2665,7 @@ def _repr_(self):
         """
         return "Ring of chart functions on {}".format(self._chart)
 
-    def is_integral_domain(self):
+    def is_integral_domain(self, proof=True):
         """
         Return ``False`` as ``self`` is not an integral domain.
 

src/sage/manifolds/differentiable/automorphismfield.py

@@ -984,84 +984,6 @@ def __call__(self, *arg):
         else:
             raise TypeError("wrong number of arguments")
 
-    def __invert__(self):
-        r"""
-        Return the inverse automorphism of ``self``.
-
-        EXAMPLES::
-
-            sage: M = Manifold(2, 'M')
-            sage: X.<x,y> = M.chart()
-            sage: a = M.automorphism_field([[0, 2], [-1, 0]], name='a')
-            sage: b = a.inverse(); b
-            Field of tangent-space automorphisms a^(-1) on the 2-dimensional
-             differentiable manifold M
-            sage: b[:]
-            [  0  -1]
-            [1/2   0]
-            sage: a[:]
-            [ 0  2]
-            [-1  0]
-
-        The result is cached::
-
-            sage: a.inverse() is b
-            True
-
-        Instead of ``inverse()``, one can use the power minus one to get the
-        inverse::
-
-            sage: b is a^(-1)
-            True
-
-        or the operator ``~``::
-
-            sage: b is ~a
-            True
-
-        """
-        from sage.matrix.constructor import matrix
-        from sage.tensor.modules.comp import Components
-        from sage.manifolds.differentiable.vectorframe import CoordFrame
-        if self._is_identity:
-            return self
-        if self._inverse is None:
-            if self._name is None:
-                inv_name = None
-            else:
-                inv_name = self._name  + '^(-1)'
-            if self._latex_name is None:
-                inv_latex_name = None
-            else:
-                inv_latex_name = self._latex_name + r'^{-1}'
-            fmodule = self._fmodule
-            si = fmodule._sindex ; nsi = fmodule._rank + si
-            self._inverse = fmodule.automorphism(name=inv_name,
-                                                 latex_name=inv_latex_name)
-            for frame in self._components:
-                if isinstance(frame, CoordFrame):
-                    chart = frame._chart
-                else:
-                    chart = self._domain._def_chart #!# to be improved
-                try:
-                    # TODO: do the computation without the 'SR' enforcement
-                    mat_self = matrix(
-                              [[self.comp(frame)[i, j, chart].expr(method='SR')
-                              for j in range(si, nsi)] for i in range(si, nsi)])
-                except (KeyError, ValueError):
-                    continue
-                mat_inv = mat_self.inverse()
-                cinv = Components(fmodule._ring, frame, 2, start_index=si,
-                                  output_formatter=fmodule._output_formatter)
-                for i in range(si, nsi):
-                    for j in range(si, nsi):
-                        val = chart.simplify(mat_inv[i-si,j-si], method='SR')
-                        cinv[i, j] = {chart: val}
-                self._inverse._components[frame] = cinv
-        return self._inverse
-
-    inverse = __invert__
-
     def restrict(self, subdomain, dest_map=None):
         r"""
         Return the restriction of ``self`` to some subset of its domain.