Trac #30274: first trial of immutability

Author: Michael Jung

src/sage/manifolds/differentiable/automorphismfield.py

@@ -209,7 +209,7 @@ def _repr_(self):
 
         """
         description = "Field of tangent-space "
-        if self._is_identity:
+        if self is self.parent().one():
             description += "identity maps "
         else:
             description += "automorphisms "
@@ -304,20 +304,20 @@ class :class:`~sage.tensor.modules.comp.Components`; if such
             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::
+        Since the identity map is an immutable 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
+            AssertionError: the components of an immutable element 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)
+        comp = super().set_comp(basis=basis)
+        self._is_identity = False  # a priori
+        return comp
 
     def add_comp(self, basis=None):
         r"""
@@ -384,13 +384,13 @@ class :class:`~sage.tensor.modules.comp.Components`;
             sage: id.add_comp(e)[0,1] = u*v
             Traceback (most recent call last):
             ...
-            AssertionError: the components of the identity map cannot be changed
+            AssertionError: the components of an immutable element 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)
+        comp = super().add_comp(basis=basis)
+        self._is_identity = False  # a priori
+        return comp
 
     def _new_instance(self):
         r"""
@@ -526,6 +526,41 @@ def __call__(self, *arg):
         # Case of 2 arguments:
         return TensorField.__call__(self, *arg)
 
+    def copy(self, name=None, latex_name=None):
+        r"""
+        Return an exact copy of the automorphism field ``self``.
+
+        INPUT:
+
+        - ``name`` -- (default: ``None``) name given to the copy
+        - ``latex_name`` -- (default: ``None``) LaTeX symbol to denote the
+          copy; if none is provided, the LaTeX symbol is set to ``name``
+
+        .. NOTE::
+
+            The name and the derived quantities are not copied.
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M')
+            sage: U = M.open_subset('U') ; V = M.open_subset('V')
+            sage: M.declare_union(U,V)   # M is the union of U and V
+            sage: c_xy.<x,y> = U.chart() ; c_uv.<u,v> = V.chart()
+            sage: xy_to_uv = c_xy.transition_map(c_uv, (x+y, x-y),
+            ....:                    intersection_name='W', restrictions1= x>0,
+            ....:                    restrictions2= u+v>0)
+            sage: uv_to_xy = xy_to_uv.inverse()
+            sage: Id = M.tangent_identity_field(); Id
+            Field of tangent-space identity maps on the 2-dimensional
+             differentiable manifold M
+            sage: one = Id.copy('1'); one
+            Field of tangent-space automorphisms 1 on the 2-dimensional
+             differentiable manifold M
+
+        """
+        copy = super().copy(name=name, latex_name=latex_name)
+        copy._is_identity = self._is_identity
+        return copy
 
     #### MultiplicativeGroupElement methods ####
 
@@ -868,9 +903,9 @@ def restrict(self, subdomain, dest_map=None):
         if subdomain == self._domain:
             return self
         if subdomain not in self._restrictions:
-            if not self._is_identity:
+            if self is not self.parent().one():
                 return TensorField.restrict(self, subdomain, dest_map=dest_map)
-            # Special case of the identity map:
+            # Special case of the immutable identity map:
             if not subdomain.is_subset(self._domain):
                 raise ValueError("the provided domain is not a subset of " +
                                  "the field's domain")
@@ -1035,7 +1070,7 @@ def _repr_(self):
 
         """
         description = "Field of tangent-space "
-        if self._is_identity:
+        if self is self.parent().one():
             description += "identity maps "
         else:
             description += "automorphisms "

src/sage/manifolds/differentiable/automorphismfield_group.py

@@ -314,8 +314,9 @@ def one(self):
             if dom.is_manifestly_parallelizable():
                 fmodule = dom.vector_field_module()
                 resu._restrictions[dom] = fmodule.identity_map(name='Id',
-                                                      latex_name=r'\mathrm{Id}')
+                                                     latex_name=r'\mathrm{Id}')
         resu._is_identity = True
+        resu.set_immutable()
         return resu
 
     #### End of monoid methods ####

src/sage/manifolds/differentiable/diff_form_module.py

@@ -447,9 +447,10 @@ 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_unsafe(frame)
+                zero.add_comp(frame)
                 # (since new components are initialized to zero)
         zero._is_zero = True  # This element is certainly zero
