Add is_trivial_zero() to coordinate functions and scalar fields and use it in tensor calculus

Author: egourgoulhon

src/sage/manifolds/coord_func.py

@@ -322,6 +322,35 @@ def __bool__(self):
 
         """
 
+    @abstract_method
+    def is_trivial_zero(self):
+        r"""
+        Check if ``self`` is trivially equal to zero without any
+        simplification.
+
+        This method is supposed to be fast as compared with
+        ``self.is_zero()`` or ``self == 0`` and is intended to be
+        used in library code where trying to obtain a mathematically
+        correct result by applying potentially expensive rewrite rules
+        is not desirable.
+
+        TESTS:
+
+        This method must be implemented by derived classes; it is not
+        implemented here::
+
+            sage: M = Manifold(2, 'M', structure='topological')
+            sage: X.<x,y> = M.chart()
+            sage: from sage.manifolds.coord_func import CoordFunction
+            sage: f = CoordFunction(X.function_ring())
+            sage: f.is_trivial_zero()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError: <abstract method is_trivial_zero at 0x...>
+
+        """
+
+
     @abstract_method
     def copy(self):
         r"""

src/sage/manifolds/coord_func_symb.py

@@ -189,8 +189,7 @@ class CoordFunctionSymb(CoordFunction):
         1
 
     Another difference regards the display of partial derivatives:
-    for callable symbolic functions, it relies on Pynac notation
-    ``D[0]``, ``D[1]``, etc.::
+    for callable symbolic functions, it involves ``diff``::
 
         sage: g = function('g')(x, y)
         sage: f0(x,y) = diff(g, x) + diff(g, y)
@@ -211,13 +210,13 @@ class CoordFunctionSymb(CoordFunction):
         \frac{\partial\,g}{\partial x} + \frac{\partial\,g}{\partial y}
 
     Note that this regards only the display of coordinate functions:
-    internally, the Pynac notation is still used, as we can check by asking
+    internally, the ``diff`` notation is still used, as we can check by asking
     for the symbolic expression stored in ``f``::
 
         sage: f.expr()
         diff(g(x, y), x) + diff(g(x, y), y)
 
-    One can switch to Pynac notation by changing the options::
+    One can switch to the standard symbolic notation by changing the options::
 
         sage: Manifold.options.textbook_output=False
         sage: latex(f)
@@ -519,6 +518,54 @@ def __bool__(self):
 
     __nonzero__ = __bool__   # For Python2 compatibility
 
+    def is_trivial_zero(self):
+        r"""
+        Check if ``self`` is trivially equal to zero without any
+        simplification.
+
+        This method is supposed to be fast as compared with
+        ``self.is_zero()`` or ``self == 0`` and is intended to be
+        used in library code where trying to obtain a mathematically
+        correct result by applying potentially expensive rewrite rules
+        is not desirable.
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M', structure='topological')
+            sage: X.<x,y> = M.chart()
+            sage: f = X.function(0)
+            sage: f.is_trivial_zero()
+            True
+            sage: f = X.function(float(0.0))
+            sage: f.is_trivial_zero()
+            True
+            sage: f = X.function(x-x)
+            sage: f.is_trivial_zero()
+            True
+            sage: X.zero_function().is_trivial_zero()
+            True
+
+        No simplification is attempted, so that ``False`` is returned for
+        non-trivial cases::
+
+            sage: f = X.function(cos(x)^2 + sin(x)^2 - 1)
+            sage: f.is_trivial_zero()
+            False
+
+        On the contrary, the method
+        :meth:`~sage.structure.element.Element.is_zero` and the direct
+        comparison to zero involve some simplification algorithms and
+        return ``True``::
+
+            sage: f.is_zero()
+            True
+            sage: f == 0
+            True
+
+        """
+        return self._express.is_trivial_zero()
+
+
     def copy(self):
         r"""
         Return an exact copy of the object.
@@ -1742,7 +1789,7 @@ def characteristic(self):
             0
         """
         return self._chart.manifold().base_field().characteristic()
