Spacetimeengine Save

A Python utility for analyzing a given solution to the Einstein's field equations. Built on Sympy.

Project README

alt text

A Python utility built on Sympy (A symbolic mathematics library) which will analyze any given metric solution to the Einstein field equations.

$G_{\mu\nu} + \Lambda g_{\mu\nu} = \frac{8\pi G}{c^4}T_{\mu\nu}$

Prerequisites (Linux)

1.) Install Python3

$ sudo apt install python3

2.) Install pip3

$ sudo apt install python3-pip

3.) Install git

$ sudo apt-get install git

Prerequisites (MacOS)

1.) Install homebrew

$ ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" brew doctor

2.) Set python as an enviornmental varible.

$ export PATH="/usr/local/opt/python/libexec/bin:$PATH"

2.) Install git

$ brew install git

3.) Install python3 and pip3 (https://docs.python-guide.org/starting/install3/osx/)

$ brew install python3
$ brew postinstall python3

Prerequisites (Windows)

1.) Install Python3 & pip3

Navigate to https://www.python.org/downloads/

3.) Install git

Navigate to https://gitforwindows.org/

Installation with pip3

1.) Install with pip3

$ pip3 install spacetimeengine

2.) Enter python shell

$ python3

3.) Import spacetimeengine

>> from spacetimeengine import *

4.) Create a SpaceTime object which describes the Schwarzschild spacetime

>> schwarzschild_spacetime = SpaceTime(Solution().schwarzschild())

5.) Enjoy watching the coefficients get computed.

Installation with git

1.) Clone repository

$ git clone https://github.com/spacetimeengineer/spacetimeengine

2.) Enter directory

$ cd spacetimeengine/spacetimeengine/samples

3.) Run example.py

$ python3 example.py

Suggested Use

If you are a student or researcher, and you find yourself reading a publication based in General Relativity which provides metric solutions, then this utility can be used for working out the curvature coefficients which associate with the solution provided by the user. This can be a helpful utility as you read through the literature because you will be able to cross-reference the information provided by the literature with the values the spacetimeengine provides (this is why I developed it originally). More commonly, this utility can be used for error checking.

Metric Tensor

Generally speaking, any metric solution to the Einstein field equations will be packaged into a geometric object known as the metric tensor. The metric tensor is often represented in matrix form and the spacetimeengine package adopts this representation.

$g_{\mu\nu}=\begin{bmatrix} \left ( 1-\frac{2GM}{rc^{2}} \right ) & 0 & 0 & 0 \\ 0 & -\left ( 1-\frac{2GM}{rc^{2}} \right )^{-1} & 0 & 0 \\ 0 & 0 & -r^{2} & 0 \\ 0 & 0 & 0 & -r^{2}\sin^{2}\theta \end{bmatrix}$

The spacetimeengine package employs the Sympy 'Matrix' object for packaging the metric tensor and it serves as the essential parameter for constructing a 'SpaceTime' object. The Solutions module currently stores some well-known metrics for study, but these can be used for understanding how to construct new solutions.

Constructing a solution (In development)

Currently, all metric solutions are packaged by specifying four key parameters and storing them in an array. These parameters include an index configuration for the given metric solution, the coordinates to define the metric in terms of, the metric itself, and the cosmological constant. It is important to note that a zero-valued cosmological constant indicates the employment of a classical formulation to the Einstein field equations. Below represents a valid definition of the Schwarzschild stationary black hole solution.

def schwarzschild(self):    

    # Assigns meaning to the coordinates.
    x0, x1, x2, x3 = symbols('t r theta phi')
    # Groups the coordinates in an array.
    coordinate_set = [x0, x1, x2, x3]
    
    
    # Constants required to describe the metric.
    G, M, c = symbols('G M c')
    
    
    # Metric.
    metric = Matrix([    
                        [ (1-(2*G*M)/(x1*c**2)), 0, 0, 0 ], 
                        [ 0, - (1-(2*G*M)/(x1*c**2))**(-1), 0, 0 ], 
                        [ 0, 0, - x1**2, 0 ], 
                        [ 0, 0, 0, - x1**2*sin(x2)**2 ]
                    ])
    
    # Describes the index configuration which which the metric represents.
    index_config = "dd"
    
    
    # Cosmological constant.
    cosmological_constant = 0
    
    
    # An array detailing the solution.
    solution_array = [ metric, coordinate_set, index_config, cosmological_constant ]
    
    
    # Returns solution
    return solution_array

It may be helpful to store the solutions in a separate module. I prefer to keep my solutions in a 'Solution()' class, which can be found in the 'solutions' module. To construct a 'SpaceTime' object just execute the command below, but first consider the given solution since high complexity solutions can take exponentially longer to process.

>>> spacetime = SpaceTime(Solution().schwarzschild())

