Degenerate manifolds

class sage.manifolds.differentiable.degenerate.DegenerateManifold(n, name, metric_name=None, signature=None, base_manifold=None, diff_degree=+Infinity, latex_name=None, metric_latex_name=None, start_index=0, category=None, unique_tag=None)[source]

Bases: DifferentiableManifold

Degenerate Manifolds

A degenerate manifold (or a null manifold) is a pair \((M,g)\) where \(M\) is a real differentiable manifold (see DifferentiableManifold) and \(g\) is a field of degenerate symmetric bilinear forms on \(M\) (see DegenerateMetric).

INPUT:

  • n – positive integer; dimension of the manifold

  • name – string; name (symbol) given to the manifold

  • metric_name – (default: None) string; name (symbol) given to the metric; if None, 'g' is used

  • signature – (default: None) signature \(S\) of the metric as a tuple: \(S = (n_+, n_-, n_0)\), where \(n_+\) (resp. \(n_-\), resp. \(n_0\)) is the number of positive terms (resp. negative terms, resp. zero tems) in any diagonal writing of the metric components; if signature is not provided, \(S\) is set to \((ndim-1, 0, 1)\), being \(ndim\) the manifold’s dimension

  • ambient – (default: None) if not None, must be a differentiable manifold; the created object is then an open subset of ambient

  • diff_degree – (default: infinity) degree \(k\) of differentiability

  • latex_name – (default: None) string; LaTeX symbol to denote the manifold; if none is provided, it is set to name

  • metric_latex_name – (default: None) string; LaTeX symbol to denote the metric; if none is provided, it is set to metric_name

  • start_index – (default: 0) integer; lower value of the range of indices used for “indexed objects” on the manifold, e.g. coordinates in a chart

  • category – (default: None) to specify the category; if None, Manifolds(RR).Differentiable() (or Manifolds(RR).Smooth() if diff_degree = infinity) is assumed (see the category Manifolds)

  • unique_tag – (default: None) tag used to force the construction of a new object when all the other arguments have been used previously (without unique_tag, the UniqueRepresentation behavior inherited from ManifoldSubset, via DifferentiableManifold and TopologicalManifold, would return the previously constructed object corresponding to these arguments).

EXAMPLES:

A degenerate manifold is constructed via the generic function Manifold(), using the keyword structure:

sage: M = Manifold(3, 'M', structure='degenerate_metric')
sage: M
3-dimensional degenerate_metric manifold M
sage: M.parent()
<class 'sage.manifolds.differentiable.degenerate.DegenerateManifold_with_category'>

>>> from sage.all import *
>>> M = Manifold(Integer(3), 'M', structure='degenerate_metric')
>>> M
3-dimensional degenerate_metric manifold M
>>> M.parent()
<class 'sage.manifolds.differentiable.degenerate.DegenerateManifold_with_category'>

The metric associated with M is:

sage: g = M.metric()
sage: g
degenerate metric g on the 3-dimensional degenerate_metric manifold M
sage: g.signature()
(0, 2, 1)

>>> from sage.all import *
>>> g = M.metric()
>>> g
degenerate metric g on the 3-dimensional degenerate_metric manifold M
>>> g.signature()
(0, 2, 1)

Its value has to be initialized either by setting its components in various vector frames (see the above examples regarding the 2-sphere and Minkowski spacetime) or by making it equal to a given field of symmetric bilinear forms (see the method set() of the metric class). Both methods are also covered in the documentation of method metric() below.

REFERENCES:

metric(name=None, signature=None, latex_name=None, dest_map=None)[source]

Return the metric giving the null manifold structure to the manifold, or define a new metric tensor on the manifold.

INPUT:

  • name – (default: None) name given to the metric; if name is None or matches the name of the metric defining the null manifold structure of self, the latter metric is returned

  • signature – (default: None; ignored if name is None) signature \(S\) of the metric as a tuple: \(S = (n_+, n_-, n_0)\), where \(n_+\) (resp. \(n_-\), resp. \(n_0\)) is the number of positive terms (resp. negative terms, resp. zero tems) in any diagonal writing of the metric components; if signature is not provided, \(S\) is set to \((ndim-1, 0, 1)\), being \(ndim\) the manifold’s dimension

  • latex_name – (default: None; ignored if name is None) LaTeX symbol to denote the metric; if None, it is formed from name

  • dest_map – (default: None; ignored if name is None) instance of class DiffMap representing the destination map \(\Phi:\ U \rightarrow M\), where \(U\) is the current manifold; if None, the identity map is assumed (case of a metric tensor field on \(U\))

OUTPUT:

EXAMPLES:

Metric of a 3-dimensional degenerate manifold:

sage: M = Manifold(3, 'M', structure='degenerate_metric', start_index=1)
sage: X.<x,y,z> = M.chart()
sage: g = M.metric(); g
degenerate metric g on the 3-dimensional degenerate_metric manifold M

