einsteinengine 0.5.0__py3-none-any.whl

einsteinengine/symbolic/weyl.py

@@ -0,0 +1,83 @@
+import symengine as se
+import sympy as sp
+from einsteinengine.symbolic import metric
+from einsteinengine.symbolic.tensor import BaseRelativityTensor
+from einsteinengine.symbolic.ricci_tensor import RicciTensor
+from einsteinengine.symbolic.ricci_scalar import RicciScalar
+from einsteinengine.symbolic.riemann import RiemannCurvatureTensor
+
+class WeylTensor(BaseRelativityTensor):
+    
+    @classmethod
+    def from_metric(cls, metric, riemann=None, verbose=False):
+        dims = metric.dims
+        syms = metric.syms
+        
+        # 1. Pipeline check: If Riemann tensor is not provided, compute it from metric
+        if riemann is None:
+            riemann = RiemannCurvatureTensor.from_metric(metric, verbose=verbose)
+            
+        # 2. Leverage your native OOP contraction pipeline to build Ricci structures
+        ricci_tensor = RicciTensor.from_riemann(riemann, verbose=verbose)
+        ricci_scalar_obj = RicciScalar.from_ricci_tensor_and_metric(ricci_tensor, metric, verbose=verbose)
+        
+        # Extract the underlying raw data arrays for high-speed element access
+        r_tensor_data = ricci_tensor.get_raw_data()
+        
+        # Ensure the Ricci Scalar data is unboxed properly if wrapped in a single-element list
+        r_scalar_data = ricci_scalar_obj.get_raw_data()
+        
+        # Robust unboxing: Drill down in case the scalar is trapped in nested lists (e.g., [[value]])
+        while isinstance(r_scalar_data, list):
+            r_scalar_data = r_scalar_data[0]
+            
+        # Explicitly cast to a SymEngine object. 
+        r_scalar_data = se.sympify(r_scalar_data)
+
+        g_inv = metric.inv().get_raw_data()        
+        g_cov = metric.get_raw_data()
+
+        # 3. Raise one index on the Ricci Tensor manually to build R^mu_rho for the Weyl formula
+        # Mathematical definition: R^mu_rho = g^mu_alpha * R_alpha_rho
+        ricci_up_tensor = ricci_tensor.raise_index(0, metric.inv(), verbose=verbose)
+        ricci_up = ricci_up_tensor.get_raw_data()
+
+        # 4. Initialize the 4D nested list to store the final Weyl components
+        c_array = [[[[0 for _ in range(dims)] for _ in range(dims)] for _ in range(dims)] for _ in range(dims)]
+
+        if verbose:
+            print(f"Building Weyl Tensor from {metric.name} components...")
+
+        # 5. Core 4D Tensor Contraction: Trace-free subtraction of Ricci curvature from Riemann
+        for mu in range(dims):
+            for nu in range(dims):
+                for rho in range(dims):
+                    for sigma in range(dims):
+                        # Inline evaluation of Kronecker delta terms
+                        kronecker_mu_rho = 1 if mu == rho else 0
+                        kronecker_mu_sigma = 1 if mu == sigma else 0
+                        
+                        # Retrieve the base Riemann component
+                        term_riemann = riemann.get_raw_data()[mu][nu][rho][sigma]
+                        
+                        # Part 1: Ricci Tensor corrections (trace removal)
+                        term_ricci = (
+                            kronecker_mu_rho * r_tensor_data[nu][sigma]
+                            - kronecker_mu_sigma * r_tensor_data[nu][rho]
+                            + g_cov[nu][sigma] * ricci_up[mu][rho]
+                            - g_cov[nu][rho] * ricci_up[mu][sigma]
+                        )
+                        
+                        # Part 2: Ricci Scalar corrections
+                        term_scalar = (
+                            kronecker_mu_rho * g_cov[nu][sigma]
+                            - kronecker_mu_sigma * g_cov[nu][rho]
+                        )
+                        
+                        # Combine all geometric pieces according to the 4D Weyl formulation
+                        c_val = term_riemann - sp.Rational(1, 2) * term_ricci + sp.Rational(1, 6) * r_scalar_data * term_scalar                        
+                        # Enforce optimization by wrapping the result as a native SymEngine object
+                        c_array[mu][nu][rho][sigma] = se.sympify(c_val)
+
+        # Return the final object using your base relativity constructor configuration
+        return cls(c_array, syms, config="ulll", name=f"Weyl_{metric.name}", verbose=verbose)

