einsteinengine 0.5.0__tar.gz → 1.0.0__tar.gz

einsteinengine-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rafael Salazar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

einsteinengine-1.0.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: einsteinengine
+Version: 1.0.0
+Summary: A high-performance, object-oriented symbolic tensor engine for General Relativity.
+Author-email: Rafael Salazar <rsalazard2005@gmail.com>
+Project-URL: Homepage, https://github.com/RSalazarD/EinsteinEngine
+Project-URL: Bug Tracker, https://github.com/RSalazarD/EinsteinEngine/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sympy>=1.12
+Requires-Dist: symengine>=0.11.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Dynamic: license-file
+
+# EinsteinEngine
+
+EinsteinEngine is a symbolic tensor library for General Relativity built around a simple idea: make tensor calculations faster and more structured without giving up exact symbolic mathematics.
+
+The project combines Python with SymEngine for the heavy symbolic work, and exposes an object-oriented API for common relativistic objects such as metrics, Christoffel symbols, curvature tensors, Ricci tensors, Einstein tensors, geodesics, tetrads and spin connections.
+
+## What the library can do today
+
+EinsteinEngine currently provides a practical toolkit for symbolic GR workflows, including:
+
+- Metric tensor construction and validation
+- Metric inversion for diagonal and standard symbolic cases
+- Christoffel symbol computation
+- Riemann tensor construction
+- Ricci tensor and Ricci scalar computation
+- Einstein tensor construction
+- Geodesic equation generation
+- Tetrad and spin connection support
+- Tensor component access, contraction, index raising/lowering and basic tensor arithmetic
+- Rich LaTeX-style rendering for notebooks and a plain-text fallback for lighter output
+
+The focus of the library is not only correctness, but also performance in symbolic pipelines that would otherwise become very expensive in pure SymPy.
+
+## Installation
+
+From PyPI:
+
+```bash
+pip install einsteinengine
+```
+
+From source:
+
+```bash
+git clone https://github.com/RSalazarD/EinsteinEngine.git
+cd EinsteinEngine
+pip install -e .
+```
+
+## Quick start
+
+```python
+import sympy as sp
+from einsteinengine.symbolic.metric import MetricTensor
+from einsteinengine.symbolic.riemann import RiemannCurvatureTensor
+
+# Coordinates and parameters
+t, r, theta, phi = sp.symbols('t r theta phi', real=True)
+M = sp.symbols('M', real=True)
+
+# Schwarzschild metric
+g_schwarzschild = [
+    [-(1 - 2*M/r), 0, 0, 0],
+    [0, 1/(1 - 2*M/r), 0, 0],
+    [0, 0, r**2, 0],
+    [0, 0, 0, r**2 * sp.sin(theta)**2],
+]
+
+metric = MetricTensor(g_schwarzschild, [t, r, theta, phi], name="Schwarzschild")
+riemann = RiemannCurvatureTensor.from_metric(metric, verbose=False)
+
+print(riemann.get_component(1, 0, 1, 0))
+```
+
+A typical output for the Schwarzschild case is the known exact component:
+
+```python
+2*M*(2*M - r)/r**4
+```
+
+## Current strengths
+
+EinsteinEngine is particularly useful when you want to:
+
+- build symbolic curvature tensors from a metric,
+- test GR expressions quickly in notebooks or scripts,
+- compare symbolic performance against pure SymPy,
+- explore exact tensor structures without writing all the algebra by hand.
+
+## Benchmarks
+
+A simple benchmark script is available in the benchmarks folder to compare EinsteinEngine against pure SymPy on a representative symbolic workload.
+
+Run it from the project root with:
+
+```bash
+python benchmarks/compare_sympy_vs_einsteinengine.py
+```
+
+The script prints timing information for both engines and a rough speedup estimate.
+
+## Testing
+
+The project includes a pytest suite covering core computations such as metric handling, curvature tensors, geodesics and rendering behaviour.
+
+Run tests with:
+
+```bash
+pytest
+```
+
+## Roadmap and future directions
+
+This project is already usable for a broad set of symbolic GR tasks, but there is still room to grow. Possible future work includes:
+
+- more optimized tensor contractions and higher-rank workflows,
+- broader support for non-diagonal and more general metrics,
+- improved simplification strategies with configurable modes,
+- additional GR utilities such as more advanced invariants and field equations,
+- better documentation and more benchmark examples.
+
+The goal is to keep the library practical today while expanding toward a more complete symbolic GR toolkit over time.

