Coverage for local/lib/python2.7/site-packages/sage/manifolds/differentiable/diff_map.py : 83%
Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
|
r""" Differentiable Maps between Differentiable Manifolds
The class :class:`DiffMap` implements differentiable maps from a differentiable manifold `M` to a differentiable manifold `N` over the same topological field `K` as `M` (in most applications, `K = \RR` or `K = \CC`):
.. MATH::
\Phi: M \longrightarrow N
AUTHORS:
- Eric Gourgoulhon, Michal Bejger (2013-2015): initial version
REFERENCES:
- Chap. 1 of [KN1963]_ - Chaps. 2 and 3 of [Lee2013]_
"""
#***************************************************************************** # Copyright (C) 2015 Eric Gourgoulhon <eric.gourgoulhon@obspm.fr> # Copyright (C) 2015 Michal Bejger <bejger@camk.edu.pl> # # Distributed under the terms of the GNU General Public License (GPL) # as published by the Free Software Foundation; either version 2 of # the License, or (at your option) any later version. # http://www.gnu.org/licenses/ #*****************************************************************************
r""" Differentiable map between two differentiable manifolds.
This class implements differentiable maps of the type
.. MATH::
\Phi: M \longrightarrow N
where `M` and `N` are differentiable manifolds over the same topological field `K` (in most applications, `K = \RR` or `K = \CC`).
Differentiable maps are the *morphisms* of the *category* of differentiable manifolds. The set of all differentiable maps from `M` to `N` is therefore the homset between `M` and `N`, which is denoted by `\mathrm{Hom}(M,N)`.
The class :class:`DiffMap` is a Sage *element* class, whose *parent* class is :class:`~sage.manifolds.differentiable.manifold_homset.DifferentiableManifoldHomset`. It inherits from the class :class:`~sage.manifolds.continuous_map.ContinuousMap` since a differentiable map is obviously a continuous one.
INPUT:
- ``parent`` -- homset `\mathrm{Hom}(M,N)` to which the differentiable map belongs - ``coord_functions`` -- (default: ``None``) if not ``None``, must be a dictionary of the coordinate expressions (as lists (or tuples) of the coordinates of the image expressed in terms of the coordinates of the considered point) with the pairs of charts (chart1, chart2) as keys (chart1 being a chart on `M` and chart2 a chart on `N`). If the dimension of the map's codomain is 1, a single coordinate expression can be passed instead of a tuple with a single element - ``name`` -- (default: ``None``) name given to the differentiable map - ``latex_name`` -- (default: ``None``) LaTeX symbol to denote the differentiable map; if ``None``, the LaTeX symbol is set to ``name`` - ``is_isomorphism`` -- (default: ``False``) determines whether the constructed object is a isomorphism (i.e. a diffeomorphism); if set to ``True``, then the manifolds `M` and `N` must have the same dimension. - ``is_identity`` -- (default: ``False``) determines whether the constructed object is the identity map; if set to ``True``, then `N` must be `M` and the entry ``coord_functions`` is not used.
.. NOTE::
If the information passed by means of the argument ``coord_functions`` is not sufficient to fully specify the differentiable map, further coordinate expressions, in other charts, can be subsequently added by means of the method :meth:`~sage.manifolds.continuous_map.ContinuousMap.add_expr`
EXAMPLES:
The standard embedding of the sphere `S^2` into `\RR^3`::
sage: M = Manifold(2, 'S^2') # the 2-dimensional sphere S^2 sage: U = M.open_subset('U') # complement of the North pole sage: c_xy.<x,y> = U.chart() # stereographic coordinates from the North pole sage: V = M.open_subset('V') # complement of the South pole sage: c_uv.<u,v> = V.chart() # stereographic coordinates from the South pole sage: M.declare_union(U,V) # S^2 is the union of U and V sage: xy_to_uv = c_xy.transition_map(c_uv, (x/(x^2+y^2), y/(x^2+y^2)), ....: intersection_name='W', restrictions1= x^2+y^2!=0, ....: restrictions2= u^2+v^2!=0) sage: uv_to_xy = xy_to_uv.inverse() sage: N = Manifold(3, 'R^3', r'\RR^3') # R^3 sage: c_cart.<X,Y,Z> = N.chart() # Cartesian coordinates on R^3 sage: Phi = M.diff_map(N, ....: {(c_xy, c_cart): [2*x/(1+x^2+y^2), 2*y/(1+x^2+y^2), (x^2+y^2-1)/(1+x^2+y^2)], ....: (c_uv, c_cart): [2*u/(1+u^2+v^2), 2*v/(1+u^2+v^2), (1-u^2-v^2)/(1+u^2+v^2)]}, ....: name='Phi', latex_name=r'\Phi') sage: Phi Differentiable map Phi from the 2-dimensional differentiable manifold S^2 to the 3-dimensional differentiable manifold R^3 sage: Phi.parent() Set of Morphisms from 2-dimensional differentiable manifold S^2 to 3-dimensional differentiable manifold R^3 in Category of smooth manifolds over Real Field with 53 bits of precision sage: Phi.parent() is Hom(M, N) True sage: type(Phi) <class 'sage.manifolds.differentiable.manifold_homset.DifferentiableManifoldHomset_with_category.element_class'> sage: Phi.display() Phi: S^2 --> R^3 on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1)) on V: (u, v) |--> (X, Y, Z) = (2*u/(u^2 + v^2 + 1), 2*v/(u^2 + v^2 + 1), -(u^2 + v^2 - 1)/(u^2 + v^2 + 1))
It is possible to create the map via the method :meth:`~sage.manifolds.differentiable.manifold.DifferentiableManifold.diff_map` only in a single pair of charts: the argument ``coord_functions`` is then a mere list of coordinate expressions (and not a dictionary) and the arguments ``chart1`` and ``chart2`` have to be provided if the charts differ from the default ones on the domain and/or the codomain::
sage: Phi1 = M.diff_map(N, [2*x/(1+x^2+y^2), 2*y/(1+x^2+y^2), ....: (x^2+y^2-1)/(1+x^2+y^2)], ....: chart1=c_xy, chart2=c_cart, name='Phi', ....: latex_name=r'\Phi')
Since ``c_xy`` and ``c_cart`` are the default charts on respectively ``M`` and ``N``, they can be omitted, so that the above declaration is equivalent to::
sage: Phi1 = M.diff_map(N, [2*x/(1+x^2+y^2), 2*y/(1+x^2+y^2), ....: (x^2+y^2-1)/(1+x^2+y^2)], ....: name='Phi', latex_name=r'\Phi')
With such a declaration, the differentiable map is only partially defined on the manifold `S^2`, being known in only one chart::
sage: Phi1.display() Phi: S^2 --> R^3 on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1))
The definition can be completed by means of the method :meth:`~sage.manifolds.continuous_map.ContinuousMap.add_expr`::
sage: Phi1.add_expr(c_uv, c_cart, [2*u/(1+u^2+v^2), 2*v/(1+u^2+v^2), ....: (1-u^2-v^2)/(1+u^2+v^2)]) sage: Phi1.display() Phi: S^2 --> R^3 on U: (x, y) |--> (X, Y, Z) = (2*x/(x^2 + y^2 + 1), 2*y/(x^2 + y^2 + 1), (x^2 + y^2 - 1)/(x^2 + y^2 + 1)) on V: (u, v) |--> (X, Y, Z) = (2*u/(u^2 + v^2 + 1), 2*v/(u^2 + v^2 + 1), -(u^2 + v^2 - 1)/(u^2 + v^2 + 1))
At this stage, ``Phi1`` and ``Phi`` are fully equivalent::
sage: Phi1 == Phi True
The test suite is passed::
sage: TestSuite(Phi).run() sage: TestSuite(Phi1).run()
The map acts on points::
sage: np = M.point((0,0), chart=c_uv, name='N') # the North pole sage: Phi(np) Point Phi(N) on the 3-dimensional differentiable manifold R^3 sage: Phi(np).coord() # Cartesian coordinates (0, 0, 1) sage: sp = M.point((0,0), chart=c_xy, name='S') # the South pole sage: Phi(sp).coord() # Cartesian coordinates (0, 0, -1)
The differential `\mathrm{d}\Phi` of the map `\Phi` at the North pole and at the South pole::
sage: Phi.differential(np) Generic morphism: From: Tangent space at Point N on the 2-dimensional differentiable manifold S^2 To: Tangent space at Point Phi(N) on the 3-dimensional differentiable manifold R^3 sage: Phi.differential(sp) Generic morphism: From: Tangent space at Point S on the 2-dimensional differentiable manifold S^2 To: Tangent space at Point Phi(S) on the 3-dimensional differentiable manifold R^3
The matrix of the linear map `\mathrm{d}\Phi_N` with respect to the default bases of `T_N S^2` and `T_{\Phi(N)} \RR^3`::
sage: Phi.differential(np).matrix() [2 0] [0 2] [0 0]
the default bases being::
sage: Phi.differential(np).domain().default_basis() Basis (d/du,d/dv) on the Tangent space at Point N on the 2-dimensional differentiable manifold S^2 sage: Phi.differential(np).codomain().default_basis() Basis (d/dX,d/dY,d/dZ) on the Tangent space at Point Phi(N) on the 3-dimensional differentiable manifold R^3
Differentiable maps can be composed by means of the operator ``*``: let us introduce the map `\RR^3\rightarrow \RR^2` corresponding to the projection from the point `(X,Y,Z)=(0,0,1)` onto the equatorial plane `Z=0`::
sage: P = Manifold(2, 'R^2', r'\RR^2') # R^2 (equatorial plane) sage: cP.<xP, yP> = P.chart() sage: Psi = N.diff_map(P, (X/(1-Z), Y/(1-Z)), name='Psi', ....: latex_name=r'\Psi') sage: Psi Differentiable map Psi from the 3-dimensional differentiable manifold R^3 to the 2-dimensional differentiable manifold R^2 sage: Psi.display() Psi: R^3 --> R^2 (X, Y, Z) |--> (xP, yP) = (-X/(Z - 1), -Y/(Z - 1))
Then we compose ``Psi`` with ``Phi``, thereby getting a map `S^2\rightarrow \RR^2`::
sage: ster = Psi*Phi ; ster Differentiable map from the 2-dimensional differentiable manifold S^2 to the 2-dimensional differentiable manifold R^2
Let us test on the South pole (``sp``) that ``ster`` is indeed the composite of ``Psi`` and ``Phi``::
sage: ster(sp) == Psi(Phi(sp)) True
Actually ``ster`` is the stereographic projection from the North pole, as its coordinate expression reveals::
sage: ster.display() S^2 --> R^2 on U: (x, y) |--> (xP, yP) = (x, y) on V: (u, v) |--> (xP, yP) = (u/(u^2 + v^2), v/(u^2 + v^2))
If its codomain is 1-dimensional, a differentiable map must be defined by a single symbolic expression for each pair of charts, and not by a list/tuple with a single element::
sage: N = Manifold(1, 'N') sage: c_N = N.chart('X') sage: Phi = M.diff_map(N, {(c_xy, c_N): x^2+y^2, ....: (c_uv, c_N): 1/(u^2+v^2)}) # not ...[1/(u^2+v^2)] or (1/(u^2+v^2),)
An example of differentiable map `\RR \rightarrow \RR^2`::
sage: R = Manifold(1, 'R') # field R sage: T.<t> = R.chart() # canonical chart on R sage: R2 = Manifold(2, 'R^2') # R^2 sage: c_xy.<x,y> = R2.chart() # Cartesian coordinates on R^2 sage: Phi = R.diff_map(R2, [cos(t), sin(t)], name='Phi') ; Phi Differentiable map Phi from the 1-dimensional differentiable manifold R to the 2-dimensional differentiable manifold R^2 sage: Phi.parent() Set of Morphisms from 1-dimensional differentiable manifold R to 2-dimensional differentiable manifold R^2 in Category of smooth manifolds over Real Field with 53 bits of precision sage: Phi.parent() is Hom(R, R2) True sage: Phi.display() Phi: R --> R^2 t |--> (x, y) = (cos(t), sin(t))
An example of diffeomorphism between the unit open disk and the Euclidean plane `\RR^2`::
sage: D = R2.open_subset('D', coord_def={c_xy: x^2+y^2<1}) # the open unit disk sage: Phi = D.diffeomorphism(R2, [x/sqrt(1-x^2-y^2), y/sqrt(1-x^2-y^2)], ....: name='Phi', latex_name=r'\Phi') sage: Phi Diffeomorphism Phi from the Open subset D of the 2-dimensional differentiable manifold R^2 to the 2-dimensional differentiable manifold R^2 sage: Phi.parent() Set of Morphisms from Open subset D of the 2-dimensional differentiable manifold R^2 to 2-dimensional differentiable manifold R^2 in Join of Category of subobjects of sets and Category of smooth manifolds over Real Field with 53 bits of precision sage: Phi.parent() is Hom(D, R2) True sage: Phi.display() Phi: D --> R^2 (x, y) |--> (x, y) = (x/sqrt(-x^2 - y^2 + 1), y/sqrt(-x^2 - y^2 + 1))
The image of a point::
sage: p = D.point((1/2,0)) sage: q = Phi(p) ; q Point on the 2-dimensional differentiable manifold R^2 sage: q.coord() (1/3*sqrt(3), 0)
The inverse diffeomorphism is computed by means of the method :meth:`~sage.manifolds.continuous_map.ContinuousMap.inverse`::
sage: Phi.inverse() Diffeomorphism Phi^(-1) from the 2-dimensional differentiable manifold R^2 to the Open subset D of the 2-dimensional differentiable manifold R^2 sage: Phi.inverse().display() Phi^(-1): R^2 --> D (x, y) |--> (x, y) = (x/sqrt(x^2 + y^2 + 1), y/sqrt(x^2 + y^2 + 1))
Equivalently, one may use the notations ``^(-1)`` or ``~`` to get the inverse::
sage: Phi^(-1) is Phi.inverse() True sage: ~Phi is Phi.inverse() True
Check that ``~Phi`` is indeed the inverse of ``Phi``::
sage: (~Phi)(q) == p True sage: Phi * ~Phi == R2.identity_map() True sage: ~Phi * Phi == D.identity_map() True
The coordinate expression of the inverse diffeomorphism::
sage: (~Phi).display() Phi^(-1): R^2 --> D (x, y) |--> (x, y) = (x/sqrt(x^2 + y^2 + 1), y/sqrt(x^2 + y^2 + 1))
A special case of diffeomorphism: the identity map of the open unit disk::
sage: id = D.identity_map() ; id Identity map Id_D of the Open subset D of the 2-dimensional differentiable manifold R^2 sage: latex(id) \mathrm{Id}_{D} sage: id.parent() Set of Morphisms from Open subset D of the 2-dimensional differentiable manifold R^2 to Open subset D of the 2-dimensional differentiable manifold R^2 in Join of Category of subobjects of sets and Category of smooth manifolds over Real Field with 53 bits of precision sage: id.parent() is Hom(D, D) True sage: id is Hom(D,D).one() # the identity element of the monoid Hom(D,D) True
The identity map acting on a point::
sage: id(p) Point on the 2-dimensional differentiable manifold R^2 sage: id(p) == p True sage: id(p) is p True
The coordinate expression of the identity map::
sage: id.display() Id_D: D --> D (x, y) |--> (x, y)
The identity map is its own inverse::
sage: id^(-1) is id True sage: ~id is id True
""" latex_name=None, is_isomorphism=False, is_identity=False): r""" Construct a differentiable map.
TESTS::
sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: N = Manifold(3, 'N') sage: Y.<u,v,w> = N.chart() sage: f = Hom(M,N)({(X,Y): (x+y, x*y, x-y)}, name='f') ; f Differentiable map f from the 2-dimensional differentiable manifold M to the 3-dimensional differentiable manifold N sage: f.display() f: M --> N (x, y) |--> (u, v, w) = (x + y, x*y, x - y) sage: TestSuite(f).run()
The identity map::
sage: f = Hom(M,M)({}, is_identity=True) ; f Identity map Id_M of the 2-dimensional differentiable manifold M sage: f.display() Id_M: M --> M (x, y) |--> (x, y) sage: TestSuite(f).run()
""" name=name, latex_name=latex_name, is_isomorphism=is_isomorphism, is_identity=is_identity)
# # SageObject methods #
r""" String representation of the object.
TESTS::
sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: N = Manifold(2, 'N') sage: Y.<u,v> = N.chart() sage: f = Hom(M,N)({(X,Y): (x+y,x*y)}) sage: f._repr_() 'Differentiable map from the 2-dimensional differentiable manifold M to the 2-dimensional differentiable manifold N' sage: f = Hom(M,N)({(X,Y): (x+y,x*y)}, name='f') sage: f._repr_() 'Differentiable map f from the 2-dimensional differentiable manifold M to the 2-dimensional differentiable manifold N' sage: f = Hom(M,N)({(X,Y): (x+y,x-y)}, name='f', is_isomorphism=True) sage: f._repr_() 'Diffeomorphism f from the 2-dimensional differentiable manifold M to the 2-dimensional differentiable manifold N' sage: f = Hom(M,M)({(X,X): (x+y,x-y)}, name='f', is_isomorphism=True) sage: f._repr_() 'Diffeomorphism f of the 2-dimensional differentiable manifold M' sage: f = Hom(M,M)({}, name='f', is_identity=True) sage: f._repr_() 'Identity map f of the 2-dimensional differentiable manifold M'
""" " of the {}".format(self._domain) else: else: else: self._codomain)
r""" Initialize the derived quantities.
TESTS::
sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: f = M.diffeomorphism(M, [x+y, x-y]) sage: f._init_derived() sage: f._restrictions {} sage: f._inverse
""" # class # keys: pair of charts
r""" Delete the derived quantities.
TESTS::
sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: f = M.diffeomorphism(M, [x+y, x-y]) sage: f^(-1) Diffeomorphism of the 2-dimensional differentiable manifold M sage: f._inverse # was set by f^(-1) Diffeomorphism of the 2-dimensional differentiable manifold M sage: f._del_derived() sage: f._inverse # has been set to None by _del_derived()
""" # class
r""" Return the differential of ``self`` at a given point.
If the differentiable map ``self`` is
.. MATH::
\Phi: M \longrightarrow N,
where `M` and `N` are differentiable manifolds, the *differential* of `\Phi` at a point `p \in M` is the tangent space linear map:
.. MATH::
\mathrm{d}\Phi_p: T_p M \longrightarrow T_{\Phi(p)} N
defined by
.. MATH::
\begin{array}{rccc} \forall v\in T_p M,\quad \mathrm{d}\Phi_p(v) : & C^k(N) & \longrightarrow & \mathbb{R} \\ & f & \longmapsto & v(f\circ \Phi) \end{array}
INPUT:
- ``point`` -- point `p` in the domain `M` of the differentiable map `\Phi`
OUTPUT:
- `\mathrm{d}\Phi_p`, the differential of `\Phi` at `p`, as a :class:`~sage.tensor.modules.free_module_morphism.FiniteRankFreeModuleMorphism`
EXAMPLES:
Differential of a differentiable map between a 2-dimensional manifold and a 3-dimensional one::
sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: N = Manifold(3, 'N') sage: Y.<u,v,w> = N.chart() sage: Phi = M.diff_map(N, {(X,Y): (x-2*y, x*y, x^2-y^3)}, name='Phi', ....: latex_name = r'\Phi') sage: p = M.point((2,-1), name='p') sage: dPhip = Phi.differential(p) ; dPhip Generic morphism: From: Tangent space at Point p on the 2-dimensional differentiable manifold M To: Tangent space at Point Phi(p) on the 3-dimensional differentiable manifold N sage: latex(dPhip) {\mathrm{d}\Phi}_{p} sage: dPhip.parent() Set of Morphisms from Tangent space at Point p on the 2-dimensional differentiable manifold M to Tangent space at Point Phi(p) on the 3-dimensional differentiable manifold N in Category of finite dimensional vector spaces over Symbolic Ring
The matrix of `\mathrm{d}\Phi_p` w.r.t. to the default bases of `T_p M` and `T_{\Phi(p)} N`::
sage: dPhip.matrix() [ 1 -2] [-1 2] [ 4 -3]
""" # Search for a common chart to perform the computation
# 1/ Search without any extra computation else: # 2/ Search with a coordinate transformation on the point chartp = chart_pair
# 3/ Search with a coordinate evaluation of self except ValueError: pass
raise ValueError("no common chart have been found for the " + "coordinate expressions of {} and {}".format(self, point))
for i in range(n2)] else: name = None point._latex_name) else: latex_name = None name=name, latex_name=latex_name)
r""" Return the coordinate expression of the differential of the differentiable map with respect to a pair of charts.
If the differentiable map is
.. MATH::
\Phi: M \longrightarrow N,
where `M` and `N` are differentiable manifolds, the *differential* of `\Phi` at a point `p \in M` is the tangent space linear map:
.. MATH::
\mathrm{d}\Phi_p: T_p M \longrightarrow T_{\Phi(p)} N
defined by
.. MATH::
\begin{array}{rccc} \forall v\in T_p M,\quad \mathrm{d}\Phi_p(v) : & C^k(N) & \longrightarrow & \mathbb{R}, \\ & f & \longmapsto & v(f\circ \Phi). \end{array}
If the coordinate expression of `\Phi` is
.. MATH::
y^i = Y^i(x^1, \ldots, x^n), \quad 1 \leq i \leq m,
where `(x^1, \ldots, x^n)` are coordinates of a chart on `M` and `(y^1, \ldots, y^m)` are coordinates of a chart on `\Phi(M)`, the expression of the differential of `\Phi` with respect to these coordinates is
.. MATH::
J_{ij} = \frac{\partial Y^i}{\partial x^j} \quad 1\leq i \leq m, \qquad 1 \leq j \leq n.
`\left. J_{ij} \right|_p` is then the matrix of the linear map `\mathrm{d}\Phi_p` with respect to the bases of `T_p M` and `T_{\Phi(p)} N` associated to the above charts:
.. MATH::
\mathrm{d}\Phi_p\left( \left. \frac{\partial}{\partial x^j} \right|_p \right) = \left. J_{ij} \right|_p \; \left. \frac{\partial}{\partial y^i} \right| _{\Phi(p)}.
INPUT:
- ``chart1`` -- (default: ``None``) chart on the domain `M` of `\Phi` (coordinates denoted by `(x^j)` above); if ``None``, the domain's default chart is assumed - ``chart2`` -- (default: ``None``) chart on the codomain of `\Phi` (coordinates denoted by `(y^i)` above); if ``None``, the codomain's default chart is assumed
OUTPUT:
- the functions `J_{ij}` as a double array, `J_{ij}` being the element ``[i][j]`` represented by a :class:`~sage.manifolds.chart_func.ChartFunction`
To get symbolic expressions, use the method :meth:`jacobian_matrix` instead.
EXAMPLES:
Differential functions of a map between a 2-dimensional manifold and a 3-dimensional one::
sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: N = Manifold(3, 'N') sage: Y.<u,v,w> = N.chart() sage: Phi = M.diff_map(N, {(X,Y): (x-2*y, x*y, x^2-y^3)}, name='Phi', ....: latex_name = r'\Phi') sage: J = Phi.differential_functions(X, Y) ; J [ 1 -2] [ y x] [ 2*x -3*y^2]
The result is cached::
sage: Phi.differential_functions(X, Y) is J True
The elements of ``J`` are functions of the coordinates of the chart ``X``::
sage: J[2][0] 2*x sage: type(J[2][0]) <class 'sage.manifolds.chart_func.ChartFunctionRing_with_category.element_class'>
sage: J[2][0].display() (x, y) |--> 2*x
In contrast, the method :meth:`jacobian_matrix` leads directly to symbolic expressions::
sage: JJ = Phi.jacobian_matrix(X,Y) ; JJ [ 1 -2] [ y x] [ 2*x -3*y^2] sage: JJ[2,0] 2*x sage: type(JJ[2,0]) <type 'sage.symbolic.expression.Expression'> sage: bool( JJ[2,0] == J[2][0].expr() ) True
""" chart1 = dom1._def_chart chart2 = dom2._def_chart
r""" Return the Jacobian matrix resulting from the coordinate expression of the differentiable map with respect to a pair of charts.
If `\Phi` is the current differentiable map and its coordinate expression is
.. MATH::
y^i = Y^i(x^1, \ldots, x^n), \quad 1 \leq i \leq m,
where `(x^1, \ldots, x^n)` are coordinates of a chart `X` on the domain of `\Phi` and `(y^1, \ldots, y^m)` are coordinates of a chart `Y` on the codomain of `\Phi`, the *Jacobian matrix* of the differentiable map `\Phi` w.r.t. to charts `X` and `Y` is
.. MATH::
J = \left( \frac{\partial Y^i}{\partial x^j} \right)_{{1 \leq i \leq m \atop 1 \leq j \leq n}},
where `i` is the row index and `j` the column one.
INPUT:
- ``chart1`` -- (default: ``None``) chart `X` on the domain of `\Phi`; if none is provided, the domain's default chart is assumed - ``chart2`` -- (default: ``None``) chart `Y` on the codomain of `\Phi`; if none is provided, the codomain's default chart is assumed
OUTPUT:
- the matrix `J` defined above
EXAMPLES:
Jacobian matrix of a map between a 2-dimensional manifold and a 3-dimensional one::
sage: M = Manifold(2, 'M') sage: X.<x,y> = M.chart() sage: N = Manifold(3, 'N') sage: Y.<u,v,w> = N.chart() sage: Phi = M.diff_map(N, {(X,Y): (x-2*y, x*y, x^2-y^3)}, name='Phi', ....: latex_name = r'\Phi') sage: Phi.display() Phi: M --> N (x, y) |--> (u, v, w) = (x - 2*y, x*y, -y^3 + x^2) sage: J = Phi.jacobian_matrix(X, Y) ; J [ 1 -2] [ y x] [ 2*x -3*y^2] sage: J.parent() Full MatrixSpace of 3 by 2 dense matrices over Symbolic Ring
""" for i in range(n2)])
r""" Pullback operator associated with ``self``.
In what follows, let `\Phi` denote a differentiable map, `M` its domain and `N` its codomain.
INPUT:
- ``tensor`` -- :class:`~sage.manifolds.differentiable.tensorfield.TensorField`; a fully covariant tensor field `T` on `N`, i.e. a tensor field of type `(0, p)`, with `p` a positive or zero integer; the case `p = 0` corresponds to a scalar field
OUTPUT:
- a :class:`~sage.manifolds.differentiable.tensorfield.TensorField` representing a fully covariant tensor field on `M` that is the pullback of `T` by `\Phi`
EXAMPLES:
Pullback on `S^2` of a scalar field defined on `R^3`::
sage: M = Manifold(2, 'S^2', start_index=1) sage: U = M.open_subset('U') # the complement of a meridian (domain of spherical coordinates) sage: c_spher.<th,ph> = U.chart(r'th:(0,pi):\theta ph:(0,2*pi):\phi') # spherical coord. on U sage: N = Manifold(3, 'R^3', r'\RR^3', start_index=1) sage: c_cart.<x,y,z> = N.chart() # Cartesian coord. on R^3 sage: Phi = U.diff_map(N, (sin(th)*cos(ph), sin(th)*sin(ph), cos(th)), ....: name='Phi', latex_name=r'\Phi') sage: f = N.scalar_field(x*y*z, name='f') ; f Scalar field f on the 3-dimensional differentiable manifold R^3 sage: f.display() f: R^3 --> R (x, y, z) |--> x*y*z sage: pf = Phi.pullback(f) ; pf Scalar field Phi_*(f) on the Open subset U of the 2-dimensional differentiable manifold S^2 sage: pf.display() Phi_*(f): U --> R (th, ph) |--> cos(ph)*cos(th)*sin(ph)*sin(th)^2
Pullback on `S^2` of the standard Euclidean metric on `R^3`::
sage: g = N.sym_bilin_form_field('g') sage: g[1,1], g[2,2], g[3,3] = 1, 1, 1 sage: g.display() g = dx*dx + dy*dy + dz*dz sage: pg = Phi.pullback(g) ; pg Field of symmetric bilinear forms Phi_*(g) on the Open subset U of the 2-dimensional differentiable manifold S^2 sage: pg.display() Phi_*(g) = dth*dth + sin(th)^2 dph*dph
Pullback on `S^2` of a 3-form on `R^3`::
sage: a = N.diff_form(3, 'A') sage: a[1,2,3] = f sage: a.display() A = x*y*z dx/\dy/\dz sage: pa = Phi.pullback(a) ; pa 3-form Phi_*(A) on the Open subset U of the 2-dimensional differentiable manifold S^2 sage: pa.display() # should be zero (as any 3-form on a 2-dimensional manifold) Phi_*(A) = 0
""" CompFullySym, CompFullyAntiSym)
r""" Helper function performing the pullback on chart domains only.
INPUT:
- ``diff_map`` -- a restriction of ``self``, whose both domain and codomain are chart domains - ``tensor`` -- a covariant tensor field, whose domain is the codomain of ``diff_map``
OUTPUT:
- the pull back of ``tensor`` by ``diff_map``
""" tensor._latex_name is not None): tensor._latex_name latex_name=resu_latex_name, sym=tensor._sym, antisym=tensor._antisym) diff_map._coord_expression): # Computation at the component level: start_index=si1, output_formatter=of1) start_index=si1, output_formatter=of1) elif isinstance(tcomp, CompWithSym): ptcomp = CompWithSym(ring1, frame1, ncov, start_index=si1, output_formatter=of1, sym=tcomp.sym, antisym=tcomp.antisym) else: ptcomp = Components(ring1, frame1, ncov, start_index=si1, output_formatter=of1) # X2 coordinates expressed in terms of # X1 ones via the diff. map: # End of function _pullback_chart
# Special case of the identity map: return tensor # no test for efficiency # Generic case: raise ValueError("the tensor field is not defined on the map codomain") raise TypeError("the pullback cannot be taken on a tensor " + "with some contravariant part") tensor._latex_name # Case of a scalar field dom_resu = dom_resu.union(fc.parent()._chart._domain) latex_name=resu_latex_name) else: # Case of tensor field of rank >= 1 raise TypeError("the pullback is defined only for tensor " + "fields on {}".format(dom2)) dom_resu = dom_resu.union(rst._domain) latex_name=resu_latex_name, sym=resu_rst[0]._sym, antisym=resu_rst[0]._antisym) resu._restrictions[rst._domain] = rst
r""" Pushforward operator associated with ``self``.
In what follows, let `\Phi` denote the differentiable map, `M` its domain and `N` its codomain.
INPUT:
- ``tensor`` -- :class:`~sage.manifolds.differentiable.tensorfield.TensorField`; a fully contrariant tensor field `T` on `M`, i.e. a tensor field of type `(p, 0)`, with `p` a positive integer
OUTPUT:
- a :class:`~sage.manifolds.differentiable.tensorfield.TensorField` representing a fully contravariant tensor field along `M` with values in `N`, which is the pushforward of `T` by `\Phi`
EXAMPLES:
Pushforward of a vector field on the 2-sphere `S^2` to the Euclidean 3-space `\RR^3`, via the standard embedding of `S^2`::
sage: S2 = Manifold(2, 'S^2', start_index=1) sage: U = S2.open_subset('U') # domain of spherical coordinates sage: spher.<th,ph> = U.chart(r'th:(0,pi):\theta ph:(0,2*pi):\phi') sage: R3 = Manifold(3, 'R^3', start_index=1) sage: cart.<x,y,z> = R3.chart() sage: Phi = U.diff_map(R3, {(spher, cart): [sin(th)*cos(ph), ....: sin(th)*sin(ph), cos(th)]}, name='Phi', latex_name=r'\Phi') sage: v = U.vector_field(name='v') sage: v[:] = 0, 1 sage: v.display() v = d/dph sage: pv = Phi.pushforward(v); pv Vector field Phi^*(v) along the Open subset U of the 2-dimensional differentiable manifold S^2 with values on the 3-dimensional differentiable manifold R^3 sage: pv.display() Phi^*(v) = -sin(ph)*sin(th) d/dx + cos(ph)*sin(th) d/dy
Pushforward of a vector field on the real line to the `\RR^3`, via a helix embedding::
sage: R.<t> = RealLine() sage: Psi = R.diff_map(R3, [cos(t), sin(t), t], name='Psi', ....: latex_name=r'\Psi') sage: u = R.vector_field(name='u') sage: u[0] = 1 sage: u.display() u = d/dt sage: pu = Psi.pushforward(u); pu Vector field Psi^*(u) along the Real number line R with values on the 3-dimensional differentiable manifold R^3 sage: pu.display() Psi^*(u) = -sin(t) d/dx + cos(t) d/dy + d/dz
""" CompFullySym, CompFullyAntiSym) raise ValueError("the {} does not take its ".format(tensor) + "values on the domain of the {}".format(self)) raise ValueError("the pushforward cannot be taken on a tensor " + "with some covariant part") raise ValueError("the pushforward cannot be taken on a scalar " + "field") raise NotImplementedError("the case of a non-trivial destination" + " map is not implemented yet") raise NotImplementedError("the case of a non-parallelizable " + "domain is not implemented yet") # A pair of charts (chart1, chart2) where the computation # is feasable is searched, privileging the default chart of the # map's domain for chart1 and (def_chart1, def_chart2) in self._coord_expression): else: for (chart1n, chart2n) in self._coord_expression: if (chart2n == def_chart2 and chart1n._frame in tensor._components): chart1 = chart1n chart2 = def_chart2 break # It is not possible to have def_chart2 as chart for # expressing the result; any other chart is then looked for: for (chart1n, chart2n) in self._coord_expression: if chart1n._frame in tensor._components: chart1 = chart1n chart2 = chart2n break # Computations of components are attempted chart1 = dom1.default_chart() tensor.comp(chart1.frame()) for chart2n in self._codomain.atlas(): try: self.coord_functions(chart1, chart2n) chart2 = chart2n break except ValueError: pass else: raise ValueError("no pair of charts could be found to " + "compute the pushforward of " + "the {} by the {}".format(tensor, self)) # Vector field module for the result: # # Computation at the component level: # Construction of the pushforward components (ptcomp): ptcomp = CompFullySym(ring2, frame2, ncon, start_index=si2, output_formatter=of2) ptcomp = CompFullyAntiSym(ring2, frame2, ncon, start_index=si2, output_formatter=of2) ptcomp = CompWithSym(ring2, frame2, ncon, start_index=si2, output_formatter=of2, sym=tcomp._sym, antisym=tcomp._antisym) else: output_formatter=of2) # Computation of the pushforward components: # Name of the result: # Creation of the result with the components obtained above: latex_name=resu_latex_name) |