Symbolic Coordinate Functions

In the context of a topological manifold M over a topological field K, a coordinate function is a function from a chart codomain to K. In other words, a coordinate function is a K-valued function of the coordinates associated to some chart.

More precisely, let (U, \varphi) be a chart on M, i.e. U is an open subset of M and \varphi: U \to V \subset K^n is a homeomorphism from U to an open subset V of K^n. A coordinate function associated to the chart (U, \varphi) is a function

\begin{array}{cccc}
    f:&  V \subset K^n & \longrightarrow & K \\
      &  (x^1, \ldots, x^n) & \longmapsto & f(x^1, \ldots, x^n)
\end{array}

This module implements symbolic coordinate functions via the class CoordFunctionSymb.

AUTHORS:

  • Eric Gourgoulhon, Michal Bejger (2013-2015) : initial version
  • Travis Scrimshaw (2016) : make coordinate functions elements of CoordFunctionSymbRing.
class sage.manifolds.coord_func_symb.CoordFunctionSymb(parent, expression)

Bases: sage.manifolds.coord_func.CoordFunction

Coordinate function with symbolic representation.

If (U, \varphi) is a chart on a topological manifold M of dimension n over a topological field K, a coordinate function associated to (U, \varphi) is a map

\begin{array}{llcl}
f:& V \subset K^n & \longrightarrow & K \\
  & (x^1, \ldots, x^n) & \longmapsto & f(x^1, \ldots, x^n),
\end{array}

where V is the codomain of \varphi. In other words, f is a K-valued function of the coordinates associated to the chart (U, \varphi).

INPUT:

  • parent – the algebra of coordinate functions on the chart (U, \varphi)
  • expression – a symbolic expression representing f(x^1, \ldots, x^n), where (x^1, \ldots, x^n) are the coordinates of the chart (U, \varphi)

EXAMPLES:

A symbolic coordinate function associated with a 2-dimensional chart:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x^2+3*y+1)
sage: type(f)
<class 'sage.manifolds.coord_func_symb.CoordFunctionSymbRing_with_category.element_class'>
sage: f.display()
(x, y) |--> x^2 + 3*y + 1
sage: f(x,y)
x^2 + 3*y + 1

The symbolic expression is returned when asking the direct display of the function:

sage: f
x^2 + 3*y + 1
sage: latex(f)
x^{2} + 3 \, y + 1

A similar output is obtained by means of the method expr():

sage: f.expr()
x^2 + 3*y + 1

The value of the function at specified coordinates is obtained by means of the standard parentheses notation:

sage: f(2,-1)
2
sage: var('a b')
(a, b)
sage: f(a,b)
a^2 + 3*b + 1

An unspecified coordinate function:

sage: g = X.function(function('G')(x, y))
sage: g
G(x, y)
sage: g.display()
(x, y) |--> G(x, y)
sage: g.expr()
G(x, y)
sage: g(2,3)
G(2, 3)

Coordinate functions can be compared to other values:

sage: f = X.function(x^2+3*y+1)
sage: f == 2
False
sage: f == x^2 + 3*y + 1
True
sage: g = X.function(x*y)
sage: f == g
False
sage: h = X.function(x^2+3*y+1)
sage: f == h
True

Differences between CoordFunctionSymb and callable symbolic expressions

Callable symbolic expressions are defined directly from symbolic expressions of the coordinates:

sage: f0(x,y) = x^2 + 3*y + 1
sage: type(f0)
<type 'sage.symbolic.expression.Expression'>
sage: f0
(x, y) |--> x^2 + 3*y + 1
sage: f0(x,y)
x^2 + 3*y + 1

To get an output similar to that of f0 for the coordinate function f, we must use the method display():

sage: f
x^2 + 3*y + 1
sage: f.display()
(x, y) |--> x^2 + 3*y + 1
sage: f(x,y)
x^2 + 3*y + 1

More importantly, instances of CoordFunctionSymb differ from callable symbolic expression by the automatic simplifications in all operations. For instance, adding the two callable symbolic expressions:

sage: f0(x,y,z) = cos(x)^2 ; g0(x,y,z) = sin(x)^2

results in:

sage: f0 + g0
(x, y, z) |--> cos(x)^2 + sin(x)^2

To get 1, one has to call simplify_trig():

sage: (f0 + g0).simplify_trig()
(x, y, z) |--> 1

On the contrary, the sum of the corresponding CoordFunctionSymb instances is automatically simplified (see simplify_chain_real() and simplify_chain_generic() for details):