einsteinengine-1.0.0/README.md

@@ -0,0 +1,112 @@
+# EinsteinEngine
+
+EinsteinEngine is a symbolic tensor library for General Relativity built around a simple idea: make tensor calculations faster and more structured without giving up exact symbolic mathematics.
+
+The project combines Python with SymEngine for the heavy symbolic work, and exposes an object-oriented API for common relativistic objects such as metrics, Christoffel symbols, curvature tensors, Ricci tensors, Einstein tensors, geodesics, tetrads and spin connections.
+
+## What the library can do today
+
+EinsteinEngine currently provides a practical toolkit for symbolic GR workflows, including:
+
+- Metric tensor construction and validation
+- Metric inversion for diagonal and standard symbolic cases
+- Christoffel symbol computation
+- Riemann tensor construction
+- Ricci tensor and Ricci scalar computation
+- Einstein tensor construction
+- Geodesic equation generation
+- Tetrad and spin connection support
+- Tensor component access, contraction, index raising/lowering and basic tensor arithmetic
+- Rich LaTeX-style rendering for notebooks and a plain-text fallback for lighter output
+
+The focus of the library is not only correctness, but also performance in symbolic pipelines that would otherwise become very expensive in pure SymPy.
+
+## Installation
+
+From PyPI:
+
+```bash
+pip install einsteinengine
+```
+
+From source:
+
+```bash
+git clone https://github.com/RSalazarD/EinsteinEngine.git
+cd EinsteinEngine
+pip install -e .
+```
+
+## Quick start
+
+```python
+import sympy as sp
+from einsteinengine.symbolic.metric import MetricTensor
+from einsteinengine.symbolic.riemann import RiemannCurvatureTensor
+
+# Coordinates and parameters
+t, r, theta, phi = sp.symbols('t r theta phi', real=True)
+M = sp.symbols('M', real=True)
+
+# Schwarzschild metric
+g_schwarzschild = [
+    [-(1 - 2*M/r), 0, 0, 0],
+    [0, 1/(1 - 2*M/r), 0, 0],
+    [0, 0, r**2, 0],
+    [0, 0, 0, r**2 * sp.sin(theta)**2],
+]
+
+metric = MetricTensor(g_schwarzschild, [t, r, theta, phi], name="Schwarzschild")
+riemann = RiemannCurvatureTensor.from_metric(metric, verbose=False)
+
+print(riemann.get_component(1, 0, 1, 0))
+```
+
+A typical output for the Schwarzschild case is the known exact component:
+
+```python
+2*M*(2*M - r)/r**4
+```
+
+## Current strengths
+
+EinsteinEngine is particularly useful when you want to:
+
+- build symbolic curvature tensors from a metric,
+- test GR expressions quickly in notebooks or scripts,
+- compare symbolic performance against pure SymPy,
+- explore exact tensor structures without writing all the algebra by hand.
+
+## Benchmarks
+
+A simple benchmark script is available in the benchmarks folder to compare EinsteinEngine against pure SymPy on a representative symbolic workload.
+
+Run it from the project root with:
+
+```bash
+python benchmarks/compare_sympy_vs_einsteinengine.py
+```
+
+The script prints timing information for both engines and a rough speedup estimate.
+
+## Testing
+
+The project includes a pytest suite covering core computations such as metric handling, curvature tensors, geodesics and rendering behaviour.
+
+Run tests with:
+
+```bash
+pytest
+```
+
+## Roadmap and future directions
+
+This project is already usable for a broad set of symbolic GR tasks, but there is still room to grow. Possible future work includes:
+
+- more optimized tensor contractions and higher-rank workflows,
+- broader support for non-diagonal and more general metrics,
+- improved simplification strategies with configurable modes,
+- additional GR utilities such as more advanced invariants and field equations,
+- better documentation and more benchmark examples.
+
+The goal is to keep the library practical today while expanding toward a more complete symbolic GR toolkit over time.

{einsteinengine-0.5.0 → einsteinengine-1.0.0}/einsteinengine/symbolic/christoffel.py

