Trac #28562: Tensor Fields: Better Zero Treatment

The zero element is always a special element. Therefore it should be
treated as such. It should shorten computations and certainly be
immutable. This ticket is devoted to that topic. (Similarly for the one
element in the scalar field and mixed form algebra).

This ticket is part of the metaticket #28519.

**Features**

- an assertion error arises when altering the fixed elements zero or one
- a new attribute `_is_zero` is added to tensor fields and mixed form
(similar to scalar fields)
- computations with involved zero or one are shortened by using a simple
check
- due to immutability of algebra elements, no copies are returned
anymore for scalar field operations with zero or one
- `_is_zero` attribute is applied for copies

URL: https://trac.sagemath.org/28562
Reported by: gh-DeRhamSource
Ticket author(s): Michael Jung
Reviewer(s): Eric Gourgoulhon, Travis Scrimshaw

Author: Release Manager

src/sage/manifolds/differentiable/automorphismfield.py

@@ -139,8 +139,7 @@ class AutomorphismField(TensorField):
         True
 
     """
-    def __init__(self, vector_field_module, name=None, latex_name=None,
-                 is_identity=False):
+    def __init__(self, vector_field_module, name=None, latex_name=None):
         r"""
         Construct a field of tangent-space automorphisms on a
         non-parallelizable manifold.