+        zero.set_immutable()
         return zero
 
     #### End of Parent methods

src/sage/manifolds/differentiable/manifold.py

@@ -2520,8 +2520,7 @@ def automorphism_field(self, *comp, **kwargs):
             resu._init_components(*comp, **kwargs)
         return resu
 
-    def tangent_identity_field(self, name='Id', latex_name=None,
-                               dest_map=None):
+    def tangent_identity_field(self, dest_map=None):
         r"""
         Return the field of identity maps in the tangent spaces on ``self``.
 
@@ -2589,7 +2588,7 @@ def tangent_identity_field(self, name='Id', latex_name=None,
 
         """
         vmodule = self.vector_field_module(dest_map)
-        return vmodule.identity_map(name=name, latex_name=latex_name)
+        return vmodule.identity_map()
 
     def default_frame(self):
         r"""

src/sage/manifolds/differentiable/multivector_module.py

@@ -399,8 +399,10 @@ 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_unsafe(frame)
+                zero.add_comp(frame)
                 # (since new components are initialized to zero)
+        zero._is_zero = True  # This element is certainly zero
+        zero.set_immutable()
         return zero
 
     #### End of Parent methods

src/sage/manifolds/differentiable/tensorfield.py

@@ -55,11 +55,12 @@
 
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
-from sage.structure.element import ModuleElement
+from sage.structure.element import ModuleElementWithMutability
+from sage.misc.cachefunc import cached_method
 from sage.tensor.modules.free_module_tensor import FreeModuleTensor
 from sage.tensor.modules.tensor_with_indices import TensorWithIndices
 
-class TensorField(ModuleElement):
+class TensorField(ModuleElementWithMutability):
     r"""
     Tensor field along a differentiable manifold.
 
@@ -361,6 +362,35 @@ class TensorField(ModuleElement):
         sage: s.restrict(U) == f.restrict(U) * t.restrict(U)
         True
 
+    Notice that the zero tensor field is immutable, and therefore its
+    components cannot be changed::
+
+        sage: zer = M.tensor_field_module((1, 1)).zero()
+        sage: zer.is_immutable()
+        True
+        sage: zer.set_comp()
+        Traceback (most recent call last):
+        ...
+        AssertionError: the components of an immutable element cannot be
+         changed
+
+    Other tensor fields can be declared immutable, too::
+
+        sage: t.is_immutable()
+        False
+        sage: t.set_immutable()
+        sage: t.is_immutable()
+        True
+        sage: t.set_comp()
+        Traceback (most recent call last):
+        ...
+        AssertionError: the components of an immutable element cannot be
+         changed
+        sage: t.set_name('b')
+        Traceback (most recent call last):
+        ...
+        AssertionError: the name of an immutable element cannot be changed
+
     """
     def __init__(self, vector_field_module, tensor_type, name=None,
                  latex_name=None, sym=None, antisym=None, parent=None):
@@ -409,7 +439,7 @@ def __init__(self, vector_field_module, tensor_type, name=None,
         """
         if parent is None:
             parent = vector_field_module.tensor_module(*tensor_type)
-        ModuleElement.__init__(self, parent)
+        ModuleElementWithMutability.__init__(self, parent)
         self._vmodule = vector_field_module
         self._tensor_type = tuple(tensor_type)
         self._tensor_rank = self._tensor_type[0] + self._tensor_type[1]
@@ -601,6 +631,9 @@ def set_name(self, name=None, latex_name=None):
             a
 
         """
+        if self.is_immutable():
+            raise AssertionError("the name of an immutable element "
+                                 "cannot be changed")
         if name is not None:
             self._name = name
             if latex_name is None:
@@ -907,6 +940,26 @@ def symmetries(self):
 
     #### End of simple accessors #####
 
+    def set_immutable(self):
+        r"""
+        Set ``self`` and all restrictions of ``self`` immutable.
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M')
+            sage: X.<x,y> = M.chart()
+            sage: U = M.open_subset('U', coord_def={X: x^2+y^2<1})
+            sage: a = M.tensor_field(1, 1, [[1+y,x], [0,x+y]], name='a')
+            sage: aU = a.restrict(U)
+            sage: a.set_immutable()
+            sage: aU.is_immutable()
+            True
+
+        """
+        for rst in self._restrictions.values():
+            rst.set_immutable()
+        super().set_immutable()
+
     def set_restriction(self, rst):
         r"""
         Define a restriction of ``self`` to some subdomain.
