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:

a CoordFunctionSymb

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:

a CoordFunctionSymb representing the partial derivative $\frac{\partial f}{\partial x^i}$

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:

symbolic expression involving the chart coordinates

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

Symbolic Coordinate Functions¶

Previous topic

Next topic

This Page