einsteinengine-0.5.0.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: einsteinengine
+Version: 0.5.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
+Requires-Dist: sympy>=1.12
+Requires-Dist: symengine>=0.11.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+
+#  EinsteinEngine
+
+**A high-performance, object-oriented symbolic tensor engine for General Relativity, powered by Python and C++.**
+
+EinsteinEngine is designed to solve the performance bottlenecks of traditional pure-Python symbolic calculators. By wrapping `SymEngine` (C++) backend inside a Python API, it computes Christoffel Symbols, Riemann Tensors, and other complex relativistic structures faster than standard pure Python libraries.
+
+---
+
+## Key Features
+
+* **⚡ C++ Backend:** Mathematical heavy-lifting (partial derivatives, massive tensor contractions) is routed directly to `SymEngine`, bypassing Python's native performance limits.
+* **🧠 Smart Memoization:** Built-in memory caching prevents redundant calculations of highly complex objects like inverse metric tensors.
+* **📦 Clean Object-Oriented API:** Complex tensor pipelines are reduced to a few lines of readable code using class inheritance.
+* **🛡️ Exact Mathematics:** Built to handle rational numbers securely, preventing floating-point contamination and ensuring textbook-perfect algebraic simplifications.
+
+---
+
+## Quick Start
+
+EinsteinEngine calculates the entire Riemann Curvature Tensor of a Black Hole in just two lines of code:
+
+```python
+import sympy as sp
+from einsteinpy.symbolic.metric import MetricTensor
+from einsteinpy.symbolic.riemann import RiemannCurvatureTensor
+
+# 1. Define your symbols and metric array
+t, r, theta, phi = sp.symbols('t r theta phi', real=True)
+M = sp.symbols('M', real=True)
+
+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]
+]
+
+# 2. Run the EinsteinEngine Pipeline
+metric = MetricTensor(g_schwarzschild, [t, r, theta, phi], name="Schwarzschild")
+riemann = RiemannCurvatureTensor.from_metric(metric)
+
+# 3. Extract exact, simplified textbook results
+print(riemann.get_component(1, 0, 1, 0))
+# Output: 2*M*(2*M - r)/r**4

einsteinengine-0.5.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+einsteinengine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+einsteinengine/symbolic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+einsteinengine/symbolic/christoffel.py,sha256=nAtV9Cvb-CfD2v5wxc74XKyPKgHdQKQZdVyGU30KE3Q,1768
+einsteinengine/symbolic/connection.py,sha256=p7D_ytOfgF_RSjX8j4fD1Luc9mmyURQLpi6iE3IKVk4,5204
+einsteinengine/symbolic/core.py,sha256=BHs1rqPKuE7u-48bP3apJrS_6DHmE1txx8lhYp0DELk,5658
+einsteinengine/symbolic/einstein_tensor.py,sha256=KOCzbpIYZdwJIaI5dxB4On4p53RjXT0Mr0xyknIZYMg,2459
+einsteinengine/symbolic/energy_momentum.py,sha256=0cgKJkkJVdHb-XkihLu-Q7qMj2Ti-adhrFQqVRwjLLs,1855
+einsteinengine/symbolic/geodesics.py,sha256=sr6UrBcfuDyyTLYGc-T4h60jgjzGBGY_j57qLciEuqY,4528
+einsteinengine/symbolic/metric.py,sha256=gKCWndCJhDA7VimeOsdaZBxOdmlxMrbTOe89O2nttP8,2171
+einsteinengine/symbolic/ricci_scalar.py,sha256=UDAghYaSEMAPB7Z2UwOt7aerdoYPvJd8NBzXH9MJVzY,1178
+einsteinengine/symbolic/ricci_tensor.py,sha256=uJqiqzooO0CfucSheDPO7kb7x3sfQ_eagZ0OkFNkvCw,826
+einsteinengine/symbolic/riemann.py,sha256=3vluw9gUIFg3fY69i96KOxLp667h6vJWTRbiTGKpVeY,5371
+einsteinengine/symbolic/spin_connection.py,sha256=M1AS1qW2MJX8rMOSjPv3Yo6kP2US_ZB_0hUMmA7vAts,1995
+einsteinengine/symbolic/tensor.py,sha256=K1PD6sOb0tRXYyv0YCCam6H8pcPi-NftP5e_RB0g4v0,20003
+einsteinengine/symbolic/tetrad.py,sha256=F5qPGQOAujnDa610Y_4k6dn1boK4YHlwoiO09Kt5HK8,2114
+einsteinengine/symbolic/weyl.py,sha256=Wct6TS66qshZ4O3f-heXKUQiVFdfQWvFJhz6hBfAzj0,4351
+einsteinengine-0.5.0.dist-info/METADATA,sha256=04G0lda-UkB5yWBBFOysKsDzPKz_kjy47fszEB15SE0,2784
+einsteinengine-0.5.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+einsteinengine-0.5.0.dist-info/top_level.txt,sha256=Ck8GEuFHyZekPtEtAO8DH4czTx7oTaFn2bEmFACiglw,15
+einsteinengine-0.5.0.dist-info/RECORD,,

einsteinengine-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

einsteinengine-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+einsteinengine