@@ -943,6 +996,9 @@ def set_restriction(self, rst):
             True
 
         """
+        if self.is_immutable():
+            raise AssertionError("the restrictions of an immutable element "
+                                 "cannot be changed")
         if not isinstance(rst, TensorField):
             raise TypeError("the argument must be a tensor field")
         if not rst._domain.is_subset(self._domain):
@@ -1116,7 +1172,8 @@ def restrict(self, subdomain, dest_map=None):
                         res._restrictions.update(rst._restrictions)
                     res._restrictions_graph.update(rst._restrictions_graph)
                     rst._extensions_graph.update(res._extensions_graph)
-
+            if self.is_immutable():
+                res.set_immutable()  # restrictions must be immutable, too
             self._restrictions[subdomain] = res
             self._restrictions_graph[subdomain] = res
             res._extensions_graph.update(self._extensions_graph)
@@ -1242,17 +1299,18 @@ 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::
+        Since zero is an immutable, 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
+            AssertionError: the components of an immutable element cannot be
+             changed
 
         """
-        if self is self.parent().zero():
-            raise AssertionError("the components of the zero element "
+        if self.is_immutable():
+            raise AssertionError("the components of an immutable element "
                                  "cannot be changed")
         self._is_zero = False  # a priori
         if basis is None:
@@ -1374,14 +1432,15 @@ def add_comp(self, basis=None):
         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
+            sage: z.add_comp(e_uv)[1, 1] = u^2
             Traceback (most recent call last):
             ...
-            AssertionError: the components of the zero element cannot be changed
+            AssertionError: the components of an immutable element cannot be
+             changed
 
         """
-        if self is self.parent().zero():
-            raise AssertionError("the components of the zero element "
+        if self.is_immutable():
+            raise AssertionError("the components of an immutable element "
                                  "cannot be changed")
         self._is_zero = False  # a priori
         if basis is None:
@@ -1455,6 +1514,9 @@ def add_comp_by_continuation(self, frame, subdomain, chart=None):
         and `a` is defined on the entire manifold `S^2`.
 
         """
+        if self.is_immutable():
+            raise AssertionError("the components of an immutable element "
+                                 "cannot be changed")
         dom = frame._domain
         if not dom.is_subset(self._domain):
             raise ValueError("the vector frame is not defined on a subset " +
@@ -1552,14 +1614,17 @@ def add_expr_from_subdomain(self, frame, subdomain):
             on V: (xp, yp) |--> 1/(xp^2 + yp^2)
 
         """
+        if self.is_immutable():
+            raise AssertionError("the expressions of an immutable element "
+                                 "cannot be changed")
         dom = frame._domain
         if not dom.is_subset(self._domain):
             raise ValueError("the vector frame is not defined on a subset " +
                              "of the tensor field domain")
         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._add_comp_unsafe(frame)
+        comp = self._add_comp_unsafe(frame)  # the components stay the same
         scomp = self.restrict(subdomain).comp(frame.restrict(subdomain))
         for ind in comp.non_redundant_index_generator():
             comp[[ind]]._express.update(scomp[[ind]]._express)
@@ -1879,7 +1944,6 @@ def display_comp(self, frame=None, chart=None, coordinate_labels=True,
                                 only_nonzero=only_nonzero,
                                 only_nonredundant=only_nonredundant)
 
-
     def __getitem__(self, args):
         r"""
         Return a component with respect to some frame.
@@ -2041,6 +2105,9 @@ def copy_from(self, other):
             False
 
         """
+        if self.is_immutable():
+            raise AssertionError("the components of an immutable element "
+                                 "cannot be changed")
         if other not in self.parent():
             raise TypeError("the original must be an element "
                             + "of {}".format(self.parent()))

src/sage/manifolds/differentiable/tensorfield_module.py

@@ -580,9 +580,10 @@ 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_unsafe(frame)
+                resu.add_comp(frame)
                 # (since new components are initialized to zero)
         resu._is_zero = True  # This element is certainly zero
+        resu.set_immutable()
         return resu
 
 #***********************************************************************