The index configuration in this case is "dd" which represents a down-down configuration, which reflects a double covariant index configuration. These can be "uu", "dd", "ud", "du", but this library currently only supports certain index configurations depending on the quantity in question.

Stress-Energy-Momentum Tensor

The Einstein field equations describe the equivilence of space-time curvature to mass-energy. The mass-energy is described by the coefficents encompassed within the stress-energy-momentum tensor denoted by T_{\mu\nu}. The cosmological constant denoted by Lambda is treated as an input parameter (since it is independent of the metric in most cases) and represents the dark energy thought to be responsble for the accellerated expansion of the cosmos.

$T_{\mu \nu }={\frac {c^{4}}{8\pi G}}\left ( G_{\mu \nu }+\Lambda g_{\mu \nu } \right )$

>>> cosmological_constant = 0
>>> mu = 0 # (dt)
>>> nu = 1 # (dr)
>>> index_config = "dd"
>>> spacetime.print_stress_energy_coefficient(index_config, mu, nu, cosmological_constant)

0

Since the Schwarzschild solution is a vacuum solution, any stress energy coefficient will yield a zero.

The Einstein Tensor

The Einstein tensor denoted by $G_{\my\nu}$ desribes the curvature of spacetime and allows the Einstein field equations to be written in concise form.

$G_{\mu \nu }=R_{\mu \nu }-{\tfrac {1}{2}}Rg_{\mu \nu }$

>>> mu = 0 # (dt)
>>> nu = 1 # (dr)
>>> index_config = "dd"
>>> spacetime.print_einstein_coefficient(index_config, mu, nu)

G₀₁ = 0

Ricci Tensor

In differential geometry, the Ricci curvature tensor represents the amount by which the volume of a narrow conical piece of a small geodesic ball in a curved Riemannian manifold deviates from that of the standard ball in Euclidean space. As such, it provides one way of measuring the degree to which the geometry determined by a given Riemannian metric might differ from that of ordinary Euclidean n-space.

$R_{ij} = {R^k}_{ikj}$

>>> mu = 0 # (dt)
>>> nu = 1 # (dr)
>>> index_config = "dd"
>>> spacetime.print_ricci_coefficient(index_config, 3, 2)

R₃₂ = 0

Riemann Tensor

In the mathematical field of differential geometry, the Riemann curvature tensor is the most common method used to express the curvature of Riemannian manifolds. It assigns a tensor to each point of a Riemannian manifold (i.e., it is a tensor field), that measures the extent to which the metric tensor is not locally isometric to that of Euclidean space.

$R^\rho{}_{\sigma\mu\nu} = \partial_\mu\Gamma^\rho{}_{\nu\sigma} - \partial_\nu\Gamma^\rho{}_{\mu\sigma} + \Gamma^\rho{}_{\mu\lambda}\Gamma^\lambda{}_{\nu\sigma} - \Gamma^\rho{}_{\nu\lambda}\Gamma^\lambda{}_{\mu\sigma}$

>>> index_config = "uddd"
>>> spacetime.print_reimann_coefficient(index_config, 3, 2, 2, 3)

        -2⋅G⋅M 
R³₂₂₃ = ───────
          2    
         c ⋅x₁

$R_{ik\ell m}={\frac {1}{2}}\left({\frac {\partial ^{2}g_{im}}{\partial x^{k}\partial x^{\ell }}}+{\frac {\partial ^{2}g_{k\ell }}{\partial x^{i}\partial x^{m}}}-{\frac {\partial ^{2}g_{i\ell }}{\partial x^{k}\partial x^{m}}}-{\frac {\partial ^{2}g_{km}}{\partial x^{i}\partial x^{\ell }}}\right)+g_{np}\left(\Gamma ^{n}{}_{k\ell }\Gamma ^{p}{}_{im}-\Gamma ^{n}{}_{km}\Gamma ^{p}{}_{i\ell }\right)$

>>> spacetime.print_riemann_coefficient("dddd", 2, 0, 2, 0)

            ⎛         2  ⎞
        G⋅M⋅⎝2⋅G⋅M - c ⋅r⎠
R₂₀₂₀ = ──────────────────
               4  2       
              c ⋅r

Christoffel symbols of the First Kind

The connection coefficients or 'Christoffel symbol' are an array of numbers which represent the metric connection. The metric connection can be used to measure distances along curved manifolds. In General Relativity, the metric connection actually identifies the meaning of the gravitational field and can be used to track trajectories through spacetime.

$\Gamma _{cab}={\tfrac {1}{2}}\left({\frac {\partial g_{ca}}{\partial x^{b}}}+{\frac {\partial g_{cb}}{\partial x^{a}}}-{\frac {\partial g_{ab}}{\partial x^{c}}}\right)$

>>> spacetime.print_connection_coefficient("ddd", 1, 0, 0)

       -G⋅M 