@@ -1,39 +1,39 @@
-import symengine as se
-from einsteinengine.symbolic.connection import BaseConnection
-class ChristoffelSymbols(BaseConnection):
-    """
-    Computes the Christoffel Symbols of the second kind (Gamma^lambda_{mu nu})
-    optimized via SymEngine backend processing.
-    """
-    @classmethod
-    def from_metric(cls, metric, verbose=False):
-        """
-        Computes the Christoffel Symbols of the second kind (Gamma^lambda_{mu nu})
-        optimized via SymEngine backend processing.
-        """
-        if verbose:
-            print(f"Computing Christoffel Symbols for '{metric.name}' in C++...")
-            
-        g = metric._data
-        g_inv = metric.inv()._data
-        syms = metric.syms
-        dims = metric.dims
-        
-        # Initialize a 3D grid structure for Gamma (4x4x4)
-        Gamma = [[[se.sympify(0) for _ in range(dims)] for _ in range(dims)] for _ in range(dims)]
-        
-        # Heavy-lifting partial derivative loops triggered directly in C++
-        for lambda_ in range(dims):
-            for mu in range(dims):
-                for nu in range(dims):
-                    tmp_sum = se.sympify(0)
-                    for sigma in range(dims):
-                        term1 = se.diff(g[nu][sigma], syms[mu])
-                        term2 = se.diff(g[mu][sigma], syms[nu])
-                        term3 = se.diff(g[mu][nu], syms[sigma])
-                        tmp_sum += g_inv[lambda_][sigma] * (term1 + term2 - term3)
-                    
-                    Gamma[lambda_][mu][nu] = se.Rational(1, 2) * tmp_sum
-                    
-        # Devuelve instanciando la nueva clase madre BaseConnection
+import symengine as se
+from einsteinengine.symbolic.connection import BaseConnection
+class ChristoffelSymbols(BaseConnection):
+    """
+    Computes the Christoffel Symbols of the second kind (Gamma^lambda_{mu nu})
+    optimized via SymEngine backend processing.
+    """
+    @classmethod
+    def from_metric(cls, metric, verbose=False):
+        """
+        Computes the Christoffel Symbols of the second kind (Gamma^lambda_{mu nu})
+        optimized via SymEngine backend processing.
+        """
+        if verbose:
+            print(f"Computing Christoffel Symbols for '{metric.name}' in C++...")
+            
+        g = metric._data
+        g_inv = metric.inv()._data
+        syms = metric.syms
+        dims = metric.dims
+        
+        # Initialize a 3D grid structure for Gamma (4x4x4)
+        Gamma = [[[se.sympify(0) for _ in range(dims)] for _ in range(dims)] for _ in range(dims)]
+        
+        # Heavy-lifting partial derivative loops triggered directly in C++
+        for lambda_ in range(dims):
+            for mu in range(dims):
+                for nu in range(dims):
+                    tmp_sum = se.sympify(0)
+                    for sigma in range(dims):
+                        term1 = se.diff(g[nu][sigma], syms[mu])
+                        term2 = se.diff(g[mu][sigma], syms[nu])
+                        term3 = se.diff(g[mu][nu], syms[sigma])
+                        tmp_sum += g_inv[lambda_][sigma] * (term1 + term2 - term3)
+                    
+                    Gamma[lambda_][mu][nu] = se.Rational(1, 2) * tmp_sum
+                    
+        # Devuelve instanciando la nueva clase madre BaseConnection
         return cls(Gamma, syms, config="ull", name=f"Christoffel_{metric.name}", verbose=verbose)

{einsteinengine-0.5.0 → einsteinengine-1.0.0}/einsteinengine/symbolic/connection.py

