def __init__(self, tensor, embedding, screen=None):
r"""
TESTS::
sage: M = Manifold(4, 'M', structure="Lorentzian")
sage: X.<t,x,y,z> = M.chart()
sage: S = Manifold(3, 'S', ambient=M, structure='degenerate_metric')
sage: X_S.<u,v,w> = S.chart()
sage: Phi = S.diff_map(M, {(X_S, X): [u, u, v, w]},
....: name='Phi', latex_name=r'\Phi');
sage: Phi_inv = M.diff_map(S, {(X, X_S): [x,y, z]}, name='Phi_inv',
....: latex_name=r'\Phi^{-1}');
sage: S.set_immersion(Phi, inverse=Phi_inv); S.declare_embedding()
sage: g = M.metric()
sage: g[0,0], g[1,1], g[2,2], g[3,3] = -1,1,1,1
sage: v = M.vector_field(); v[1] = 1
sage: S.set_transverse(rigging=v)
sage: xi = M.vector_field(); xi[0] = 1; xi[1] = 1
sage: U = M.vector_field(); U[2] = 1; V = M.vector_field(); V[3] = 1
sage: Sc = S.screen('Sc', (U,V), xi);
sage: T1 = M.tensor_field(1,1).along(Phi); T1[0,0] = 1
sage: from sage.manifolds.differentiable.degenerate_submanifold import TangentTensor
sage: T2 = TangentTensor(T1, Phi); T2
Tensor field of type (1,1) along the degenerate hypersurface S embedded in
4-dimensional differentiable manifold M with values on the 4-dimensional
Lorentzian manifold M
"""
if not isinstance(tensor, TensorField):
raise TypeError("the second argument must be a tensor field")
self._tensor = tensor
self._tensor.set_name(tensor._name, latex_name=tensor._latex_name)
self._embedding = embedding
try:
tensor = tensor.along(embedding)
except ValueError:
pass
if isinstance(tensor, TensorFieldParal):
TensorFieldParal.__init__(self, tensor._vmodule, tensor._tensor_type, name=tensor._name,
latex_name=tensor._latex_name, sym=tensor._sym, antisym=tensor._antisym)
else:
TensorField.__init__(self, tensor._vmodule, tensor._tensor_type, name=tensor._name,
latex_name=tensor._latex_name, sym=tensor._sym, antisym=tensor._antisym)
f = tensor._domain._ambient.default_frame().along(embedding)
self[f, :] = tensor[f, :]
frame = self._domain.adapted_frame(screen)
self.display(frame)
for i in self._domain._ambient.index_generator(tensor.tensor_rank()):
for j in range(len(i)):
if i[j]==self._domain._ambient._dim-self._domain._sindex-1:
self[frame, i] = 0
def __init__(self,
vector_field_module,
name=None,
latex_name=None,
is_identity=False):
r"""
Construct a field of tangent-space automorphisms.
TESTS:
Construction via ``parent.element_class``, and not via a direct call
to ``AutomorphismFieldParal``, to fit with the category framework::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart() # makes M parallelizable
sage: XM = M.vector_field_module()
sage: GL = XM.general_linear_group()
sage: a = GL.element_class(XM, name='a'); a
Field of tangent-space automorphisms a on the 2-dimensional
differentiable manifold M
sage: a[:] = [[1+x^2, x*y], [0, 1+y^2]]
sage: a.parent()
General linear group of the Free module X(M) of vector fields on
the 2-dimensional differentiable manifold M
sage: a.parent() is M.automorphism_field_group()
True
sage: TestSuite(a).run()
Construction of the field of identity maps::
sage: b = GL.element_class(XM, is_identity=True); b
Field of tangent-space identity maps on the 2-dimensional
differentiable manifold M
sage: b[:]
[1 0]
[0 1]
sage: TestSuite(b).run()
"""
FreeModuleAutomorphism.__init__(self,
vector_field_module,
name=name,
latex_name=latex_name,
is_identity=is_identity)
# TensorFieldParal attributes:
self._vmodule = vector_field_module
self._domain = vector_field_module._domain
self._ambient_domain = vector_field_module._ambient_domain
self._extensions_graph = {self._domain: self}
self._restrictions_graph = {self._domain: self}
# Initialization of derived quantities:
TensorFieldParal._init_derived(self)
def _init_derived(self):
r"""
Initialize the derived quantities of ``self``.
TESTS::
sage: M = Manifold(3, 'M')
sage: X.<x,y,z> = M.chart() # makes M parallelizable
sage: a = M.diff_form(2, name='a')
sage: a._init_derived()
"""
TensorFieldParal._init_derived(self)
def _init_derived(self):
r"""
Initialize the derived quantities of ``self``.
TESTS::
sage: M = Manifold(3, 'M')
sage: X.<x,y,z> = M.chart() # makes M parallelizable
sage: a = M.diff_form(2, name='a')
sage: a._init_derived()
"""
TensorFieldParal._init_derived(self)
def __call__(self, *args):
r"""
Redefinition of
:meth:`~sage.tensor.modules.free_module_tensor.FreeModuleTensor.__call__`
to allow for domain treatment.
TESTS::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart()
sage: a = M.diff_form(2, name='a')
sage: a[0,1] = x*y
sage: a.display()
a = x*y dx/\dy
sage: u = M.vector_field(name='u')
sage: u[:] = [1+x, 2-y]
sage: v = M.vector_field(name='v')
sage: v[:] = [-y, x]
sage: s = a.__call__(u,v); s
Scalar field a(u,v) on the 2-dimensional differentiable manifold M
sage: s.display()
a(u,v): M --> R
(x, y) |--> -x*y^3 + 2*x*y^2 + (x^3 + x^2)*y
sage: s == a[[0,1]]*(u[[0]]*v[[1]] -u[[1]]*v[[0]])
True
sage: s == a(u,v) # indirect doctest
True
"""
return TensorFieldParal.__call__(self, *args)
def __call__(self, *args):
r"""
Redefinition of
:meth:`~sage.tensor.modules.free_module_tensor.FreeModuleTensor.__call__`
to allow for domain treatment.
TESTS::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart()
sage: a = M.diff_form(2, name='a')
sage: a[0,1] = x*y
sage: a.display()
a = x*y dx/\dy
sage: u = M.vector_field(name='u')
sage: u[:] = [1+x, 2-y]
sage: v = M.vector_field(name='v')
sage: v[:] = [-y, x]
sage: s = a.__call__(u,v); s
Scalar field a(u,v) on the 2-dimensional differentiable manifold M
sage: s.display()
a(u,v): M --> R
(x, y) |--> -x*y^3 + 2*x*y^2 + (x^3 + x^2)*y
sage: s == a[[0,1]]*(u[[0]]*v[[1]] -u[[1]]*v[[0]])
True
sage: s == a(u,v) # indirect doctest
True
"""
return TensorFieldParal.__call__(self, *args)
def __init__(self, vector_field_module, name=None, latex_name=None,
is_identity=False):
r"""
Construct a field of tangent-space automorphisms.
TESTS:
Construction via ``parent.element_class``, and not via a direct call
to ``AutomorphismFieldParal``, to fit with the category framework::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart() # makes M parallelizable
sage: XM = M.vector_field_module()
sage: GL = XM.general_linear_group()
sage: a = GL.element_class(XM, name='a'); a
Field of tangent-space automorphisms a on the 2-dimensional
differentiable manifold M
sage: a[:] = [[1+x^2, x*y], [0, 1+y^2]]
sage: a.parent()
General linear group of the Free module X(M) of vector fields on
the 2-dimensional differentiable manifold M
sage: a.parent() is M.automorphism_field_group()
True
sage: TestSuite(a).run()
Construction of the field of identity maps::
sage: b = GL.element_class(XM, is_identity=True); b
Field of tangent-space identity maps on the 2-dimensional
differentiable manifold M
sage: b[:]
[1 0]
[0 1]
sage: TestSuite(b).run()
"""
FreeModuleAutomorphism.__init__(self, vector_field_module,
name=name, latex_name=latex_name,
is_identity=is_identity)
# TensorFieldParal attributes:
self._vmodule = vector_field_module
self._domain = vector_field_module._domain
self._ambient_domain = vector_field_module._ambient_domain
self._extensions_graph = {self._domain: self}
self._restrictions_graph = {self._domain: self}
# Initialization of derived quantities:
TensorFieldParal._init_derived(self)
def __init__(self, vector_field_module, name=None, latex_name=None):
r"""
Construct a vector field with values on a parallelizable manifold.
TESTS:
Construction via ``parent.element_class``, and not via a direct call
to ``VectorFieldParal``, to fit with the category framework::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart() # makes M parallelizable
sage: XM = M.vector_field_module() # the parent
sage: v = XM.element_class(XM, name='v'); v
Vector field v on the 2-dimensional differentiable manifold M
sage: v[:] = (-y, x)
sage: v.display()
v = -y d/dx + x d/dy
sage: TestSuite(v).run()
Construction via ``DifferentiableManifold.vector_field``::
sage: u = M.vector_field(name='u'); u
Vector field u on the 2-dimensional differentiable manifold M
sage: type(u) == type(v)
True
sage: u.parent() is v.parent()
True
sage: u[:] = (1+x, 1-y)
sage: TestSuite(u).run()
"""
FiniteRankFreeModuleElement.__init__(self,
vector_field_module,
name=name,
latex_name=latex_name)
# TensorFieldParal attributes:
self._domain = vector_field_module._domain
self._ambient_domain = vector_field_module._ambient_domain
# VectorField attributes:
self._vmodule = vector_field_module
# Initialization of derived quantities:
TensorFieldParal._init_derived(self)
VectorField._init_derived(self)
# Initialization of list of quantities depending on self:
self._init_dependencies()
def _del_derived(self, del_restrictions=True):
r"""
Delete the derived quantities.
INPUT:
- ``del_restrictions`` -- (default: ``True``) determines whether the
restrictions of ``self`` to subdomains are deleted
TEST::
sage: M = Manifold(3, 'M')
sage: X.<x,y,z> = M.chart() # makes M parallelizable
sage: a = M.diff_form(2, name='a')
sage: a._del_derived()
"""
TensorFieldParal._del_derived(self, del_restrictions=del_restrictions)
self.exterior_derivative.clear_cache()
def _del_derived(self, del_restrictions=True):
r"""
Delete the derived quantities.
INPUT:
- ``del_restrictions`` -- (default: ``True``) determines whether the
restrictions of ``self`` to subdomains are deleted
TESTS::
sage: M = Manifold(3, 'M')
sage: X.<x,y,z> = M.chart() # makes M parallelizable
sage: a = M.diff_form(2, name='a')
sage: a._del_derived()
"""
TensorFieldParal._del_derived(self, del_restrictions=del_restrictions)
self.exterior_derivative.clear_cache()
def __init__(self, vector_field_module, name=None, latex_name=None):
r"""
Construct a vector field with values on a parallelizable manifold.
TESTS:
Construction via ``parent.element_class``, and not via a direct call
to ``VectorFieldParal``, to fit with the category framework::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart() # makes M parallelizable
sage: XM = M.vector_field_module() # the parent
sage: v = XM.element_class(XM, name='v'); v
Vector field v on the 2-dimensional differentiable manifold M
sage: v[:] = (-y, x)
sage: v.display()
v = -y d/dx + x d/dy
sage: TestSuite(v).run()
Construction via ``DifferentiableManifold.vector_field``::
sage: u = M.vector_field(name='u'); u
Vector field u on the 2-dimensional differentiable manifold M
sage: type(u) == type(v)
True
sage: u.parent() is v.parent()
True
sage: u[:] = (1+x, 1-y)
sage: TestSuite(u).run()
"""
FiniteRankFreeModuleElement.__init__(self, vector_field_module,
name=name, latex_name=latex_name)
# TensorFieldParal attributes:
self._domain = vector_field_module._domain
self._ambient_domain = vector_field_module._ambient_domain
# VectorField attributes:
self._vmodule = vector_field_module
# Initialization of derived quantities:
TensorFieldParal._init_derived(self)
VectorField._init_derived(self)
# Initialization of list of quantities depending on self:
self._init_dependencies()
def _del_derived(self, del_restrictions=True):
r"""
Delete the derived quantities.
INPUT:
- ``del_restrictions`` -- (default: ``True``) determines whether the
restrictions of ``self`` to subdomains are deleted.
TESTS::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart()
sage: a = M.automorphism_field(name='a')
sage: a._del_derived()
"""
# Delete the derived quantities pertaining to the mother classes:
FreeModuleAutomorphism._del_derived(self)
TensorFieldParal._del_derived(self, del_restrictions=del_restrictions)
def _del_derived(self, del_restrictions=True):
r"""
Delete the derived quantities.
INPUT:
- ``del_restrictions`` -- (default: ``True``) determines whether
the restrictions of ``self`` to subdomains are deleted
TESTS::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart() # makes M parallelizable
sage: v = M.vector_field(name='v')
sage: v._del_derived()
"""
TensorFieldParal._del_derived(self, del_restrictions=del_restrictions)
VectorField._del_derived(self)
self._del_dependencies()
def _del_derived(self, del_restrictions=True):
r"""
Delete the derived quantities.
INPUT:
- ``del_restrictions`` -- (default: ``True``) determines whether the
restrictions of ``self`` to subdomains are deleted.
TESTS::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart()
sage: a = M.automorphism_field(name='a')
sage: a._del_derived()
"""
# Delete the derived quantities pertaining to the mother classes:
FreeModuleAutomorphism._del_derived(self)
TensorFieldParal._del_derived(self, del_restrictions=del_restrictions)
def _del_derived(self, del_restrictions=True):
r"""
Delete the derived quantities.
INPUT:
- ``del_restrictions`` -- (default: ``True``) determines whether
the restrictions of ``self`` to subdomains are deleted
TESTS::
sage: M = Manifold(2, 'M')
sage: X.<x,y> = M.chart() # makes M parallelizable
sage: v = M.vector_field(name='v')
sage: v._del_derived()
"""
TensorFieldParal._del_derived(self, del_restrictions=del_restrictions)
VectorField._del_derived(self)
self._del_dependencies()
def restrict(self, subdomain, dest_map=None):
r"""
Return the restriction of ``self`` to some subset of its domain.
If such restriction has not been defined yet, it is constructed here.
This is a redefinition of
:meth:`sage.manifolds.differentiable.tensorfield_paral.TensorFieldParal.restrict`
to take into account the identity map.
INPUT:
- ``subdomain`` --
:class:`~sage.manifolds.differentiable.manifold.DifferentiableManifold`;
open subset `V` of ``self._domain``
- ``dest_map`` -- (default: ``None``)
:class:`~sage.manifolds.differentiable.diff_map.DiffMap`
destination map `\Phi:\ V \rightarrow N`, where `N` is a subset of
``self._codomain``; if ``None``, the restriction of
``self.base_module().destination_map()`` to `V` is used
OUTPUT:
- a :class:`AutomorphismFieldParal` representing the restriction
EXAMPLES:
Restriction of an automorphism field defined on `\RR^2` to a disk::
sage: M = Manifold(2, 'R^2')
sage: c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
sage: D = M.open_subset('D') # the unit open disc
sage: c_cart_D = c_cart.restrict(D, x^2+y^2<1)
sage: a = M.automorphism_field(name='a') ; a
Field of tangent-space automorphisms a on the 2-dimensional
differentiable manifold R^2
sage: a[:] = [[1, x*y], [0, 3]]
sage: a.restrict(D)
Field of tangent-space automorphisms a on the Open subset D of the
2-dimensional differentiable manifold R^2
sage: a.restrict(D)[:]
[ 1 x*y]
[ 0 3]
Restriction to the disk of the field of tangent-space identity maps::
sage: id = M.tangent_identity_field() ; id
Field of tangent-space identity maps on the 2-dimensional
differentiable manifold R^2
sage: id.restrict(D)
Field of tangent-space identity maps on the Open subset D of the
2-dimensional differentiable manifold R^2
sage: id.restrict(D)[:]
[1 0]
[0 1]
sage: id.restrict(D) == D.tangent_identity_field()
True
"""
if subdomain == self._domain:
return self
if subdomain not in self._restrictions:
if not self._is_identity:
return TensorFieldParal.restrict(self, subdomain,
dest_map=dest_map)
# Special case of the identity map:
if not subdomain.is_subset(self._domain):
raise ValueError("the provided domain is not a subset of " +
"the field's domain.")
if dest_map is None:
dest_map = self._fmodule._dest_map.restrict(subdomain)
elif not dest_map._codomain.is_subset(self._ambient_domain):
raise ValueError("the argument 'dest_map' is not compatible " +
"with the ambient domain of " +
"the {}".format(self))
smodule = subdomain.vector_field_module(dest_map=dest_map)
self._restrictions[subdomain] = smodule.identity_map()
return self._restrictions[subdomain]
def restrict(self, subdomain, dest_map=None):
r"""
Return the restriction of ``self`` to some subset of its domain.
If such restriction has not been defined yet, it is constructed here.
This is a redefinition of
:meth:`sage.manifolds.differentiable.tensorfield_paral.TensorFieldParal.restrict`
to take into account the identity map.
INPUT:
- ``subdomain`` --
:class:`~sage.manifolds.differentiable.manifold.DifferentiableManifold`;
open subset `V` of ``self._domain``
- ``dest_map`` -- (default: ``None``)
:class:`~sage.manifolds.differentiable.diff_map.DiffMap`
destination map `\Phi:\ V \rightarrow N`, where `N` is a subset of
``self._codomain``; if ``None``, the restriction of
``self.base_module().destination_map()`` to `V` is used
OUTPUT:
- a :class:`AutomorphismFieldParal` representing the restriction
EXAMPLES:
Restriction of an automorphism field defined on `\RR^2` to a disk::
sage: M = Manifold(2, 'R^2')
sage: c_cart.<x,y> = M.chart() # Cartesian coordinates on R^2
sage: D = M.open_subset('D') # the unit open disc
sage: c_cart_D = c_cart.restrict(D, x^2+y^2<1)
sage: a = M.automorphism_field(name='a') ; a
Field of tangent-space automorphisms a on the 2-dimensional
differentiable manifold R^2
sage: a[:] = [[1, x*y], [0, 3]]
sage: a.restrict(D)
Field of tangent-space automorphisms a on the Open subset D of the
2-dimensional differentiable manifold R^2
sage: a.restrict(D)[:]
[ 1 x*y]
[ 0 3]
Restriction to the disk of the field of tangent-space identity maps::
sage: id = M.tangent_identity_field() ; id
Field of tangent-space identity maps on the 2-dimensional
differentiable manifold R^2
sage: id.restrict(D)
Field of tangent-space identity maps on the Open subset D of the
2-dimensional differentiable manifold R^2
sage: id.restrict(D)[:]
[1 0]
[0 1]
sage: id.restrict(D) == D.tangent_identity_field()
True
"""
if subdomain == self._domain:
return self
if subdomain not in self._restrictions:
if not self._is_identity:
return TensorFieldParal.restrict(self, subdomain,
dest_map=dest_map)
# Special case of the identity map:
if not subdomain.is_subset(self._domain):
raise ValueError("the provided domain is not a subset of " +
"the field's domain.")
if dest_map is None:
dest_map = self._fmodule._dest_map.restrict(subdomain)
elif not dest_map._codomain.is_subset(self._ambient_domain):
raise ValueError("the argument 'dest_map' is not compatible " +
"with the ambient domain of " +
"the {}".format(self))
smodule = subdomain.vector_field_module(dest_map=dest_map)
self._restrictions[subdomain] = smodule.identity_map()
return self._restrictions[subdomain]