sage: f = X.function(cos(x)^2) ; g = X.function(sin(x)^2)
sage: f + g
1

Another difference regards the display of partial derivatives: for callable symbolic functions, it relies on Pynac notation D[0], D[1], etc.:

sage: g = function('g')(x, y)
sage: f0(x,y) = diff(g, x) + diff(g, y)
sage: f0
(x, y) |--> D[0](g)(x, y) + D[1](g)(x, y)

while for coordinate functions, the display is more “textbook” like:

sage: f = X.function(diff(g, x) + diff(g, y))
sage: f
d(g)/dx + d(g)/dy

The difference is even more dramatic on LaTeX outputs:

sage: latex(f0)
\left( x, y \right) \ {\mapsto} \ D[0]\left(g\right)\left(x, y\right)
 + D[1]\left(g\right)\left(x, y\right)
sage: latex(f)
\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 for the symbolic expression stored in f:

sage: f.expr()
D[0](g)(x, y) + D[1](g)(x, y)

One can switch to Pynac notation by changing the options:

sage: Manifold.options.textbook_output=False
sage: latex(f)
D[0]\left(g\right)\left(x, y\right) + D[1]\left(g\right)\left(x, y\right)
sage: Manifold.options._reset()
sage: latex(f)
\frac{\partial\,g}{\partial x} + \frac{\partial\,g}{\partial y}

Another difference between CoordFunctionSymb and callable symbolic expression is the possibility to switch off the display of the arguments of unspecified functions. Consider for instance:

sage: f = X.function(function('u')(x, y) * function('v')(x, y))
sage: f
u(x, y)*v(x, y)
sage: f0(x,y) = function('u')(x, y) * function('v')(x, y)
sage: f0
(x, y) |--> u(x, y)*v(x, y)

If there is a clear understanding that u and v are functions of (x,y), the explicit mention of the latter can be cumbersome in lengthy tensor expressions. We can switch it off by:

sage: Manifold.options.omit_function_arguments=True
sage: f
u*v

Note that neither the callable symbolic expression f0 nor the internal expression of f is affected by the above command:

sage: f0
(x, y) |--> u(x, y)*v(x, y)
sage: f.expr()
u(x, y)*v(x, y)

We revert to the default behavior by:

sage: Manifold.options._reset()
sage: f
u(x, y)*v(x, y)
arccos()

Arc cosine of self.

