# 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{split}\begin{array}{cccc} f:& V \subset K^n & \longrightarrow & K \\ & (x^1, \ldots, x^n) & \longmapsto & f(x^1, \ldots, x^n) \end{array}\end{split}$

This module implements symbolic coordinate functions via the class CoordFunctionSymb.

AUTHORS:

class sage.manifolds.coord_func_symb.CoordFunctionSymb(parent, expression)

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{split}\begin{array}{llcl} f:& V \subset K^n & \longrightarrow & K \\ & (x^1, \ldots, x^n) & \longmapsto & f(x^1, \ldots, x^n), \end{array}\end{split}$

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 involves diff:

sage: g = function('g')(x, y)
sage: f0(x,y) = diff(g, x) + diff(g, y)
sage: f0
(x, y) |--> diff(g(x, y), x) + diff(g(x, y), 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} \ \frac{\partial}{\partial x}g\left(x, y\right) + \frac{\partial}{\partial y}g\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 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 the standard symbolic notation by changing the options:

sage: Manifold.options.textbook_output=False
sage: latex(f)
\frac{\partial}{\partial x}g\left(x, y\right) + \frac{\partial}{\partial y}g\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_trivial_zero()

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 is_zero() and the direct comparison to zero involve some simplification algorithms and return True:

sage: f.is_zero()
True
sage: f == 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 + abs(x)
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
-x
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)

Ring of all symbolic coordinate functions on a chart.

INPUT:

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

characteristic()

Return the characteristic of the function ring.

This is the characteristic of the base ring.

EXAMPLES:

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

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