>>> from sage.all import *
>>> M = Manifold(Integer(3), 'M', structure='degenerate_metric', start_index=Integer(1))
>>> X = M.chart(names=('x', 'y', 'z',)); (x, y, z,) = X._first_ngens(3)
>>> g = M.metric(); g
degenerate metric g on the 3-dimensional degenerate_metric manifold M

The metric remains to be initialized, for instance by setting its components in the coordinate frame associated to the chart X:

sage: g[1,1], g[2,2] = -1, 1
sage: g.display()
g = -dx⊗dx + dy⊗dy
sage: g[:]
[-1  0  0]
[ 0  1  0]
[ 0  0  0]

>>> from sage.all import *
>>> g[Integer(1),Integer(1)], g[Integer(2),Integer(2)] = -Integer(1), Integer(1)
>>> g.display()
g = -dx⊗dx + dy⊗dy
>>> g[:]
[-1  0  0]
[ 0  1  0]
[ 0  0  0]

Alternatively, the metric can be initialized from a given field of degenerate symmetric bilinear forms; we may create the former object by:

sage: X.coframe()
Coordinate coframe (M, (dx,dy,dz))
sage: dx, dy = X.coframe()[1], X.coframe()[2]
sage: b = dx*dx + dy*dy
sage: b
Field of symmetric bilinear forms dx⊗dx+dy⊗dy on the 3-dimensional
degenerate_metric manifold M

>>> from sage.all import *
>>> X.coframe()
Coordinate coframe (M, (dx,dy,dz))
>>> dx, dy = X.coframe()[Integer(1)], X.coframe()[Integer(2)]
>>> b = dx*dx + dy*dy
>>> b
Field of symmetric bilinear forms dx⊗dx+dy⊗dy on the 3-dimensional
degenerate_metric manifold M

We then use the metric method set() to make g being equal to b as a symmetric tensor field of type (0,2):

sage: g.set(b)
sage: g.display()
g = dx⊗dx + dy⊗dy

>>> from sage.all import *
>>> g.set(b)
>>> g.display()
g = dx⊗dx + dy⊗dy

Another metric can be defined on M by specifying a metric name distinct from that chosen at the creation of the manifold (which is g by default, but can be changed thanks to the keyword metric_name in Manifold()):

sage: h = M.metric('h'); h
degenerate metric h on the 3-dimensional degenerate_metric manifold M
sage: h[1,1], h[2,2], h[3,3] = 1+y^2, 1+z^2, 1+x^2
sage: h.display()
h = (y^2 + 1) dx⊗dx + (z^2 + 1) dy⊗dy + (x^2 + 1) dz⊗dz

>>> from sage.all import *
>>> h = M.metric('h'); h
degenerate metric h on the 3-dimensional degenerate_metric manifold M
>>> h[Integer(1),Integer(1)], h[Integer(2),Integer(2)], h[Integer(3),Integer(3)] = Integer(1)+y**Integer(2), Integer(1)+z**Integer(2), Integer(1)+x**Integer(2)
>>> h.display()
h = (y^2 + 1) dx⊗dx + (z^2 + 1) dy⊗dy + (x^2 + 1) dz⊗dz

The metric tensor h is distinct from the metric entering in the definition of the degenerate manifold M:

sage: h is M.metric()
False

>>> from sage.all import *
>>> h is M.metric()
False

while we have of course:

sage: g is M.metric()
True

>>> from sage.all import *
>>> g is M.metric()
True

Providing the same name as the manifold’s default metric returns the latter:

sage: M.metric('g') is M.metric()
True

>>> from sage.all import *
>>> M.metric('g') is M.metric()
True
open_subset(name, latex_name=None, coord_def={})[source]

Create an open subset of self.

An open subset is a set that is (i) included in the manifold and (ii) open with respect to the manifold’s topology. It is a differentiable manifold by itself. Moreover, equipped with the restriction of the manifold metric to itself, it is a null manifold. Hence the returned object is an instance of DegenerateManifold.

INPUT:

  • name – name given to the open subset

  • latex_name – (default: None) LaTeX symbol to denote the subset; if none is provided, it is set to name

  • coord_def – (default: {}) definition of the subset in terms of coordinates; coord_def must a be dictionary with keys charts in the manifold’s atlas and values the symbolic expressions formed by the coordinates to define the subset.

OUTPUT:

EXAMPLES:

Open subset of a 3-dimensional degenerate manifold:

sage: M = Manifold(3, 'M', structure='degenerate_metric', start_index=1)
sage: X.<x,y,z> = M.chart()
sage: U = M.open_subset('U', coord_def={X: [x>0, y>0]}); U
Open subset U of the 3-dimensional degenerate_metric manifold M
sage: type(U)
<class 'sage.manifolds.differentiable.degenerate.DegenerateManifold_with_category'>