OUTPUT:

  • coordinate function \arccos(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.arccos()
arccos(x*y)
sage: arccos(f)  # equivalent to f.arccos()
arccos(x*y)
sage: acos(f)  # equivalent to f.arccos()
arccos(x*y)
sage: arccos(f).display()
(x, y) |--> arccos(x*y)
sage: arccos(X.zero_function()).display()
(x, y) |--> 1/2*pi
arccosh()

Inverse hyperbolic cosine of self.

OUTPUT:

  • coordinate function \mathrm{arcosh}(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.arccosh()
arccosh(x*y)
sage: arccosh(f)  # equivalent to f.arccosh()
arccosh(x*y)
sage: acosh(f)  # equivalent to f.arccosh()
arccosh(x*y)
sage: arccosh(f).display()
(x, y) |--> arccosh(x*y)
sage: arccosh(X.function(1)) == X.zero_function()
True
arcsin()

Arc sine of self.

OUTPUT:

  • coordinate function \arcsin(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.arcsin()
arcsin(x*y)
sage: arcsin(f)  # equivalent to f.arcsin()
arcsin(x*y)
sage: asin(f)  # equivalent to f.arcsin()
arcsin(x*y)
sage: arcsin(f).display()
(x, y) |--> arcsin(x*y)
sage: arcsin(X.zero_function()) == X.zero_function()
True
arcsinh()

Inverse hyperbolic sine of self.

OUTPUT:

  • coordinate function \mathrm{arsinh}(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.arcsinh()
arcsinh(x*y)
sage: arcsinh(f)  # equivalent to f.arcsinh()
arcsinh(x*y)
sage: asinh(f)  # equivalent to f.arcsinh()
arcsinh(x*y)
sage: arcsinh(f).display()
(x, y) |--> arcsinh(x*y)
sage: arcsinh(X.zero_function()) == X.zero_function()
True
arctan()

Arc tangent of self.

OUTPUT:

  • coordinate function \arctan(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.arctan()
arctan(x*y)
sage: arctan(f)  # equivalent to f.arctan()
arctan(x*y)
sage: atan(f)  # equivalent to f.arctan()
arctan(x*y)
sage: arctan(f).display()
(x, y) |--> arctan(x*y)
sage: arctan(X.zero_function()) == X.zero_function()
True
arctanh()

Inverse hyperbolic tangent of self.

OUTPUT:

  • coordinate function \mathrm{artanh}(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.arctanh()
arctanh(x*y)
sage: arctanh(f)  # equivalent to f.arctanh()
arctanh(x*y)
sage: atanh(f)  # equivalent to f.arctanh()
arctanh(x*y)
sage: arctanh(f).display()
(x, y) |--> arctanh(x*y)
sage: arctanh(X.zero_function()) == X.zero_function()
True
collect(s)

Collect the coefficients of s in the expression of self into a group.

INPUT:

  • s – the symbol whose coefficients will be collected

OUTPUT:

  • self with the coefficients of s grouped in its expression

EXAMPLES:

Action on a 2-dimensional coordinate function:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x^2*y + x*y + (x*y)^2)
sage: f.display()
(x, y) |--> x^2*y^2 + x^2*y + x*y
sage: f.collect(y)
x^2*y^2 + (x^2 + x)*y

The method collect() has changed the expression of f:

sage: f.display()
(x, y) |--> x^2*y^2 + (x^2 + x)*y
collect_common_factors()

Collect common factors in the expression of self.

This method does not perform a full factorization but only looks for factors which are already explicitly present.

OUTPUT:

  • self with the common factors collected in its expression

EXAMPLES:

Action on a 2-dimensional coordinate function:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x/(x^2*y + x*y))
sage: f.display()
(x, y) |--> x/(x^2*y + x*y)
sage: f.collect_common_factors()
1/((x + 1)*y)

The method collect_common_factors() has changed the expression of f:

sage: f.display()
(x, y) |--> 1/((x + 1)*y)
copy()

Return an exact copy of the object.

OUTPUT:

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x+y^2)
sage: g = f.copy(); g
y^2 + x

By construction, g is identical to f:

sage: type(g) == type(f)
True
sage: g == f
True

but it is not the same object:

sage: g is f
False
cos()

Cosine of self.

OUTPUT:

  • coordinate function \cos(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.cos()
cos(x*y)
sage: cos(f)  # equivalent to f.cos()
cos(x*y)
sage: cos(f).display()
(x, y) |--> cos(x*y)
sage: cos(X.zero_function()).display()
(x, y) |--> 1
cosh()

Hyperbolic cosine of self.

OUTPUT:

  • coordinate function \cosh(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.cosh()
cosh(x*y)
sage: cosh(f)  # equivalent to f.cosh()
cosh(x*y)
sage: cosh(f).display()
(x, y) |--> cosh(x*y)
sage: cosh(X.zero_function()).display()
(x, y) |--> 1
diff(coord)

Partial derivative with respect to a coordinate.

INPUT:

  • coord – either the coordinate x^i with respect to which the derivative of the coordinate function f is to be taken, or the index i labelling this coordinate (with the index convention defined on the chart domain via the parameter start_index)

OUTPUT:

EXAMPLES:

Partial derivatives of a 2-dimensional coordinate function:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x^2+3*y+1); f
x^2 + 3*y + 1
sage: f.diff(x)
2*x
sage: f.diff(y)
3

Each partial derivatives is itself a coordinate function:

sage: type(f.diff(x))
<class 'sage.manifolds.coord_func_symb.CoordFunctionSymbRing_with_category.element_class'>

An index can be used instead of the coordinate symbol:

sage: f.diff(0)
2*x
sage: f.diff(1)
3

The index range depends on the convention used on the chart’s domain:

sage: M = Manifold(2, 'M', structure='topological', start_index=1)
sage: X.<x,y> = M.chart()
sage: f = X.function(x^2+3*y+1)
sage: f.diff(0)
Traceback (most recent call last):
...
ValueError: coordinate index out of range
sage: f.diff(1)
2*x
sage: f.diff(2)
3
disp()

Display self in arrow notation.

The output is either text-formatted (console mode) or LaTeX-formatted (notebook mode).

EXAMPLES:

Coordinate function on a 2-dimensional manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(cos(x*y/2))
sage: f.display()
(x, y) |--> cos(1/2*x*y)
sage: latex(f.display())
\left(x, y\right) \mapsto \cos\left(\frac{1}{2} \, x y\right)

A shortcut is disp():

sage: f.disp()
(x, y) |--> cos(1/2*x*y)

Display of the zero function:

sage: X.zero_function().display()
(x, y) |--> 0
display()

Display self in arrow notation.

The output is either text-formatted (console mode) or LaTeX-formatted (notebook mode).

EXAMPLES:

Coordinate function on a 2-dimensional manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(cos(x*y/2))
sage: f.display()
(x, y) |--> cos(1/2*x*y)
sage: latex(f.display())
\left(x, y\right) \mapsto \cos\left(\frac{1}{2} \, x y\right)

A shortcut is disp():

sage: f.disp()
(x, y) |--> cos(1/2*x*y)

Display of the zero function:

sage: X.zero_function().display()
(x, y) |--> 0
exp()

Exponential of self.

OUTPUT:

  • coordinate function \exp(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x+y)
sage: f.exp()
e^(x + y)
sage: exp(f) # equivalent to f.exp()
e^(x + y)
sage: exp(f).display()
(x, y) |--> e^(x + y)
sage: exp(X.zero_function())
1
expand()

Expand the coordinate expression of self.

OUTPUT:

  • self with its expression expanded

EXAMPLES:

Expanding a 2-dimensional coordinate function:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function((x - y)^2)
sage: f.display()
(x, y) |--> (x - y)^2
sage: f.expand()
x^2 - 2*x*y + y^2

The method expand() has changed the expression of f:

sage: f.display()
(x, y) |--> x^2 - 2*x*y + y^2
expr()

Return the symbolic expression representing the image of self.

OUTPUT:

EXAMPLES:

Coordinate function of a 2-dimensional manifold:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x^2+3*y+1)
sage: f.expr()
x^2 + 3*y + 1
sage: type(f.expr())
<type 'sage.symbolic.expression.Expression'>

For a symbolic coordinate function, one shall always have:

sage: bool( f.expr() == f(*(f.chart()[:])) )
True

The method expr() is useful for accessing to all the symbolic expression functionalities in Sage; for instance:

sage: var('a')
a
sage: f = X.function(a*x*y); f.display()
(x, y) |--> a*x*y
sage: f.expr()
a*x*y
sage: f.expr().subs(a=2)
2*x*y

Note that for substituting the value of a coordinate, the function call can be used as well:

sage: f(x,3)
3*a*x
sage: bool( f(x,3) == f.expr().subs(y=3) )
True
factor()

Factorize the coordinate expression of self.

OUTPUT:

  • self with its expression factorized

EXAMPLES:

Factorization of a 2-dimensional coordinate function:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x^2 + 2*x*y + y^2)
sage: f.display()
(x, y) |--> x^2 + 2*x*y + y^2
sage: f.factor()
(x + y)^2

The method factor() has changed the expression of f:

sage: f.display()
(x, y) |--> (x + y)^2
is_zero()

Return True if the function is zero and False otherwise.

EXAMPLES:

Coordinate functions associated to a 2-dimensional chart:

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_zero()
False
sage: f == 0
False
sage: g = X.function(0)
sage: g.is_zero()
True
sage: g == 0
True
sage: X.zero_function().is_zero()
True
sage: X.zero_function() == 0
True
log(base=None)

Logarithm of self.

INPUT:

  • base – (default: None) base of the logarithm; if None, the natural logarithm (i.e. logarithm to base e) is returned

OUTPUT:

  • coordinate function \log_a(f), where f is the current coordinate function and a is the base

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x+y)
sage: f.log()
log(x + y)
sage: log(f) # equivalent to f.log()
log(x + y)
sage: log(f).display()
(x, y) |--> log(x + y)
sage: f.log(2)
log(x + y)/log(2)
sage: log(f, 2)
log(x + y)/log(2)
simplify()

Simplify the coordinate expression of self.

For details about the employed chain of simplifications, see simplify_chain_real() for coordinate functions on real manifolds and simplify_chain_generic() for the generic case.

OUTPUT:

  • self with its expression simplified

EXAMPLES:

Simplification of a 2-dimension coordinate function:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(cos(x)^2+sin(x)^2 + sqrt(x^2))
sage: f.display()
(x, y) |--> cos(x)^2 + sin(x)^2 + sqrt(x^2)
sage: f.simplify()
abs(x) + 1

The method simplify() has changed the expression of f:

sage: f.display()
(x, y) |--> abs(x) + 1

Another example:

sage: f = X.function((x^2-1)/(x+1))
sage: f
(x^2 - 1)/(x + 1)
sage: f.simplify()
x - 1

Examples taking into account the declared range of a coordinate:

sage: M =  Manifold(2, 'M_1', structure='topological')
sage: X.<x,y> = M.chart('x:(0,+oo) y')
sage: f = X.function(sqrt(x^2))
sage: f
x
sage: f.simplify()
x
sage: forget()  # to clear the previous assumption on x
sage: M =  Manifold(2, 'M_2', structure='topological')
sage: X.<x,y> = M.chart('x:(-oo,0) y')
sage: f = X.function(sqrt(x^2))
sage: f
sqrt(x^2)
sage: f.simplify()
-x
sin()

Sine of self.

OUTPUT:

  • coordinate function \sin(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.sin()
sin(x*y)
sage: sin(f)  # equivalent to f.sin()
sin(x*y)
sage: sin(f).display()
(x, y) |--> sin(x*y)
sage: sin(X.zero_function()) == X.zero_function()
True
sinh()

Hyperbolic sine of self.

OUTPUT:

  • coordinate function \sinh(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.sinh()
sinh(x*y)
sage: sinh(f)  # equivalent to f.sinh()
sinh(x*y)
sage: sinh(f).display()
(x, y) |--> sinh(x*y)
sage: sinh(X.zero_function()) == X.zero_function()
True
sqrt()

Square root of self.

OUTPUT:

  • coordinate function \sqrt{f}, where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x+y)
sage: f.sqrt()
sqrt(x + y)
sage: sqrt(f)  # equivalent to f.sqrt()
sqrt(x + y)
sage: sqrt(f).display()
(x, y) |--> sqrt(x + y)
sage: sqrt(X.zero_function()).display()
(x, y) |--> 0
tan()

Tangent of self.

OUTPUT:

  • coordinate function \tan(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.tan()
sin(x*y)/cos(x*y)
sage: tan(f)  # equivalent to f.tan()
sin(x*y)/cos(x*y)
sage: tan(f).display()
(x, y) |--> sin(x*y)/cos(x*y)
sage: tan(X.zero_function()) == X.zero_function()
True
tanh()

Hyperbolic tangent of self.

OUTPUT:

  • coordinate function \tanh(f), where f is the current coordinate function

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: f = X.function(x*y)
sage: f.tanh()
sinh(x*y)/cosh(x*y)
sage: tanh(f)  # equivalent to f.tanh()
sinh(x*y)/cosh(x*y)
sage: tanh(f).display()
(x, y) |--> sinh(x*y)/cosh(x*y)
sage: tanh(X.zero_function()) == X.zero_function()
True
class sage.manifolds.coord_func_symb.CoordFunctionSymbRing(chart)

Bases: sage.structure.parent.Parent, sage.structure.unique_representation.UniqueRepresentation

Ring of all symbolic coordinate functions on a chart.

INPUT:

  • chart – a coordinate chart, as an instance of class Chart

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: FR = X.function_ring(); FR
Ring of coordinate functions on Chart (M, (x, y))
sage: type(FR)
<class 'sage.manifolds.coord_func_symb.CoordFunctionSymbRing_with_category'>
sage: FR.category()
Category of commutative algebras over Symbolic Ring
Element

alias of CoordFunctionSymb

from_base_ring(r)

Return the canonical embedding of r into self.

INPUT:

  • r – an element of self.base_ring()

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: FR = X.function_ring()
sage: f = FR.from_base_ring(x*y)
sage: f.display()
(x, y) |--> x*y
is_field()

Return False as self is not an integral domain.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: FR = X.function_ring()
sage: FR.is_integral_domain()
False
sage: FR.is_field()
False
is_integral_domain()

Return False as self is not an integral domain.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: FR = X.function_ring()
sage: FR.is_integral_domain()
False
sage: FR.is_field()
False
one()

Return the constant function 1 in self.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: FR = X.function_ring()
sage: FR.one()
1

sage: M = Manifold(2, 'M', structure='topological', field=Qp(5))
sage: X.<x,y> = M.chart()
sage: X.function_ring().one()
1 + O(5^20)
zero()

Return the constant function 0 in self.

EXAMPLES:

sage: M = Manifold(2, 'M', structure='topological')
sage: X.<x,y> = M.chart()
sage: FR = X.function_ring()
sage: FR.zero()
0

sage: M = Manifold(2, 'M', structure='topological', field=Qp(5))
sage: X.<x,y> = M.chart()
sage: X.function_ring().zero()
0