Zero/One check added

Author: Michael Jung

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,152 @@ def _del_derived(self):
         # then deletes the inverse automorphism:
         self._inverse = None
 
+    def set_comp(self, basis=None, **kwargs):
+        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(self, basis=basis, check_elements=False)
+
+    def add_comp(self, basis=None, **kwargs):
+        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(self, basis=basis, check_elements=False)
+
     def _new_instance(self):
         r"""
         Create an instance of the same class as ``self`` on the same
@@ -789,8 +921,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 +964,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 +990,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 +1000,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_module.py

@@ -446,7 +446,7 @@ def zero(self):
         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(frame, check_elements=False)
                 # (since new components are initialized to zero)
         zero._is_zero = True  # This element is certainly zero
         return zero

src/sage/manifolds/differentiable/multivector_module.py

@@ -395,7 +395,7 @@ def zero(self):
         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(frame, check_elements=False)
                 # (since new components are initialized to zero)
         return zero
 

src/sage/manifolds/differentiable/tensorfield.py

@@ -1077,7 +1077,7 @@ def restrict(self, subdomain, dest_map=None):
 
         return self._restrictions[subdomain]
 
-    def set_comp(self, basis=None):
+    def set_comp(self, basis=None, **kwargs):
         r"""
         Return the components of ``self`` in a given vector frame
         for assignment.
@@ -1132,15 +1132,28 @@ def set_comp(self, basis=None):
             ValueError: no basis could be found for computing the components
              in the Coordinate frame (V, (d/du,d/dv))
 
+        Since zero is a special element, its components cannot be changed::
+
+            sage: z = M.tensor_field_module((1, 1)).zero()
+            sage: z.set_comp(e)[0,1] = u*v
+            Traceback (most recent call last):
+            ...
+            AssertionError: the components of the zero element cannot be changed
+
         """
+        check_elements = kwargs.pop('check_elements', True)
+        if check_elements:
+            if self is self.parent().zero():
+                raise AssertionError("the components of the zero element "
+                                     "cannot be changed")
+            self._is_zero = False  # a priori
         if basis is None:
             basis = self._domain._def_frame
         self._del_derived() # deletes the derived quantities
-        self._is_zero = False  # a priori
         rst = self.restrict(basis._domain, dest_map=basis._dest_map)
-        return rst.set_comp(basis)
+        return rst.set_comp(basis, **kwargs)
 
-    def add_comp(self, basis=None):
+    def add_comp(self, basis=None, **kwargs):
         r"""
         Return the components of ``self`` in a given vector frame
         for assignment.
@@ -1191,13 +1204,26 @@ def add_comp(self, basis=None):
             sage: t.display(e_uv)
             t = (u + v) d/dv*du*dv
 
+        Since zero is a special element, its components cannot be changed::
+
+            sage: z = M.tensor_field_module((1, 1)).zero()
+            sage: z.add_comp(e)[0,1] = u*v
+            Traceback (most recent call last):
+            ...
+            AssertionError: the components of the zero element cannot be changed
+
         """
+        check_elements = kwargs.pop('check_elements', True)
+        if check_elements:
+            if self is self.parent().zero():
+                raise AssertionError("the components of the zero element "
+                                     "cannot be changed")
+            self._is_zero = False  # a priori
         if basis is None:
             basis = self._domain._def_frame
         self._del_derived() # deletes the derived quantities
-        self._is_zero = False  # a priori
         rst = self.restrict(basis._domain, dest_map=basis._dest_map)
-        return rst.add_comp(basis)
+        return rst.add_comp(basis, **kwargs)
 
     def add_comp_by_continuation(self, frame, subdomain, chart=None):
         r"""
@@ -1271,10 +1297,10 @@ def add_comp_by_continuation(self, frame, subdomain, chart=None):
         sframe = frame.restrict(subdomain)
         schart = chart.restrict(subdomain)
         scomp = self.comp(sframe)
-        resu = self.add_comp(frame) # _del_derived is performed here
+        resu = self.add_comp(frame, check_elements=False) # _del_derived is
+                                                          # performed here
         for ind in resu.non_redundant_index_generator():
             resu[[ind]] = dom.scalar_field({chart: scomp[[ind]].expr(schart)})
-        self._is_zero = False  # a priori
 
     def add_expr_from_subdomain(self, frame, subdomain):
         r"""
@@ -1366,14 +1392,13 @@ def add_expr_from_subdomain(self, frame, subdomain):
         if frame not in self.restrict(frame.domain())._components:
             raise ValueError("the tensor doesn't have an expression in "
                              "the frame"+frame._repr_())
-        comp = self.comp(frame)
+        comp = self.add_comp(frame, check_elements=False)
         scomp = self.restrict(subdomain).comp(frame.restrict(subdomain))
         for ind in comp.non_redundant_index_generator():
             comp[[ind]]._express.update(scomp[[ind]]._express)
 
         rst = self._restrictions.copy()
         self._del_derived()         # delete restrictions
-        self._is_zero = False  # a priori
         self._restrictions = rst
 
     def comp(self, basis=None, from_basis=None):

src/sage/manifolds/differentiable/tensorfield_module.py

@@ -575,7 +575,7 @@ def zero(self):
         resu = self._element_constructor_(name='zero', latex_name='0')
         for frame in self._domain._frames:
             if self._dest_map.restrict(frame._domain) == frame._dest_map:
-                resu.add_comp(frame)
+                resu.add_comp(frame, check_elements=False)
                 # (since new components are initialized to zero)
         resu._is_zero = True  # This element is certainly zero
         return resu