@@ -1,111 +1,111 @@
-from einsteinengine.symbolic.core import BaseRelativityObject
-
-class BaseConnection(BaseRelativityObject):
-    """
-    Base class for mathematical Connections (e.g., Levi-Civita, Spin, Affine).
-    Inherits coordinate and array management from BaseRelativityObject.
-    
-    IMPORTANT: Connections are NOT tensors. They do not transform homogeneously 
-    under coordinate changes, and operations like raising/lowering all indices 
-    using the metric do not apply in the standard tensorial way.
-    """
-    def __init__(self, arr, syms, config="ull", name="GenericConnection", verbose=False):
-        # 1. Delegate the heavy lifting to the parent object
-        super().__init__(arr, syms, name=name, verbose=verbose)
-        
-        # 2. Connection index configuration (usually one upper, two lower)
-        self.config = config
-        
-        # 3. Validation: Connections in standard GR are 3-index objects
-        if self._data and isinstance(arr, list):
-            rank = self._calculate_rank(arr)
-            if rank != 3:
-                raise ValueError(f"A connection must have exactly 3 indices. Got {rank}.")
-
-        if self.verbose:
-            print(f"[{self.name}] Connection initialized. Note: This object is NOT a tensor.")
-
-    def _calculate_rank(self, arr):
-        """
-        Calculates the mathematical rank (number of indices) of the array
-        by measuring the depth of the nested lists.
-        """
-        if isinstance(arr, list):
-            return 1 + self._calculate_rank(arr[0])
-        return 0
-
-    # --- Core geometric operations for Connections ---
-    
-    def covariant_derivative(self, tensor_obj, verbose=False):
-        r"""
-        Computes the covariant derivative (\nabla_\mu) of a given tensor.
-        The derivative adds a new covariant index (lower 'l') at the beginning of the tensor.
-        Nabla_\mu T^{a}_{b} = \partial_\mu T^{a}_{b} + \Gamma^a_{\mu \sigma} T^\sigma_b - \Gamma^\sigma_{\mu b} T^a_\sigma
-        """
-        import symengine as se
-        
-        if verbose:
-            print(f"[{self.name}] Computing covariant derivative for tensor '{tensor_obj.name}'...")
-            
-        dims = self.dims
-        syms = self.syms
-        rank = len(tensor_obj.config)
-        T_data = tensor_obj.get_raw_data()
-        Gamma = self._data  # self is the connection, config 'ull': Gamma[up][down][down]
-        
-        # Helper to extract the tensor component safely regardless of rank
-        def get_T(indices):
-            val = T_data
-            for idx in indices:
-                val = val[idx]
-            return val
-
-        # The covariant derivative ADDS a new covariant index at the front.
-        # e.g., T^\alpha_\beta (config "ul") -> \nabla_\mu T^\alpha_\beta (config "lul")
-        new_config = 'l' + tensor_obj.config
-        
-        def build_cov_dir(current_indices):
-            # Base case: we have selected all coordinates for the new tensor
-            if len(current_indices) == rank + 1:
-                mu = current_indices[0]      # The derivative index (\nabla_\mu)
-                T_indices = current_indices[1:] # The original tensor indices
-                
-                # 1. Base term: Partial derivative \partial_\mu T^{...}
-                term = se.diff(get_T(T_indices), syms[mu])
-                
-                # 2. Correction terms: loop over each index of the original tensor
-                for p in range(rank):
-                    idx_type = tensor_obj.config[p]
-                    current_idx_val = T_indices[p]
-                    
-                    if idx_type == 'u':
-                        # Add connection term for contravariant index
-                        # + \sum_\sigma \Gamma^{current_idx_val}_{\mu \sigma} * T^{... \sigma ...}
-                        for sigma in range(dims):
-                            mod_indices = list(T_indices)
-                            mod_indices[p] = sigma
-                            term += Gamma[current_idx_val][mu][sigma] * get_T(mod_indices)
-                            
-                    elif idx_type == 'l':
-                        # Subtract connection term for covariant index
-                        # - \sum_\sigma \Gamma^{\sigma}_{\mu current_idx_val} * T^{... \sigma ...}
-                        for sigma in range(dims):
-                            mod_indices = list(T_indices)
-                            mod_indices[p] = sigma
-                            term -= Gamma[sigma][mu][current_idx_val] * get_T(mod_indices)
-                            
-                return term
-            
-            # Recursive case: dive deeper into the dimensions
-            else:
-                return [build_cov_dir(current_indices + [d]) for d in range(dims)]
-                
-        cov_data = build_cov_dir([])
-        
-        # Local import to avoid circular dependencies
-        from einsteinengine.symbolic.tensor import BaseRelativityTensor
-        
-        final_name = f"CovDeriv_{tensor_obj.name}"
-        return BaseRelativityTensor(cov_data, syms, config=new_config, name=final_name, verbose=verbose)
-
-
+from einsteinengine.symbolic.core import BaseRelativityObject
+
+class BaseConnection(BaseRelativityObject):
+    """
+    Base class for mathematical Connections (e.g., Levi-Civita, Spin, Affine).
+    Inherits coordinate and array management from BaseRelativityObject.
+    
+    IMPORTANT: Connections are NOT tensors. They do not transform homogeneously 
+    under coordinate changes, and operations like raising/lowering all indices 
+    using the metric do not apply in the standard tensorial way.
+    """
+    def __init__(self, arr, syms, config="ull", name="GenericConnection", verbose=False):
+        # 1. Delegate the heavy lifting to the parent object
+        super().__init__(arr, syms, name=name, verbose=verbose)
+        
+        # 2. Connection index configuration (usually one upper, two lower)
+        self.config = config
+        
+        # 3. Validation: Connections in standard GR are 3-index objects
+        if self._data and isinstance(arr, list):
+            rank = self._calculate_rank(arr)
+            if rank != 3:
+                raise ValueError(f"A connection must have exactly 3 indices. Got {rank}.")
+
+        if self.verbose:
+            print(f"[{self.name}] Connection initialized. Note: This object is NOT a tensor.")
+
+    def _calculate_rank(self, arr):
+        """
+        Calculates the mathematical rank (number of indices) of the array
+        by measuring the depth of the nested lists.
+        """
+        if isinstance(arr, list):
+            return 1 + self._calculate_rank(arr[0])
+        return 0
+
+    # --- Core geometric operations for Connections ---
+    
+    def covariant_derivative(self, tensor_obj, verbose=False):
+        r"""
+        Computes the covariant derivative (\nabla_\mu) of a given tensor.
+        The derivative adds a new covariant index (lower 'l') at the beginning of the tensor.
+        Nabla_\mu T^{a}_{b} = \partial_\mu T^{a}_{b} + \Gamma^a_{\mu \sigma} T^\sigma_b - \Gamma^\sigma_{\mu b} T^a_\sigma
+        """
+        import symengine as se
+        
+        if verbose:
+            print(f"[{self.name}] Computing covariant derivative for tensor '{tensor_obj.name}'...")
+            
+        dims = self.dims
+        syms = self.syms
+        rank = len(tensor_obj.config)
+        T_data = tensor_obj.get_raw_data()
+        Gamma = self._data  # self is the connection, config 'ull': Gamma[up][down][down]
+        
+        # Helper to extract the tensor component safely regardless of rank
+        def get_T(indices):
+            val = T_data
+            for idx in indices:
+                val = val[idx]
+            return val
+
+        # The covariant derivative ADDS a new covariant index at the front.
+        # e.g., T^\alpha_\beta (config "ul") -> \nabla_\mu T^\alpha_\beta (config "lul")
+        new_config = 'l' + tensor_obj.config
+        
+        def build_cov_dir(current_indices):
+            # Base case: we have selected all coordinates for the new tensor
+            if len(current_indices) == rank + 1:
+                mu = current_indices[0]      # The derivative index (\nabla_\mu)
+                T_indices = current_indices[1:] # The original tensor indices
+                
+                # 1. Base term: Partial derivative \partial_\mu T^{...}
+                term = se.diff(get_T(T_indices), syms[mu])
+                
+                # 2. Correction terms: loop over each index of the original tensor
+                for p in range(rank):
+                    idx_type = tensor_obj.config[p]
+                    current_idx_val = T_indices[p]
+                    
+                    if idx_type == 'u':
+                        # Add connection term for contravariant index
+                        # + \sum_\sigma \Gamma^{current_idx_val}_{\mu \sigma} * T^{... \sigma ...}
+                        for sigma in range(dims):
+                            mod_indices = list(T_indices)
+                            mod_indices[p] = sigma
+                            term += Gamma[current_idx_val][mu][sigma] * get_T(mod_indices)
+                            
+                    elif idx_type == 'l':
+                        # Subtract connection term for covariant index
+                        # - \sum_\sigma \Gamma^{\sigma}_{\mu current_idx_val} * T^{... \sigma ...}
+                        for sigma in range(dims):
+                            mod_indices = list(T_indices)
+                            mod_indices[p] = sigma
+                            term -= Gamma[sigma][mu][current_idx_val] * get_T(mod_indices)
+                            
+                return term
+            
+            # Recursive case: dive deeper into the dimensions
+            else:
+                return [build_cov_dir(current_indices + [d]) for d in range(dims)]
+                
+        cov_data = build_cov_dir([])
+        
+        # Local import to avoid circular dependencies
+        from einsteinengine.symbolic.tensor import BaseRelativityTensor
+        
+        final_name = f"CovDeriv_{tensor_obj.name}"
+        return BaseRelativityTensor(cov_data, syms, config=new_config, name=final_name, verbose=verbose)
+
+