Γ₁₀₀ = ─────
        2  2
       c ⋅r

Christoffel symbols of the Second Kind

$\Gamma ^{i}{}_{kl}={\tfrac {1}{2}}g^{im}\left({\frac {\partial g_{mk}}{\partial x^{l}}}+{\frac {\partial g_{ml}}{\partial x^{k}}}-{\frac {\partial g_{kl}}{\partial x^{m}}}\right)$

>>> index_config = "udd"
>>> spacetime.print_connection_coefficient(index_config, 1, 3, 3)

       ⎛         2   ⎞    2    
       ⎝2⋅G⋅M - c ⋅x₁⎠⋅sin (x₂)
Γ¹₃₃ = ────────────────────────
                   2           
                  c

Weyl Tensor

In differential geometry, the Weyl curvature tensor, named after Hermann Weyl, is a measure of the curvature of spacetime or, more generally, a pseudo-Riemannian manifold. Like the Riemann curvature tensor, the Weyl tensor expresses the tidal force that a body feels when moving along a geodesic. The Weyl tensor differs from the Riemann curvature tensor in that it does not convey information on how the volume of the body changes, but rather only how the shape of the body is distorted by the tidal force.

$C_{ik\ell m}=R_{ik\ell m}+{\frac {1}{n-2}}\left(R_{im}g_{k\ell }-R_{i\ell }g_{km}+R_{k\ell }g_{im}-R_{km}g_{i\ell }\right)+{\frac {1}{(n-1)(n-2)}}R\left(g_{i\ell }g_{km}-g_{im}g_{k\ell }\right),$

>>> index_config = "dddd"
>>> spacetime.print_weyl_coefficient(index_config, 3, 2, 2, 3)

                   2   
        2⋅G⋅M⋅r⋅sin (θ)
C₃₂₂₃ = ───────────────
                2      
               c

Schouten Tensor (Experimental)

$P_{ij} = \frac{1}{n-2}\left ( R_{ij} - \frac{R}{2d-2}\: g_{ij} \right )$

>>> spacetime.get_schouten_coefficient("dd",0,0)

                                2
          ⎛         2  ⎞ ⎛d    ⎞ 
      G⋅M⋅⎝2⋅G⋅M - c ⋅r⎠⋅⎜──(t)⎟ 
                         ⎝dt   ⎠ 
P₀₀ = ───────────────────────────
                  4  3           
                 c ⋅r

Geodesics parametrized by proper time (Experimental)

This is a measure of the local acceleration; that which could be measured by an accelerometer.

$\frac{d^{2}x^{\lambda}}{d\tau^{2}}+\Gamma^{\lambda}_{\mu\nu}\frac{dx^{\mu}}{d\tau}\frac{dx^{\nu}}{d\tau}=0$

>>> spacetime.print_proper_acceleration(0)

Geodesics parametrized by coordinate time (Experimental)

This is a measure of the accelleration one observers another undergoing.

$\frac{d^{2}x^{\lambda}}{dt^{2}}=\Gamma^{0}_{\mu\nu}\frac{dx^{\mu}}{dt}\frac{dx^{\nu}}{dt}\frac{dx^{\lambda}}{dt}\;-\;\Gamma^{\lambda}_{\mu\nu}\frac{dx^{\mu}}{dt}\frac{dx^{\nu}}{dt}$

>>> spacetime.print_coordinate_acceleration(0)

Geodesic deviation equation (Experimental)

This is a measure of how much two initial paralell geodesic paths will deviate or converge.

$\frac{d^{2}\xi^{\lambda}}{dt^{2}}=-\;R^{\lambda}_{\mu\nu\ell}\frac{dx^{\mu}}{dt}\frac{dx^{\nu}}{dt}\xi^{\ell}$

>>> spacetime.print_separation_geodesic_acceleration(0)

Using with Jupyter Notebook (In development)

Jupyter notebook has become very popular tool for python development in recent years. It is great for science and research and this api is no exception. In order to use with Jupyter notebook the only thing to consider is the printing system.

Buy me a cold brew

Open Source Agenda is not affiliated with "Spacetimeengine" Project. README Source: spacetimeengineer/spacetimeengine

Stars

143

Open Issues

Last Commit

1 year ago

Repository

spacetimeengineer/spacetimeengine

Open Source Agenda Badge

<a href="https://www.opensourceagenda.com/projects/spacetimeengine"><img src="https://www.opensourceagenda.com/projects/spacetimeengine/reviews/badge.svg" alt="Open Source Agenda"></a>

Submit Review Review Your Favorite Project

Submit Resource Articles, Courses, Videos

Submit Article Submit a post to our blog

From the blog

Dec 11, 2022

How to Choose Which Programming Language to Learn First?

From the blog

Dec 11, 2022