>>> from sage.all import *
>>> M = Manifold(Integer(3), 'M', structure='degenerate_metric', start_index=Integer(1))
>>> X = M.chart(names=('x', 'y', 'z',)); (x, y, z,) = X._first_ngens(3)
>>> U = M.open_subset('U', coord_def={X: [x>Integer(0), y>Integer(0)]}); U
Open subset U of the 3-dimensional degenerate_metric manifold M
>>> type(U)
<class 'sage.manifolds.differentiable.degenerate.DegenerateManifold_with_category'>

We initialize the metric of M:

sage: g = M.metric()
sage: g[1,1], g[2,2] = -1, 1

>>> from sage.all import *
>>> g = M.metric()
>>> g[Integer(1),Integer(1)], g[Integer(2),Integer(2)] = -Integer(1), Integer(1)

Then the metric on U is determined as the restriction of g to U:

sage: gU = U.metric(); gU
degenerate metric g on the Open subset U of the 3-dimensional
degenerate_metric manifold M
sage: gU.display()
g = -dx⊗dx + dy⊗dy
sage: gU is g.restrict(U)
True

>>> from sage.all import *
>>> gU = U.metric(); gU
degenerate metric g on the Open subset U of the 3-dimensional
degenerate_metric manifold M
>>> gU.display()
g = -dx⊗dx + dy⊗dy
>>> gU is g.restrict(U)
True
class sage.manifolds.differentiable.degenerate.TangentTensor(tensor, embedding, screen=None)[source]

Bases: TensorFieldParal

Let S be a lightlike submanifold embedded in a pseudo-Riemannian manifold (M,g) with Phi the embedding map. Let T1 be a tensor on M along S or not. TangentTensor(T1, Phi) returns the restriction T2 of T1 along S that in addition can be applied only on vector fields tangent to S, when T1 has a covariant part.

INPUT:

  • tensor – a tensor field on the ambient manifold

  • embedding – the embedding map Phi

EXAMPLES:

Section of the lightcone of the Minkowski space with a hyperplane passing through the origin:

sage: M = Manifold(4, 'M', structure='Lorentzian')
sage: X.<t,x,y,z> = M.chart()
sage: S = Manifold(2, 'S', ambient=M, structure='degenerate_metric')
sage: X_S.<u,v> = S.chart()
sage: Phi = S.diff_map(M, {(X_S, X): [sqrt(u^2+v^2), u, v, 0]},
....:                  name='Phi', latex_name=r'\Phi')
sage: Phi_inv = M.diff_map(S, {(X, X_S): [x, y]}, 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(0,0,0,1)
sage: S.set_transverse(rigging=t, normal=V)
sage: xi = M.vector_field(sqrt(x^2+y^2+z^2), x, y, 0)
sage: U = M.vector_field(0, -y, x, 0)
sage: Sc = S.screen('Sc', U, xi);
sage: T1 = M.tensor_field(1,1).along(Phi); T1[0,0] = 1
sage: V1 = M.vector_field().along(Phi); V1[0] = 1; V1[1]=1
sage: T1(V1).display()
∂/∂t
sage: from sage.manifolds.differentiable.degenerate_submanifold import TangentTensor
sage: T2 = TangentTensor(T1, Phi)
sage: T2
Tensor field of type (1,1) along the 2-dimensional degenerate
 submanifold S embedded in 4-dimensional differentiable manifold M
 with values on the 4-dimensional Lorentzian manifold M
sage: V2 = S.projection(V1)
sage: T2(V2).display()
u/sqrt(u^2 + v^2) ∂/∂t

>>> from sage.all import *
>>> M = Manifold(Integer(4), 'M', structure='Lorentzian')
>>> X = M.chart(names=('t', 'x', 'y', 'z',)); (t, x, y, z,) = X._first_ngens(4)
>>> S = Manifold(Integer(2), 'S', ambient=M, structure='degenerate_metric')
>>> X_S = S.chart(names=('u', 'v',)); (u, v,) = X_S._first_ngens(2)
>>> Phi = S.diff_map(M, {(X_S, X): [sqrt(u**Integer(2)+v**Integer(2)), u, v, Integer(0)]},
...                  name='Phi', latex_name=r'\Phi')
>>> Phi_inv = M.diff_map(S, {(X, X_S): [x, y]}, name='Phi_inv',
...                      latex_name=r'\Phi^{-1}')
>>> S.set_immersion(Phi, inverse=Phi_inv); S.declare_embedding()
>>> g = M.metric()
>>> g[Integer(0),Integer(0)], g[Integer(1),Integer(1)], g[Integer(2),Integer(2)], g[Integer(3),Integer(3)] = -Integer(1), Integer(1), Integer(1), Integer(1)
>>> V = M.vector_field(Integer(0),Integer(0),Integer(0),Integer(1))
>>> S.set_transverse(rigging=t, normal=V)
>>> xi = M.vector_field(sqrt(x**Integer(2)+y**Integer(2)+z**Integer(2)), x, y, Integer(0))
>>> U = M.vector_field(Integer(0), -y, x, Integer(0))
>>> Sc = S.screen('Sc', U, xi);
>>> T1 = M.tensor_field(Integer(1),Integer(1)).along(Phi); T1[Integer(0),Integer(0)] = Integer(1)
>>> V1 = M.vector_field().along(Phi); V1[Integer(0)] = Integer(1); V1[Integer(1)]=Integer(1)
>>> T1(V1).display()
∂/∂t
>>> from sage.manifolds.differentiable.degenerate_submanifold import TangentTensor
>>> T2 = TangentTensor(T1, Phi)
>>> T2
Tensor field of type (1,1) along the 2-dimensional degenerate
 submanifold S embedded in 4-dimensional differentiable manifold M
 with values on the 4-dimensional Lorentzian manifold M
>>> V2 = S.projection(V1)
>>> T2(V2).display()
u/sqrt(u^2 + v^2) ∂/∂t

Of course \(T1\) and \(T2\) give the same output on vector fields tangent to S:

sage: T1(xi.along(Phi)).display()
sqrt(u^2 + v^2) ∂/∂t
sage: T2(xi.along(Phi)).display()
sqrt(u^2 + v^2) ∂/∂t

>>> from sage.all import *
>>> T1(xi.along(Phi)).display()
sqrt(u^2 + v^2) ∂/∂t
>>> T2(xi.along(Phi)).display()
sqrt(u^2 + v^2) ∂/∂t
extension()[source]

Return initial tensor

EXAMPLES:

Section of the lightcone of the Minkowski space with a hyperplane passing through the origin:

sage: M = Manifold(4, 'M', structure='Lorentzian')
sage: X.<t,x,y,z> = M.chart()
sage: S = Manifold(2, 'S', ambient=M, structure='degenerate_metric')
sage: X_S.<u,v> = S.chart()
sage: Phi = S.diff_map(M, {(X_S, X): [sqrt(u^2+v^2), u, v, 0]},
....:               name='Phi', latex_name=r'\Phi')
sage: Phi_inv = M.diff_map(S, {(X, X_S): [x, y]}, 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[3] = 1
sage: S.set_transverse(rigging=t, normal=V)
sage: xi = M.vector_field(); xi[0] = sqrt(x^2+y^2+z^2); xi[1] = x; xi[2] = y
sage: U = M.vector_field(); U[1] = -y; U[2] = x
sage: Sc = S.screen('Sc', U, 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); T3 = T2.extension()
sage: T3 is T2
False
sage: T3 is T1
True

>>> from sage.all import *
>>> M = Manifold(Integer(4), 'M', structure='Lorentzian')
>>> X = M.chart(names=('t', 'x', 'y', 'z',)); (t, x, y, z,) = X._first_ngens(4)
>>> S = Manifold(Integer(2), 'S', ambient=M, structure='degenerate_metric')
>>> X_S = S.chart(names=('u', 'v',)); (u, v,) = X_S._first_ngens(2)
>>> Phi = S.diff_map(M, {(X_S, X): [sqrt(u**Integer(2)+v**Integer(2)), u, v, Integer(0)]},
...               name='Phi', latex_name=r'\Phi')
>>> Phi_inv = M.diff_map(S, {(X, X_S): [x, y]}, name='Phi_inv',
...                       latex_name=r'\Phi^{-1}')
>>> S.set_immersion(Phi, inverse=Phi_inv); S.declare_embedding()
>>> g = M.metric()
>>> g[Integer(0),Integer(0)], g[Integer(1),Integer(1)], g[Integer(2),Integer(2)], g[Integer(3),Integer(3)] = -Integer(1),Integer(1),Integer(1),Integer(1)
>>> V = M.vector_field(); V[Integer(3)] = Integer(1)
>>> S.set_transverse(rigging=t, normal=V)
>>> xi = M.vector_field(); xi[Integer(0)] = sqrt(x**Integer(2)+y**Integer(2)+z**Integer(2)); xi[Integer(1)] = x; xi[Integer(2)] = y
>>> U = M.vector_field(); U[Integer(1)] = -y; U[Integer(2)] = x
>>> Sc = S.screen('Sc', U, xi);
>>> T1 = M.tensor_field(Integer(1),Integer(1)).along(Phi); T1[Integer(0),Integer(0)] = Integer(1)
>>> from sage.manifolds.differentiable.degenerate_submanifold import TangentTensor
>>> T2 = TangentTensor(T1, Phi); T3 = T2.extension()
>>> T3 is T2
False
>>> T3 is T1
True