@@ -168,7 +167,7 @@ def __init__(self, vector_field_module, name=None, latex_name=None,
 
         Construction of the identity field::
 
-            sage: b = GL.element_class(XM, is_identity=True); b
+            sage: b = GL.one(); b
             Field of tangent-space identity maps on the 2-dimensional
              differentiable manifold M
             sage: TestSuite(b).run(skip='_test_pickling')
@@ -186,24 +185,11 @@ def __init__(self, vector_field_module, name=None, latex_name=None,
             Fix ``_test_pickling`` (in the superclass :class:`TensorField`).
 
         """
-        if is_identity:
-            if name is None:
-                name = 'Id'
-            if latex_name is None and name == 'Id':
-                latex_name = r'\mathrm{Id}'
         TensorField.__init__(self, vector_field_module, (1,1), name=name,
                              latex_name=latex_name,
                              parent=vector_field_module.general_linear_group())
-        self._is_identity = is_identity
+        self._is_identity = False # a priori
         self._init_derived() # initialization of derived quantities
-        # Specific initializations for the field of identity maps:
-        if self._is_identity:
-            self._inverse = self
-            for dom in self._domain._subsets:
-                if dom.is_manifestly_parallelizable():
-                    fmodule = dom.vector_field_module()
-                    self._restrictions[dom] = fmodule.identity_map(name=name,
-                                                         latex_name=latex_name)
 
     def _repr_(self):
         r"""
@@ -261,6 +247,151 @@ def _del_derived(self):
         # then deletes the inverse automorphism:
         self._inverse = None
 
+    def set_comp(self, basis=None):
+        r"""
+        Return the components of ``self`` w.r.t. a given module basis for
+        assignment.
+
+        The components with respect to other bases are deleted, in order to
+        avoid any inconsistency. To keep them, use the method :meth:`add_comp`
+        instead.
+
+        INPUT:
+
+        - ``basis`` -- (default: ``None``) basis in which the components are
+          defined; if none is provided, the components are assumed to refer to
+          the module's default basis
+
+        OUTPUT:
+
+        - components in the given basis, as an instance of the
+          class :class:`~sage.tensor.modules.comp.Components`; if such
+          components did not exist previously, they are created.
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M') # the 2-dimensional sphere S^2
+            sage: U = M.open_subset('U') # complement of the North pole
+            sage: c_xy.<x,y> = U.chart() # stereographic coordinates from the North pole
+            sage: V = M.open_subset('V') # complement of the South pole
+            sage: c_uv.<u,v> = V.chart() # stereographic coordinates from the South pole
+            sage: M.declare_union(U,V)   # S^2 is the union of U and V
+            sage: e_uv = c_uv.frame()
+            sage: a= M.automorphism_field(name='a')
+            sage: a.set_comp(e_uv)
+            2-indices components w.r.t. Coordinate frame (V, (d/du,d/dv))
+            sage: a.set_comp(e_uv)[0,0] = u+v
+            sage: a.set_comp(e_uv)[1,1] = u+v
+            sage: a.display(e_uv)
+            a = (u + v) d/du*du + (u + v) d/dv*dv
+
+        Setting the components in a new frame::
+
+            sage: e = V.vector_frame('e')
+            sage: a.set_comp(e)
+            2-indices components w.r.t. Vector frame (V, (e_0,e_1))
+            sage: a.set_comp(e)[0,1] = u*v
+            sage: a.set_comp(e)[1,0] = u*v
+            sage: a.display(e)
+            a = u*v e_0*e^1 + u*v e_1*e^0
+
+        Since the frames ``e`` and ``e_uv`` are defined on the same domain, the
+        components w.r.t. ``e_uv`` have been erased::
+
+            sage: a.display(c_uv.frame())
+            Traceback (most recent call last):
+            ...
+            ValueError: no basis could be found for computing the components
+             in the Coordinate frame (V, (d/du,d/dv))
+
+        Since the identity map is a special element, its components cannot be
+        changed::
+
+            sage: id = M.tangent_identity_field()
+            sage: id.add_comp(e)[0,1] = u*v
+            Traceback (most recent call last):
+            ...
+            AssertionError: the components of the identity map cannot be changed
+
+        """
+        if self._is_identity:
+            raise AssertionError("the components of the identity map cannot be "
+                                 "changed")
+        return TensorField._set_comp_unsafe(self, basis=basis)
+
+    def add_comp(self, basis=None):
+        r"""
+        Return the components of ``self`` w.r.t. a given module basis for
+        assignment, keeping the components w.r.t. other bases.
+
+        To delete the components w.r.t. other bases, use the method
+        :meth:`set_comp` instead.
+
+        INPUT:
+
+        - ``basis`` -- (default: ``None``) basis in which the components are
+          defined; if none is provided, the components are assumed to refer to
+          the module's default basis
+
+        .. WARNING::
+
+            If the automorphism field has already components in other bases, it
+            is the user's responsibility to make sure that the components
+            to be added are consistent with them.
+
+        OUTPUT:
+
+        - components in the given basis, as an instance of the
+          class :class:`~sage.tensor.modules.comp.Components`;
+          if such components did not exist previously, they are created
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M') # the 2-dimensional sphere S^2
+            sage: U = M.open_subset('U') # complement of the North pole
+            sage: c_xy.<x,y> = U.chart() # stereographic coordinates from the North pole
+            sage: V = M.open_subset('V') # complement of the South pole
+            sage: c_uv.<u,v> = V.chart() # stereographic coordinates from the South pole
+            sage: M.declare_union(U,V)   # S^2 is the union of U and V
+            sage: e_uv = c_uv.frame()
+            sage: a= M.automorphism_field(name='a')
+            sage: a.add_comp(e_uv)
+            2-indices components w.r.t. Coordinate frame (V, (d/du,d/dv))
+            sage: a.add_comp(e_uv)[0,0] = u+v
+            sage: a.add_comp(e_uv)[1,1] = u+v
+            sage: a.display(e_uv)
+            a = (u + v) d/du*du + (u + v) d/dv*dv
+
+        Setting the components in a new frame::
+
+            sage: e = V.vector_frame('e')
+            sage: a.add_comp(e)
+            2-indices components w.r.t. Vector frame (V, (e_0,e_1))
+            sage: a.add_comp(e)[0,1] = u*v
+            sage: a.add_comp(e)[1,0] = u*v
+            sage: a.display(e)
+            a = u*v e_0*e^1 + u*v e_1*e^0
+
+        The components with respect to ``e_uv`` are kept::
+
+            sage: a.display(e_uv)
+            a = (u + v) d/du*du + (u + v) d/dv*dv
+
+        Since the identity map is a special element, its components cannot be
+        changed::
+
+            sage: id = M.tangent_identity_field()
+            sage: id.add_comp(e)[0,1] = u*v
+            Traceback (most recent call last):
+            ...
+            AssertionError: the components of the identity map cannot be changed
+
+        """
+        if self._is_identity:
+            raise AssertionError("the components of the identity map cannot be "
+                                 "changed")
+        return TensorField._add_comp_unsafe(self, basis=basis)
+
     def _new_instance(self):
         r"""
         Create an instance of the same class as ``self`` on the same
@@ -789,8 +920,6 @@ class AutomorphismFieldParal(FreeModuleAutomorphism, TensorFieldParal):
     - ``name`` -- (default: ``None``) name given to the field
     - ``latex_name`` -- (default: ``None``) LaTeX symbol to denote the field;
       if none is provided, the LaTeX symbol is set to ``name``
-    - ``is_identity`` -- (default: ``False``) determines whether the
-      constructed object is a field of identity automorphisms
 
     EXAMPLES:
 
@@ -834,8 +963,7 @@ class AutomorphismFieldParal(FreeModuleAutomorphism, TensorFieldParal):
         True
 
     """
-    def __init__(self, vector_field_module, name=None, latex_name=None,
-                 is_identity=False):
+    def __init__(self, vector_field_module, name=None, latex_name=None):
         r"""
         Construct a field of tangent-space automorphisms.
 
@@ -861,7 +989,7 @@ def __init__(self, vector_field_module, name=None, latex_name=None,
 
         Construction of the field of identity maps::
 
-            sage: b = GL.element_class(XM, is_identity=True); b
+            sage: b = GL.one(); b
             Field of tangent-space identity maps on the 2-dimensional
              differentiable manifold M
             sage: b[:]
@@ -871,12 +999,12 @@ def __init__(self, vector_field_module, name=None, latex_name=None,
 
         """
         FreeModuleAutomorphism.__init__(self, vector_field_module,
-                                        name=name, latex_name=latex_name,
-                                        is_identity=is_identity)
+                                        name=name, latex_name=latex_name)
         # TensorFieldParal attributes:
         self._vmodule = vector_field_module
         self._domain = vector_field_module._domain
         self._ambient_domain = vector_field_module._ambient_domain
+        self._is_identity = False # a priori
         # Initialization of derived quantities:
         TensorFieldParal._init_derived(self)
 

src/sage/manifolds/differentiable/automorphismfield_group.py

@@ -300,7 +300,16 @@ def one(self):
             [0 1]
 
         """
-        return self.element_class(self._vmodule, is_identity=True)
+        # Specific initializations for the field of identity maps:
+        resu = self._element_constructor_(name='Id', latex_name=r'\mathrm{Id}')
+        resu._inverse = resu
+        for dom in resu._domain._subsets:
+            if dom.is_manifestly_parallelizable():
+                fmodule = dom.vector_field_module()
+                resu._restrictions[dom] = fmodule.identity_map(name='Id',
+                                                      latex_name=r'\mathrm{Id}')
+        resu._is_identity = True
+        return resu
 
     #### End of monoid methods ####
 

src/sage/manifolds/differentiable/diff_form.py

@@ -525,6 +525,21 @@ def wedge(self, other):
                 raise ValueError("incompatible ambient domains for exterior product")
         dom_resu = self._domain.intersection(other._domain)
         ambient_dom_resu = self._ambient_domain.intersection(other._ambient_domain)
+        resu_degree = self._tensor_rank + other._tensor_rank
+        dest_map = self._vmodule._dest_map
+        dest_map_resu = dest_map.restrict(dom_resu,
+                                          subcodomain=ambient_dom_resu)
+        # Facilitate computations involving zero:
+        if resu_degree > ambient_dom_resu._dim:
+            return dom_resu.diff_form_module(resu_degree,
+                                             dest_map=dest_map_resu).zero()
+        if self._is_zero or other._is_zero:
+            return dom_resu.diff_form_module(resu_degree,
+                                             dest_map=dest_map_resu).zero()
+        if self is other and (self._tensor_rank % 2) == 1:
+            return dom_resu.diff_form_module(resu_degree,
+                                             dest_map=dest_map_resu).zero()
+        # Generic case:
         self_r = self.restrict(dom_resu)
         other_r = other.restrict(dom_resu)
         if ambient_dom_resu.is_manifestly_parallelizable():
@@ -549,11 +564,7 @@ def wedge(self, other):
             if not is_atomic(olname):
                 olname = '(' + olname + ')'
             resu_latex_name = slname + r'\wedge ' + olname
-        dest_map = self._vmodule._dest_map
-        dest_map_resu = dest_map.restrict(dom_resu,
-                                          subcodomain=ambient_dom_resu)
         vmodule = dom_resu.vector_field_module(dest_map=dest_map_resu)
-        resu_degree = self._tensor_rank + other._tensor_rank
         resu = vmodule.alternating_form(resu_degree, name=resu_name,
                                         latex_name=resu_latex_name)
         for dom in self_r._restrictions:

src/sage/manifolds/differentiable/diff_form_module.py

@@ -443,13 +443,12 @@ def zero(self):
             2-form zero on the 3-dimensional differentiable manifold M
 
         """
-        zero = self.element_class(self._vmodule, self._degree, name='zero',
-                                  latex_name='0')
         zero = self._element_constructor_(name='zero', latex_name='0')
         for frame in self._domain._frames:
             if self._dest_map.restrict(frame._domain) == frame._dest_map:
-                zero.add_comp(frame)
+                zero._add_comp_unsafe(frame)
                 # (since new components are initialized to zero)
+        zero._is_zero = True  # This element is certainly zero
         return zero
 
     #### End of Parent methods