# sparse-tensor: typesafe tensor algebra library

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

This package is intended to be used as a general purpose tensor algebra library. It defines the usual tensor algebra functions such as addition, scalar multiplication, tensor product, and contractions, but also general symmetrizations and further utility functions.

The implemented tensor data type is capable of being used with an arbitrary number of general abstract indices and can incorporate values of any type that allow for a meaningful addition, scaling, and multiplication. The package is thus very flexible and can easily be customised at wish.

This package performs best when the values a given tensor provides are explicitly needed. In particular all incorporated functions are implemented such that they explicitly manipulate the values of the given tensors. This allows for fast evaluation of the individual values from given tensors.

In order to improve memory usage, the tensors in this package employ a sparse storage paradigm. In other words, one may define a tensor by only providing its non-zero values explicitly. All remaining values are taken to be zero.

Furthermore this package also provides the functionality of fully automatically computing all linear independent expressions with given rank and symmetries that can be composed by using the Minkowski metric and the totally antisymmetric tensor. In order words, the package includes functions that construct a basis of the space of Lorentz invariant tensors of given symmetry and rank. With slight modifications the therefore implemented algorithms can also be used for the computation of invariant tensor bases of any other special orthogonal group SO(p,q).

## Properties

Versions 0.1.0.0, 0.1.0.0, 0.2, 0.2.1, 0.2.1.1, 0.2.1.2, 0.2.1.3, 0.2.1.4, 0.2.1.5 CHANGELOG.md ad (>=4.3 && <4.4), base (>=4.7 && <5), bytestring (>=0.10.8 && <0.11), cereal (>=0.5.7 && <0.6), containers (>=0.5.7 && <0.7), deepseq (>=1.4.2 && <1.5), eigen (==3.3.4.1), ghc-typelits-knownnat (>=0.5.1 && <0.7), ghc-typelits-natnormalise (>=0.6.2 && <0.7), parallel (>=3.2.2 && <3.3), singletons (>=2.4.1 && <2.6), tf-random (>=0.5 && <0.6), zlib (>=0.6.2 && <0.7) [details] MIT 2019 Tobias Reinhart and Nils Alex Tobias Reinhart and Nils Alex tobi.reinhart@fau.de, nils.alex@fau.de Data, Math, Algebra https://github.com/TobiReinhart/sparse-tensor#readme head: git clone git://github.com/TobiReinhart/sparse-tensor.git by nalex at 2019-08-16T13:44:18Z

## Modules

[Index]

#### Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

[back to package description]

# The sparse-tensor Package

sparse-tensor is a Haskell tensor algebra library. It defines the usual tensor algebra functions such as

result = t1 &+ t2

• scalar multiplication
result = s &. t

• tensor product
result = t1 &* t2

• or symmetrizations
result = symTens (0,1) t -- symmetrization in first two indices


## The Tensor type

Tensor types can be defined with any value type and index types. For example, a tensor type with n contravariant and m covariant 4-d spacetime indices ranging from 0 to 3 and Rational values can be defined as

type MyTensor n m  = AbsTensor2 n m Ind3 (SField Rational)


The operations on tensors are type-safe, for example it is not possible to add two tensors of different rank,

>>> :set -XDataKinds
>>> (undefined :: MyTensor 0 1) &+ (undefined :: MyTensor 0 2)

<interactive>:3:33: error:
• Couldn't match type ‘2’ with ‘1’
[...]


as this causes a type error at compile time.

## Predefined tensors

The package comes with pre-defined tensor types. Basic tensors of these types for applications in mathematical physics are exported by Math.Tensor.Examples.Gravity:

>>> sequence_ $fmap print$ toListT2' delta3  -- print assocs of spacetime delta
(([0],[0]),SField (1 % 1))
(([1],[1]),SField (1 % 1))
(([2],[2]),SField (1 % 1))
(([3],[3]),SField (1 % 1))

>>> sequence_ $fmap print$ toListT2' eta     -- print assocs of Minkowski metric
(([],[0,0]),SField ((-1) % 1))
(([],[1,1]),SField (1 % 1))
(([],[2,2]),SField (1 % 1))
(([],[3,3]),SField (1 % 1))

>>> let t = invEta &* epsilon
>>> contrATens1 (0,0) $contrATens1 (1,1) t -- contraction of inverse eta with epsilon ZeroTensor  It is of course possible to define further custom tensor types and tensors. Math.Tensor.LorentzGenerator exports functionality to generate a basis for the space of Lorentz-invariant tensors of certain rank which obey certain symmetries. ## Automatic differentiation sparse-tensor also supports tensors with functions as values. For such tensors, the package also provides the partial function for automatic differentiation. Math.Tensor.Examples.Gravity.Schwarzschild exports the Einstein tensor for a Schwarzschild spacetime, calculated from the Schwarzschild metric: >>> let e = einstein 2.0 -- Einstein tensor for Schwarzschild metric with r_s = 2.0 >>> e evalSec [1.2, 3.1, 1.3, 2.2] -- evaluate at spacetime point ZeroTensor  ## Symbolic calculations The package can also handle symbolic tensor values. All manipulations, including differentiation, are then performed on strings which may be passed to a computer algebra engine. sparse-tensor itself cannot yet simplify these symbolic values. Math.Tensor.Examples.Gravity.SchwarzschildSymbolic exports the Schwarzschild metric with symbolic entries and methods to calculate derived geometric entities: >>> let g = schwarzschildS >>> let g' = schwarzschildS' >>> let gamma = christoffelS g g' >>> let comps = toListT2 gamma -- get assocs >>> print$ snd \$ comps !! 1       -- component gamma^t_tr
SSymbolic "(1 % 2)*((1/(1 - rs/r))*(diff(1 - rs / r, r)))"