-    
+
     def from_base_ring(self, r):
         """
         Return the canonical embedding of ``r`` into ``self``.

src/sage/manifolds/differentiable/diff_form_module.py

@@ -38,6 +38,7 @@
 from sage.structure.unique_representation import UniqueRepresentation
 from sage.structure.parent import Parent
 from sage.categories.modules import Modules
+from sage.rings.integer import Integer
 from sage.tensor.modules.ext_pow_free_module import ExtPowerDualFreeModule
 from sage.manifolds.differentiable.diff_form import DiffForm, DiffFormParal
 from sage.manifolds.differentiable.tensorfield import TensorField
@@ -318,7 +319,7 @@ def _element_constructor_(self, comp=[], frame=None, name=None,
             True
 
         """
-        if comp == 0:
+        if isinstance(comp, (int, Integer)) and comp == 0:
             return self.zero()
         if isinstance(comp, (DiffForm, DiffFormParal)):
             # coercion by domain restriction
@@ -767,7 +768,7 @@ def _element_constructor_(self, comp=[], frame=None, name=None,
             True
 
         """
-        if comp == 0:
+        if isinstance(comp, (int, Integer)) and comp == 0:
             return self.zero()
         if isinstance(comp, (DiffForm, DiffFormParal)):
             # coercion by domain restriction

src/sage/manifolds/differentiable/tensorfield.py

@@ -1778,8 +1778,6 @@ def _add_(self, other):
             True
 
         """
-        if other == 0:
-            return +self
         resu_rst = {}
         for dom in self._common_subdomains(other):
             resu_rst[dom] = self._restrictions[dom] + other._restrictions[dom]
@@ -1843,8 +1841,6 @@ def _sub_(self, other):
             True
 
         """
-        if other == 0:
-            return +self
         resu_rst = {}
         for dom in self._common_subdomains(other):
             resu_rst[dom] = self._restrictions[dom] - other._restrictions[dom]
@@ -2240,13 +2236,13 @@ def __call__(self, *args):
                 self_rr = self_r._restrictions[dom]
                 args_rr = [args_r[i]._restrictions[dom] for i in range(p)]
                 resu_rr = self_rr(*args_rr)
-                if resu_rr == 0:
+                if resu_rr.is_trivial_zero():
                     for chart in resu_rr._domain._atlas:
                         resu._express[chart] = chart._zero_function
                 else:
                     for chart, expr in resu_rr._express.items():
                         resu._express[chart] = expr
-            if resu == 0:
+            if resu.is_trivial_zero():
                 return dom_resu._zero_scalar_field
             # Name of the output:
             res_name = None

src/sage/manifolds/differentiable/tensorfield_module.py

@@ -41,6 +41,7 @@
 from sage.structure.unique_representation import UniqueRepresentation
 from sage.structure.parent import Parent
 from sage.categories.modules import Modules
+from sage.rings.integer import Integer
 from sage.tensor.modules.tensor_free_module import TensorFreeModule
 from sage.manifolds.differentiable.tensorfield import TensorField
 from sage.manifolds.differentiable.tensorfield_paral import TensorFieldParal
@@ -303,10 +304,10 @@ def _element_constructor_(self, comp=[], frame=None, name=None,
             True
 
         """
-        if comp == 0:
+        if isinstance(comp, (int, Integer)) and comp == 0:
             return self.zero()
         if isinstance(comp, DiffForm):
-            # coercion of a p-form to a type-(0,p) tensor:
+            # coercion of a p-form to a type-(0,p) tensor field:
             form = comp # for readability
             p = form.degree()
             if self._tensor_type != (0,p) or self._vmodule != form.base_module():
@@ -747,7 +748,7 @@ def _element_constructor_(self, comp=[], frame=None, name=None,
             True
 
         """
-        if comp == 0:
+        if isinstance(comp, (int, Integer)) and comp == 0:
             return self.zero()
         if isinstance(comp, DiffFormParal):
             # coercion of a p-form to a type-(0,p) tensor field:

src/sage/manifolds/differentiable/vectorfield_module.py

@@ -42,6 +42,7 @@
 from sage.structure.parent import Parent
 from sage.categories.modules import Modules
 from sage.misc.cachefunc import cached_method
+from sage.rings.integer import Integer
 from sage.tensor.modules.finite_rank_free_module import FiniteRankFreeModule
 from sage.manifolds.differentiable.vectorfield import (VectorField, VectorFieldParal)
 
@@ -255,7 +256,7 @@ def _element_constructor_(self, comp=[], frame=None, name=None,
             True
 
         """
-        if comp == 0:
+        if isinstance(comp, (int, Integer)) and comp == 0:
             return self.zero()
         if isinstance(comp, VectorField):
             if (self._domain.is_subset(comp._domain)
@@ -1241,7 +1242,7 @@ def _element_constructor_(self, comp=[], basis=None, name=None,
             True
 
         """
-        if comp == 0:
+        if isinstance(comp, (int, Integer)) and comp == 0:
             return self.zero()
         if isinstance(comp, VectorField):
             if (self._domain.is_subset(comp._domain)

src/sage/manifolds/scalarfield.py

@@ -697,6 +697,66 @@ def __bool__(self):
 
     __nonzero__ = __bool__   # For Python2 compatibility
 
+    def is_trivial_zero(self):
+        r"""
+        Check if ``self`` is trivially equal to zero without any
+        simplification.
+
+        This method is supposed to be fast as compared with
+        ``self.is_zero()`` or ``self == 0`` and is intended to be
+        used in library code where trying to obtain a mathematically
+        correct result by applying potentially expensive rewrite rules
+        is not desirable.
+
+        EXAMPLES::
+
+            sage: M = Manifold(2, 'M', structure='topological')
+            sage: X.<x,y> = M.chart()
+            sage: f = M.scalar_field({X: 0})
+            sage: f.is_trivial_zero()
+            True
+            sage: f = M.scalar_field(0)
+            sage: f.is_trivial_zero()
+            True
+            sage: M.zero_scalar_field().is_trivial_zero()
+            True
+            sage: f = M.scalar_field({X: x+y})
+            sage: f.is_trivial_zero()
+            False
+
+        Scalar field defined by means of two charts::
+
+            sage: U1 = M.open_subset('U1'); X1.<x1,y1> = U1.chart()
+            sage: U2 = M.open_subset('U2'); X2.<x2,y2> = U2.chart()
+            sage: f = M.scalar_field({X1: 0, X2: 0})
+            sage: f.is_trivial_zero()
+            True
+            sage: f = M.scalar_field({X1: 0, X2: 1})
+            sage: f.is_trivial_zero()
+            False
+
+        No simplification is attempted, so that ``False`` is returned for
+        non-trivial cases::
+
+            sage: f = M.scalar_field({X: cos(x)^2 + sin(x)^2 - 1})
+            sage: f.is_trivial_zero()
+            False
+
+        On the contrary, the method
+        :meth:`~sage.structure.element.Element.is_zero` and the direct
+        comparison to zero involve some simplification algorithms and
+        return ``True``::
+
+            sage: f.is_zero()
+            True
+            sage: f == 0
+            True
+
+        """
+        if self._is_zero:
+            return True
+        return all(func.is_trivial_zero() for func in self._express.values())
+
     def __eq__(self, other):
         r"""
         Comparison (equality) operator.

src/sage/tensor/modules/alternating_contr_tensor.py

@@ -408,9 +408,13 @@ def display(self, basis=None, format_spec=None):
         for ind in comp.non_redundant_index_generator():
             ind_arg = ind + (format_spec,)
             coef = comp[ind_arg]
-            if not (coef == 0):   # NB: coef != 0 would return False for
-                                  # cases in which Sage cannot conclude
-                                  # see :trac:`22520`
+            # Check whether the coefficient is zero, preferably via
+            # the fast method is_trivial_zero():
+            if hasattr(coef, 'is_trivial_zero'):
+                zero_coef = coef.is_trivial_zero()
+            else:
+                zero_coef = coef == 0
+            if not zero_coef:
                 bases_txt = []
                 bases_latex = []
                 for k in range(self._tensor_rank):